@xopcai/xopc 0.0.202 → 0.0.204

package/dist/src/agent-manifest/schema.d.ts

@@ -250,11 +250,16 @@ export declare const RuntimePolicySchema: z.ZodOptional<z.ZodObject<{
     maxTurns: z.ZodOptional<z.ZodNumber>;
     timeoutMs: z.ZodOptional<z.ZodNumber>;
     maxToolFailuresPerTurn: z.ZodOptional<z.ZodNumber>;
-    promptCacheRetention: z.ZodOptional<z.ZodEnum<{
-        none: "none";
-        short: "short";
-        long: "long";
-    }>>;
+    promptCache: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            auto: "auto";
+        }>>;
+        lifetime: z.ZodDefault<z.ZodEnum<{
+            short: "short";
+            long: "long";
+        }>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>>;
 export declare const PromptPolicySchema: z.ZodOptional<z.ZodObject<{
     customInstructions: z.ZodOptional<z.ZodString>;
@@ -399,11 +404,16 @@ export declare const AgentManifestSchema: z.ZodObject<{
         maxTurns: z.ZodOptional<z.ZodNumber>;
         timeoutMs: z.ZodOptional<z.ZodNumber>;
         maxToolFailuresPerTurn: z.ZodOptional<z.ZodNumber>;
-        promptCacheRetention: z.ZodOptional<z.ZodEnum<{
-            none: "none";
-            short: "short";
-            long: "long";
-        }>>;
+        promptCache: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                off: "off";
+                auto: "auto";
+            }>>;
+            lifetime: z.ZodDefault<z.ZodEnum<{
+                short: "short";
+                long: "long";
+            }>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     prompt: z.ZodOptional<z.ZodObject<{
         customInstructions: z.ZodOptional<z.ZodString>;
@@ -536,11 +546,16 @@ export declare const AgentConfigEntrySchema: z.ZodObject<{
         maxTurns: z.ZodOptional<z.ZodNumber>;
         timeoutMs: z.ZodOptional<z.ZodNumber>;
         maxToolFailuresPerTurn: z.ZodOptional<z.ZodNumber>;
-        promptCacheRetention: z.ZodOptional<z.ZodEnum<{
-            none: "none";
-            short: "short";
-            long: "long";
-        }>>;
+        promptCache: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                off: "off";
+                auto: "auto";
+            }>>;
+            lifetime: z.ZodDefault<z.ZodEnum<{
+                short: "short";
+                long: "long";
+            }>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     prompt: z.ZodOptional<z.ZodObject<{
         customInstructions: z.ZodOptional<z.ZodString>;
@@ -659,11 +674,16 @@ export declare const CapabilityPresetSchema: z.ZodObject<{
         maxTurns: z.ZodOptional<z.ZodNumber>;
         timeoutMs: z.ZodOptional<z.ZodNumber>;
         maxToolFailuresPerTurn: z.ZodOptional<z.ZodNumber>;
-        promptCacheRetention: z.ZodOptional<z.ZodEnum<{
-            none: "none";
-            short: "short";
-            long: "long";
-        }>>;
+        promptCache: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                off: "off";
+                auto: "auto";
+            }>>;
+            lifetime: z.ZodDefault<z.ZodEnum<{
+                short: "short";
+                long: "long";
+            }>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     locks: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;

package/dist/src/agent-manifest/schema.js

@@ -157,11 +157,10 @@ var init_schema = __esmMin((() => {
 		maxTurns: z.number().int().positive().optional(),
 		timeoutMs: z.number().int().positive().optional(),
 		maxToolFailuresPerTurn: z.number().int().positive().optional(),
-		promptCacheRetention: z.enum([
-			"none",
-			"short",
-			"long"
-		]).optional()
+		promptCache: z.object({
+			mode: z.enum(["off", "auto"]).default("auto"),
+			lifetime: z.enum(["short", "long"]).default("short")
+		}).strict().optional()
 	}).strict().optional();
 	PromptPolicySchema = z.object({ customInstructions: z.string().optional() }).strict().optional();
 	AgentIdentitySchema = z.object({

package/dist/src/agent-runtime/index.js

@@ -1,7 +1,7 @@
+import { buildMemoryRuntime } from "./memory-runtime.js";
 import { checkBoundary } from "./boundary-guard.js";
 import { resolveModelRole } from "./model-router.js";
 import { buildRuntimeToolRegistry } from "./tool-registry.js";
-import { buildMemoryRuntime } from "./memory-runtime.js";
 import { resolveWorkflow, validateWorkflowForRuntime } from "./workflow-runtime.js";
 import { buildAgentRuntimeProfile } from "./runtime-profile.js";
 import { appendAgentRunEvent, createAgentRunTrace, finishAgentRunTrace, hashEffectiveManifest } from "./run-trace.js";

package/dist/src/agent-runtime/runtime-profile.js

@@ -1,9 +1,9 @@
 import { buildAgentManifestPromptSection } from "../agent-manifest/prompt.js";
 import "../agent-manifest/index.js";
+import { buildMemoryRuntime } from "./memory-runtime.js";
 import { checkBoundary } from "./boundary-guard.js";
 import { resolveModelRole } from "./model-router.js";
 import { buildRuntimeToolRegistry } from "./tool-registry.js";
-import { buildMemoryRuntime } from "./memory-runtime.js";
 import { resolveWorkflow, validateWorkflowForRuntime } from "./workflow-runtime.js";
 //#region src/agent-runtime/runtime-profile.ts
 function buildAgentRuntimeProfile(params) {

package/dist/src/cli/commands/gateway/lifecycle.js

@@ -1,8 +1,8 @@
 import { init_paths, resolveConfigPath } from "../../../config/paths.js";
 import { loadConfig } from "../../../config/loader.js";
 import "../../../config/index.js";
-import { isRestartEnabled } from "../../../config/commands.flags.js";
 import { resolveGatewayService } from "../../../daemon/service.js";
+import { isRestartEnabled } from "../../../config/commands.flags.js";
 import { authorizeGatewaySigusr1Restart, writeGatewayRestartIntentSync } from "../../../infra/restart.js";
 import { findVerifiedGatewayListenerPidsOnPortSync, formatGatewayPidList, signalVerifiedGatewayPidSync } from "../../../infra/gateway-processes.js";
 import { runServiceRestart, runServiceStop } from "./lifecycle-core.js";

package/dist/src/config/schema.d.ts

@@ -164,11 +164,16 @@ export declare const AgentsConfigSchema: z.ZodDefault<z.ZodObject<{
             maxTurns: z.ZodOptional<z.ZodNumber>;
             timeoutMs: z.ZodOptional<z.ZodNumber>;
             maxToolFailuresPerTurn: z.ZodOptional<z.ZodNumber>;
-            promptCacheRetention: z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                short: "short";
-                long: "long";
-            }>>;
+            promptCache: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodEnum<{
+                    off: "off";
+                    auto: "auto";
+                }>>;
+                lifetime: z.ZodDefault<z.ZodEnum<{
+                    short: "short";
+                    long: "long";
+                }>>;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
         locks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>>;
@@ -299,11 +304,16 @@ export declare const AgentsConfigSchema: z.ZodDefault<z.ZodObject<{
             maxTurns: z.ZodOptional<z.ZodNumber>;
             timeoutMs: z.ZodOptional<z.ZodNumber>;
             maxToolFailuresPerTurn: z.ZodOptional<z.ZodNumber>;
-            promptCacheRetention: z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                short: "short";
-                long: "long";
-            }>>;
+            promptCache: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodEnum<{
+                    off: "off";
+                    auto: "auto";
+                }>>;
+                lifetime: z.ZodDefault<z.ZodEnum<{
+                    short: "short";
+                    long: "long";
+                }>>;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
         prompt: z.ZodOptional<z.ZodObject<{
             customInstructions: z.ZodOptional<z.ZodString>;
@@ -1699,11 +1709,16 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                 maxTurns: z.ZodOptional<z.ZodNumber>;
                 timeoutMs: z.ZodOptional<z.ZodNumber>;
                 maxToolFailuresPerTurn: z.ZodOptional<z.ZodNumber>;
-                promptCacheRetention: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    short: "short";
-                    long: "long";
-                }>>;
+                promptCache: z.ZodOptional<z.ZodObject<{
+                    mode: z.ZodDefault<z.ZodEnum<{
+                        off: "off";
+                        auto: "auto";
+                    }>>;
+                    lifetime: z.ZodDefault<z.ZodEnum<{
+                        short: "short";
+                        long: "long";
+                    }>>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>;
             locks: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>>;
@@ -1834,11 +1849,16 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                 maxTurns: z.ZodOptional<z.ZodNumber>;
                 timeoutMs: z.ZodOptional<z.ZodNumber>;
                 maxToolFailuresPerTurn: z.ZodOptional<z.ZodNumber>;
-                promptCacheRetention: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    short: "short";
-                    long: "long";
-                }>>;
+                promptCache: z.ZodOptional<z.ZodObject<{
+                    mode: z.ZodDefault<z.ZodEnum<{
+                        off: "off";
+                        auto: "auto";
+                    }>>;
+                    lifetime: z.ZodDefault<z.ZodEnum<{
+                        short: "short";
+                        long: "long";
+                    }>>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>;
             prompt: z.ZodOptional<z.ZodObject<{
                 customInstructions: z.ZodOptional<z.ZodString>;

package/dist/src/extensions/types/providers.d.ts

@@ -92,8 +92,6 @@ export interface ProviderStreamParams {
     maxRetries?: number;
     /** Provider request metadata */
     metadata?: Record<string, unknown>;
-    /** Prompt cache retention preference */
-    cacheRetention?: string;
     /** Preferred transport, if the provider supports multiple transports */
     transport?: string;
     /** Custom token budgets for thinking levels */

package/dist/src/gateway/chat-stream/mapper.js

@@ -1,6 +1,9 @@
 import { resolveToolActivity } from "../../../packages/gateway-contract/src/tool-activity.js";
 import { createPetFeedback } from "./pet-feedback.js";
 //#region src/gateway/chat-stream/mapper.ts
+const MAX_REALTIME_TOOL_RESULT_BYTES = 256 * 1024;
+const MAX_REALTIME_TOOL_RESULT_TEXT_BYTES = 128 * 1024;
+const TOOL_RESULT_TRUNCATION_MARKER = "\n\n[Tool result truncated for realtime delivery. The complete result remains in the session transcript.]";
 let lastTaskPlanRevision = 0;
 function nextTaskPlanRevision() {
 	lastTaskPlanRevision = Math.max(Date.now(), lastTaskPlanRevision + 1);
@@ -321,18 +324,19 @@ var ChatStreamMapper = class {
 		const toolCallId = String(event.toolCallId ?? "");
 		if (!toolCallId) return [];
 		const messageId = this.toolCallToMessageId.get(toolCallId) ?? this.ensureAssistantMessageId();
-		const result = normalizeToolResult(event.result);
+		const fullResult = normalizeToolResult(event.result);
+		const result = boundRealtimeToolResult(fullResult);
 		const toolName = String(event.toolName ?? "unknown");
 		const events = [this.make("tool_end", {
 			messageId,
 			toolCallId,
 			toolName,
 			status: event.isError ? "error" : "success",
-			activity: resolveToolActivity(toolName, event.isError ? "failed" : "completed", result),
+			activity: resolveToolActivity(toolName, event.isError ? "failed" : "completed", fullResult),
 			result,
-			errorMessage: event.isError ? result?.text : void 0
+			errorMessage: event.isError ? result?.text ?? extractText(result?.content) : void 0
 		})];
-		const details = asRecord(result?.details);
+		const details = asRecord(fullResult?.details);
 		if (toolName === "exec_command" && details) events.push(this.make("command_completed", {
 			messageId,
 			toolCallId,
@@ -509,6 +513,42 @@ function normalizeToolResult(value) {
 		text: extractText(rec.content) ?? (typeof rec.text === "string" ? rec.text : void 0)
 	};
 }
+function boundRealtimeToolResult(result) {
+	if (!result) return result;
+	let serialized;
+	try {
+		serialized = JSON.stringify(result);
+	} catch {
+		return result;
+	}
+	const originalBytes = Buffer.byteLength(serialized);
+	if (originalBytes <= MAX_REALTIME_TOOL_RESULT_BYTES) return result;
+	return {
+		content: [{
+			type: "text",
+			text: `${truncateUtf8(result.text ?? extractText(result.content) ?? "", MAX_REALTIME_TOOL_RESULT_TEXT_BYTES)}${TOOL_RESULT_TRUNCATION_MARKER}`
+		}],
+		details: {
+			truncated: true,
+			reason: "realtime_payload_limit",
+			originalBytes
+		}
+	};
+}
+function truncateUtf8(value, maxBytes) {
+	if (Buffer.byteLength(value) <= maxBytes) return value;
+	let low = 0;
+	let high = value.length;
+	while (low < high) {
+		const middle = Math.ceil((low + high) / 2);
+		if (Buffer.byteLength(value.slice(0, middle)) <= maxBytes) low = middle;
+		else high = middle - 1;
+	}
+	let end = low;
+	const code = value.charCodeAt(end - 1);
+	if (code >= 55296 && code <= 56319) end -= 1;
+	return value.slice(0, Math.max(0, end));
+}
 function extractTurnPlan(details) {
 	const plan = (Array.isArray(details.plan) ? details.plan : []).map((item) => {
 		const rec = asRecord(item);

package/dist/src/gateway/heartbeat/service.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { shouldSilence, stripHeartbeatToken } from "../../heartbeat/tokens.js";
-import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { isWithinActiveHours } from "../../heartbeat/active-hours.js";
 import { isHeartbeatContentEmpty } from "../../heartbeat/content-check.js";
+import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { createHeartbeatWake } from "../../heartbeat/wake.js";
 import { resolveHeartbeatMdPath } from "../workspace-heartbeat-path.js";
 import { readFile } from "fs/promises";

package/dist/src/gateway/hono/lib/config-payload.d.ts

@@ -191,7 +191,10 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
                 maxTurns?: number;
                 timeoutMs?: number;
                 maxToolFailuresPerTurn?: number;
-                promptCacheRetention?: "none" | "short" | "long";
+                promptCache?: {
+                    mode: "off" | "auto";
+                    lifetime: "short" | "long";
+                };
             };
             locks?: string[];
         }>;

package/dist/src/heartbeat/index.js

@@ -1,6 +1,6 @@
 import { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, shouldSilence, stripHeartbeatToken } from "./tokens.js";
-import { appendCronEventLines } from "./event-prompt.js";
 import { isWithinActiveHours } from "./active-hours.js";
 import { isHeartbeatContentEmpty } from "./content-check.js";
+import { appendCronEventLines } from "./event-prompt.js";
 import { createHeartbeatWake } from "./wake.js";
 export { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, appendCronEventLines, createHeartbeatWake, isHeartbeatContentEmpty, isWithinActiveHours, shouldSilence, stripHeartbeatToken };

package/dist/src/infra/update-restart.js

@@ -2,8 +2,8 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { init_paths, resolveConfigPath } from "../config/paths.js";
 import { init_loader, loadConfig } from "../config/loader.js";
-import { isRestartEnabled } from "../config/commands.flags.js";
 import { resolveGatewayService } from "../daemon/service.js";
+import { isRestartEnabled } from "../config/commands.flags.js";
 import { authorizeGatewaySigusr1Restart, writeGatewayRestartIntentSync } from "./restart.js";
 import { findVerifiedGatewayListenerPidsOnPortSync, signalVerifiedGatewayPidSync } from "./gateway-processes.js";
 import { refreshGatewayServiceAfterUpdate } from "./update-service-refresh.js";

package/dist/src/providers/extension-stream-bridge.js

@@ -51,7 +51,6 @@ function collectExtraStreamOptions(options) {
 		"signal",
 		"apiKey",
 		"transport",
-		"cacheRetention",
 		"sessionId",
 		"onPayload",
 		"onResponse",
@@ -93,7 +92,6 @@ function createExtensionAwareStreamFn() {
 			timeoutMs: options?.timeoutMs,
 			maxRetries: options?.maxRetries,
 			metadata: options?.metadata,
-			cacheRetention: options?.cacheRetention,
 			transport: options?.transport,
 			thinkingBudgets: options?.thinkingBudgets,
 			extra: collectExtraStreamOptions(options),

package/dist/src/providers/google-managed-prompt-cache.d.ts

@@ -0,0 +1,14 @@
+import type { Api, Model } from '@earendil-works/pi-ai';
+import type { PromptCachePolicy } from './prompt-cache-plan.js';
+export declare function applyGoogleManagedPromptCache(params: {
+    model: Model<Api>;
+    context: {
+        systemPrompt?: string;
+    };
+    payload: unknown;
+    policy: PromptCachePolicy;
+    apiKey?: string;
+    fetchImpl?: typeof fetch;
+    now?: number;
+}): Promise<unknown>;
+export declare function clearGoogleManagedPromptCaches(): void;

package/dist/src/providers/google-managed-prompt-cache.js

@@ -0,0 +1,125 @@
+import { splitPromptCacheBoundary, stripPromptCacheBoundary } from "../agent/prompt/cache-boundary.js";
+import { canonicalizeCacheValue, digestCacheText } from "./prompt-cache-fingerprint.js";
+//#region src/providers/google-managed-prompt-cache.ts
+const DEFAULT_GOOGLE_API_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+const MIN_CACHEABLE_PROMPT_CHARS = 4096;
+const FAILURE_BACKOFF_MS = 10 * 6e4;
+const MAX_CACHE_ENTRIES = 128;
+const entries = /* @__PURE__ */ new Map();
+const pendingCreates = /* @__PURE__ */ new Map();
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function resolveBaseUrl(model) {
+	return (model.baseUrl?.trim() || DEFAULT_GOOGLE_API_BASE_URL).replace(/\/models(?:\/.*)?$/, "").replace(/\/+$/, "");
+}
+function resolveTtlSeconds(policy) {
+	return policy.lifetime === "long" ? 3600 : 300;
+}
+function parseExpiry(expireTime, fallback) {
+	if (typeof expireTime !== "string") return fallback;
+	const parsed = Date.parse(expireTime);
+	return Number.isFinite(parsed) ? parsed : fallback;
+}
+function remember(key, entry) {
+	entries.delete(key);
+	entries.set(key, entry);
+	while (entries.size > MAX_CACHE_ENTRIES) {
+		const oldest = entries.keys().next().value;
+		if (typeof oldest !== "string") break;
+		entries.delete(oldest);
+	}
+}
+function insertDynamicRuntimeContext(payload, dynamicSuffix) {
+	if (!dynamicSuffix || !Array.isArray(payload.contents)) return payload;
+	const contents = [...payload.contents];
+	const insertAt = Math.max(0, contents.length - 1);
+	contents.splice(insertAt, 0, {
+		role: "user",
+		parts: [{ text: `<runtime_context>\n${dynamicSuffix}\n</runtime_context>` }]
+	});
+	return {
+		...payload,
+		contents
+	};
+}
+async function applyGoogleManagedPromptCache(params) {
+	if (params.policy.mode === "off") return params.payload;
+	const payload = asRecord(params.payload);
+	const config = asRecord(payload?.config);
+	const apiKey = params.apiKey?.trim();
+	if (!payload || !config || !apiKey) return params.payload;
+	const split = splitPromptCacheBoundary(params.context.systemPrompt ?? "");
+	const stablePrompt = split?.stablePrefix ?? stripPromptCacheBoundary(params.context.systemPrompt ?? "");
+	const dynamicSuffix = split?.dynamicSuffix ?? "";
+	if (stablePrompt.length < MIN_CACHEABLE_PROMPT_CHARS) return params.payload;
+	const cacheConfig = {
+		tools: config.tools,
+		toolConfig: config.toolConfig
+	};
+	const key = digestCacheText(`${params.model.provider}\0${params.model.id}\0${stablePrompt}\0${canonicalizeCacheValue(cacheConfig)}`);
+	const now = params.now ?? Date.now();
+	const existing = entries.get(key);
+	let name;
+	if (existing?.status === "ready" && existing.expiresAt - now > 3e4) name = existing.name;
+	else if (existing?.status === "failed" && existing.retryAt > now) return params.payload;
+	else {
+		const ttlSeconds = resolveTtlSeconds(params.policy);
+		let pending = pendingCreates.get(key);
+		if (!pending) {
+			pending = (async () => {
+				try {
+					const response = await (params.fetchImpl ?? globalThis.fetch)(`${resolveBaseUrl(params.model)}/cachedContents`, {
+						method: "POST",
+						headers: {
+							"content-type": "application/json",
+							"x-goog-api-key": apiKey
+						},
+						body: JSON.stringify({
+							model: params.model.id.startsWith("models/") ? params.model.id : `models/${params.model.id}`,
+							ttl: `${ttlSeconds}s`,
+							systemInstruction: { parts: [{ text: stablePrompt }] },
+							...config.tools ? { tools: config.tools } : {},
+							...config.toolConfig ? { toolConfig: config.toolConfig } : {}
+						})
+					});
+					if (!response.ok) throw new Error(`Google cachedContents returned ${response.status}`);
+					const body = await response.json();
+					if (typeof body.name !== "string" || !body.name.trim()) throw new Error("Google cachedContents response did not include a name");
+					return {
+						status: "ready",
+						name: body.name.trim(),
+						expiresAt: parseExpiry(body.expireTime, now + ttlSeconds * 1e3)
+					};
+				} catch {
+					return {
+						status: "failed",
+						retryAt: now + FAILURE_BACKOFF_MS
+					};
+				}
+			})();
+			pendingCreates.set(key, pending);
+		}
+		const created = await pending.finally(() => pendingCreates.delete(key));
+		remember(key, created);
+		if (created.status === "failed") return params.payload;
+		name = created.name;
+	}
+	const nextConfig = {
+		...config,
+		cachedContent: name
+	};
+	delete nextConfig.systemInstruction;
+	delete nextConfig.tools;
+	delete nextConfig.toolConfig;
+	return insertDynamicRuntimeContext({
+		...payload,
+		config: nextConfig
+	}, dynamicSuffix);
+}
+function clearGoogleManagedPromptCaches() {
+	entries.clear();
+	pendingCreates.clear();
+}
+//#endregion
+export { applyGoogleManagedPromptCache, clearGoogleManagedPromptCaches };

package/dist/src/providers/index.js

@@ -7,7 +7,7 @@ import { init_model_ref, splitProviderModelRef } from "./model-ref.js";
 import { ModelRegistry, getModelRegistry, init_model_registry, prewarmModelRegistry, resetModelRegistry } from "./model-registry.js";
 import { CredentialResolver, hasCredentials, init_credentials } from "../auth/credentials.js";
 import { EXTENSION_PROVIDER_BASE_URL, init_constants } from "./constants.js";
-import { getSupplementalModels, init_model_supplements } from "./model-supplements.js";
+import { applyOfficialModelMetadataCorrections, getSupplementalModels, init_model_supplements } from "./model-supplements.js";
 import { getProviderRegistry, init_plugin_registry } from "./plugin-registry.js";
 import { init_provider_auth_service, resolveProviderApiKey } from "./provider-auth-service.js";
 import { getModel, getModels, getProviders } from "@earendil-works/pi-ai/compat";
@@ -45,11 +45,12 @@ var providers_exports = /* @__PURE__ */ __exportAll({
 	resolveModel: () => resolveModel
 });
 function normalizeProviderModel(model) {
+	const correctedModel = applyOfficialModelMetadataCorrections(model);
 	if (model.provider === "openai-codex" && model.api === "openai-codex-responses") return {
-		...model,
+		...correctedModel,
 		baseUrl: OPENAI_CODEX_CANONICAL_BASE_URL
 	};
-	return model;
+	return correctedModel;
 }
 /** Map a plugin registry model to the pi-ai {@link Model} shape. */
 function pluginModelToModel(providerId, definition) {
@@ -91,7 +92,7 @@ function resolveModel(ref) {
 	const trimmedRef = typeof ref === "string" ? ref.trim() : "";
 	if (!trimmedRef) throw new Error("No default model configured. Choose a model in onboarding or set agents.capabilityPresets.default.models.roles.<role>.model.");
 	const customModel = getModelRegistry().resolve(trimmedRef);
-	if (customModel) return customModel;
+	if (customModel) return normalizeProviderModel(customModel);
 	const qualifiedRef = splitProviderModelRef(trimmedRef);
 	if (qualifiedRef) {
 		const { provider, modelId } = qualifiedRef;

package/dist/src/providers/model-call.js

@@ -1,7 +1,7 @@
 import { init_constants } from "./constants.js";
 import { getApiKey, init_providers } from "./index.js";
 import { createExtensionAwareStreamFn } from "./extension-stream-bridge.js";
-import { complete } from "@earendil-works/pi-ai/compat";
+import { completeSimple } from "@earendil-works/pi-ai/compat";
 //#region src/providers/model-call.ts
 init_constants();
 init_providers();
@@ -43,7 +43,7 @@ async function resolveModelCallOptions(model, options = {}, credentialOptions) {
 async function completeWithResolvedCredentials(model, context, options = {}, credentialOptions) {
 	const resolvedOptions = await resolveModelCallOptions(model, options, credentialOptions);
 	if (model.baseUrl === "extension://provider-plugin") return await (await createExtensionAwareStreamFn()(model, context, resolvedOptions)).result();
-	return await complete(model, context, resolvedOptions);
+	return await completeSimple(model, context, resolvedOptions);
 }
 /**
 * Start a model stream with xopc credential resolution and extension-provider routing.

package/dist/src/providers/model-supplements.d.ts

@@ -1,4 +1,6 @@
 import { type Api, type Model } from '@earendil-works/pi-ai/compat';
+/** Correct narrowly scoped upstream catalog metadata while older pi-ai data is still installed. */
+export declare function applyOfficialModelMetadataCorrections(model: Model<Api>): Model<Api>;
 /**
  * Small local supplement for official model aliases that may lag in pi-ai.
  * Keep this list narrow: full provider catalogs should come from pi-ai.

package/dist/src/providers/model-supplements.js

@@ -1,6 +1,15 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { getModel } from "@earendil-works/pi-ai/compat";
 //#region src/providers/model-supplements.ts
+/** Correct narrowly scoped upstream catalog metadata while older pi-ai data is still installed. */
+function applyOfficialModelMetadataCorrections(model) {
+	const correctedContextWindow = OPENAI_CONTEXT_WINDOW_CORRECTIONS.get(model.id);
+	if ((model.provider === "openai" || model.provider === "openai-codex") && correctedContextWindow !== void 0 && model.contextWindow === STALE_OPENAI_CONTEXT_WINDOW) return {
+		...model,
+		contextWindow: correctedContextWindow
+	};
+	return model;
+}
 /**
 * Small local supplement for official model aliases that may lag in pi-ai.
 * Keep this list narrow: full provider catalogs should come from pi-ai.
@@ -14,7 +23,19 @@ function getSupplementalModels() {
 		name: "GPT-5.6"
 	}];
 }
-var init_model_supplements = __esmMin((() => {}));
+var STALE_OPENAI_CONTEXT_WINDOW, OPENAI_CONTEXT_WINDOW_CORRECTIONS;
+var init_model_supplements = __esmMin((() => {
+	STALE_OPENAI_CONTEXT_WINDOW = 272e3;
+	OPENAI_CONTEXT_WINDOW_CORRECTIONS = new Map([
+		["gpt-5.4", 105e4],
+		["gpt-5.4-mini", 4e5],
+		["gpt-5.5", 105e4],
+		["gpt-5.6", 105e4],
+		["gpt-5.6-luna", 105e4],
+		["gpt-5.6-sol", 105e4],
+		["gpt-5.6-terra", 105e4]
+	]);
+}));
 //#endregion
 init_model_supplements();
-export { getSupplementalModels, init_model_supplements };
+export { applyOfficialModelMetadataCorrections, getSupplementalModels, init_model_supplements };

package/dist/src/providers/prompt-cache-fingerprint.d.ts

@@ -0,0 +1,4 @@
+/** Canonical JSON used only for bounded prompt-cache fingerprints. */
+export declare function canonicalizeCacheValue(value: unknown): string;
+export declare function digestCacheValue(value: unknown): string;
+export declare function digestCacheText(value: string): string;