ai-runtime-engine 1.3.0 → 2.8.0

package/dist/config/defaults.d.ts

@@ -24,9 +24,11 @@ export interface ResolvedConfig {
     privacy: ResolvedPrivacy;
     telemetry: {
         enabled: boolean;
-        sink: 'memory' | 'file';
+        sink: 'memory' | 'file' | 'otlp';
         storePrompts: false;
         path?: string;
+        endpoint?: string;
+        headersEnv?: string;
     };
     learning: {
         enabled: boolean;

package/dist/config/defaults.js

@@ -33,6 +33,8 @@ export function resolveConfig(cfg) {
         sink: cfg.telemetry?.sink ?? 'memory',
         storePrompts: false,
         ...(cfg.telemetry?.path !== undefined ? { path: cfg.telemetry.path } : {}),
+        ...(cfg.telemetry?.endpoint !== undefined ? { endpoint: cfg.telemetry.endpoint } : {}),
+        ...(cfg.telemetry?.headersEnv !== undefined ? { headersEnv: cfg.telemetry.headersEnv } : {}),
     };
     return {
         providers: cfg.providers,

package/dist/config/schema.d.ts

@@ -6,4 +6,5 @@
 import type { RouterConfig } from '../types.js';
 /** Canonical strategy names. Exported for reuse by the runtime-config layer (no duplication). */
 export declare const STRATEGIES: readonly ["best", "fastest", "cheapest", "highest-quality", "local-only", "cloud-only", "privacy-first", "provider-specific", "fallback-only"];
+export declare const KEY_LIKE: RegExp;
 export declare function parseConfig(raw: unknown): RouterConfig;

package/dist/config/schema.js

@@ -10,7 +10,7 @@ export const STRATEGIES = ['best', 'fastest', 'cheapest', 'highest-quality', 'lo
 const EVIDENCE = ['unsupported', 'unknown', 'inferred', 'documented', 'verified'];
 const GROUPS = ['input', 'output', 'intelligence', 'agent'];
 const KINDS = ['openai-compatible', 'gemini', 'groq', 'anthropic', 'ollama', 'custom', 'mock'];
-const KEY_LIKE = /^(sk-|gsk_|Bearer\s|[A-Za-z0-9_-]{40,}$)/;
+export const KEY_LIKE = /^(sk-|gsk_|Bearer\s|[A-Za-z0-9_-]{40,}$)/;
 const capabilityRequirement = z.object({
     group: z.enum(GROUPS),
     key: z.string().min(1),
@@ -64,7 +64,7 @@ const routerConfig = z
         .object({ allowCloud: z.boolean().optional(), allowLocal: z.boolean().optional(), sensitiveDataAllowedOnCloud: z.boolean().optional(), treatUnknownAsSensitive: z.boolean().optional(), defaultSensitivity: z.enum(['low', 'high', 'unknown']).optional() })
         .strict()
         .optional(),
-    telemetry: z.object({ enabled: z.boolean().optional(), sink: z.enum(['memory', 'file']).optional(), storePrompts: z.literal(false).optional(), path: z.string().optional() }).strict().optional(),
+    telemetry: z.object({ enabled: z.boolean().optional(), sink: z.enum(['memory', 'file', 'otlp']).optional(), storePrompts: z.literal(false).optional(), path: z.string().optional(), endpoint: z.string().optional(), headersEnv: z.string().refine((v) => v === undefined || !KEY_LIKE.test(v), { message: 'headersEnv must be an env-var NAME, not a header/token value' }).optional() }).strict().optional(),
     tasks: z.array(taskDefinition).optional(),
 })
     .strict();

package/dist/context/lossVerifier.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Model-based context-loss verification (Phase 16) — an OPT-IN rung ON TOP OF the deterministic
+ * `validate()` in the compiler. After the sync `compileContext` runs, this asks a model "does the compiled
+ * context drop anything task-critical that was in the originals?" and returns a single check that the caller
+ * APPENDS to `validation.checks`. It NEVER blocks: any budget/parse/model problem yields an `ok:true`
+ * `inconclusive` check, and the deterministic `validation.ok` is untouched. Both the originals and the
+ * compiled text are `wrapUntrusted`-fenced — they are data to inspect, never instructions.
+ */
+import type { AI } from '../plugin/ai.js';
+import type { ContextBlock, CompiledContext } from './compiler.js';
+export interface VerifyLossInput {
+    ai: AI;
+    /** The ORIGINAL blocks handed to the compiler (pre-compression). */
+    blocks: ContextBlock[];
+    /** The compiler's output (its `system` string is what will actually be sent). */
+    compiled: CompiledContext;
+}
+/** The check appended to `ContextValidation.checks`. `ok:false` means the model flagged task-critical loss. */
+export type LossCheck = {
+    name: 'model-loss-verify';
+    ok: boolean;
+    why?: string;
+};
+export declare function verifyContextLoss(input: VerifyLossInput): Promise<LossCheck>;

package/dist/context/lossVerifier.js

@@ -0,0 +1,45 @@
+/**
+ * Model-based context-loss verification (Phase 16) — an OPT-IN rung ON TOP OF the deterministic
+ * `validate()` in the compiler. After the sync `compileContext` runs, this asks a model "does the compiled
+ * context drop anything task-critical that was in the originals?" and returns a single check that the caller
+ * APPENDS to `validation.checks`. It NEVER blocks: any budget/parse/model problem yields an `ok:true`
+ * `inconclusive` check, and the deterministic `validation.ok` is untouched. Both the originals and the
+ * compiled text are `wrapUntrusted`-fenced — they are data to inspect, never instructions.
+ */
+import { wrapUntrusted } from '../tools/untrusted.js';
+import { extractJson } from '../util/extractJson.js';
+export async function verifyContextLoss(input) {
+    const inconclusive = (why) => ({ name: 'model-loss-verify', ok: true, why: `inconclusive: ${why}` });
+    try {
+        // Only critical/high blocks carry task-critical information worth verifying.
+        const important = input.blocks.filter((b) => b.retention === 'critical' || b.retention === 'high');
+        if (important.length === 0)
+            return inconclusive('no task-critical blocks to verify');
+        const originals = important.map((b) => `[${b.retention}:${b.id}] ${b.resolveContent ? b.resolveContent() : b.text}`).join('\n');
+        const prompt = `You verify whether a COMPILED model context dropped anything task-critical from the ORIGINAL blocks.\n\n` +
+            `ORIGINAL task-critical blocks:\n${wrapUntrusted('context-originals', originals)}\n\n` +
+            `COMPILED context that will be sent:\n${wrapUntrusted('context-compiled', input.compiled.system)}\n\n` +
+            `Reply ONLY with JSON: {"lost": true|false, "items": ["<short phrase>", ...]}. Set "lost" true ONLY if ` +
+            `something task-critical present in the originals is ABSENT or corrupted in the compiled context.`;
+        const result = await input.ai.run({
+            task: 'chat',
+            input: { text: prompt },
+            system: 'You are a context-loss verifier. Respond only with the requested JSON.',
+            output: { format: 'json' },
+            requirements: { intelligence: ['reasoning'], output: ['json'] },
+        });
+        if (!result.ok || !result.response)
+            return inconclusive('verifier run did not complete');
+        const verdict = (result.response.json ?? extractJson(result.response.text ?? ''));
+        if (typeof verdict?.lost !== 'boolean')
+            return inconclusive('verifier response was not parseable JSON');
+        if (!verdict.lost)
+            return { name: 'model-loss-verify', ok: true, why: 'model found no task-critical loss' };
+        const items = Array.isArray(verdict.items) ? verdict.items.filter((x) => typeof x === 'string').slice(0, 5) : [];
+        return { name: 'model-loss-verify', ok: false, why: items.length ? `model flagged omissions: ${items.join('; ')}` : 'model flagged task-critical loss' };
+    }
+    catch {
+        // A verifier problem must never break a run — report it as inconclusive, leave validation.ok alone.
+        return inconclusive('verifier error');
+    }
+}

package/dist/context/summarize.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Opt-in abstractive summarization pre-pass (Phase 16) — runs BEFORE `compileContext`. For non-critical
+ * blocks (`high`/`normal`) whose estimate exceeds their fair share of the budget, it asks a model for a
+ * shorter text and swaps it in. `critical` and `discardable` blocks are NEVER summarized (critical must stay
+ * verbatim; discardable is dropped by the compiler anyway). Originals are never mutated — a new block array
+ * is returned. Any model failure, or a "summary" that does not actually shrink the block, keeps the original
+ * (the compiler's deterministic truncation then handles it, exactly as before). Content is `wrapUntrusted`-
+ * fenced. Absent config ⇒ this never runs and the compiler sees the original blocks.
+ */
+import type { AI } from '../plugin/ai.js';
+import type { ContextBlock } from './compiler.js';
+import { TokenEstimator } from './tokens.js';
+export interface SummarizeInput {
+    ai: AI;
+    blocks: ContextBlock[];
+    budgetTokens: number;
+    estimator?: TokenEstimator;
+}
+export declare function summarizeOverBudget(input: SummarizeInput): Promise<ContextBlock[]>;

package/dist/context/summarize.js

@@ -0,0 +1,53 @@
+/**
+ * Opt-in abstractive summarization pre-pass (Phase 16) — runs BEFORE `compileContext`. For non-critical
+ * blocks (`high`/`normal`) whose estimate exceeds their fair share of the budget, it asks a model for a
+ * shorter text and swaps it in. `critical` and `discardable` blocks are NEVER summarized (critical must stay
+ * verbatim; discardable is dropped by the compiler anyway). Originals are never mutated — a new block array
+ * is returned. Any model failure, or a "summary" that does not actually shrink the block, keeps the original
+ * (the compiler's deterministic truncation then handles it, exactly as before). Content is `wrapUntrusted`-
+ * fenced. Absent config ⇒ this never runs and the compiler sees the original blocks.
+ */
+import { TokenEstimator } from './tokens.js';
+import { wrapUntrusted } from '../tools/untrusted.js';
+export async function summarizeOverBudget(input) {
+    const estimator = input.estimator ?? new TokenEstimator();
+    const compressible = input.blocks.filter((b) => b.retention === 'high' || b.retention === 'normal');
+    if (compressible.length === 0)
+        return input.blocks;
+    // Fair share: the budget split across the compressible blocks. Only those exceeding it are summarized.
+    const share = Math.max(1, Math.floor(Math.max(0, input.budgetTokens) / compressible.length));
+    const out = [];
+    for (const b of input.blocks) {
+        if (b.retention !== 'high' && b.retention !== 'normal') {
+            out.push(b); // critical stays verbatim; discardable is the compiler's to drop
+            continue;
+        }
+        const full = b.resolveContent ? b.resolveContent() : b.text;
+        if (estimator.estimate(full) <= share) {
+            out.push(b); // already within its share — nothing to gain
+            continue;
+        }
+        try {
+            const prompt = `Summarize the following content to about ${share} tokens or fewer, preserving EVERY identifier, ` +
+                `file path, number, and task-critical fact. Output ONLY the summary text.\n\n${wrapUntrusted(`block:${b.id}`, full)}`;
+            const result = await input.ai.run({
+                task: 'chat',
+                input: { text: prompt },
+                system: 'You compress context while preserving task-critical facts and identifiers. Output only the summary text.',
+                requirements: { intelligence: ['reasoning'], output: ['text'] },
+            });
+            const summary = result.ok ? (result.response?.text ?? '').trim() : '';
+            // Accept only a summary that genuinely shrinks the block; otherwise keep the original.
+            if (summary && estimator.estimate(summary) < estimator.estimate(full)) {
+                out.push({ ...b, text: summary, ...(b.resolveContent ? { resolveContent: () => summary } : {}) });
+            }
+            else {
+                out.push(b);
+            }
+        }
+        catch {
+            out.push(b); // model failure → keep the original; the compiler truncates deterministically as before
+        }
+    }
+    return out;
+}

package/dist/core/fallback/fallback.d.ts

@@ -11,6 +11,7 @@ import type { RequestTemplate } from '../router/normalize.js';
 import { AIError } from './errors.js';
 import type { BudgetTracker } from '../policies/budget.js';
 import type { Clock } from '../../util/clock.js';
+import type { KeyedSemaphore } from '../../util/semaphore.js';
 export interface FallbackInput {
     ranked: ScoredCandidate[];
     template: RequestTemplate;
@@ -28,6 +29,10 @@ export interface FallbackInput {
     budget?: BudgetTracker;
     /** Estimated USD cost of a candidate call, consulted before spending (used with `budget`). */
     costOf?: (providerId: string, model: string) => Promise<number>;
+    /** Phase 19: optional per-provider in-flight limiter, SHARED across concurrent router calls. Bounds how
+     *  many calls to a given provider run at once (this fallback walks candidates sequentially, so it only
+     *  bites under fan-out). Absent / unlimited ⇒ a zero-overhead pass-through. */
+    providerLimiter?: KeyedSemaphore;
 }
 export type FallbackResult = {
     ok: true;

package/dist/core/fallback/fallback.js

@@ -34,7 +34,9 @@ export async function runWithFallback(input) {
         tried += 1;
         const started = clock.now();
         const request = buildRequest(input.template, model.id, input.signal);
-        const outcome = await executeOnce(provider, request, input.onDelta);
+        const outcome = input.providerLimiter
+            ? await input.providerLimiter.run(providerId, () => executeOnce(provider, request, input.onDelta))
+            : await executeOnce(provider, request, input.onDelta);
         const latencyMs = clock.now() - started;
         input.budget?.recordCall(estCost);
         if (outcome.ok) {

package/dist/core/router/router.d.ts

@@ -14,6 +14,7 @@ import type { PerformanceStore } from '../../learning/performanceStore.js';
 import type { CapabilityOverlay } from '../capabilities/overlay.js';
 import type { Clock } from '../../util/clock.js';
 import type { RunRequest, RunResult } from '../../types.js';
+import type { KeyedSemaphore } from '../../util/semaphore.js';
 export interface RouterDeps {
     registry: ProviderRegistry;
     tasks: TaskRegistry;
@@ -23,6 +24,8 @@ export interface RouterDeps {
     performance?: PerformanceStore;
     overlay?: CapabilityOverlay;
     clock?: Clock;
+    /** Phase 19: shared per-provider in-flight limiter, forwarded to fallback (bounds concurrent calls to a provider). */
+    providerLimiter?: KeyedSemaphore;
 }
 export declare class Router {
     private readonly deps;

package/dist/core/router/router.js

@@ -144,6 +144,7 @@ export class Router {
             ...(template.stream && req.onDelta ? { onDelta: req.onDelta } : {}),
             validate: (response) => validateResponse({ response, ...(template.output ? { output: template.output } : {}), ...(template.tools ? { tools: template.tools } : {}) }),
             ...(budget ? { budget, costOf } : {}),
+            ...(this.deps.providerLimiter ? { providerLimiter: this.deps.providerLimiter } : {}),
         });
         baseReport.attempts = fb.attempts;
         const fallbackCount = Math.max(0, fb.attempts.length - 1);