pi-memory-evolution 0.2.3 → 0.2.5

package/src/memory/processing-state.ts

@@ -1,24 +1,65 @@
 import type { Database } from './sqlite.ts';
 import { fingerprint } from './privacy.ts';
-import { CALL_WINDOW_MS, MAX_CALLS_PER_WINDOW, FAILURE_WINDOW_MS, MAX_WINDOW_FAILURES, NOTICE_COOLDOWN_MS } from './recovery.ts';
+import { CALL_WINDOW_MS, FAILURE_WINDOW_MS, MAX_WINDOW_FAILURES, NOTICE_COOLDOWN_MS, type FailureCode } from './recovery.ts';
+import { DEFAULT_POLICY, type RoutingPolicy } from './routing-policy.ts';
+import type { Diagnostic } from './diagnostics.ts';
 
-/** Called inside the store's write transaction, so multiple Pi processes share one budget. */
-export function budgetUntil(db: Database, model: string, now: number): number {
- const calls = db.prepare('SELECT at FROM model_calls WHERE model=? AND at>? ORDER BY at DESC').all(model, now - CALL_WINDOW_MS);
- const failures = db.prepare("SELECT finished_at AS at FROM model_calls WHERE model=? AND outcome='failed' AND finished_at>? ORDER BY finished_at DESC")
+export interface CallPricing { input: number; output: number; cacheRead: number; cacheWrite: number; tiers?: { input: number; output: number; cacheRead: number; cacheWrite: number }[] }
+export interface CallOptions { provider: string; pricing?: CallPricing; outputTokens?: number; promptBytes?: number }
+export function estimatedCost(inputBytes: number, options?: CallOptions): number | null {
+ const rates = options?.pricing ? [options.pricing, ...(options.pricing.tiers ?? [])] : [];
+ if (!rates.length || rates.some(r => ![r.input,r.output,r.cacheRead,r.cacheWrite].every(n => Number.isFinite(n) && n >= 0))) return null;
+ const input = Math.max(...rates.flatMap(r => [r.input,r.cacheRead,r.cacheWrite]));
+ const output = Math.max(...rates.map(r => r.output));
+ // All-zero custom catalog pricing is frequently missing, not proof of a free account.
+ if (!input && !output) return null;
+ return ((inputBytes + (options?.promptBytes ?? 20_000)) * input + (options?.outputTokens ?? 8192) * output) / 1_000_000;
+}
+/** Atomic callers share the hard request ceiling across models/providers and Pi processes. */
+export function budgetUntil(db: Database, model: string, now: number, policy: RoutingPolicy = DEFAULT_POLICY, reserveUsd?: number | null): number {
+ const calls = db.prepare('SELECT at FROM model_calls WHERE at>? ORDER BY at DESC').all(now - CALL_WINDOW_MS);
+ const failures = db.prepare("SELECT finished_at AS at FROM model_calls WHERE model=? AND outcome='failed' AND code IN ('provider','timeout','interrupted') AND finished_at>? ORDER BY finished_at DESC")
   .all(model, now - FAILURE_WINDOW_MS);
- return Math.max(calls.length >= MAX_CALLS_PER_WINDOW ? Number(calls[MAX_CALLS_PER_WINDOW - 1].at) + CALL_WINDOW_MS : 0,
+ let until = Math.max(calls.length >= policy.callsPerHour ? Number(calls[policy.callsPerHour - 1].at) + CALL_WINDOW_MS : 0,
   failures.length >= MAX_WINDOW_FAILURES ? Number(failures[MAX_WINDOW_FAILURES - 1].at) + FAILURE_WINDOW_MS : 0);
+ if (policy.dailyEstimatedUsd !== null) {
+  const day = db.prepare('SELECT at,reserved_usd,charged_usd FROM model_calls WHERE at>? ORDER BY at').all(now - 86_400_000);
+  const cost = day.reduce((sum, r) => sum + Number(r.charged_usd ?? r.reserved_usd ?? 0), 0);
+  if (reserveUsd === null || day.some(r => r.charged_usd === null && r.reserved_usd === null)
+   || cost + (reserveUsd ?? 0) > policy.dailyEstimatedUsd) until = Math.max(until, Number(day[0]?.at ?? now) + 86_400_000);
+ }
+ return until;
 }
-export function reserveCall(db: Database, source: string, attempt: number, model: string, now: number): void {
- // Retain at most a day's operational receipts, not model bodies or token-level traces.
+export function reserveCall(db: Database, source: string, attempt: number, model: string, now: number, provider = model.split('/')[0], reserveUsd: number | null = null): void {
  db.prepare("DELETE FROM model_calls WHERE at<? AND outcome!='running'").run(now - 86_400_000);
- db.prepare('INSERT INTO model_calls(source_id,attempt,model,at) VALUES (?,?,?,?)').run(source, attempt, model, now);
+ db.prepare('INSERT INTO model_calls(source_id,attempt,model,provider,at,reserved_usd) VALUES (?,?,?,?,?,?)').run(source, attempt, model, provider, now, reserveUsd);
+}
+export function finishCall(db: Database, source: string, attempt: number, outcome: 'done' | 'failed' | 'cancelled', now: number, code: FailureCode | '' = '', diagnostic: Diagnostic = {}): void {
+ const row = db.prepare("SELECT at,model,provider FROM model_calls WHERE source_id=? AND attempt=? AND outcome='running'").get(source, attempt);
+ if (!row) return;
+ // Zero usage on an error/timeout is not a receipt proving a request was free.
+ const reported = diagnostic.reportedUsd !== undefined && (outcome === 'done' || diagnostic.inputTokens || diagnostic.outputTokens) ? diagnostic.reportedUsd : null;
+ db.prepare("UPDATE model_calls SET outcome=?,finished_at=?,code=?,charged_usd=?,input_tokens=?,output_tokens=? WHERE source_id=? AND attempt=?")
+  .run(outcome, now, code, reported, diagnostic.inputTokens ?? null, diagnostic.outputTokens ?? null, source, attempt);
+ db.prepare('UPDATE sources SET call_ms=call_ms+? WHERE id=?').run(Math.max(0, now - Number(row.at)), source);
+ if (outcome !== 'failed' || !code) return;
+ let scope = '', delay = 0;
+ if (['auth','quota','rate_limit'].includes(code)) {
+  scope = `provider:${row.provider}`;
+  delay = code === 'auth' ? 900_000 : code === 'quota' ? 3_600_000 : 60_000;
+ } else if (['request','context_limit'].includes(code)) { scope = `model:${row.model}`; delay = 3_600_000; }
+ else if (['provider','timeout','interrupted','invalid_output','output_limit'].includes(code)) {
+  const family = ['invalid_output','output_limit'].includes(code) ? "'invalid_output','output_limit'" : "'provider','timeout','interrupted'";
+  const count = Number(db.prepare(`SELECT COUNT(*) AS n FROM model_calls WHERE model=? AND outcome='failed' AND code IN (${family}) AND finished_at>?`).get(row.model, now - FAILURE_WINDOW_MS)!.n);
+  if (count >= 2) { scope = `model:${row.model}`; delay = FAILURE_WINDOW_MS; }
+ }
+ if (scope) db.prepare('INSERT INTO route_health VALUES (?,?,?) ON CONFLICT(id) DO UPDATE SET until=MAX(until,excluded.until),code=excluded.code')
+  .run(scope, now + Math.max(delay, diagnostic.retryAfterMs ?? 0), code);
 }
-export function finishCall(db: Database, source: string, attempt: number, outcome: 'done' | 'failed' | 'cancelled', now: number): void {
- db.prepare("UPDATE model_calls SET outcome=?,finished_at=? WHERE source_id=? AND attempt=? AND outcome='running'").run(outcome, now, source, attempt);
+export function routeUntil(db: Database, model: string, provider: string, now: number): number {
+ const row = db.prepare('SELECT MAX(until) AS until FROM route_health WHERE id IN (?,?)').get(`model:${model}`, `provider:${provider}`);
+ return Math.max(now, Number(row?.until ?? 0));
 }
-/** Fixed keys/hashes only; atomic callers prevent duplicate warnings across reload/processes. */
 export function takeNotice(db: Database, identity: string, now: number): boolean {
  const key = fingerprint(identity);
  db.prepare('DELETE FROM recovery_notices WHERE at<=?').run(now - NOTICE_COOLDOWN_MS);

package/src/memory/progress-targets.ts

@@ -25,7 +25,7 @@ export function nominateProgress(memories: readonly DurableMemory[], input: { sc
   const body = features(memory.content), aliases = features((memory.searchTerms ?? []).join(' '));
   let resourceScore = 0, resourceReason = '', resourceConflict = false;
   for (const resource of resources) {
-   const path = resource.path.toLowerCase();
+   const path = resource.path; // Do not merge case-distinct files/directories on the host.
    const literals = [...body].filter(w => w.startsWith('literal:/')).map(w => w.slice(8));
    const exact = literals.some(l => l === path || (resource.kind === 'directory' && l.startsWith(path + '/')));
    const named = resource.kind === 'directory' && names(memory.content, resource.name);

package/src/memory/recovery.ts

@@ -6,16 +6,16 @@ export const EVOLUTION_MAX_TOKENS = 8192;
 export const RECOVERY_POLL_MS = 15_000;
 export const LEASE_GRACE_MS = 30_000;
 export const MAX_FAILURES = 5;
-export const MAX_OUTPUT_FAILURES = 2;
+export const MAX_OUTPUT_FAILURES = 3; // Initial output, one correction, at most one alternate model.
 export const CALL_WINDOW_MS = 3_600_000;
 export const MAX_CALLS_PER_WINDOW = 20;
 export const FAILURE_WINDOW_MS = 900_000;
 export const MAX_WINDOW_FAILURES = 5;
 export const NOTICE_COOLDOWN_MS = 3_600_000;
-export const PAUSED_SQL = `(failures>=${MAX_FAILURES} OR output_failures>=${MAX_OUTPUT_FAILURES} OR last_error IN ('write_rejected','unavailable','auth','request'))`;
+export const PAUSED_SQL = `(failures>=${MAX_FAILURES} OR output_failures>=${MAX_OUTPUT_FAILURES} OR last_error IN ('write_rejected','unavailable','safety'))`;
 const RETRY_DELAYS_MS = [60_000, 300_000, 900_000, 3_600_000];
 
-export const FAILURE_CODES = ["timeout", "cancelled", "output_limit", "invalid_output", "stale", "write_rejected", "unavailable", "provider", "auth", "request", "rate_limit", "interrupted", "unknown"] as const;
+export const FAILURE_CODES = ["timeout", "cancelled", "output_limit", "invalid_output", "stale", "write_rejected", "unavailable", "provider", "auth", "request", "rate_limit", "quota", "context_limit", "safety", "interrupted", "unknown"] as const;
 export type FailureCode = typeof FAILURE_CODES[number];
 
 /** Never persist raw exception messages/provider bodies (they may contain secrets). */

package/src/memory/routing-policy.ts

@@ -0,0 +1,31 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/** Extension policy only: model catalog, credentials and the default model belong to Pi. */
+export interface RoutingPolicy {
+ crossProviderFallback: boolean;
+ fallbackModels: string[];
+ callsPerHour: number;
+ sourceCalls: number;
+ sourceModels: number;
+ timeoutMs: number;
+ sourceTimeMs: number;
+ dailyEstimatedUsd: number | null;
+}
+export const DEFAULT_POLICY: RoutingPolicy = {
+ crossProviderFallback: true, fallbackModels: [], callsPerHour: 20, sourceCalls: 4, sourceModels: 2,
+ timeoutMs: 120_000, sourceTimeMs: 300_000, dailyEstimatedUsd: null,
+};
+export function loadRoutingPolicy(dir: string): RoutingPolicy {
+ let value: unknown;
+ try { const text = readFileSync(join(dir, 'recovery.json'), 'utf8'); if (Buffer.byteLength(text) > 8192) throw new Error(); value = JSON.parse(text); }
+ catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { ...DEFAULT_POLICY, fallbackModels: [] }; throw new Error('Invalid recovery.json'); }
+ if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid recovery.json');
+ const p = { ...DEFAULT_POLICY, ...value } as RoutingPolicy;
+ const bounds = { callsPerHour: [1, 1000], sourceCalls: [1, 8], sourceModels: [1, 3], timeoutMs: [1000, 120_000], sourceTimeMs: [1000, 600_000] };
+ if (Object.keys(value).some(k => !Object.hasOwn(DEFAULT_POLICY, k)) || typeof p.crossProviderFallback !== 'boolean'
+  || !Array.isArray(p.fallbackModels) || p.fallbackModels.length > 16 || !p.fallbackModels.every(m => typeof m === 'string' && m.length <= 200 && /^[^\s/]+\/.+$/u.test(m))
+  || Object.entries(bounds).some(([k, [min, max]]) => !Number.isSafeInteger(p[k as keyof typeof bounds]) || p[k as keyof typeof bounds] < min || p[k as keyof typeof bounds] > max)
+  || (p.dailyEstimatedUsd !== null && (!Number.isFinite(p.dailyEstimatedUsd) || p.dailyEstimatedUsd <= 0 || p.dailyEstimatedUsd > 1000))) throw new Error('Invalid recovery.json');
+ return p;
+}

package/src/memory/scheduler.ts

@@ -0,0 +1,64 @@
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import { completeMemory, type CompleteMemory } from '../adapter/pi-api.ts';
+import { modelLabel } from './diagnostics.ts';
+import { evolve } from './evolution.ts';
+import { failureCode } from './recovery.ts';
+import type { MemoryStore, RetryMode } from './memory-store.ts';
+
+type Model = NonNullable<ExtensionContext['model']>;
+export const modelKey = (model: Model): string => modelLabel(`${model.provider}/${model.id}`);
+/** Catalog lookup only: no paid probes, credential reads, or changes to the foreground model. */
+export function routeCandidates(ctx: ExtensionContext, store: MemoryStore): Model[] {
+ const primary = ctx.model;
+ if (!primary) return [];
+ if (!store.policy.crossProviderFallback) return [primary];
+ const available = typeof ctx.modelRegistry?.getAvailable === 'function' ? ctx.modelRegistry.getAvailable() : [];
+ const order = store.policy.fallbackModels;
+ const price = (m: Model) => m.cost && m.cost.input + m.cost.output > 0 ? m.cost.input + m.cost.output : Infinity;
+ const fallback = available.filter(m => m.provider !== primary.provider && m.input?.includes('text') && ((m as Model & { output?: string[] }).output?.includes('text') ?? true)
+  && (!order.length || order.includes(modelKey(m))))
+  .sort((a,b) => (order.length ? order.indexOf(modelKey(a)) - order.indexOf(modelKey(b)) : price(a) - price(b))
+   || (a.reasoning === b.reasoning ? 0 : a.reasoning ? 1 : -1) || modelKey(a).localeCompare(modelKey(b)));
+ return [primary, ...[...new Map(fallback.map(m => [modelKey(m),m])).values()].slice(0,32)];
+}
+function contextFor(ctx: ExtensionContext, model: Model): ExtensionContext {
+ const child = Object.create(ctx) as ExtensionContext;
+ Object.defineProperty(child, 'model', { value: model });
+ return child;
+}
+/** At most two immediate attempts. Delayed retries are persisted, never sleeping in the queue. */
+export async function evolveRouted(store: MemoryStore, id: string, ctx: ExtensionContext, signal: AbortSignal,
+ complete: CompleteMemory = completeMemory, retry: RetryMode = false, timeoutMs = store.policy.timeoutMs): Promise<boolean> {
+ const candidates = routeCandidates(ctx, store);
+ // Preserve the single-model/old-host error path and dependency-injected test seam.
+ if (!candidates.length) return evolve(store, id, ctx, signal, complete, retry, timeoutMs);
+ const attempted = new Set<string>();
+ let lastError: unknown;
+ for (let pass = 0; pass < (retry === true ? 1 : 2); pass++) {
+  signal.throwIfAborted();
+  const info = store.routingInfo(id);
+  const candidate = candidates.find(m => !attempted.has(modelKey(m))
+   && (retry === true || (store.routeAvailable(modelKey(m), m.provider)
+    && !(info.outputFailures >= 2 && info.model === modelKey(m) && ['invalid_output','output_limit'].includes(info.error))
+    && (info.models.includes(modelKey(m)) || info.models.length < store.policy.sourceModels))));
+  if (!candidate) break;
+  attempted.add(modelKey(candidate));
+  try {
+   // Only a known route failure justifies bypassing source backoff for an alternate model.
+   const result = await evolve(store, id, contextFor(ctx, candidate), signal, complete, pass ? 'fallback' : retry, timeoutMs);
+   if (result) return true;
+   // A concurrent claim, terminal source or shared budget rejection cannot authorize another call.
+   break;
+  } catch (error) {
+   lastError = error;
+   const code = failureCode(error, signal);
+   const reroute = ['auth','quota','rate_limit','request','context_limit'].includes(code)
+    || (['provider','timeout','invalid_output','output_limit','interrupted'].includes(code)
+     && !store.routeAvailable(modelKey(candidate), candidate.provider));
+   if (!reroute || retry === true || signal.aborted) throw error;
+  }
+ }
+ store.checked(id); // Round-robin past sources waiting on unavailable routes, without consuming attempts.
+ if (lastError) throw lastError;
+ return false;
+}

package/src/memory/search.ts

@@ -61,7 +61,7 @@ export function features(text: string, includeSingle = false): Set<string> {
 	const result = new Set<string>();
 	let prose = redact(text).replace(/\[REDACTED[^\]\n]*\]/gu, " ");
 	prose = prose.replace(LITERALS, (literal) => {
-		const clean = literal.replace(/[.:]+$/u, "").toLowerCase();
+		const clean = literal.replace(/[.:]+$/u, ''); // Literal resource identity is case-sensitive, unlike prose.
 		result.add(`literal:${clean}`);
 		result.add(`literal:${clean.split("/").at(-1)}`);
 		return " ";
@@ -94,7 +94,7 @@ export function featureOffset(text: string, feature: string): number {
 		pattern.lastIndex = 0;
 		return pattern.exec(prose)?.index ?? -1;
 	}
-	return prose.toLowerCase().indexOf(feature.replace(/^literal:/u, ""));
+	return feature.startsWith('literal:') ? text.indexOf(feature.slice(8)) : prose.toLowerCase().indexOf(feature);
 }
 
 export function validSearchTerms(value: unknown): value is string[] | undefined {