@xopcai/xopc 0.0.201 → 0.0.203

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/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/gateway/hono/oauth-async.d.ts

@@ -9,6 +9,7 @@ import { Hono } from 'hono';
 import type { GatewayService } from '../service.js';
 import { type OAuthCredentials } from '../../auth/oauth/types.js';
 export declare function refreshModelCatalogAfterOAuth(provider: string, service: Pick<GatewayService, 'getModelCatalogSync'>): Promise<void>;
+export declare function normalizeDesktopOAuthReturnPath(value: unknown): string | undefined;
 export declare function resolveOAuthLoginMethodPreference(params: {
     requestedMethod?: unknown;
     supportedMethods?: readonly string[];

package/dist/src/gateway/hono/oauth-async.js

@@ -53,6 +53,18 @@ setInterval(() => {
 function generateSessionId() {
 	return `oauth_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
 }
+function normalizeDesktopOAuthReturnPath(value) {
+	if (typeof value !== "string") return void 0;
+	const path = value.trim();
+	if (path.length === 0 || path.length > 2048 || !path.startsWith("/") || path.startsWith("//") || path.includes("\\") || /[\u0000-\u001f\u007f]/.test(path)) return;
+	return path;
+}
+function desktopOAuthReturnUrl(sessionId, returnPath) {
+	const params = new URLSearchParams({ request_id: sessionId });
+	const normalizedReturnPath = normalizeDesktopOAuthReturnPath(returnPath);
+	if (normalizedReturnPath) params.set("return_path", normalizedReturnPath);
+	return `xopc://cloud/model-connected?${params.toString()}`;
+}
 function cancelOAuthSession(session, message = "OAuth flow cancelled") {
 	if (session.abortController) session.abortController.abort();
 	if (session.manualCodeResolve) session.manualCodeResolve("");
@@ -110,7 +122,7 @@ function createOAuthAsyncHandler(service) {
 		const session = {
 			id: sessionId,
 			provider,
-			...body.client === "desktop" && provider === "xopc-cloud" ? { returnToAppUrl: `xopc://cloud/model-connected?request_id=${encodeURIComponent(sessionId)}` } : {},
+			...body.client === "desktop" && provider === "xopc-cloud" ? { returnToAppUrl: desktopOAuthReturnUrl(sessionId, body.returnPath) } : {},
 			preferredLoginMethod: preferredOAuthLoginMethod({
 				provider,
 				requestedMethod: body.loginMethod,
@@ -330,4 +342,4 @@ function deleteOAuthCredentialsFromCache(provider) {
 	oauthCredentialsCache.delete(provider);
 }
 //#endregion
-export { createOAuthAsyncHandler, deleteOAuthCredentialsFromCache, getOAuthCredentialsFromCache, refreshModelCatalogAfterOAuth, resolveOAuthLoginMethodPreference, setOAuthCredentialsToCache };
+export { createOAuthAsyncHandler, deleteOAuthCredentialsFromCache, getOAuthCredentialsFromCache, normalizeDesktopOAuthReturnPath, refreshModelCatalogAfterOAuth, resolveOAuthLoginMethodPreference, setOAuthCredentialsToCache };

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/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;

package/dist/src/providers/prompt-cache-fingerprint.js

@@ -0,0 +1,44 @@
+import { createHash } from "node:crypto";
+//#region src/providers/prompt-cache-fingerprint.ts
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+const MAX_FINGERPRINT_DEPTH = 64;
+const MAX_FINGERPRINT_NODES = 2e4;
+const MAX_FINGERPRINT_STRING_CHARS = 1e5;
+function canonicalize(value, state, depth) {
+	state.nodes += 1;
+	if (depth > MAX_FINGERPRINT_DEPTH || state.nodes > MAX_FINGERPRINT_NODES) return "\"[fingerprint-limit]\"";
+	if (typeof value === "string" && value.length > MAX_FINGERPRINT_STRING_CHARS) return JSON.stringify(`${value.slice(0, MAX_FINGERPRINT_STRING_CHARS)}[fingerprint-limit]`);
+	if (Array.isArray(value)) {
+		if (state.seen.has(value)) return "\"[circular]\"";
+		state.seen.add(value);
+		const result = `[${value.map((entry) => canonicalize(entry, state, depth + 1)).join(",")}]`;
+		state.seen.delete(value);
+		return result;
+	}
+	const record = asRecord(value);
+	if (record) {
+		if (state.seen.has(record)) return "\"[circular]\"";
+		state.seen.add(record);
+		const result = `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalize(record[key], state, depth + 1)}`).join(",")}}`;
+		state.seen.delete(record);
+		return result;
+	}
+	return JSON.stringify(value) ?? "null";
+}
+/** Canonical JSON used only for bounded prompt-cache fingerprints. */
+function canonicalizeCacheValue(value) {
+	return canonicalize(value, {
+		nodes: 0,
+		seen: /* @__PURE__ */ new WeakSet()
+	}, 0);
+}
+function digestCacheValue(value) {
+	return createHash("sha256").update(canonicalizeCacheValue(value)).digest("base64url");
+}
+function digestCacheText(value) {
+	return createHash("sha256").update(value).digest("base64url");
+}
+//#endregion
+export { canonicalizeCacheValue, digestCacheText, digestCacheValue };

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

@@ -0,0 +1,9 @@
+import type { Api, Model } from '@earendil-works/pi-ai';
+import type { PromptCachePolicy } from './prompt-cache-plan.js';
+export declare function resolvePromptCacheTtlMs(model: Model<Api>, policy: PromptCachePolicy): number;
+export declare function recordPromptCacheTouch(sessionKey: string, model: Model<Api>, usage: {
+    cacheRead?: number;
+    cacheWrite?: number;
+}, now?: number): void;
+export declare function isPromptCacheExpired(sessionKey: string, model: Model<Api>, policy: PromptCachePolicy, now?: number): boolean;
+export declare function clearPromptCacheTouches(): void;

package/dist/src/providers/prompt-cache-lifecycle.js

@@ -0,0 +1,31 @@
+//#region src/providers/prompt-cache-lifecycle.ts
+const cacheTouchByScope = /* @__PURE__ */ new Map();
+const MAX_CACHE_TOUCHES = 512;
+function scopeKey(sessionKey, model) {
+	return `${sessionKey}\0${model.provider}/${model.id}`;
+}
+function resolvePromptCacheTtlMs(model, policy) {
+	if (model.api === "openai-responses" && /^gpt-5\.6(?:-|$)/.test(model.id)) return 30 * 6e4;
+	return policy.lifetime === "long" ? 60 * 6e4 : 5 * 6e4;
+}
+function recordPromptCacheTouch(sessionKey, model, usage, now = Date.now()) {
+	if ((usage.cacheRead ?? 0) <= 0 && (usage.cacheWrite ?? 0) <= 0) return;
+	const key = scopeKey(sessionKey, model);
+	cacheTouchByScope.delete(key);
+	cacheTouchByScope.set(key, now);
+	while (cacheTouchByScope.size > MAX_CACHE_TOUCHES) {
+		const oldest = cacheTouchByScope.keys().next().value;
+		if (typeof oldest !== "string") break;
+		cacheTouchByScope.delete(oldest);
+	}
+}
+function isPromptCacheExpired(sessionKey, model, policy, now = Date.now()) {
+	if (policy.mode === "off") return false;
+	const touchedAt = cacheTouchByScope.get(scopeKey(sessionKey, model));
+	return touchedAt !== void 0 && now - touchedAt >= resolvePromptCacheTtlMs(model, policy);
+}
+function clearPromptCacheTouches() {
+	cacheTouchByScope.clear();
+}
+//#endregion
+export { clearPromptCacheTouches, isPromptCacheExpired, recordPromptCacheTouch, resolvePromptCacheTtlMs };

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

@@ -0,0 +1,20 @@
+import type { Api, Model } from '@earendil-works/pi-ai';
+export type PromptCacheChangeReason = 'model_changed' | 'reasoning_changed' | 'system_changed' | 'dynamic_context_changed' | 'tools_changed';
+export interface PromptCacheSnapshot {
+    modelRef: string;
+    api: string;
+    reasoning?: string;
+    stableSystemDigest: string;
+    dynamicSystemDigest: string;
+    toolDigest: string;
+    toolCount: number;
+}
+export declare function buildPromptCacheSnapshot(params: {
+    model: Model<Api>;
+    systemPrompt?: string;
+    tools?: unknown[];
+    reasoning?: string;
+}): PromptCacheSnapshot;
+export declare function diffPromptCacheSnapshots(previous: PromptCacheSnapshot | undefined, next: PromptCacheSnapshot): PromptCacheChangeReason[];
+export declare function observePromptCacheSnapshot(scope: string, snapshot: PromptCacheSnapshot): PromptCacheChangeReason[];
+export declare function clearPromptCacheObservations(): void;

package/dist/src/providers/prompt-cache-observability.js

@@ -0,0 +1,44 @@
+import { splitPromptCacheBoundary, stripPromptCacheBoundary } from "../agent/prompt/cache-boundary.js";
+import { digestCacheText, digestCacheValue } from "./prompt-cache-fingerprint.js";
+//#region src/providers/prompt-cache-observability.ts
+const MAX_TRACKED_SCOPES = 512;
+const previousByScope = /* @__PURE__ */ new Map();
+function buildPromptCacheSnapshot(params) {
+	const rawPrompt = params.systemPrompt ?? "";
+	const split = splitPromptCacheBoundary(rawPrompt);
+	return {
+		modelRef: `${params.model.provider}/${params.model.id}`,
+		api: params.model.api,
+		...params.reasoning ? { reasoning: params.reasoning } : {},
+		stableSystemDigest: digestCacheText(split?.stablePrefix ?? stripPromptCacheBoundary(rawPrompt)),
+		dynamicSystemDigest: digestCacheText(split?.dynamicSuffix ?? ""),
+		toolDigest: digestCacheValue(params.tools ?? []),
+		toolCount: params.tools?.length ?? 0
+	};
+}
+function diffPromptCacheSnapshots(previous, next) {
+	if (!previous) return [];
+	const reasons = [];
+	if (previous.modelRef !== next.modelRef || previous.api !== next.api) reasons.push("model_changed");
+	if (previous.reasoning !== next.reasoning) reasons.push("reasoning_changed");
+	if (previous.stableSystemDigest !== next.stableSystemDigest) reasons.push("system_changed");
+	if (previous.dynamicSystemDigest !== next.dynamicSystemDigest) reasons.push("dynamic_context_changed");
+	if (previous.toolDigest !== next.toolDigest) reasons.push("tools_changed");
+	return reasons;
+}
+function observePromptCacheSnapshot(scope, snapshot) {
+	const reasons = diffPromptCacheSnapshots(previousByScope.get(scope), snapshot);
+	previousByScope.delete(scope);
+	previousByScope.set(scope, snapshot);
+	while (previousByScope.size > MAX_TRACKED_SCOPES) {
+		const oldest = previousByScope.keys().next().value;
+		if (typeof oldest !== "string") break;
+		previousByScope.delete(oldest);
+	}
+	return reasons;
+}
+function clearPromptCacheObservations() {
+	previousByScope.clear();
+}
+//#endregion
+export { buildPromptCacheSnapshot, clearPromptCacheObservations, diffPromptCacheSnapshots, observePromptCacheSnapshot };

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

@@ -1,13 +1,20 @@
 import type { Api, Model, SimpleStreamOptions } from '@earendil-works/pi-ai';
-export declare function transformPromptCachePayload(model: Model<Api>, payload: unknown): unknown;
+import { type PromptCachePlan, type PromptCachePolicy } from './prompt-cache-plan.js';
 export declare function buildPromptCacheKey(model: Model<Api>, context: {
     systemPrompt?: string;
     tools?: unknown[];
-}): string;
+}, reasoning?: string): string;
+export declare function buildPromptCachePlan(model: Model<Api>, context: {
+    systemPrompt?: string;
+    tools?: unknown[];
+}, policyInput?: PromptCachePolicy, reasoning?: string): PromptCachePlan;
+export declare function transformPromptCachePayload(model: Model<Api>, payload: unknown, plan?: PromptCachePlan, context?: {
+    systemPrompt?: string;
+}): unknown;
 export declare function preparePromptCacheContext<T extends {
     systemPrompt?: string;
 }>(model: Model<Api>, context: T): T;
 export declare function withPromptCachePayloadTransform(model: Model<Api>, context: {
     systemPrompt?: string;
     tools?: unknown[];
-}, options: SimpleStreamOptions | undefined): SimpleStreamOptions | undefined;
+}, options: SimpleStreamOptions | undefined, policyInput?: PromptCachePolicy): SimpleStreamOptions;