salmon-loop 0.2.3

package/dist/core/llm/ai-sdk.js

@@ -0,0 +1,92 @@
+import { randomUUID } from 'crypto';
+import { LIMITS } from '../config/limits.js';
+import { getPatchPrompt, getPlanPrompt } from '../prompts/runtime.js';
+import { executeAiSdkChatRequest, executeAiSdkChatStreamRequest } from './ai-sdk/chat-executor.js';
+import { toAiSdkMessages, toAiSdkToolSet } from './ai-sdk/message-mapper.js';
+import { withAuditObservationName } from './ai-sdk/observation-context.js';
+import { createAiSdkChatModel, resolveAiSdkModelId } from './ai-sdk/provider-factory.js';
+import { wrapPlanEmpty, sanitizeError, LlmError } from './errors.js';
+import { extractUnifiedDiffFromLLMContent, formatContextForPrompt, parsePlanFromLLMContent, } from './utils.js';
+export class AiSdkLLM {
+    cfg;
+    model;
+    modelId;
+    timeoutMs;
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.modelId = resolveAiSdkModelId(cfg.modelId);
+        this.timeoutMs = cfg.timeoutMs;
+        this.model = createAiSdkChatModel(cfg, this.modelId);
+    }
+    getModelId() {
+        return this.modelId;
+    }
+    getCapabilities() {
+        return {
+            toolCalling: true,
+            responseFormatJsonObject: true,
+            streaming: true,
+        };
+    }
+    async chat(messages, options = {}) {
+        const aiMessages = toAiSdkMessages(messages);
+        const tools = toAiSdkToolSet(options.tools, options.toolSpecs);
+        return executeAiSdkChatRequest({
+            model: this.model,
+            modelId: this.modelId,
+            timeoutMs: this.timeoutMs,
+            langfuseEnabled: Boolean(this.cfg.langfuseEnabled),
+            requestId: randomUUID(),
+            messages: aiMessages,
+            tools,
+            options,
+        });
+    }
+    async *chatStream(messages, options = {}) {
+        const aiMessages = toAiSdkMessages(messages);
+        const tools = toAiSdkToolSet(options.tools, options.toolSpecs);
+        yield* executeAiSdkChatStreamRequest({
+            model: this.model,
+            modelId: this.modelId,
+            timeoutMs: this.timeoutMs,
+            langfuseEnabled: Boolean(this.cfg.langfuseEnabled),
+            requestId: randomUUID(),
+            messages: aiMessages,
+            tools,
+            options,
+        });
+    }
+    /**
+     * Explicit tool-aware streaming method for the pipeline.
+     * This surfaces text deltas and tool calls as they arrive.
+     */
+    async *chatWithToolsStreaming(messages, options = {}) {
+        // Current pipeline implementation expects chatStream to handle basic deltas.
+        // This is a specialized version that ensures tool-call governance can be observed.
+        yield* this.chatStream(messages, options);
+    }
+    async createPlan(context, instruction, lastError, signal) {
+        const prompt = await getPlanPrompt(formatContextForPrompt(context), instruction, LIMITS.maxFilesChanged, lastError);
+        const response = await withAuditObservationName('PLAN:plan-json', async () => this.chat([{ role: 'user', content: prompt }], { signal }));
+        const content = response.content;
+        if (!content) {
+            throw wrapPlanEmpty();
+        }
+        try {
+            return parsePlanFromLLMContent(content);
+        }
+        catch (e) {
+            throw new LlmError('LLM plan parsing failed', 'LLM_PLAN_INVALID_JSON', {
+                causeMessage: sanitizeError(e),
+            });
+        }
+    }
+    async createPatch(context, plan, lastError, signal) {
+        const planStr = JSON.stringify(plan, null, 2);
+        const formattedContext = formatContextForPrompt(context);
+        const prompt = await getPatchPrompt(planStr, formattedContext, LIMITS.maxFilesChanged, LIMITS.maxDiffLines, lastError);
+        const response = await withAuditObservationName('PATCH:unified-diff', async () => this.chat([{ role: 'user', content: prompt }], { signal }));
+        return extractUnifiedDiffFromLLMContent(response.content || '');
+    }
+}
+//# sourceMappingURL=ai-sdk.js.map

package/dist/core/llm/audit.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=audit.js.map

