@kilnai/cli 1.0.7 → 2.0.0

package/dist/wrapper/provider-session.js

@@ -1,38 +1,174 @@
 import { randomUUID } from "node:crypto";
-import { AnthropicAdapter, appendExecutionIdentity, OpenAIAdapter, DeepSeekAdapter, OpenRouterAdapter, OllamaAdapter, resolveExecutionIdentity, textPart, } from "@kilnai/core";
+import { AllCredentialsExhaustedError, EventBus, KilnError, appendExecutionIdentity, getDirectProviderExecutionProfile, resolveExecutionIdentity, textPart, resolveDirectProviderExecutionProfile, } from "@kilnai/core";
+import { buildEffectiveTurnAuthorityPolicyInputs, createAttachedRuntimeBuiltinToolSurface, } from "@kilnai/runtime";
 import { buildProviderSystemPrompt } from "./preamble-builder.js";
+import { PermissionPolicyAuthorizer } from "./permission-policy-authorizer.js";
 import { ProviderContextTracker } from "./provider-context.js";
+import { createDirectProviderAdapter } from "./direct-provider-adapter-factory.js";
+import { createCliOperatorThemeController } from "../application/operator-theme-preferences.js";
 const PROVIDER_PRIORITY = {
+    "codex-oauth": 1,
+    "opencode-go": 2,
+    "opencode-zen": 3,
     anthropic: 4,
     openai: 5,
     openrouter: 6,
     deepseek: 7,
     ollama: 8,
+    lmstudio: 9,
 };
