mirror of
https://github.com/garrytan/gbrain.git
synced 2026-08-17 10:22:34 +00:00
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Garry TanandClaude Fable 5
|
3fa01a4538 | ||
|
|
ded4aeaeae |
@@ -186,6 +186,18 @@ export function isSourceStale(src: SourceRow, now = Date.now(), floorMin = FULL_
|
||||
return ageMin >= floorMin;
|
||||
}
|
||||
|
||||
/**
|
||||
* #2060: count sources past the per-source cycle freshness floor. Consumed
|
||||
* by autopilot's dispatch decision — a stale source forces the fanout path
|
||||
* even when the doctor plan is small (score 70–94, plan ≤ 3, est < 300s),
|
||||
* so targeted mode can't leave cycle_freshness stale indefinitely.
|
||||
* dispatchPerSource's own throttles (skipped_fresh / fanoutMax / failure
|
||||
* cooldown) bound the resulting work.
|
||||
*/
|
||||
export function countStaleSources(sources: SourceRow[], now = Date.now(), floorMin = FULL_CYCLE_FLOOR_MIN): number {
|
||||
return sources.filter((s) => isSourceStale(s, now, floorMin)).length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Most recent SUCCESSFUL cycle for a source. Prefers `last_source_cycle_at`
|
||||
* (per-source phases, written by the split cycle) and falls back to the legacy
|
||||
|
||||
@@ -901,13 +901,27 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
|
||||
const FULL_CYCLE_FLOOR_MIN = 60;
|
||||
const minutesSinceLastFull = (Date.now() - lastFullCycleAt) / 60000;
|
||||
|
||||
// #2060: stale per-source cycle freshness is a dispatch input. Without
|
||||
// it, a brain sitting at score 70–94 with a small targeted plan (≤3
|
||||
// steps, <300s) stays in targeted mode indefinitely and no per-source
|
||||
// cycle is ever dispatched — cycle_freshness never advances. A stale
|
||||
// source forces the fanout path; dispatchPerSource's throttles
|
||||
// (skipped_fresh / fanoutMax / failure cooldown) bound the work.
|
||||
// Fail-open to 0: a read failure must not block dispatch.
|
||||
let staleCycleSources = 0;
|
||||
try {
|
||||
const { countStaleSources } = await import('./autopilot-fanout.ts');
|
||||
staleCycleSources = countStaleSources(await engine.listAllSources({ localPathOnly: true }));
|
||||
} catch { /* fail-open: freshness is a dispatch hint, not a gate */ }
|
||||
|
||||
const shouldFullCycle =
|
||||
(score >= 95 && plan.length === 0 && minutesSinceLastFull >= FULL_CYCLE_FLOOR_MIN) ||
|
||||
plan.length > 3 ||
|
||||
estTotal >= 300 ||
|
||||
score < 70;
|
||||
score < 70 ||
|
||||
staleCycleSources > 0;
|
||||
|
||||
const shouldSleep = score >= 95 && plan.length === 0 && minutesSinceLastFull < FULL_CYCLE_FLOOR_MIN;
|
||||
const shouldSleep = score >= 95 && plan.length === 0 && minutesSinceLastFull < FULL_CYCLE_FLOOR_MIN && staleCycleSources === 0;
|
||||
|
||||
if (shouldSleep) {
|
||||
if (jsonMode) {
|
||||
|
||||
@@ -90,30 +90,6 @@ export function isValidOpenAITextEmbedding3Dim(modelId: string, dims: number): b
|
||||
return Number.isInteger(dims) && dims >= 1 && dims <= max;
|
||||
}
|
||||
|
||||
// Perplexity hosted embeddings (#1046): Matryoshka-style flexible dims,
|
||||
// any integer from 128 up to the model's native size. `dimensions` is the
|
||||
// native wire field (no translation needed); output encoding divergence
|
||||
// (base64 int8) is handled by perplexityCompatFetch in gateway.ts.
|
||||
const PERPLEXITY_EMBEDDING_MAX_DIMS: Record<string, number> = {
|
||||
'pplx-embed-v1-0.6b': 1024,
|
||||
'pplx-embed-v1-4b': 2560,
|
||||
};
|
||||
export const PERPLEXITY_MIN_DIMS = 128;
|
||||
|
||||
export function isPerplexityEmbeddingModel(modelId: string): boolean {
|
||||
return modelId in PERPLEXITY_EMBEDDING_MAX_DIMS;
|
||||
}
|
||||
|
||||
export function maxPerplexityEmbeddingDim(modelId: string): number | undefined {
|
||||
return PERPLEXITY_EMBEDDING_MAX_DIMS[modelId];
|
||||
}
|
||||
|
||||
export function isValidPerplexityDim(modelId: string, dims: number): boolean {
|
||||
const max = PERPLEXITY_EMBEDDING_MAX_DIMS[modelId];
|
||||
if (max === undefined) return false;
|
||||
return Number.isInteger(dims) && dims >= PERPLEXITY_MIN_DIMS && dims <= max;
|
||||
}
|
||||
|
||||
// NVIDIA NIM hosted embedding models use asymmetric input_type values. Most
|
||||
// emit fixed natural dimensions, but llama-nemotron-embed-1b-v2 accepts
|
||||
// Matryoshka-style dimension overrides (e.g. matching an existing 1280d
|
||||
@@ -250,23 +226,6 @@ export function dimsProviderOptions(
|
||||
},
|
||||
};
|
||||
}
|
||||
// Perplexity pplx-embed-v1-* — flexible dims via the native
|
||||
// `dimensions` field. Fail-loud when the configured dim is outside
|
||||
// the model's range (same rationale as the Voyage/ZE guards: the
|
||||
// upstream HTTP 400 misroutes as a transient network error).
|
||||
// Symmetric retrieval — inputType is never emitted.
|
||||
if (isPerplexityEmbeddingModel(modelId)) {
|
||||
if (!isValidPerplexityDim(modelId, dims)) {
|
||||
const max = maxPerplexityEmbeddingDim(modelId)!;
|
||||
throw new AIConfigError(
|
||||
`Perplexity model "${modelId}" supports embedding_dimensions in ` +
|
||||
`${PERPLEXITY_MIN_DIMS}..${max}, got ${dims}.`,
|
||||
`Set \`embedding_dimensions\` to a value between ${PERPLEXITY_MIN_DIMS} and ${max} ` +
|
||||
`in your gbrain config.`,
|
||||
);
|
||||
}
|
||||
return { openaiCompatible: { dimensions: dims } };
|
||||
}
|
||||
// NVIDIA NIM hosted embeddings are OpenAI-compatible but require
|
||||
// asymmetric input_type. Use passage for indexing/document-side vectors
|
||||
// and query for search-side vectors. Only llama-nemotron-embed-1b-v2
|
||||
|
||||
@@ -263,18 +263,6 @@ export class ZeroEntropyResponseTooLargeError extends Error {
|
||||
}
|
||||
}
|
||||
|
||||
/** Perplexity twin of the Voyage/ZE OOM caps (#1046). Int8 components are
|
||||
* 1 byte each, so a real response (512 texts × 2560 dims) is ~1.3 MB —
|
||||
* anything near this cap is unambiguously not legitimate. */
|
||||
const MAX_PERPLEXITY_RESPONSE_BYTES = 256 * 1024 * 1024;
|
||||
|
||||
export class PerplexityResponseTooLargeError extends Error {
|
||||
constructor(message: string) {
|
||||
super(message);
|
||||
this.name = 'PerplexityResponseTooLargeError';
|
||||
}
|
||||
}
|
||||
|
||||
// ---- Unified auth resolution (D12=A) ----
|
||||
//
|
||||
// Pre-v0.32, openai-compatible auth was duplicated across instantiateEmbedding,
|
||||
@@ -1304,103 +1292,6 @@ const openAICompatAsymmetricFetch = (async (input: RequestInfo | URL, init?: Req
|
||||
return fetch(typeof input === 'string' ? input : input.toString(), baseInit);
|
||||
}) as unknown as typeof fetch;
|
||||
|
||||
/**
|
||||
* Perplexity compatibility shim (#1046). Perplexity's `/v1/embeddings`
|
||||
* endpoint is OpenAI-shaped but diverges on two points that break the AI
|
||||
* SDK's openai-compatible adapter:
|
||||
* - `encoding_format` only accepts 'base64_int8' (default) or
|
||||
* 'base64_binary'; the SDK sends 'float', which Perplexity rejects.
|
||||
* Force 'base64_int8' on the wire.
|
||||
* - The response `embedding` is a base64 string encoding SIGNED INT8
|
||||
* components (natively quantized output). The SDK schema expects
|
||||
* `number[]` — decode Int8Array → number[] here. Cosine similarity is
|
||||
* scale-invariant, so the raw int8 components rank correctly.
|
||||
* `dimensions` is Perplexity's native field name — no translation needed
|
||||
* (dims.ts emits it directly). Layer 1/Layer 2 OOM caps mirror the Voyage
|
||||
* pattern.
|
||||
*
|
||||
* Exported for tests (behavioral coverage of the int8 decode); not part of
|
||||
* the public gateway API.
|
||||
*/
|
||||
export const perplexityCompatFetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
|
||||
// OUTBOUND: force the encoding Perplexity actually accepts.
|
||||
if (init?.body && typeof init.body === 'string') {
|
||||
try {
|
||||
const parsed = JSON.parse(init.body);
|
||||
if (parsed && typeof parsed === 'object' && parsed.encoding_format !== 'base64_int8') {
|
||||
parsed.encoding_format = 'base64_int8';
|
||||
// Drop Content-Length so fetch recomputes from the new body.
|
||||
const headers = new Headers(init.headers ?? {});
|
||||
headers.delete('content-length');
|
||||
init = { ...init, body: JSON.stringify(parsed), headers };
|
||||
}
|
||||
} catch {
|
||||
// Body wasn't JSON — pass through untouched.
|
||||
}
|
||||
}
|
||||
|
||||
const resp = await fetch(input as any, init);
|
||||
if (!resp.ok) return resp;
|
||||
const ct = resp.headers.get('content-type') ?? '';
|
||||
if (!ct.toLowerCase().includes('application/json')) return resp;
|
||||
|
||||
// Layer 1: Content-Length pre-check BEFORE the body is parsed.
|
||||
const contentLengthHeader = resp.headers.get('content-length');
|
||||
if (contentLengthHeader) {
|
||||
const len = parseInt(contentLengthHeader, 10);
|
||||
if (Number.isFinite(len) && len > MAX_PERPLEXITY_RESPONSE_BYTES) {
|
||||
throw new PerplexityResponseTooLargeError(
|
||||
`Perplexity response Content-Length=${len} exceeds ${MAX_PERPLEXITY_RESPONSE_BYTES} bytes — ` +
|
||||
`likely compromised endpoint or misconfiguration`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// INBOUND: decode base64 int8 embeddings to number[] so the SDK's Zod
|
||||
// schema validates.
|
||||
try {
|
||||
const json: any = await resp.clone().json();
|
||||
if (!json || typeof json !== 'object') return resp;
|
||||
let modified = false;
|
||||
if (Array.isArray(json.data)) {
|
||||
for (const item of json.data) {
|
||||
if (item && typeof item.embedding === 'string') {
|
||||
// Layer 2: per-embedding cap for chunked responses that skipped
|
||||
// Layer 1. base64 → bytes is the canonical 0.75 ratio.
|
||||
const estDecoded = Math.ceil(item.embedding.length * 0.75);
|
||||
if (estDecoded > MAX_PERPLEXITY_RESPONSE_BYTES) {
|
||||
throw new PerplexityResponseTooLargeError(
|
||||
`Perplexity embedding base64 exceeds ${MAX_PERPLEXITY_RESPONSE_BYTES} bytes ` +
|
||||
`(estimated ${estDecoded} bytes from ${item.embedding.length} base64 chars)`,
|
||||
);
|
||||
}
|
||||
// base64_int8: one signed int8 per component.
|
||||
const bytes = Buffer.from(item.embedding, 'base64');
|
||||
item.embedding = Array.from(new Int8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength));
|
||||
modified = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (json.usage && typeof json.usage === 'object' && json.usage.prompt_tokens === undefined) {
|
||||
json.usage.prompt_tokens = typeof json.usage.total_tokens === 'number'
|
||||
? json.usage.total_tokens
|
||||
: 0;
|
||||
modified = true;
|
||||
}
|
||||
if (!modified) return resp;
|
||||
return new Response(JSON.stringify(json), {
|
||||
status: resp.status,
|
||||
statusText: resp.statusText,
|
||||
headers: resp.headers,
|
||||
});
|
||||
} catch (err) {
|
||||
// OOM-cap throws MUST propagate; anything else falls back to the
|
||||
// original response (same contract as voyageCompatFetch).
|
||||
if (err instanceof PerplexityResponseTooLargeError) throw err;
|
||||
return resp;
|
||||
}
|
||||
}) as unknown as typeof fetch;
|
||||
|
||||
async function resolveEmbeddingProvider(modelStr: string): Promise<{ model: any; recipe: Recipe; modelId: string }> {
|
||||
const { parsed, recipe } = resolveRecipe(modelStr);
|
||||
assertTouchpoint(recipe, 'embedding', parsed.modelId, getExtendedModelsForProvider(parsed.providerId));
|
||||
@@ -1469,8 +1360,6 @@ function instantiateEmbedding(recipe: Recipe, modelId: string, cfg: AIGatewayCon
|
||||
? zeroEntropyCompatFetch
|
||||
: recipe.id === 'nvidia'
|
||||
? nvidiaCompatFetch
|
||||
: recipe.id === 'perplexity'
|
||||
? perplexityCompatFetch
|
||||
: openAICompatAsymmetricFetch);
|
||||
const client = createOpenAICompatible({
|
||||
name: recipe.id,
|
||||
|
||||
@@ -26,7 +26,6 @@ import { llamaServerReranker } from './llama-server-reranker.ts';
|
||||
import { moonshot } from './moonshot.ts';
|
||||
import { mistral } from './mistral.ts';
|
||||
import { nvidia } from './nvidia.ts';
|
||||
import { perplexity } from './perplexity.ts';
|
||||
|
||||
const ALL: Recipe[] = [
|
||||
openai,
|
||||
@@ -49,7 +48,6 @@ const ALL: Recipe[] = [
|
||||
moonshot,
|
||||
mistral,
|
||||
nvidia,
|
||||
perplexity,
|
||||
];
|
||||
|
||||
/** Map from `provider:id` key to recipe. */
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
import type { Recipe } from '../types.ts';
|
||||
|
||||
/**
|
||||
* Perplexity's hosted embeddings API (#1046). OpenAI-shaped at
|
||||
* `POST {base}/embeddings` but diverges on the wire:
|
||||
* - `encoding_format` only accepts 'base64_int8' (default) or
|
||||
* 'base64_binary' — the AI SDK's 'float' default is rejected.
|
||||
* - The response `embedding` is a base64 string encoding SIGNED INT8
|
||||
* components (natively quantized output), not a float array.
|
||||
* Both divergences are handled by perplexityCompatFetch in gateway.ts
|
||||
* (force 'base64_int8' outbound; decode Int8Array → number[] inbound).
|
||||
* Cosine similarity is scale-invariant, so the raw int8 components store
|
||||
* and rank correctly as floats.
|
||||
*
|
||||
* Models (per docs.perplexity.ai/api-reference/embeddings-post, 2026-07):
|
||||
* - pplx-embed-v1-0.6b: dims 128..1024 (default 1024)
|
||||
* - pplx-embed-v1-4b: dims 128..2560 (default 2560)
|
||||
* The flexible-dim range validation lives in src/core/ai/dims.ts
|
||||
* (PERPLEXITY_EMBEDDING_MAX_DIMS). default_dims is pinned at 1024 so both
|
||||
* models work out of the box on a plain vector(N) column; users who want
|
||||
* the 4b model's full 2560 width set `embedding_dimensions: 2560` and the
|
||||
* existing halfvec path (dims > 2000) covers storage + ANN.
|
||||
*
|
||||
* Auth is PERPLEXITY_API_KEY only — deliberately NO OPENAI_API_KEY
|
||||
* fallback (a Perplexity brain must never silently bill/route through
|
||||
* OpenAI). If your key lives in PPLX_API_KEY, re-export it.
|
||||
*/
|
||||
export const perplexity: Recipe = {
|
||||
id: 'perplexity',
|
||||
name: 'Perplexity',
|
||||
tier: 'openai-compat',
|
||||
implementation: 'openai-compatible',
|
||||
base_url_default: 'https://api.perplexity.ai/v1',
|
||||
auth_env: {
|
||||
required: ['PERPLEXITY_API_KEY'],
|
||||
setup_url: 'https://www.perplexity.ai/settings/api',
|
||||
},
|
||||
touchpoints: {
|
||||
embedding: {
|
||||
models: ['pplx-embed-v1-0.6b', 'pplx-embed-v1-4b'],
|
||||
default_dims: 1024,
|
||||
cost_per_1m_tokens_usd: 0.03, // pplx-embed-v1-4b; 0.6b is $0.004/M
|
||||
price_last_verified: '2026-07-21',
|
||||
// Perplexity enforces 120K combined tokens (and 512 texts) per
|
||||
// request. Same pre-split posture as Voyage: assume a dense
|
||||
// tokenizer (1 char ≈ 1 token) at 0.5 utilization; the gateway's
|
||||
// recursive halving is the runtime safety net.
|
||||
max_batch_tokens: 120_000,
|
||||
chars_per_token: 1,
|
||||
safety_factor: 0.5,
|
||||
},
|
||||
},
|
||||
setup_hint: 'Get an API key at https://www.perplexity.ai/settings/api, then `export PERPLEXITY_API_KEY=...` (re-export PPLX_API_KEY if that is where your key lives).',
|
||||
};
|
||||
+19
-10
@@ -854,7 +854,10 @@ interface SyncPhaseResult extends PhaseResult {
|
||||
/**
|
||||
* Resolve the source id for a brain directory by looking up the sources
|
||||
* table. Returns undefined when no registered source matches (falls back
|
||||
* to pre-v0.18 global config.sync.* keys).
|
||||
* to pre-v0.18 global config.sync.* keys) OR when MORE than one source
|
||||
* claims the path — an ambiguous match must not scope phases or stamp
|
||||
* last_full_cycle_at for an arbitrarily-picked source (the "freshness
|
||||
* stamp that lies" this resolution exists to prevent).
|
||||
*/
|
||||
async function resolveSourceForDir(
|
||||
engine: BrainEngine,
|
||||
@@ -865,10 +868,10 @@ async function resolveSourceForDir(
|
||||
if (brainDir === null) return undefined;
|
||||
try {
|
||||
const rows = await engine.executeRaw<{ id: string }>(
|
||||
`SELECT id FROM sources WHERE local_path = $1 LIMIT 1`,
|
||||
`SELECT id FROM sources WHERE local_path = $1 LIMIT 2`,
|
||||
[brainDir],
|
||||
);
|
||||
return rows[0]?.id;
|
||||
return rows.length === 1 ? rows[0]!.id : undefined;
|
||||
} catch {
|
||||
// sources table might not exist on very old brains — fall through.
|
||||
return undefined;
|
||||
@@ -2365,17 +2368,23 @@ export async function runCycle(
|
||||
}
|
||||
|
||||
// v0.38 (codex r1 P0-5): persist per-source cycle completion timestamp
|
||||
// when the cycle ran successfully against an explicit source. Read by
|
||||
// autopilot's per-source freshness gate next tick. Skipped when:
|
||||
// - opts.sourceId is unset (legacy callers — autopilot still here)
|
||||
// - engine is null (no-DB path)
|
||||
// when the cycle ran successfully against a resolvable source. Read by
|
||||
// autopilot's per-source freshness gate next tick.
|
||||
//
|
||||
// #1993: keyed off `cycleSourceId` (opts.sourceId ?? the source resolved
|
||||
// from brainDir) — the SAME id the cycle locked + scoped its phases to —
|
||||
// NOT raw opts.sourceId. The autopilot's inline cycle sets brainDir but
|
||||
// passes no explicit sourceId, so keying off opts.sourceId alone never
|
||||
// advanced last_full_cycle_at and cycle_freshness stayed stale even while
|
||||
// the autopilot cycled every interval. Skipped when:
|
||||
// - no source resolves (engine null, or no checkout AND no opts.sourceId)
|
||||
// - status is 'failed' or 'skipped' (don't mark a non-run as fresh)
|
||||
// - dryRun (writes are out of scope)
|
||||
//
|
||||
// Best-effort: a write failure does NOT change the CycleReport status.
|
||||
// The cost of writing the wrong timestamp post-failure is higher than
|
||||
// the cost of missing a successful write (next cycle will redo work).
|
||||
if (opts.sourceId && engine && !dryRun && !aborted && (status === 'ok' || status === 'clean' || status === 'partial')) {
|
||||
if (cycleSourceId && engine && !dryRun && !aborted && (status === 'ok' || status === 'clean' || status === 'partial')) {
|
||||
try {
|
||||
const nowIso = new Date().toISOString();
|
||||
// #2194 fix #3 (the cycle split): `last_source_cycle_at` is the NEW gate
|
||||
@@ -2385,13 +2394,13 @@ export async function runCycle(
|
||||
// phases (those gate on autopilot.last_global_at), so writing it on a
|
||||
// source-only cycle does not re-introduce the freshness poisoning codex
|
||||
// flagged in the rejected skip-based design.
|
||||
await engine.updateSourceConfig(opts.sourceId, {
|
||||
await engine.updateSourceConfig(cycleSourceId, {
|
||||
last_source_cycle_at: nowIso,
|
||||
last_full_cycle_at: nowIso,
|
||||
});
|
||||
} catch (e) {
|
||||
// Best-effort; cycle already succeeded by the time we get here.
|
||||
console.warn(`[cycle] failed to write last_source_cycle_at for source ${opts.sourceId}: ${e instanceof Error ? e.message : String(e)}`);
|
||||
console.warn(`[cycle] failed to write last_source_cycle_at for source ${cycleSourceId}: ${e instanceof Error ? e.message : String(e)}`);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -32,10 +32,6 @@ import {
|
||||
nvidiaEmbeddingDim,
|
||||
nvidiaEmbeddingDimOptions,
|
||||
supportsNvidiaEmbeddingDimension,
|
||||
isPerplexityEmbeddingModel,
|
||||
isValidPerplexityDim,
|
||||
maxPerplexityEmbeddingDim,
|
||||
PERPLEXITY_MIN_DIMS,
|
||||
} from './ai/dims.ts';
|
||||
|
||||
/**
|
||||
@@ -466,15 +462,6 @@ function isCustomDimValidForProvider(
|
||||
`(allowed: ${ZEROENTROPY_VALID_DIMS.join(', ')}).`,
|
||||
};
|
||||
}
|
||||
if (recipe.id === 'perplexity' && isPerplexityEmbeddingModel(modelId)) {
|
||||
if (isValidPerplexityDim(modelId, requestedDims)) return { valid: true, error: '' };
|
||||
return {
|
||||
valid: false,
|
||||
error:
|
||||
`Perplexity ${modelId} accepts dimensions ${PERPLEXITY_MIN_DIMS}..${maxPerplexityEmbeddingDim(modelId)}, ` +
|
||||
`got ${requestedDims}.`,
|
||||
};
|
||||
}
|
||||
if (recipe.id === 'openai' && isOpenAITextEmbedding3Model(modelId)) {
|
||||
if (isValidOpenAITextEmbedding3Dim(modelId, requestedDims)) return { valid: true, error: '' };
|
||||
const maxDim = maxOpenAITextEmbedding3Dim(modelId);
|
||||
|
||||
@@ -40,9 +40,6 @@ export const EMBEDDING_PRICING: Record<string, EmbeddingPricing> = {
|
||||
// Mistral (https://mistral.ai/pricing/api/, verified 2026-07-19)
|
||||
'mistral:mistral-embed': { pricePerMTok: 0.10 },
|
||||
'mistral:mistral-embed-2312': { pricePerMTok: 0.10 },
|
||||
// Perplexity (https://docs.perplexity.ai/getting-started/pricing, verified 2026-07-21)
|
||||
'perplexity:pplx-embed-v1-0.6b': { pricePerMTok: 0.004 },
|
||||
'perplexity:pplx-embed-v1-4b': { pricePerMTok: 0.03 },
|
||||
};
|
||||
|
||||
export type PriceLookupResult =
|
||||
|
||||
@@ -1,142 +0,0 @@
|
||||
/**
|
||||
* #1046 — Perplexity hosted embeddings (pplx-embed-v1-*).
|
||||
*
|
||||
* Covers the three seams the recipe touches:
|
||||
* - recipe registration + auth (PERPLEXITY_API_KEY only, never OPENAI_API_KEY)
|
||||
* - flexible-dim validation (128..native max) in dims.ts + the init
|
||||
* preflight (resolveSchemaEmbeddingDim), incl. the >2000-dim 4b case
|
||||
* - perplexityCompatFetch: forces encoding_format=base64_int8 outbound and
|
||||
* decodes the base64 int8 embedding payload to number[] inbound
|
||||
*/
|
||||
import { afterEach, describe, expect, test } from 'bun:test';
|
||||
import {
|
||||
dimsProviderOptions,
|
||||
isPerplexityEmbeddingModel,
|
||||
isValidPerplexityDim,
|
||||
maxPerplexityEmbeddingDim,
|
||||
} from '../../src/core/ai/dims.ts';
|
||||
import { getRecipe, RECIPES } from '../../src/core/ai/recipes/index.ts';
|
||||
import { perplexity } from '../../src/core/ai/recipes/perplexity.ts';
|
||||
import { defaultResolveAuth, perplexityCompatFetch } from '../../src/core/ai/gateway.ts';
|
||||
import { AIConfigError } from '../../src/core/ai/errors.ts';
|
||||
import { resolveSchemaEmbeddingDim } from '../../src/core/embedding-dim-check.ts';
|
||||
import { lookupEmbeddingPrice } from '../../src/core/embedding-pricing.ts';
|
||||
|
||||
describe('recipe: perplexity', () => {
|
||||
test('registered as an OpenAI-compatible embedding provider', () => {
|
||||
expect(RECIPES.has('perplexity')).toBe(true);
|
||||
expect(getRecipe('perplexity')).toBe(perplexity);
|
||||
expect(perplexity.tier).toBe('openai-compat');
|
||||
expect(perplexity.implementation).toBe('openai-compatible');
|
||||
expect(perplexity.base_url_default).toBe('https://api.perplexity.ai/v1');
|
||||
const e = perplexity.touchpoints.embedding!;
|
||||
expect(e.models).toEqual(['pplx-embed-v1-0.6b', 'pplx-embed-v1-4b']);
|
||||
expect(e.default_dims).toBe(1024);
|
||||
expect(e.max_batch_tokens).toBe(120_000);
|
||||
});
|
||||
|
||||
test('auth is PERPLEXITY_API_KEY bearer — no OPENAI_API_KEY fallback', () => {
|
||||
expect(perplexity.resolveAuth).toBeUndefined();
|
||||
expect(perplexity.auth_env?.required).toEqual(['PERPLEXITY_API_KEY']);
|
||||
expect(defaultResolveAuth(perplexity, { PERPLEXITY_API_KEY: 'fake-pplx' }, 'embedding')).toEqual({
|
||||
headerName: 'Authorization',
|
||||
token: 'Bearer fake-pplx',
|
||||
});
|
||||
// An OPENAI_API_KEY in the env must NOT satisfy Perplexity auth.
|
||||
expect(() => defaultResolveAuth(perplexity, { OPENAI_API_KEY: 'sk-test' }, 'embedding')).toThrow(AIConfigError);
|
||||
});
|
||||
|
||||
test('dims: 128..native-max range per model', () => {
|
||||
expect(isPerplexityEmbeddingModel('pplx-embed-v1-4b')).toBe(true);
|
||||
expect(maxPerplexityEmbeddingDim('pplx-embed-v1-4b')).toBe(2560);
|
||||
expect(maxPerplexityEmbeddingDim('pplx-embed-v1-0.6b')).toBe(1024);
|
||||
expect(isValidPerplexityDim('pplx-embed-v1-4b', 2560)).toBe(true);
|
||||
expect(isValidPerplexityDim('pplx-embed-v1-4b', 128)).toBe(true);
|
||||
expect(isValidPerplexityDim('pplx-embed-v1-4b', 64)).toBe(false);
|
||||
expect(isValidPerplexityDim('pplx-embed-v1-0.6b', 2560)).toBe(false);
|
||||
});
|
||||
|
||||
test('dimsProviderOptions emits native `dimensions`, fails loud out of range', () => {
|
||||
expect(dimsProviderOptions('openai-compatible', 'pplx-embed-v1-4b', 2560)).toEqual({
|
||||
openaiCompatible: { dimensions: 2560 },
|
||||
});
|
||||
// Symmetric provider — inputType never emitted.
|
||||
expect(dimsProviderOptions('openai-compatible', 'pplx-embed-v1-4b', 1024, 'query')).toEqual({
|
||||
openaiCompatible: { dimensions: 1024 },
|
||||
});
|
||||
expect(() => dimsProviderOptions('openai-compatible', 'pplx-embed-v1-0.6b', 2560)).toThrow(AIConfigError);
|
||||
});
|
||||
|
||||
test('init preflight accepts the 4b model at its native 2560 dims (halfvec territory)', () => {
|
||||
const res = resolveSchemaEmbeddingDim({
|
||||
embedding_model: 'perplexity:pplx-embed-v1-4b',
|
||||
embedding_dimensions: 2560,
|
||||
});
|
||||
expect(res).toEqual({
|
||||
ok: true,
|
||||
dim: 2560,
|
||||
model: 'perplexity:pplx-embed-v1-4b',
|
||||
provider: 'perplexity',
|
||||
recipeDefault: 1024,
|
||||
});
|
||||
const bad = resolveSchemaEmbeddingDim({
|
||||
embedding_model: 'perplexity:pplx-embed-v1-4b',
|
||||
embedding_dimensions: 4096,
|
||||
});
|
||||
expect(bad.ok).toBe(false);
|
||||
});
|
||||
|
||||
test('embedding pricing table knows both models', () => {
|
||||
expect(lookupEmbeddingPrice('perplexity:pplx-embed-v1-4b')).toMatchObject({ kind: 'known', pricePerMTok: 0.03 });
|
||||
expect(lookupEmbeddingPrice('perplexity:pplx-embed-v1-0.6b')).toMatchObject({ kind: 'known', pricePerMTok: 0.004 });
|
||||
});
|
||||
});
|
||||
|
||||
describe('perplexityCompatFetch — int8 wire shim', () => {
|
||||
const realFetch = globalThis.fetch;
|
||||
afterEach(() => {
|
||||
globalThis.fetch = realFetch;
|
||||
});
|
||||
|
||||
test('forces encoding_format=base64_int8 outbound and decodes int8 base64 inbound', async () => {
|
||||
const int8 = new Int8Array([3, -7, 127, -128]);
|
||||
const b64 = Buffer.from(int8.buffer).toString('base64');
|
||||
let sentBody: any;
|
||||
globalThis.fetch = (async (_input: any, init?: RequestInit) => {
|
||||
sentBody = JSON.parse(init!.body as string);
|
||||
return new Response(
|
||||
JSON.stringify({
|
||||
object: 'list',
|
||||
model: 'pplx-embed-v1-4b',
|
||||
data: [{ object: 'embedding', index: 0, embedding: b64 }],
|
||||
usage: { prompt_tokens: 4, total_tokens: 4 },
|
||||
}),
|
||||
{ status: 200, headers: { 'content-type': 'application/json' } },
|
||||
);
|
||||
}) as any;
|
||||
|
||||
const resp = await (perplexityCompatFetch as any)('https://api.perplexity.ai/v1/embeddings', {
|
||||
method: 'POST',
|
||||
headers: { 'content-type': 'application/json' },
|
||||
// The AI SDK sends encoding_format:'float' — Perplexity rejects it.
|
||||
body: JSON.stringify({ model: 'pplx-embed-v1-4b', input: ['hi'], encoding_format: 'float', dimensions: 4 }),
|
||||
});
|
||||
|
||||
expect(sentBody.encoding_format).toBe('base64_int8');
|
||||
expect(sentBody.dimensions).toBe(4); // native field, untouched
|
||||
const json = await resp.json();
|
||||
expect(json.data[0].embedding).toEqual([3, -7, 127, -128]);
|
||||
expect(json.usage.prompt_tokens).toBe(4);
|
||||
});
|
||||
|
||||
test('non-JSON and error responses pass through untouched', async () => {
|
||||
globalThis.fetch = (async () =>
|
||||
new Response('nope', { status: 401, headers: { 'content-type': 'text/plain' } })) as any;
|
||||
const resp = await (perplexityCompatFetch as any)('https://api.perplexity.ai/v1/embeddings', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ model: 'pplx-embed-v1-4b', input: ['hi'] }),
|
||||
});
|
||||
expect(resp.status).toBe(401);
|
||||
expect(await resp.text()).toBe('nope');
|
||||
});
|
||||
});
|
||||
@@ -54,6 +54,20 @@ describe('autopilot.ts ↔ dispatchPerSource wiring', () => {
|
||||
expect(AUTOPILOT_SRC).toMatch(/lastFullCycleAt\s*=\s*Date\.now\(\)/);
|
||||
});
|
||||
|
||||
test('stale per-source cycle freshness is a shouldFullCycle input (#2060)', () => {
|
||||
// Targeted mode (score 70–94, plan ≤3, est <300s) must not be able to
|
||||
// starve per-source cycle dispatch: a stale source (per countStaleSources
|
||||
// over listAllSources) forces the fanout path, and the sleep gate must
|
||||
// not fire while stale sources exist. Without these terms, cycle
|
||||
// freshness never advances for a brain that always lands in targeted mode.
|
||||
expect(AUTOPILOT_SRC).toMatch(/countStaleSources/);
|
||||
const fullCycleDeclIdx = AUTOPILOT_SRC.indexOf('const shouldFullCycle');
|
||||
expect(fullCycleDeclIdx).toBeGreaterThan(-1);
|
||||
const decl = AUTOPILOT_SRC.slice(fullCycleDeclIdx, fullCycleDeclIdx + 700);
|
||||
expect(decl).toMatch(/staleCycleSources\s*>\s*0/);
|
||||
expect(decl).toMatch(/const shouldSleep[^;]*staleCycleSources\s*===\s*0/);
|
||||
});
|
||||
|
||||
test('does NOT regress to the single-job dispatch on the full-cycle path', () => {
|
||||
// Pre-PR: the shouldFullCycle branch did:
|
||||
// const job = await queue.add('autopilot-cycle', { repoPath }, {
|
||||
|
||||
@@ -14,6 +14,7 @@ import { describe, test, expect } from 'bun:test';
|
||||
import {
|
||||
readLastFullCycleAt,
|
||||
isSourceStale,
|
||||
countStaleSources,
|
||||
selectSourcesForDispatch,
|
||||
resolveFanoutMax,
|
||||
dispatchPerSource,
|
||||
@@ -74,6 +75,23 @@ describe('isSourceStale', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('countStaleSources (#2060 dispatch-decision input)', () => {
|
||||
const NOW = Date.parse('2026-05-22T12:00:00.000Z');
|
||||
test('counts never-cycled + past-floor sources, ignores fresh', () => {
|
||||
const sources = [
|
||||
src('never-cycled'), // stale (null)
|
||||
src('old', new Date(NOW - 2 * 60 * 60_000).toISOString()), // stale (2h)
|
||||
src('fresh', new Date(NOW - 30 * 60_000).toISOString()), // fresh (30min)
|
||||
];
|
||||
expect(countStaleSources(sources, NOW)).toBe(2);
|
||||
});
|
||||
test('returns 0 for all-fresh and for empty list', () => {
|
||||
const fresh = src('a', new Date(NOW - 10 * 60_000).toISOString());
|
||||
expect(countStaleSources([fresh], NOW)).toBe(0);
|
||||
expect(countStaleSources([], NOW)).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('selectSourcesForDispatch', () => {
|
||||
const NOW = Date.parse('2026-05-22T12:00:00.000Z');
|
||||
const fresh = (id: string, agoMin: number) =>
|
||||
|
||||
@@ -3,8 +3,10 @@
|
||||
* cycles. Closes codex round-1 P0-5 (write site for last_full_cycle_at
|
||||
* was unspecified pre-PR).
|
||||
*
|
||||
* Conditions for write:
|
||||
* - opts.sourceId is set (legacy callers without sourceId skip the write)
|
||||
* Conditions for write (keyed off `cycleSourceId` = opts.sourceId ?? the
|
||||
* source resolved from brainDir, so the autopilot's inline cycle — brainDir
|
||||
* set, no explicit sourceId — also advances the timestamp, #1993):
|
||||
* - a source resolves (explicit sourceId, or brainDir matches a source)
|
||||
* - engine is non-null (no-DB path skips)
|
||||
* - status is 'ok' | 'clean' | 'partial' (failed/skipped don't mark fresh)
|
||||
* - dryRun is false
|
||||
@@ -90,17 +92,45 @@ describe('runCycle last_full_cycle_at exit hook', () => {
|
||||
});
|
||||
});
|
||||
|
||||
test('legacy caller (no sourceId) does NOT write any source timestamp', async () => {
|
||||
test('no explicit sourceId but brainDir resolves a source → writes the resolved source timestamp', async () => {
|
||||
await withEnv({ GBRAIN_HOME: gbrainHome }, async () => {
|
||||
await seedSource('default-like');
|
||||
// No sourceId passed; should remain untouched.
|
||||
// The autopilot's inline cycle sets brainDir but passes no sourceId.
|
||||
// runCycle resolves the source from brainDir (local_path match) into
|
||||
// cycleSourceId and stamps last_full_cycle_at for it — otherwise
|
||||
// cycle_freshness reports the brain stale even while the autopilot
|
||||
// cycles every interval (#1993).
|
||||
await seedSource('resolved-from-dir'); // local_path = brainDir
|
||||
expect(await readLastFullCycleAt('resolved-from-dir')).toBeNull();
|
||||
|
||||
const t0 = Date.now();
|
||||
const report = await runCycle(engine, {
|
||||
brainDir,
|
||||
phases: ['lint'],
|
||||
});
|
||||
expect(['ok', 'clean']).toContain(report.status);
|
||||
|
||||
const after = await readLastFullCycleAt('resolved-from-dir');
|
||||
expect(after).not.toBeNull();
|
||||
expect(new Date(after!).getTime()).toBeGreaterThanOrEqual(t0);
|
||||
});
|
||||
});
|
||||
|
||||
test('no sourceId and brainDir matches no source → does not write', async () => {
|
||||
await withEnv({ GBRAIN_HOME: gbrainHome }, async () => {
|
||||
// A source exists but its local_path does NOT match brainDir, so
|
||||
// resolveSourceForDir returns undefined, cycleSourceId is undefined,
|
||||
// and no per-source timestamp is written.
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO sources (id, name, local_path, config, archived, created_at)
|
||||
VALUES ('unmatched', 'unmatched', '/no/such/repo', '{}'::jsonb, false, NOW())
|
||||
ON CONFLICT (id) DO UPDATE SET local_path = EXCLUDED.local_path`,
|
||||
[],
|
||||
);
|
||||
await runCycle(engine, {
|
||||
brainDir,
|
||||
phases: ['lint'],
|
||||
});
|
||||
// No per-source write happens; default source's config stays empty.
|
||||
const after = await readLastFullCycleAt('default-like');
|
||||
expect(after).toBeNull();
|
||||
expect(await readLastFullCycleAt('unmatched')).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
Reference in New Issue
Block a user