package/dist/core/llm/base-url.js

@@ -0,0 +1,18 @@
+const ENV_ORDER = ['SALMONLOOP_BASE_URL', 'S8P_BASE_URL'];
+function trimValue(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function normalizeUrl(value) {
+    return value.replace(/\/+$/, '');
+}
+export function resolveBaseUrl(override) {
+    const candidate = trimValue(override) ||
+        ENV_ORDER.map((name) => trimValue(process.env[name])).find((v) => Boolean(v));
+    if (!candidate)
+        return undefined;
+    return normalizeUrl(candidate);
+}
+//# sourceMappingURL=base-url.js.map

package/dist/core/llm/contracts/repair.js

@@ -0,0 +1,68 @@
+import { LIMITS } from '../../config/limits.js';
+function truncateForPrompt(text, maxChars) {
+    const value = String(text ?? '');
+    if (value.length <= maxChars)
+        return value;
+    const head = Math.max(0, Math.floor(maxChars * 0.6));
+    const tail = Math.max(0, maxChars - head);
+    return `${value.slice(0, head)}\n…[truncated]…\n${value.slice(-tail)}`;
+}
+export async function repairToJsonObject(args) {
+    const { llm, baseMessages, chatOptions, badContent, reason } = args;
+    const prompt = [
+        'Your previous response did not satisfy the contract.',
+        `Reason: ${reason}`,
+        '',
+        'Return ONLY a single JSON object.',
+        '- No Markdown fences.',
+        '- No commentary.',
+        '- No leading/trailing text.',
+        '',
+        'The JSON object MUST include keys: goal, files, changes, verify.',
+        '',
+        'Previous response (truncated):',
+        truncateForPrompt(badContent, Math.min(1200, Math.max(400, LIMITS.maxContextChars / 100))),
+    ].join('\n');
+    return llm.chat([
+        ...baseMessages,
+        { role: 'assistant', content: badContent || '' },
+        { role: 'user', content: prompt },
+    ], {
+        ...chatOptions,
+        responseFormat: 'json_object',
+        // Ensure the model cannot get "distracted" by tool calling during repair.
+        tools: undefined,
+        toolSpecs: undefined,
+        toolChoice: undefined,
+        temperature: 0,
+    });
+}
+export async function repairToUnifiedDiff(args) {
+    const { llm, baseMessages, chatOptions, badContent, reason } = args;
+    const prompt = [
+        'Your previous response did not satisfy the contract.',
+        `Reason: ${reason}`,
+        '',
+        'Return ONLY a standard git unified diff patch.',
+        '- It MUST start with `diff --git`.',
+        '- No Markdown fences.',
+        '- No commentary.',
+        '- Exactly one final patch block (no multiple alternatives).',
+        '',
+        'Previous response (truncated):',
+        truncateForPrompt(badContent, Math.min(1200, Math.max(400, LIMITS.maxContextChars / 100))),
+    ].join('\n');
+    return llm.chat([
+        ...baseMessages,
+        { role: 'assistant', content: badContent || '' },
+        { role: 'user', content: prompt },
+    ], {
+        ...chatOptions,
+        responseFormat: 'text',
+        tools: undefined,
+        toolSpecs: undefined,
+        toolChoice: undefined,
+        temperature: 0,
+    });
+}
+//# sourceMappingURL=repair.js.map

package/dist/core/llm/errors.js

@@ -0,0 +1,172 @@
+import { SalmonError } from '../types/errors.js';
+import { sanitizeErrorMessage } from '../utils/sanitizer.js';
+export class LlmError extends SalmonError {
+    llmCode;
+    meta;
+    constructor(message, llmCode, meta) {
+        // Ensure SalmonError receives llmCode as its core code
+        super(message, llmCode);
+        this.llmCode = llmCode;
+        this.meta = meta;
+    }
+}
+function truncate(value, max = 500) {
+    if (value.length <= max)
+        return value;
+    return value.slice(0, max) + '...';
+}
+function extractProviderDetails(err) {
+    const details = {};
+    if (err && typeof err === 'object') {
+        const candidate = err;
+        // Handle AI SDK's APICallError/RetryError structure
+        if (candidate.lastError) {
+            return extractProviderDetails(candidate.lastError);
+        }
+        if (typeof candidate.statusCode === 'number') {
+            details.statusCode = candidate.statusCode;
+        }
+        if (typeof candidate.responseBody === 'string') {
+            // Apply sanitization to responseBody immediately after truncation
+            details.responseBody = sanitizeError(truncate(candidate.responseBody));
+            // Try to parse JSON from responseBody to get a better message
+            try {
+                const parsed = JSON.parse(candidate.responseBody);
+                if (parsed?.error?.message) {
+                    details.providerMessage = sanitizeError(parsed.error.message);
+                }
+                else if (parsed?.message) {
+                    details.providerMessage = sanitizeError(parsed.message);
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        else if (candidate.responseBody) {
+            details.responseBody = truncate(JSON.stringify(candidate.responseBody));
+        }
+        // Check for nested error objects (common in Google/Anthropic APIs)
+        const data = candidate.data;
+        if (data && typeof data.error === 'object' && data.error) {
+            const errInfo = data.error;
+            if (typeof errInfo.message === 'string') {
+                details.providerMessage = sanitizeError(truncate(errInfo.message));
+            }
+            else if (typeof errInfo.details === 'string') {
+                details.providerMessage = sanitizeError(truncate(errInfo.details));
+            }
+        }
+        // Also check if the 'message' property itself contains JSON (common in some SDK wrappers)
+        if (!details.providerMessage && typeof candidate.message === 'string') {
+            const jsonMatch = candidate.message.match(/HTTP \d+: ({[\s\S]*})/);
+            if (jsonMatch && jsonMatch[1]) {
+                try {
+                    const parsed = JSON.parse(jsonMatch[1]);
+                    if (parsed?.error?.message) {
+                        details.providerMessage = sanitizeError(parsed.error.message);
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    return details;
+}
+/**
+ * Sanitizes an error message using the shared utility to prevent leakage
+ * of sensitive technical data.
+ */
+export function sanitizeError(err) {
+    return sanitizeErrorMessage(err);
+}
+export function toLlmError(err, provider) {
+    let name = err instanceof Error ? err.name : 'UnknownError';
+    let message = err instanceof Error ? err.message : String(err);
+    // Unwrap RetryError to get the last error's message if available
+    if (name === 'AI_RetryError' || err?.lastError) {
+        const lastError = err.lastError;
+        // Update the error reference so subsequent checks work on the actual cause
+        err = lastError;
+        if (lastError instanceof Error) {
+            name = lastError.name;
+            message = lastError.message;
+        }
+    }
+    // Handle AI SDK Validation Errors (Zod)
+    if (name === 'AI_TypeValidationError' ||
+        name === 'ZodError' ||
+        name.includes('TypeValidationError') ||
+        message.includes('TypeValidationError') ||
+        err?.[Symbol.for('vercel.ai.error.AI_TypeValidationError')]) {
+        return new LlmError('LLM validation failed', 'LLM_VALIDATION_FAILED', {
+            provider,
+            causeName: name,
+            causeMessage: sanitizeError(err),
+        });
+    }
+    // Use provider-specific details if available
+    const providerDetails = extractProviderDetails(err);
+    if (providerDetails.providerMessage) {
+        message = providerDetails.providerMessage;
+    }
+    // Apply unified sanitization
+    const sanitizedMessage = sanitizeError(err);
+    const isValidationFailure = sanitizedMessage.includes('validation failed') || name === 'AI_TypeValidationError';
+    const meta = {
+        provider,
+        causeName: name,
+        causeMessage: sanitizeError(err),
+        ...providerDetails,
+    };
+    if (isValidationFailure) {
+        return new LlmError(sanitizedMessage, 'LLM_VALIDATION_FAILED', meta);
+    }
+    if (name === 'AbortError' || /aborted/i.test(message)) {
+        return new LlmError('Request aborted', 'LLM_HTTP_ABORTED', meta);
+    }
+    if (/Unexpected end of JSON input/i.test(message)) {
+        return new LlmError('Invalid JSON response from LLM', 'LLM_HTTP_RESPONSE_INVALID_JSON', meta);
+    }
+    // Use a generic message for all other HTTP failures
+    if (isContextLengthExceeded({
+        statusCode: meta.statusCode,
+        providerMessage: meta.providerMessage,
+    })) {
+        return new LlmError('LLM context length exceeded', 'LLM_CONTEXT_LENGTH_EXCEEDED', meta);
+    }
+    return new LlmError('LLM request failed', 'LLM_HTTP_REQUEST_FAILED', meta);
+}
+function isContextLengthExceeded(input) {
+    if (input.statusCode !== 400 && input.statusCode !== 413)
+        return false;
+    const msg = (input.providerMessage ?? '').toLowerCase();
+    if (!msg)
+        return false;
+    return (msg.includes('maximum context length') ||
+        msg.includes('context length') ||
+        msg.includes('too many tokens') ||
+        msg.includes('prompt is too long') ||
+        msg.includes('input is too long') ||
+        msg.includes('reduce the length') ||
+        msg.includes('please reduce'));
+}
+export function wrapPlanEmpty() {
+    return new LlmError('LLM returned an empty plan', 'LLM_PLAN_EMPTY');
+}
+export function wrapPlanInvalidJson() {
+    return new LlmError('LLM returned invalid JSON for plan', 'LLM_PLAN_INVALID_JSON');
+}
+export function wrapPatchEmpty(reason) {
+    const msg = reason ? `LLM returned an empty patch: ${reason}` : 'LLM returned an empty patch';
+    return new LlmError(msg, 'LLM_PATCH_EMPTY');
+}
+export function wrapPatchNotUnifiedDiff() {
+    return new LlmError('LLM patch is not in unified diff format', 'LLM_PATCH_NOT_UNIFIED_DIFF');
+}
+export function wrapPatchInvalid(message) {
+    return new LlmError(message, 'LLM_PATCH_INVALID');
+}
+//# sourceMappingURL=errors.js.map

package/dist/core/llm/factory.js

@@ -0,0 +1,21 @@
+import { createDefaultLlmRegistry, createDefaultOpenAiFallback, } from './registry.js';
+export function createRuntimeLlm(resolved, options) {
+    const registry = createDefaultLlmRegistry();
+    if (resolved.clientPackage) {
+        const adapter = registry.resolve({
+            providerType: resolved.type,
+            clientPackage: resolved.clientPackage,
+        });
+        if (adapter) {
+            return adapter(resolved, options);
+        }
+        // If the user requested a package explicitly but it's not registered, keep going with a stable warning.
+        const fallback = createDefaultOpenAiFallback(resolved, options);
+        return {
+            ...fallback,
+            warnings: Array.from(new Set([...fallback.warnings, 'CLIENT_PACKAGE_NOT_SUPPORTED'])),
+        };
+    }
+    return createDefaultOpenAiFallback(resolved, options);
+}
+//# sourceMappingURL=factory.js.map

package/dist/core/llm/http/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/core/llm/index.js

@@ -0,0 +1,6 @@
+// Keep `src/core/llm.ts` as the stable import path for existing code/tests.
+// Implementations live under `src/core/llm/` to match the project layout.
+export { StubLLM, FakeLLM } from './openai.js';
+export { AiSdkLLM } from './ai-sdk.js';
+export { LlmError, sanitizeError, toLlmError } from './errors.js';
+//# sourceMappingURL=index.js.map

package/dist/core/llm/message-composition.js

@@ -0,0 +1,25 @@
+function toSafeConversationMessage(msg) {
+    if (!msg || typeof msg !== 'object')
+        return null;
+    if (msg.role !== 'user' && msg.role !== 'assistant')
+        return null;
+    if (typeof msg.content !== 'string')
+        return null;
+    const content = msg.content.trimEnd();
+    if (!content)
+        return null;
+    return { role: msg.role, content };
+}
+export function composeChatMessages(params) {
+    const out = [{ role: 'system', content: String(params.system ?? '') }];
+    if (Array.isArray(params.conversationContext)) {
+        for (const msg of params.conversationContext) {
+            const safe = toSafeConversationMessage(msg);
+            if (safe)
+                out.push(safe);
+        }
+    }
+    out.push({ role: 'user', content: String(params.user ?? '') });
+    return out;
+}
+//# sourceMappingURL=message-composition.js.map

package/dist/core/llm/openai.js

@@ -0,0 +1,69 @@
+export class StubLLM {
+    getCapabilities() {
+        return {
+            toolCalling: false,
+            responseFormatJsonObject: false,
+            streaming: false,
+        };
+    }
+    async chat(messages) {
+        const lastMsg = messages[messages.length - 1];
+        return {
+            role: 'assistant',
+            content: `Stub response for: ${lastMsg.content.substring(0, 50)}...`,
+        };
+    }
+    async createPlan(_context, instruction, _lastError) {
+        return {
+            goal: `Implement functionality based on instruction "${instruction}"`,
+            files: ['example.txt'],
+            changes: ['Modify example file content'],
+            verify: 'Check if changes are applied correctly',
+        };
+    }
+    async createPatch(_context, _plan, _lastError) {
+        return `diff --git a/example.txt b/example.txt
+index 1234567..abcdefg 100644
+--- a/example.txt
++++ b/example.txt
+@@ -1,3 +1,3 @@
+-Hello
++Hello World
+ Test
+-End
++End Test`;
+    }
+}
+/**
+ * A fake LLM for deterministic testing.
+ */
+export class FakeLLM {
+    plans;
+    patches;
+    constructor(plans, patches) {
+        this.plans = plans;
+        this.patches = patches;
+    }
+    planIndex = 0;
+    patchIndex = 0;
+    getCapabilities() {
+        return {
+            toolCalling: false,
+            responseFormatJsonObject: false,
+            streaming: false,
+        };
+    }
+    async chat(_messages) {
+        return {
+            role: 'assistant',
+            content: 'Fake chat response',
+        };
+    }
+    async createPlan() {
+        return this.plans[this.planIndex++] || this.plans[this.plans.length - 1];
+    }
+    async createPatch() {
+        return this.patches[this.patchIndex++] || this.patches[this.patches.length - 1];
+    }
+}
+//# sourceMappingURL=openai.js.map

package/dist/core/llm/output-policy.js

@@ -0,0 +1,192 @@
+import { LIMITS } from '../config/limits.js';
+import { CanonicalResponsesEventEmitter } from '../streaming/canonical/canonical-responses-event-emitter.js';
+import { LLM_OUTPUT_KINDS } from '../types/llm.js';
+const SECRET_LINE_PATTERN = /(api[-_]?key|authorization|token|secret|password|cookie)/i;
+const TOKEN_LIKE_PATTERN = /[A-Za-z0-9_\-/+=]{16,}/;
+const STREAM_SANITIZATION_STATE = new Map();
+const STREAM_CANONICAL_EMITTERS = new Map();
+export const DEFAULT_LLM_OUTPUT_POLICY = {
+    kinds: ['review', 'assistant_message', 'plan'],
+};
+function normalizeKinds(kinds) {
+    const seen = new Set();
+    const out = [];
+    for (const kind of kinds) {
+        if (!LLM_OUTPUT_KINDS.includes(kind))
+            continue;
+        if (seen.has(kind))
+            continue;
+        seen.add(kind);
+        out.push(kind);
+    }
+    return out;
+}
+export function resolveLlmOutputPolicy(input) {
+    if (!input)
+        return { ...DEFAULT_LLM_OUTPUT_POLICY };
+    if (input.kinds === undefined)
+        return { ...DEFAULT_LLM_OUTPUT_POLICY };
+    return {
+        kinds: normalizeKinds(input.kinds),
+    };
+}
+export function shouldEmitLlmOutput(policy, kind) {
+    const effective = policy ?? DEFAULT_LLM_OUTPUT_POLICY;
+    return effective.kinds.includes(kind);
+}
+export function sanitizeLlmOutput(content) {
+    let output = String(content ?? '');
+    if (!output)
+        return '';
+    const redacted = output.split('\n').map(redactPotentialSecretLine).join('\n');
+    output = redacted.split('\u0000').join('');
+    if (output.length > LIMITS.maxLogLength) {
+        output = output.substring(0, LIMITS.maxLogLength) + '...';
+    }
+    return output;
+}
+function redactPotentialSecretLine(line) {
+    if (!SECRET_LINE_PATTERN.test(line))
+        return line;
+    const assignment = line.match(/^(.*?)([:=]\s*)(.+)$/);
+    if (assignment) {
+        return `${assignment[1]}${assignment[2]}[REDACTED]`;
+    }
+    if (TOKEN_LIKE_PATTERN.test(line)) {
+        return '[REDACTED]';
+    }
+    return line;
+}
+function sanitizeLlmStreamDelta(streamId, delta) {
+    if (!delta)
+        return '';
+    if (STREAM_SANITIZATION_STATE.size > 256 && !STREAM_SANITIZATION_STATE.has(streamId)) {
+        STREAM_SANITIZATION_STATE.clear();
+    }
+    const state = STREAM_SANITIZATION_STATE.get(streamId) ?? { raw: '', emittedLength: 0 };
+    state.raw = (state.raw + delta).split('\u0000').join('');
+    // Keep bounded memory while preserving enough history for cross-chunk redaction.
+    if (state.raw.length > LIMITS.maxLogLength * 4) {
+        state.raw = state.raw.slice(-LIMITS.maxLogLength * 2);
+        state.emittedLength = 0;
+    }
+    const sanitized = sanitizeLlmOutput(state.raw);
+    const next = sanitized.slice(state.emittedLength);
+    state.emittedLength = sanitized.length;
+    STREAM_SANITIZATION_STATE.set(streamId, state);
+    return next;
+}
+function getCanonicalEmitter(streamId) {
+    if (STREAM_CANONICAL_EMITTERS.size > 256 && !STREAM_CANONICAL_EMITTERS.has(streamId)) {
+        STREAM_CANONICAL_EMITTERS.clear();
+    }
+    const existing = STREAM_CANONICAL_EMITTERS.get(streamId);
+    if (existing)
+        return existing;
+    const created = new CanonicalResponsesEventEmitter();
+    STREAM_CANONICAL_EMITTERS.set(streamId, created);
+    return created;
+}
+function getSanitizedStreamText(streamId) {
+    const st = STREAM_SANITIZATION_STATE.get(streamId);
+    if (!st)
+        return '';
+    return sanitizeLlmOutput(st.raw);
+}
+export function emitLlmOutput(params) {
+    const { emit, policy, kind, step, content } = params;
+    if (!emit)
+        return;
+    if (!shouldEmitLlmOutput(policy, kind))
+        return;
+    const sanitized = sanitizeLlmOutput(content);
+    if (!sanitized.trim())
+        return;
+    emit({
+        type: 'llm.output',
+        kind,
+        step,
+        content: sanitized,
+        timestamp: new Date(),
+    });
+}
+export function emitLlmStreamDelta(params) {
+    const { emit, policy, kind, step, streamId, content } = params;
+    if (!emit)
+        return;
+    if (!shouldEmitLlmOutput(policy, kind))
+        return;
+    const sanitized = sanitizeLlmStreamDelta(streamId, content);
+    if (!sanitized)
+        return;
+    const timestamp = new Date();
+    const emitter = getCanonicalEmitter(streamId);
+    const canonical = emitter.push({
+        type: 'output_text.delta',
+        streamId,
+        delta: sanitized,
+        logprobs: [],
+    });
+    for (const event of canonical) {
+        emit({
+            type: 'llm.responses.event',
+            kind,
+            step,
+            streamId,
+            source: 'synthesized',
+            event,
+            timestamp,
+        });
+    }
+    emit({
+        type: 'llm.stream.delta',
+        kind,
+        step,
+        streamId,
+        content: sanitized,
+        timestamp,
+    });
+}
+export function emitLlmStreamEnd(params) {
+    const { emit, policy, kind, step, streamId, finishReason } = params;
+    if (!emit)
+        return;
+    if (!streamId)
+        return;
+    if (!shouldEmitLlmOutput(policy, kind))
+        return;
+    const timestamp = new Date();
+    const finalText = getSanitizedStreamText(streamId);
+    const emitter = getCanonicalEmitter(streamId);
+    const doneEvents = [
+        ...emitter.push({
+            type: 'output_text.done',
+            streamId,
+            text: finalText,
+            logprobs: [],
+        }),
+        ...emitter.finish(streamId),
+    ];
+    for (const event of doneEvents) {
+        emit({
+            type: 'llm.responses.event',
+            kind,
+            step,
+            streamId,
+            source: 'synthesized',
+            event,
+            timestamp,
+        });
+    }
+    emit({
+        type: 'llm.stream.end',
+        kind,
+        step,
+        streamId,
+        finishReason,
+        timestamp,
+    });
+    STREAM_CANONICAL_EMITTERS.delete(streamId);
+    STREAM_SANITIZATION_STATE.delete(streamId);
+}
+//# sourceMappingURL=output-policy.js.map