+function getDefaultBillingMode(provider) {
+    const profile = getDirectProviderExecutionProfile(provider);
+    if (profile?.defaultBillingMode === "metered"
+        || profile?.defaultBillingMode === "free"
+        || profile?.defaultBillingMode === "subscription") {
+        return profile.defaultBillingMode;
+    }
+    return provider === "ollama" || provider === "lmstudio" ? "free" : "metered";
+}
+function filterCapabilityMap(capabilities, allowlist) {
+    const filtered = new Map();
+    for (const [name, capability] of capabilities.entries()) {
+        if (allowlist.has(name)) {
+            filtered.set(name, capability);
+        }
+    }
+    return filtered;
+}
+function authorityDescriptorFromCapability(toolName, capability) {
+    const annotations = capability?.annotations;
+    if (!annotations) {
+        return undefined;
+    }
+    if (annotations?.destructive) {
+        return {
+            level: 4,
+            allowed: false,
+            requiresApproval: true,
+            reason: `Destructive tool "${toolName}" requires approval`,
+        };
+    }
+    if (annotations?.readOnly) {
+        return {
+            level: 1,
+            allowed: true,
+            requiresApproval: false,
+            reason: "Read-only tool, auto-execute",
+        };
+    }
+    if (annotations?.idempotent) {
+        return {
+            level: 2,
+            allowed: true,
+            requiresApproval: false,
+            reason: "Audited execution",
+        };
+    }
+    return {
+        level: 2,
+        allowed: true,
+        requiresApproval: false,
+        reason: "Audited execution",
+    };
+}
+function resolveExecutionMode(config) {
+    const profile = resolveProfile(config);
+    return profile?.executionMode ?? "text-only";
+}
+function toSessionToolUseEvent(content) {
+    try {
+        const parsed = JSON.parse(content);
+        return {
+            type: "tool_use",
+            toolName: typeof parsed.name === "string" && parsed.name.length > 0 ? parsed.name : "provider_tool_call",
+            input: parsed.input ?? {},
+        };
+    }
+    catch {
+        return {
+            type: "tool_use",
+            toolName: "provider_tool_call",
+            input: {},
+        };
+    }
+}
+function resolveProfile(config) {
+    return config.executionProfile ?? resolveDirectProviderExecutionProfile({
+        provider: config.provider,
+        model: config.model,
+        requestedExecutionMode: config.executionMode,
+    });
+}
+function toolCalledToSessionEvent(event) {
+    return {
+        type: "tool_use",
+        toolName: event.toolName,
+        input: event.toolInput ?? {},
+    };
+}
+function toolResultToSessionEvent(event) {
+    const output = event.output ?? event.resultSummary ?? "";
+    return {
+        type: "tool_result",
+        toolName: event.toolName,
+        output,
+        ...(event.resultSummary !== undefined && event.resultSummary !== output ? { outputSummary: event.resultSummary } : {}),
+        ...(event.isError ? { isError: true } : {}),
+    };
+}
+function deriveCapabilities(config, builtinToolNames) {
+    const executionMode = resolveExecutionMode(config);
+    const supportedTools = executionMode === "kiln-executable"
+        ? [...builtinToolNames]
+        : [];
+    return {
+        mcp: false,
+        streaming: true,
+        resumable: false,
+        resume: false,
+        costTrackingMode: "computed",
+        supportedTools,
+        maxContextTokens: null,
+        priority: PROVIDER_PRIORITY[config.provider],
+        fallbackTo: null,
+        permissionPolicy: config.permissionPolicy,
+    };
+}
 export class ProviderSession {
     config;
     sessionId;
     _capabilities;
+    executionProfile;
+    executionMode;
+    resolvedModel;
     contextTracker;
+    builtinTools;
+    toolDefinitions;
+    capabilityMap;
+    eventBus;
     constructor(config) {
         this.config = config;
         this.sessionId = randomUUID();
+        this.executionProfile = resolveProfile(config);
+        this.executionMode = this.executionProfile?.executionMode ?? "text-only";
+        this.resolvedModel = this.executionProfile?.model ?? config.model;
         this.contextTracker = new ProviderContextTracker({
             maxContextTokens: 128000,
             compactionThreshold: 0.85,
         });
-        this._capabilities = {
-            mcp: false,
-            streaming: true,
-            resumable: false,
-            resume: false,
-            costTrackingMode: "computed",
-            supportedTools: [],
-            maxContextTokens: null,
-            priority: PROVIDER_PRIORITY[config.provider],
-            fallbackTo: null,
-            permissionPolicy: config.permissionPolicy,
+        const operatorSurface = config.operatorSurface ?? {
+            theme: createCliOperatorThemeController(),
         };
+        const builtinToolSurface = createAttachedRuntimeBuiltinToolSurface({
+            operatorSurface,
+            builtinToolOptions: config.builtinToolOptions,
+            managedInvocation: config.managedInvocation,
+        });
+        this.builtinTools = builtinToolSurface.callBuiltinTools;
+        this.toolDefinitions = builtinToolSurface.toolDefinitions;
+        this.capabilityMap = builtinToolSurface.capabilities;
+        this.eventBus = new EventBus(100);
+        this._capabilities = deriveCapabilities(config, builtinToolSurface.toolDefinitions.map((tool) => tool.name));
     }
     get capabilities() {
         return this._capabilities;
@@ -42,7 +178,6 @@ export class ProviderSession {
     }
     async *run(options) {
         const startedAt = Date.now();
-        let isError = false;
         if (options.abortSignal?.aborted) {
             yield {
                 type: "error",
@@ -60,149 +195,438 @@ export class ProviderSession {
             return;
         }
         try {
-            const adapter = this.createAdapter(options.env);
-            const hasStructuredPreamble = this.isStructuredPreamble(options.prompt);
-            const baseSystemPrompt = hasStructuredPreamble
-                ? options.prompt
-                : (this.config.systemPrompt ?? "");
-            const userPrompt = hasStructuredPreamble
-                ? this.config.task
-                : options.prompt;
-            const systemPrompt = appendExecutionIdentity(buildProviderSystemPrompt(baseSystemPrompt, this.config.constraintInstructions), resolveExecutionIdentity({
-                configuredProvider: this.config.provider,
-                configuredModel: this.config.model,
-            }));
-            const messages = [{
-                    role: "user",
-                    parts: [textPart(userPrompt)],
-                }];
-            for await (const event of adapter.streamMessage({
-                system: systemPrompt,
-                messages,
-            })) {
-                if (options.abortSignal?.aborted) {
-                    isError = true;
-                    yield {
-                        type: "error",
-                        code: "ABORTED",
-                        message: "Aborted during execution",
-                        isRetryable: false,
-                    };
-                    yield {
-                        type: "completed",
-                        totalUsd: 0,
-                        durationMs: Date.now() - startedAt,
-                        isError,
-                        isPreflightCrash: false,
-                    };
-                    return;
-                }
-                if (event.type === "thinking") {
-                    yield { type: "text_delta", content: event.content, isThinking: true };
-                    continue;
+            if (this.executionMode === "kiln-executable") {
+                yield* this.runKilnExecutable(options, startedAt);
+                return;
+            }
+            yield* this.runTextOnly(options, startedAt);
+        }
+        catch (err) {
+            const code = this.executionMode === "kiln-executable"
+                ? "EXECUTABLE_SESSION_ERROR"
+                : "PROVIDER_SESSION_ERROR";
+            const message = this.executionMode === "kiln-executable"
+                ? formatExecutableSessionError(err)
+                : formatProviderSessionError(err);
+            yield { type: "error", code, message, isRetryable: false };
+            yield { type: "completed", totalUsd: 0, durationMs: Date.now() - startedAt, isError: true, isPreflightCrash: false };
+        }
+    }
+    async dispose() {
+        // Stateless direct-provider session; no process/socket lifecycle to tear down.
+    }
+    isStructuredPreamble(prompt) {
+        return prompt.trimStart().startsWith("<kiln-preamble>");
+    }
+    buildSystemAndPrompt(options) {
+        const hasStructuredPreamble = this.isStructuredPreamble(options.prompt);
+        const baseSystemPrompt = options.system ?? (hasStructuredPreamble ? options.prompt : (this.config.systemPrompt ?? ""));
+        const userPrompt = hasStructuredPreamble ? this.config.task : options.prompt;
+        const systemPrompt = appendExecutionIdentity(buildProviderSystemPrompt(baseSystemPrompt, this.config.constraintInstructions, { executionMode: this.executionMode }), resolveExecutionIdentity({
+            configuredProvider: this.config.provider,
+            configuredModel: this.resolvedModel,
+            configuredBillingMode: getDefaultBillingMode(this.config.provider),
+        }));
+        return { systemPrompt, userPrompt };
+    }
+    buildConversationMessages(userPrompt, messages) {
+        const hydrated = [];
+        if (messages && messages.length > 0) {
+            for (let i = 0; i < messages.length - 1; i++) {
+                const message = messages[i];
+                if (message) {
+                    hydrated.push(message);
                 }
-                if (event.type === "text") {
-                    yield { type: "text_delta", content: event.content };
-                    continue;
+            }
+        }
+        hydrated.push({ role: "user", parts: [textPart(userPrompt)] });
+        return hydrated;
+    }
+    hydrateConversation(session, messages) {
+        for (let i = 0; i < messages.length - 1; i++) {
+            const message = messages[i];
+            if (!message)
+                continue;
+            if (message.role === "user") {
+                session.addUserMessage(message.parts);
+            }
+            else {
+                session.addAssistantMessage(message.parts);
+            }
+        }
+    }
+    async *runTextOnly(options, startedAt) {
+        let isError = false;
+        const adapter = await createDirectProviderAdapter({
+            provider: this.config.provider,
+            model: this.resolvedModel,
+            configEnv: this.config.env,
+            runtimeEnv: options.env,
+        });
+        const { systemPrompt, userPrompt } = this.buildSystemAndPrompt(options);
+        const messages = this.buildConversationMessages(userPrompt, options.messages);
+        for await (const event of adapter.streamMessage({
+            system: systemPrompt,
+            messages,
+            reasoningEffort: options.reasoningEffort ?? this.config.reasoningEffort,
+        })) {
+            if (options.abortSignal?.aborted) {
+                isError = true;
+                yield { type: "error", code: "ABORTED", message: "Aborted during execution", isRetryable: false };
+                yield { type: "completed", totalUsd: 0, durationMs: Date.now() - startedAt, isError, isPreflightCrash: false };
+                return;
+            }
+            if (event.type === "thinking") {
+                yield { type: "text_delta", content: event.content, isThinking: true };
+                continue;
+            }
+            if (event.type === "text") {
+                yield { type: "text_delta", content: event.content };
+                continue;
+            }
+            if (event.type === "tool_use") {
+                yield toSessionToolUseEvent(event.content);
+                yield {
+                    type: "error",
+                    code: "TOOL_UNSUPPORTED",
+                    message: "Provider emitted a tool call in text-only execution mode.",
+                    isRetryable: false,
+                };
+                isError = true;
+                continue;
+            }
+            if (event.type === "tool_result") {
+                yield { type: "tool_result", toolName: "provider_tool_result", output: event.content };
+                continue;
+            }
+            if (event.type === "done") {
+                const doneEvent = event;
+                const inputTokens = typeof doneEvent.inputTokens === "number" ? doneEvent.inputTokens : 0;
+                const outputTokens = typeof doneEvent.outputTokens === "number" ? doneEvent.outputTokens : 0;
+                this.contextTracker.update(inputTokens, outputTokens);
+                yield {
+                    type: "cost_update",
+                    usd: 0,
+                    mode: "computed",
+                    provider: this.config.provider,
+                    model: this.resolvedModel,
+                    canonicalModel: this.resolvedModel,
+                    billingMode: getDefaultBillingMode(this.config.provider),
+                    inputTokens,
+                    outputTokens,
+                };
+                yield { type: "completed", totalUsd: 0, durationMs: Date.now() - startedAt, isError, isPreflightCrash: false };
+                return;
+            }
+        }
+        yield {
+            type: "cost_update",
+            usd: 0,
+            mode: "computed",
+            provider: this.config.provider,
+            model: this.resolvedModel,
+            canonicalModel: this.resolvedModel,
+            billingMode: getDefaultBillingMode(this.config.provider),
+        };
+        yield { type: "completed", totalUsd: 0, durationMs: Date.now() - startedAt, isError, isPreflightCrash: false };
+    }
+    buildPerCallConfig(reasoningEffort, requestedAuthority) {
+        if (!requestedAuthority || requestedAuthority === "auto") {
+            return {
+                ...(reasoningEffort ? { reasoningEffort } : {}),
+                ...(requestedAuthority ? {
+                    effectiveTurnAuthority: {
+                        executionMode: "execute",
+                        requestedAuthority,
+                        admittedAuthority: "unknown",
+                        sourcePolicy: "runtime_surface_projection",
+                        reason: "cli direct-provider requested turn authority",
+                        completeness: "partial",
+                        toolCount: this.toolDefinitions.length,
+                        deniedToolCount: 0,
+                        policyInputs: buildEffectiveTurnAuthorityPolicyInputs({
+                            executionMode: "execute",
+                            requestedAuthority,
+                            admittedAuthority: "unknown",
+                            routeReason: "cli direct-provider requested turn authority",
+                        }),
+                    },
+                } : {}),
+            };
+        }
+        const admittedToolNames = new Set();
+        const toolAuthority = new Map();
+        for (const tool of this.toolDefinitions) {
+            const capability = this.capabilityMap.get(tool.name);
+            const authority = authorityDescriptorFromCapability(tool.name, capability);
+            if (!authority || !authority.allowed || authority.requiresApproval) {
+                continue;
+            }
+            if (requestedAuthority === "read_only") {
+                if (capability?.annotations?.readOnly === true && authority.level <= 1) {
+                    admittedToolNames.add(tool.name);
+                    toolAuthority.set(tool.name, authority);
                 }
-                if (event.type === "tool_use") {
-                    // Direct API providers are not wired to Kiln's executable tool substrate.
-                    // Surface provider content as text only; do not emit executable tool events.
-                    yield { type: "text_delta", content: event.content };
-                    continue;
+                continue;
+            }
+            if (authority.level <= 2) {
+                admittedToolNames.add(tool.name);
+                toolAuthority.set(tool.name, authority);
+            }
+        }
+        const admittedAuthority = admittedToolNames.size === 0 ? "fail_closed" : requestedAuthority;
+        return {
+            ...(reasoningEffort ? { reasoningEffort } : {}),
+            toolAllowlist: admittedToolNames,
+            toolAuthority,
+            additionalTools: this.toolDefinitions.filter((tool) => admittedToolNames.has(tool.name)),
+            perCallCapabilities: filterCapabilityMap(this.capabilityMap, admittedToolNames),
+            effectiveTurnAuthority: {
+                executionMode: "execute",
+                requestedAuthority,
+                admittedAuthority,
+                sourcePolicy: "runtime_surface_projection",
+                reason: "cli direct-provider requested turn authority",
+                completeness: "authoritative",
+                toolCount: admittedToolNames.size,
+                deniedToolCount: Math.max(0, this.toolDefinitions.length - admittedToolNames.size),
+                policyInputs: buildEffectiveTurnAuthorityPolicyInputs({
+                    executionMode: "execute",
+                    requestedAuthority,
+                    admittedAuthority,
+                    routeReason: "cli direct-provider requested turn authority",
+                }),
+            },
+        };
+    }
+    async *runKilnExecutable(options, startedAt) {
+        const { RuntimeSessionOrchestrator, RuntimeSession } = await import("@kilnai/runtime");
+        const { systemPrompt, userPrompt } = this.buildSystemAndPrompt(options);
+        const adapter = await createDirectProviderAdapter({
+            provider: this.config.provider,
+            model: this.resolvedModel,
+            configEnv: this.config.env,
+            runtimeEnv: options.env,
+        });
+        const authorizer = new PermissionPolicyAuthorizer(this.config.permissionPolicy);
+        const cliSession = new RuntimeSession({
+            appName: "kiln-cli",
+            tenantId: "cli-session",
+            userId: this.sessionId,
+            systemPrompt,
+            idleTimeoutMs: 30 * 60 * 1000,
+        });
+        const orchestrator = new RuntimeSessionOrchestrator({
+            provider: adapter,
+            model: this.resolvedModel,
+            tools: this.toolDefinitions,
+            builtinTools: this.builtinTools,
+            eventBus: this.eventBus,
+            toolAuthorizer: authorizer,
+            capabilityMap: this.capabilityMap,
+            dangerousCommandDetector: undefined,
+        });
+        if (options.messages && options.messages.length > 0) {
+            this.hydrateConversation(cliSession, options.messages);
+        }
+        const promptParts = [textPart(userPrompt)];
+        const liveToolEvents = [];
+        let hasLiveToolEvents = false;
+        let wakeLiveToolDrain;
+        const enqueueLiveToolEvent = (event) => {
+            hasLiveToolEvents = true;
+            liveToolEvents.push(event);
+            wakeLiveToolDrain?.();
+            wakeLiveToolDrain = undefined;
+        };
+        const onToolCalled = (event) => {
+            if (event.sessionId !== cliSession.id)
+                return;
+            enqueueLiveToolEvent(toolCalledToSessionEvent(event));
+        };
+        const onToolResult = (event) => {
+            if (event.sessionId !== cliSession.id)
+                return;
+            enqueueLiveToolEvent(toolResultToSessionEvent(event));
+        };
+        this.eventBus.on("tool_called", onToolCalled);
+        this.eventBus.on("tool_result", onToolResult);
+        let result;
+        let processError;
+        let processSettled = false;
+        const requestedAuthority = options.requestedAuthority ?? this.config.requestedAuthority;
+        const processPromise = orchestrator.processMessage(cliSession, promptParts, undefined, undefined, this.buildPerCallConfig(options.reasoningEffort ?? this.config.reasoningEffort, requestedAuthority)).then((nextResult) => {
+            result = nextResult;
+        }).catch((err) => {
+            processError = err;
+        }).finally(() => {
+            processSettled = true;
+            wakeLiveToolDrain?.();
+            wakeLiveToolDrain = undefined;
+        });
+        try {
+            while (!processSettled || liveToolEvents.length > 0) {
+                while (liveToolEvents.length > 0) {
+                    yield liveToolEvents.shift();
                 }
-                if (event.type === "tool_result") {
-                    // Same rule as tool_use: no executable tool semantics for direct providers.
-                    yield { type: "text_delta", content: event.content };
-                    continue;
+                if (!processSettled) {
+                    await new Promise((resolve) => {
+                        wakeLiveToolDrain = resolve;
+                    });
                 }
-                if (event.type === "done") {
-                    const doneEvent = event;
-                    const inputTokens = typeof doneEvent.inputTokens === "number" ? doneEvent.inputTokens : 0;
-                    const outputTokens = typeof doneEvent.outputTokens === "number" ? doneEvent.outputTokens : 0;
-                    this.contextTracker.update(inputTokens, outputTokens);
-                    yield { type: "cost_update", usd: 0, mode: "computed" };
+            }
+            await processPromise;
+        }
+        finally {
+            this.eventBus.off("tool_called", onToolCalled);
+            this.eventBus.off("tool_result", onToolResult);
+        }
+        if (processError) {
+            throw processError;
+        }
+        if (!result) {
+            throw new Error("Runtime session orchestrator did not return a result.");
+        }
+        let isError = false;
+        for (const toolExec of result.toolExecutions ?? []) {
+            if (!hasLiveToolEvents) {
+                const output = toolExec.output ?? toolExec.resultSummary;
+                if (toolExec.toolCallId || toolExec.input) {
                     yield {
-                        type: "completed",
-                        totalUsd: 0,
-                        durationMs: Date.now() - startedAt,
-                        isError,
-                        isPreflightCrash: false,
+                        type: "tool_use",
+                        toolName: toolExec.toolName,
+                        input: toolExec.input ?? {},
+                        ...(toolExec.toolCallId ? { toolCallId: toolExec.toolCallId } : {}),
                     };
-                    return;
+                }
+                yield {
+                    type: "tool_result",
+                    toolName: toolExec.toolName,
+                    output,
+                    ...(toolExec.resultSummary !== output ? { outputSummary: toolExec.resultSummary } : {}),
+                    ...(toolExec.toolCallId ? { toolCallId: toolExec.toolCallId } : {}),
+                    ...(!toolExec.success ? { isError: true } : {}),
+                };
+            }
+            if (toolExec.fileChanges && toolExec.fileChanges.length > 0) {
+                for (const fileChange of toolExec.fileChanges) {
+                    yield { type: "file_changed", path: fileChange.path, changeType: fileChange.changeType };
                 }
             }
-            yield { type: "cost_update", usd: 0, mode: "computed" };
-            yield {
-                type: "completed",
-                totalUsd: 0,
-                durationMs: Date.now() - startedAt,
-                isError,
-                isPreflightCrash: false,
-            };
         }
-        catch (err) {
+        for (const part of result.parts) {
+            if (part.type === "text") {
+                yield { type: "text_delta", content: part.text };
+            }
+        }
+        if (result.escalation) {
             yield {
                 type: "error",
-                code: "PROVIDER_SESSION_ERROR",
-                message: err instanceof Error ? err.message : String(err),
+                code: "ESCALATION",
+                message: result.escalation.reason,
                 isRetryable: false,
             };
-            yield {
-                type: "completed",
-                totalUsd: 0,
-                durationMs: Date.now() - startedAt,
-                isError: true,
-                isPreflightCrash: false,
-            };
+            isError = true;
         }
-    }
-    async dispose() {
-        // Stateless direct-provider session; no process/socket lifecycle to tear down.
-    }
-    resolveEnv(name, runtimeEnv) {
-        return runtimeEnv?.[name] ?? this.config.env?.[name] ?? process.env[name];
-    }
-    createAdapter(runtimeEnv) {
-        const provider = this.config.provider;
-        if (provider === "anthropic") {
-            const apiKey = this.resolveRequiredApiKey("ANTHROPIC_API_KEY", runtimeEnv);
-            return new AnthropicAdapter({ apiKey, defaultModel: this.config.model });
-        }
-        if (provider === "openai") {
-            const apiKey = this.resolveRequiredApiKey("OPENAI_API_KEY", runtimeEnv);
-            return new OpenAIAdapter({ apiKey, defaultModel: this.config.model });
-        }
-        if (provider === "deepseek") {
-            const apiKey = this.resolveRequiredApiKey("DEEPSEEK_API_KEY", runtimeEnv);
-            return new DeepSeekAdapter({ apiKey, defaultModel: this.config.model });
-        }
-        if (provider === "openrouter") {
-            const apiKey = this.resolveRequiredApiKey("OPENROUTER_API_KEY", runtimeEnv);
-            const appUrl = this.resolveEnv("OPENROUTER_APP_URL", runtimeEnv);
-            const appName = this.resolveEnv("OPENROUTER_APP_NAME", runtimeEnv);
-            return new OpenRouterAdapter({
-                apiKey,
-                defaultModel: this.config.model,
-                appUrl,
-                appName,
-            });
-        }
-        const baseUrl = this.resolveEnv("OLLAMA_BASE_URL", runtimeEnv);
-        return new OllamaAdapter({
-            baseUrl,
-            defaultModel: this.config.model,
+        this.contextTracker.update(result.inputTokens ?? 0, result.outputTokens ?? 0);
+        const executionIdentity = resolveExecutionIdentity({
+            configuredProvider: this.config.provider,
+            configuredModel: this.resolvedModel,
+            configuredBillingMode: getDefaultBillingMode(this.config.provider),
+            routedProvider: result.routingDecision?.provider,
+            routedModel: result.routingDecision?.model,
+            routedCanonicalModel: result.routingDecision?.canonicalModel,
+            routedBillingMode: result.routingDecision?.billingMode,
         });
+        yield {
+            type: "cost_update",
+            usd: 0,
+            mode: "computed",
+            provider: executionIdentity?.provider,
+            model: executionIdentity?.model,
+            canonicalModel: executionIdentity?.canonicalModel,
+            billingMode: executionIdentity?.billingMode,
+            inputTokens: result.inputTokens,
+            outputTokens: result.outputTokens,
+            cacheReadTokens: result.cacheReadTokens,
+        };
+        yield { type: "completed", totalUsd: 0, durationMs: Date.now() - startedAt, isError, isPreflightCrash: false };
     }
-    resolveRequiredApiKey(name, runtimeEnv) {
-        const apiKey = this.resolveEnv(name, runtimeEnv);
-        if (!apiKey || apiKey.trim().length === 0) {
-            throw new Error(`Missing required API key: ${name}`);
+}
+function formatExecutableSessionError(error) {
+    if (error instanceof AllCredentialsExhaustedError) {
+        return formatCredentialPoolExhaustion(error);
+    }
+    if (error instanceof KilnError) {
+        const status = typeof error.context.status === "number" ? error.context.status : undefined;
+        const responseBody = typeof error.context.responseBody === "string"
+            ? error.context.responseBody.trim()
+            : "";
+        const toolReplaySummary = typeof error.context.toolReplaySummary === "string"
+            ? error.context.toolReplaySummary.trim()
+            : "";
+        const suffixParts = [];
+        if (status !== undefined) {
+            suffixParts.push(`status ${status}`);
+        }
+        if (responseBody.length > 0) {
+            const compactBody = responseBody.replace(/\s+/g, " ").slice(0, 240);
+            suffixParts.push(compactBody);
         }
-        return apiKey;
+        if (toolReplaySummary.length > 0) {
+            suffixParts.push(toolReplaySummary);
+        }
+        if (suffixParts.length === 0) {
+            return error.message;
+        }
+        return `${error.message} (${suffixParts.join(": ")})`;
     }
-    isStructuredPreamble(prompt) {
-        return prompt.trimStart().startsWith("<kiln-preamble>");
+    return formatProviderSessionError(error);
+}
+function formatProviderSessionError(error) {
+    if (error instanceof AllCredentialsExhaustedError) {
+        return formatCredentialPoolExhaustion(error);
+    }
+    return readErrorMessage(error);
+}
+function formatCredentialPoolExhaustion(error) {
+    const details = [
+        formatCredentialOutcome(error.lastOutcome),
+        formatCredentialCause(error.cause),
+    ].filter((detail) => Boolean(detail));
+    if (details.length === 0) {
+        return error.message;
     }
+    return `${error.message}: ${details.join("; ")}`;
+}
+function formatCredentialOutcome(outcome) {
+    if (!outcome) {
+        return undefined;
+    }
+    switch (outcome.type) {
+        case "rate-limited":
+            return outcome.resetAt
+                ? `last outcome rate-limited until ${new Date(outcome.resetAt).toISOString()}`
+                : "last outcome rate-limited";
+        case "quota-exceeded":
+            return "last outcome quota-exceeded";
+        case "auth-failed":
+            return "last outcome auth-failed";
+        case "connection-failed":
+            return "last outcome connection-failed";
+        case "unknown-error":
+            return outcome.message ? `last outcome unknown-error: ${outcome.message}` : "last outcome unknown-error";
+        case "ok":
+            return "last outcome ok";
+    }
+}
+function formatCredentialCause(cause) {
+    if (cause === null || cause === undefined) {
+        return undefined;
+    }
+    return `last error ${readErrorMessage(cause)}`;
+}
+function readErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
 }
 //# sourceMappingURL=provider-session.js.map