praxis-agent 0.28.0 → 0.30.0

package/dist/compatibility/claude/context.js

@@ -1,4 +1,5 @@
 import { isAbsolute, matchesGlob, relative, resolve, sep } from 'node:path';
+import { PromptComposer, } from '../../core/prompt-composer.js';
 import { renderClaudeDynamicSystemContext, renderClaudeDynamicUserContext, } from './dynamic-context.js';
 function renderResources(title, resources) {
     const rendered = resources
@@ -40,22 +41,32 @@ export class ClaudeConditionalRuleResolver {
 }
 export class ClaudeContextAssembler {
     options;
+    composer = new PromptComposer();
+    snapshots = new Map();
     constructor(options) {
         this.options = options;
     }
     async assemble(options = {}) {
-        const resources = await this.options.loadResources(options.cwd);
+        const snapshot = this.snapshot(options);
+        const mode = options.mode ??
+            (this.options.systemPrompt !== undefined
+                ? 'custom'
+                : this.options.bare
+                    ? 'bare'
+                    : 'default');
+        const resources = mode === 'bare'
+            ? { instructions: [], conditionalRules: [], memoryIndex: null }
+            : await this.loadResources(snapshot, options.cwd);
         const sections = [
             renderResources('Instructions', resources.instructions),
             renderResources('Auto-memory', resources.memoryIndex ? [limitMemoryIndex(resources.memoryIndex)] : []),
         ].filter((section) => section !== null);
-        const messages = [];
-        if (this.options.systemPrompt !== undefined) {
-            messages.push({ role: 'system', content: this.options.systemPrompt });
-        }
+        const sessionSections = [];
         if (sections.length > 0) {
-            messages.push({
-                role: 'system',
+            sessionSections.push({
+                id: 'shared-resources',
+                placement: 'system',
+                stability: 'session',
                 content: `# Shared Claude context
 
 Instructions are ordered from broadest to most specific. Auto-memory is background context and does not override instructions.
@@ -63,36 +74,199 @@ Instructions are ordered from broadest to most specific. Auto-memory is backgrou
 ${sections.join('\n\n')}`,
             });
         }
-        let firstUserMessageContext;
-        if (this.options.systemPrompt === undefined &&
-            this.options.loadDynamicContext !== undefined) {
-            const dynamic = await this.options.loadDynamicContext(options.cwd);
+        const tailSections = [];
+        if (mode !== 'bare') {
+            sessionSections.push({
+                id: 'current-date',
+                placement: 'system',
+                stability: 'session',
+                content: `# Current date\n${this.currentDate(snapshot)}`,
+            });
+        }
+        if (mode !== 'bare') {
+            const guidance = await this.loadSessionGuidance(snapshot);
+            if (guidance?.trim()) {
+                sessionSections.push({
+                    id: 'session-guidance',
+                    placement: 'system',
+                    stability: 'session',
+                    content: guidance,
+                });
+            }
+            const mcpInstructions = await this.loadMcpInstructions(snapshot);
+            tailSections.push(...mcpInstructions
+                .filter(({ instructions }) => instructions.trim().length > 0)
+                .sort((left, right) => left.server.localeCompare(right.server))
+                .map(({ server, instructions }) => ({
+                id: `mcp-instructions:${server}`,
+                placement: 'system',
+                stability: 'volatile',
+                content: `# MCP server instructions: ${server}\n${instructions.trimEnd()}`,
+            })));
+        }
+        if (mode !== 'bare' && this.options.loadDynamicContext !== undefined) {
+            const dynamic = await this.loadDynamicContext(snapshot, options.cwd);
             if (this.options.excludeDynamicSystemPromptSections) {
                 if (dynamic.memory) {
-                    messages.push({ role: 'system', content: dynamic.memory });
+                    sessionSections.push({
+                        id: 'memory-mechanics',
+                        placement: 'system',
+                        stability: 'session',
+                        content: dynamic.memory,
+                    });
                 }
-                firstUserMessageContext = renderClaudeDynamicUserContext({
-                    environment: dynamic.environment,
-                    ...(dynamic.gitStatus ? { gitStatus: dynamic.gitStatus } : {}),
+                tailSections.push({
+                    id: 'relocated-runtime-context',
+                    placement: 'first-user',
+                    stability: 'session',
+                    content: renderClaudeDynamicUserContext({
+                        environment: dynamic.environment,
+                        ...(dynamic.gitStatus ? { gitStatus: dynamic.gitStatus } : {}),
+                    }),
                 });
             }
             else {
-                messages.push({
-                    role: 'system',
+                sessionSections.push({
+                    id: 'runtime-context',
+                    placement: 'system',
+                    stability: 'session',
                     content: renderClaudeDynamicSystemContext(dynamic),
                 });
             }
         }
-        if (this.options.appendSystemPrompt !== undefined) {
-            messages.push({
-                role: 'system',
-                content: this.options.appendSystemPrompt,
-            });
+        for (const section of options.additionalSections ?? []) {
+            const target = section.stability === 'volatile' || section.placement === 'first-user'
+                ? tailSections
+                : sessionSections;
+            target.push(section);
         }
+        const composition = this.composer.compose({
+            mode,
+            ...(options.baseSystemPrompt !== undefined
+                ? { baseSystemPrompt: options.baseSystemPrompt }
+                : this.options.systemPrompt !== undefined
+                    ? { baseSystemPrompt: this.options.systemPrompt }
+                    : {}),
+            ...(this.options.appendSystemPrompt !== undefined
+                ? { appendSystemPrompt: this.options.appendSystemPrompt }
+                : {}),
+            sessionSections,
+            tailSections,
+        });
         return {
-            systemMessages: messages,
-            ...(firstUserMessageContext ? { firstUserMessageContext } : {}),
+            systemMessages: composition.systemMessages,
+            promptSections: composition.sections,
+            stableSystemSectionCount: composition.stableSystemSectionCount,
+            ...(composition.firstUserMessageContext
+                ? { firstUserMessageContext: composition.firstUserMessageContext }
+                : {}),
         };
     }
+    invalidate(options) {
+        for (const [key, snapshot] of this.snapshots) {
+            if (options.lifecycleId !== undefined &&
+                snapshot.lifecycleId !== options.lifecycleId)
+                continue;
+            if (options.reason === 'resource-reload' ||
+                options.reason === 'compact') {
+                delete snapshot.resources;
+                continue;
+            }
+            if (options.reason === 'tool-pool') {
+                delete snapshot.mcpInstructions;
+                delete snapshot.sessionGuidance;
+                continue;
+            }
+            this.snapshots.delete(key);
+        }
+    }
+    snapshot(options) {
+        if (!options.lifecycleId)
+            return undefined;
+        const key = JSON.stringify([options.lifecycleId, options.cwd ?? null]);
+        let snapshot = this.snapshots.get(key);
+        if (!snapshot) {
+            snapshot = {
+                lifecycleId: options.lifecycleId,
+                ...(options.cwd ? { cwd: options.cwd } : {}),
+            };
+            this.snapshots.set(key, snapshot);
+        }
+        return snapshot;
+    }
+    loadResources(snapshot, cwd) {
+        if (!snapshot)
+            return this.options.loadResources(cwd);
+        if (!snapshot.resources) {
+            const pending = this.options.loadResources(cwd);
+            snapshot.resources = pending;
+            void pending.catch(() => {
+                if (snapshot.resources === pending)
+                    delete snapshot.resources;
+            });
+        }
+        return snapshot.resources;
+    }
+    loadDynamicContext(snapshot, cwd) {
+        const load = this.options.loadDynamicContext;
+        if (!load)
+            throw new Error('Dynamic context loader is unavailable');
+        if (!snapshot)
+            return load(cwd);
+        if (!snapshot.dynamic) {
+            const pending = load(cwd);
+            snapshot.dynamic = pending;
+            void pending.catch(() => {
+                if (snapshot.dynamic === pending)
+                    delete snapshot.dynamic;
+            });
+        }
+        return snapshot.dynamic;
+    }
+    loadMcpInstructions(snapshot) {
+        const load = this.options.loadMcpInstructions;
+        if (!load)
+            return Promise.resolve([]);
+        if (!snapshot)
+            return load();
+        if (!snapshot.mcpInstructions) {
+            const pending = load();
+            snapshot.mcpInstructions = pending;
+            void pending.catch(() => {
+                if (snapshot.mcpInstructions === pending)
+                    delete snapshot.mcpInstructions;
+            });
+        }
+        return snapshot.mcpInstructions;
+    }
+    loadSessionGuidance(snapshot) {
+        const load = this.options.loadSessionGuidance;
+        if (!load)
+            return Promise.resolve(undefined);
+        if (!snapshot)
+            return load();
+        if (!snapshot.sessionGuidance) {
+            const pending = load();
+            snapshot.sessionGuidance = pending;
+            void pending.catch(() => {
+                if (snapshot.sessionGuidance === pending)
+                    delete snapshot.sessionGuidance;
+            });
+        }
+        return snapshot.sessionGuidance;
+    }
+    currentDate(snapshot) {
+        if (snapshot?.currentDate)
+            return snapshot.currentDate;
+        const now = (this.options.now ?? (() => new Date()))();
+        const date = [
+            String(now.getFullYear()).padStart(4, '0'),
+            String(now.getMonth() + 1).padStart(2, '0'),
+            String(now.getDate()).padStart(2, '0'),
+        ].join('-');
+        if (snapshot)
+            snapshot.currentDate = date;
+        return date;
+    }
 }
 //# sourceMappingURL=context.js.map

package/dist/core/context.d.ts

@@ -1,16 +1,29 @@
 import type { ModelMessage } from './runtime.js';
+import type { PromptCompositionMode, PromptSection } from './prompt-composer.js';
 export type SystemContextMessage = Extract<ModelMessage, {
     role: 'system';
 }>;
 export interface AssembledContext {
     systemMessages: readonly SystemContextMessage[];
     firstUserMessageContext?: string;
+    promptSections?: readonly PromptSection[];
+    stableSystemSectionCount?: number;
 }
 export interface ContextAssemblyOptions {
     cwd?: string;
+    lifecycleId?: string;
+    mode?: PromptCompositionMode;
+    baseSystemPrompt?: string;
+    additionalSections?: readonly PromptSection[];
+}
+export type ContextInvalidationReason = 'clear' | 'compact' | 'fork' | 'resource-reload' | 'restore' | 'tool-pool' | 'cwd' | 'worktree';
+export interface ContextInvalidationOptions {
+    lifecycleId?: string;
+    reason: ContextInvalidationReason;
 }
 export interface ContextAssembler {
     assemble(options?: ContextAssemblyOptions): Promise<AssembledContext>;
+    invalidate?(options: ContextInvalidationOptions): void;
 }
 export declare function injectFirstUserMessageContext(messages: readonly ModelMessage[], context: string | undefined): ModelMessage[];
 //# sourceMappingURL=context.d.ts.map

package/dist/core/prompt-composer.d.ts

@@ -0,0 +1,27 @@
+import type { SystemContextMessage } from './context.js';
+export type PromptSectionStability = 'static' | 'session' | 'volatile';
+export type PromptSectionPlacement = 'system' | 'first-user';
+export type PromptCompositionMode = 'default' | 'custom' | 'bare' | 'agent' | 'subagent';
+export interface PromptSection {
+    id: string;
+    content: string;
+    stability: PromptSectionStability;
+    placement: PromptSectionPlacement;
+}
+export interface PromptComposition {
+    sections: readonly PromptSection[];
+    systemMessages: readonly SystemContextMessage[];
+    firstUserMessageContext?: string;
+    stableSystemSectionCount: number;
+}
+export interface PromptCompositionOptions {
+    mode: PromptCompositionMode;
+    baseSystemPrompt?: string;
+    appendSystemPrompt?: string;
+    sessionSections?: readonly PromptSection[];
+    tailSections?: readonly PromptSection[];
+}
+export declare class PromptComposer {
+    compose(options: PromptCompositionOptions): PromptComposition;
+}
+//# sourceMappingURL=prompt-composer.d.ts.map

package/dist/core/prompt-composer.js

@@ -0,0 +1,99 @@
+const PRODUCT_POLICY = `# Praxis
+
+You are Praxis, a local CLI coding agent. Work until the user's request is genuinely handled or a concrete blocker requires their input.
+
+- Inspect relevant context before acting and use available tools deliberately.
+- Preserve user data, existing changes, and project-specific instructions.
+- Prefer focused, verifiable changes and report important outcomes clearly.
+- Use a scratch or work area when the runtime provides one; keep temporary artifacts out of the user's project.
+- Summarize or clear bulky intermediate results once their useful facts have been retained.
+- Treat the context window as bounded: preserve decisions and evidence before reducing detail.
+- Keep responses concise and use the user's language unless they request otherwise.`;
+function baseSection(mode, content) {
+    if (mode === 'bare')
+        return undefined;
+    if (mode === 'default') {
+        return {
+            id: 'product-policy',
+            content: PRODUCT_POLICY,
+            placement: 'system',
+            stability: 'static',
+        };
+    }
+    if (content === undefined || content.trim().length === 0) {
+        throw new Error(`${mode} prompt mode requires a base system prompt`);
+    }
+    return {
+        id: mode === 'custom'
+            ? 'custom-system'
+            : mode === 'agent'
+                ? 'agent-policy'
+                : 'subagent-policy',
+        content,
+        placement: 'system',
+        stability: 'session',
+    };
+}
+function normalizedSections(sections, group) {
+    return sections
+        .filter((section) => section.content.trim().length > 0)
+        .map((section) => {
+        if (!section.id.trim())
+            throw new Error('Prompt section id is required');
+        if (group === 'sessionSections' && section.stability === 'volatile') {
+            throw new Error('sessionSections cannot contain volatile prompt sections');
+        }
+        if (group === 'tailSections' &&
+            section.placement === 'system' &&
+            section.stability !== 'volatile') {
+            throw new Error('tailSections system entries must be volatile prompt sections');
+        }
+        return { ...section };
+    });
+}
+export class PromptComposer {
+    compose(options) {
+        const base = baseSection(options.mode, options.baseSystemPrompt);
+        const sessionSections = normalizedSections(options.sessionSections ?? [], 'sessionSections');
+        const append = options.appendSystemPrompt?.trim()
+            ? {
+                id: 'append-system',
+                content: options.appendSystemPrompt,
+                placement: 'system',
+                stability: 'session',
+            }
+            : undefined;
+        const tailSections = normalizedSections(options.tailSections ?? [], 'tailSections');
+        const sections = [
+            ...(base ? [base] : []),
+            ...sessionSections,
+            ...(append ? [append] : []),
+            ...tailSections,
+        ];
+        const identities = new Set();
+        for (const section of sections) {
+            if (identities.has(section.id)) {
+                throw new Error(`Duplicate prompt section ${section.id}`);
+            }
+            identities.add(section.id);
+        }
+        const systemSections = sections.filter((section) => section.placement === 'system');
+        const firstVolatileSystemIndex = systemSections.findIndex((section) => section.stability === 'volatile');
+        const firstUserMessageContext = sections
+            .filter((section) => section.placement === 'first-user')
+            .map((section) => section.content)
+            .join('\n\n');
+        return {
+            sections,
+            systemMessages: systemSections.map((section) => ({
+                role: 'system',
+                content: section.content,
+            })),
+            stableSystemSectionCount: firstVolatileSystemIndex < 0
+                ? systemSections.length
+                : firstVolatileSystemIndex,
+            ...(firstUserMessageContext ? { firstUserMessageContext } : {}),
+        };
+    }
+}
+//# sourceMappingURL=prompt-composer.js.map

package/dist/core/runtime.d.ts

@@ -119,6 +119,8 @@ export type ModelStreamEvent = {
 };
 export interface ModelRequest {
     messages: readonly ModelMessage[];
+    /** Number of leading system messages that form the stable prompt prefix. */
+    stableSystemMessageCount?: number;
     tools?: readonly ModelToolDefinition[];
     webSearch?: ModelWebSearch;
     signal?: AbortSignal;
@@ -450,6 +452,8 @@ export interface AgentRuntimeOptions {
 }
 export interface AgentRunRequest {
     messages: readonly ModelMessage[];
+    /** Number of leading system messages that form the stable prompt prefix. */
+    stableSystemMessageCount?: number;
     cwd?: string;
     toolResultDirectory?: string;
     observer?: AgentRunObserver;

package/dist/core/runtime.js

@@ -342,6 +342,11 @@ export class AgentRuntime {
                 this.emit({ type: 'state', state: 'awaiting-model' });
                 const providerRequest = {
                     messages: prepareProviderMessages(messages, this.provider.capabilities.images === true, this.provider.capabilities.documents === true),
+                    ...(request.stableSystemMessageCount === undefined
+                        ? {}
+                        : {
+                            stableSystemMessageCount: request.stableSystemMessageCount,
+                        }),
                 };
                 if (definitions.length > 0)
                     providerRequest.tools = definitions;

package/dist/mcp/claude-mcp-tools.d.ts

@@ -35,6 +35,7 @@ export interface ClaudeMcpRuntime {
     authenticate(name: string): Promise<void>;
     reload(): Promise<void>;
     tools(name: string): Promise<readonly ClaudeMcpToolInspection[]>;
+    instructions?(): readonly ClaudeMcpServerInstruction[];
     connectAgent?(options: {
         specs: readonly unknown[];
         base: ToolRegistry;
@@ -47,6 +48,10 @@ export interface ClaudeMcpRuntime {
     /** Release MCP transports and child processes owned by this runtime. */
     close?(): Promise<void>;
 }
+export interface ClaudeMcpServerInstruction {
+    server: string;
+    instructions: string;
+}
 export interface ClaudeMcpConfigurationStatus {
     name: string;
     path: string;
@@ -67,6 +72,7 @@ export interface ClaudeMcpToolRegistryOptions {
     signal?: AbortSignal;
     eventSink?: RuntimeEventSink;
     onPromptsChanged?: (prompts: readonly ClaudeMcpPromptDefinition[]) => void;
+    onInstructionsChanged?: (instructions: readonly ClaudeMcpServerInstruction[]) => void;
     authenticateServer?: (name: string) => Promise<void>;
     reloadResources?: () => Promise<readonly ClaudeJsonResource[]>;
     onElicitation?: (request: {
@@ -93,6 +99,7 @@ export declare class ClaudeMcpToolRegistry implements ToolRegistry, ClaudeMcpRun
     private readonly serverClients;
     private readonly reconnectableServers;
     private readonly serverCapabilities;
+    private readonly serverInstructions;
     private readonly reconnectingServers;
     private readonly promptOperations;
     private promptResultDirectoryPromise;
@@ -104,6 +111,7 @@ export declare class ClaudeMcpToolRegistry implements ToolRegistry, ClaudeMcpRun
     definitions(): readonly ModelToolDefinition[];
     schedulingPolicy(call: ModelToolCall): import("../core/runtime.js").ToolSchedulingPolicy;
     serverStatuses(): readonly ClaudeMcpServerStatus[];
+    instructions(): readonly ClaudeMcpServerInstruction[];
     inspect(): Promise<readonly ClaudeMcpServerStatus[]>;
     reconnect(name: string): Promise<void>;
     authenticate(name: string): Promise<void>;
@@ -137,6 +145,7 @@ export declare class ClaudeMcpToolRegistry implements ToolRegistry, ClaudeMcpRun
     private ensurePromptConnected;
     private reconnectServer;
     private publishPrompts;
+    private publishInstructions;
     private assertOpenGeneration;
     private trackPromptOperation;
     private promptResultDirectory;

package/dist/mcp/claude-mcp-tools.js

@@ -680,6 +680,7 @@ export class ClaudeMcpToolRegistry {
     serverClients = new Map();
     reconnectableServers = new Map();
     serverCapabilities = new Map();
+    serverInstructions = new Map();
     reconnectingServers = new Map();
     promptOperations = new Set();
     promptResultDirectoryPromise;
@@ -705,10 +706,11 @@ export class ClaudeMcpToolRegistry {
     definitions() {
         return [
             ...this.options.base.definitions(),
+            ...(this.resourceServers.size > 0 ? MCP_RESOURCE_TOOL_DEFINITIONS : []),
             ...[...this.connectedTools.entries()]
                 .filter(([name]) => !this.reservedTools.has(name))
+                .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
                 .map(([, tool]) => tool.definition),
-            ...(this.resourceServers.size > 0 ? MCP_RESOURCE_TOOL_DEFINITIONS : []),
         ];
     }
     schedulingPolicy(call) {
@@ -732,6 +734,11 @@ export class ClaudeMcpToolRegistry {
             status,
         }));
     }
+    instructions() {
+        return [...this.serverInstructions]
+            .map(([server, instructions]) => ({ server, instructions }))
+            .sort((left, right) => left.server.localeCompare(right.server));
+    }
     async inspect() {
         return this.runtimeStatuses();
     }
@@ -763,6 +770,7 @@ export class ClaudeMcpToolRegistry {
         this.statuses.clear();
         this.reconnectableServers.clear();
         this.serverCapabilities.clear();
+        this.serverInstructions.clear();
         const ambientSensitiveValues = sensitiveEnvironmentValues(process.env);
         const warn = (message) => this.options.onWarning?.(redactSensitiveText(message, ambientSensitiveValues));
         await this.configure(this.options.reloadResources
@@ -962,6 +970,7 @@ export class ClaudeMcpToolRegistry {
         await Promise.allSettled([...this.clients].map((client) => client.close()));
         this.clients.clear();
         this.serverClients.clear();
+        this.serverInstructions.clear();
         const directory = await this.promptResultDirectoryPromise?.catch(() => undefined);
         if (directory)
             await rm(directory, { recursive: true, force: true });
@@ -1052,7 +1061,9 @@ export class ClaudeMcpToolRegistry {
             if (this.closed || this.serverClients.get(serverName) !== client)
                 return;
             this.serverCapabilities.delete(serverName);
+            this.serverInstructions.delete(serverName);
             this.statuses.set(serverName, { name: serverName, status: 'failed' });
+            this.publishInstructions();
         };
         client.setRequestHandler(ElicitRequestSchema, async (request) => {
             if (!this.options.onElicitation)
@@ -1131,6 +1142,13 @@ export class ClaudeMcpToolRegistry {
                 ...(capabilities?.resources ? ['resources'] : []),
                 ...(capabilities?.prompts ? ['prompts'] : []),
             ]);
+            const serverInstruction = client.getInstructions()?.trim();
+            if (serverInstruction) {
+                this.serverInstructions.set(serverName, redactSensitiveText(serverInstruction, sensitiveValues));
+            }
+            else {
+                this.serverInstructions.delete(serverName);
+            }
             for (const [name, tool] of connectedTools)
                 this.connectedTools.set(name, tool);
             if (capabilities?.resources) {
@@ -1157,6 +1175,7 @@ export class ClaudeMcpToolRegistry {
                 status: 'connected',
                 statusDetail: 'connected',
             });
+            this.publishInstructions();
         }
         catch (error) {
             await client.close().catch(() => undefined);
@@ -1383,6 +1402,7 @@ export class ClaudeMcpToolRegistry {
         this.resourceServers.delete(serverName);
         this.promptServers.delete(serverName);
         this.serverCapabilities.delete(serverName);
+        this.serverInstructions.delete(serverName);
         await this.connectServer(serverName, reconnectable.config, reconnectable.sensitiveValues, expectedGeneration);
         if (this.statuses.get(serverName)?.status !== 'connected') {
             throw new Error(`MCP server ${serverName} could not reconnect`);
@@ -1393,6 +1413,10 @@ export class ClaudeMcpToolRegistry {
         if (!this.closed)
             this.options.onPromptsChanged?.(this.prompts());
     }
+    publishInstructions() {
+        if (!this.closed)
+            this.options.onInstructionsChanged?.(this.instructions());
+    }
     assertOpenGeneration(expectedGeneration) {
         if (this.closed || expectedGeneration !== this.generation) {
             throw new Error('MCP registry is closed');

package/dist/providers/anthropic-compatible.d.ts

@@ -1,4 +1,5 @@
 import { type ModelProvider, type ModelRequest, type ModelStreamEvent, type ModelThinkingConfig } from '../core/runtime.js';
+import { type AnthropicPromptCachePolicy } from './anthropic-prompt-cache.js';
 export interface AnthropicCompatibleProviderOptions {
     baseUrl: string;
     apiKey: string;
@@ -6,6 +7,7 @@ export interface AnthropicCompatibleProviderOptions {
     maxOutputTokens?: number;
     anthropicVersion?: string;
     webSearch?: boolean;
+    promptCaching?: AnthropicPromptCachePolicy;
     contextWindowTokens?: number;
     thinking?: ModelThinkingConfig;
     maxStreamBufferBytes?: number;
@@ -29,6 +31,7 @@ export declare class AnthropicCompatibleProvider implements ModelProvider {
     private readonly maxToolMetadataBytes;
     private readonly maxErrorBodyBytes;
     private readonly thinking;
+    private readonly promptCaching;
     constructor(options: AnthropicCompatibleProviderOptions);
     complete(request: ModelRequest): AsyncIterable<ModelStreamEvent>;
 }