@uncensoredcode/openbridge 0.1.0

package/packages/runtime/dist/execution/in-process.d.ts

@@ -0,0 +1,14 @@
+import type { ExecutionRequest, ExecutionResponse, RuntimeTool, ToolDefinition, ToolExecutor } from "./types.ts";
+type InProcessToolExecutorOptions = {
+    tools?: RuntimeTool[];
+};
+declare class InProcessToolExecutor implements ToolExecutor {
+    #private;
+    constructor(options?: InProcessToolExecutorOptions);
+    getAvailableTools(): Promise<ToolDefinition[]>;
+    executeTool(request: ExecutionRequest): Promise<ExecutionResponse>;
+}
+export declare const inProcessModule: {
+    InProcessToolExecutor: typeof InProcessToolExecutor;
+};
+export type { InProcessToolExecutor, InProcessToolExecutorOptions };

package/packages/runtime/dist/execution/in-process.js

@@ -0,0 +1,45 @@
+import { executionTypesModule } from "./types.js";
+const { ToolExecutionError, toolFailure } = executionTypesModule;
+class InProcessToolExecutor {
+    #toolsByName;
+    constructor(options = {}) {
+        this.#toolsByName = new Map((options.tools ?? []).map((tool) => [tool.definition.name, tool]));
+    }
+    async getAvailableTools() {
+        return [...this.#toolsByName.values()].map((tool) => tool.definition);
+    }
+    async executeTool(request) {
+        return executeToolCall(this.#toolsByName, request.call);
+    }
+}
+async function executeToolCall(toolsByName, call) {
+    const tool = toolsByName.get(call.name);
+    if (!tool) {
+        return {
+            ok: false,
+            payload: toolFailure("tool_not_found", `Tool "${call.name}" is not registered.`)
+        };
+    }
+    try {
+        const payload = await tool.execute(call.args);
+        return {
+            ok: true,
+            payload
+        };
+    }
+    catch (error) {
+        if (error instanceof ToolExecutionError) {
+            return {
+                ok: false,
+                payload: toolFailure(error.code, error.message)
+            };
+        }
+        return {
+            ok: false,
+            payload: toolFailure("tool_execution_failed", error instanceof Error ? error.message : String(error))
+        };
+    }
+}
+export const inProcessModule = {
+    InProcessToolExecutor
+};

package/packages/runtime/dist/execution/types.d.ts

@@ -0,0 +1,49 @@
+import type { ToolCall } from "../protocol.ts";
+type ToolSchema = {
+    type: "object";
+    properties: Record<string, {
+        type: "string" | "boolean";
+        description: string;
+    }>;
+    required: string[];
+};
+type ToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: ToolSchema;
+};
+type ToolFailurePayload = {
+    error: {
+        code: string;
+        message: string;
+    };
+};
+type ToolExecutionResult = {
+    ok: true;
+    payload: unknown;
+} | {
+    ok: false;
+    payload: ToolFailurePayload;
+};
+type ExecutionRequest = {
+    call: ToolCall;
+};
+type ExecutionResponse = ToolExecutionResult;
+interface ToolExecutor {
+    getAvailableTools(): Promise<ToolDefinition[]>;
+    executeTool(request: ExecutionRequest): Promise<ExecutionResponse>;
+}
+type RuntimeTool = {
+    definition: ToolDefinition;
+    execute(args: Record<string, unknown>): Promise<unknown>;
+};
+declare class ToolExecutionError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+declare function toolFailure(code: string, message: string): ToolFailurePayload;
+export declare const executionTypesModule: {
+    ToolExecutionError: typeof ToolExecutionError;
+    toolFailure: typeof toolFailure;
+};
+export type { ExecutionRequest, ExecutionResponse, RuntimeTool, ToolDefinition, ToolExecutionError, ToolExecutionResult, ToolExecutor, ToolFailurePayload, ToolSchema };

package/packages/runtime/dist/execution/types.js

@@ -0,0 +1,20 @@
+class ToolExecutionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ToolExecutionError";
+        this.code = code;
+    }
+}
+function toolFailure(code, message) {
+    return {
+        error: {
+            code,
+            message
+        }
+    };
+}
+export const executionTypesModule = {
+    ToolExecutionError,
+    toolFailure
+};

package/packages/runtime/dist/index.d.ts

@@ -0,0 +1,86 @@
+export declare const bridgeRuntime: {
+    AssistantProtocolError: typeof import("./assistant-protocol.ts").AssistantProtocolError;
+    createFinalResponse: (message: string) => string;
+    createToolResponse: (toolCall: import("./assistant-protocol.ts").AssistantToolCall) => string;
+    parseAndValidateAssistantResponse: (rawText: string, availableTools: import("./execution/types.ts").ToolDefinition[]) => import("./assistant-protocol.ts").AssistantFinalResponse | import("./assistant-protocol.ts").AssistantToolResponse;
+    parseAssistantResponse: (rawText: string) => import("./assistant-protocol.ts").AssistantResponse;
+    serializeAssistantResponse: (response: import("./assistant-protocol.ts").AssistantResponse) => string;
+    validateAssistantResponse: (response: import("./assistant-protocol.ts").AssistantResponse, availableTools: import("./execution/types.ts").ToolDefinition[]) => import("./assistant-protocol.ts").AssistantFinalResponse | import("./assistant-protocol.ts").AssistantToolResponse;
+    extractPacketCandidate: (rawText: string) => import("./packet-extractor.ts").PacketExtractionResult;
+    InProcessToolExecutor: typeof import("./execution/in-process.ts").InProcessToolExecutor;
+    ToolExecutionError: typeof import("./execution/types.ts").ToolExecutionError;
+    toolFailure: (code: string, message: string) => import("./execution/types.ts").ToolFailurePayload;
+    extractPacketMessage: (content: string) => string | null;
+    looksLikeInternalControlText: (content: string) => boolean;
+    sanitizeVisibleModelOutput: (content: string, options: {
+        packetMessageReason: string;
+        documentReason: string;
+        controlReason: string;
+        fallbackMessage: string;
+        documentFallbackMessage: string;
+    }) => import("./output-sanitizer.ts").VisibleModelOutputSanitizationResult;
+    normalizeProviderPacket: (_providerId: string, extractedCandidate: string) => import("./packet-normalizer.ts").PacketNormalizationResult;
+    compileProviderTurn: (input: import("./prompt-compiler.ts").CompileProviderTurnInput) => import("./prompt-compiler.ts").CompiledProviderTurn;
+    createBashTool: (options: {
+        runtimeRoot: string;
+    }) => import("./execution/types.ts").RuntimeTool;
+    createDefaultRuntimeTools: (runtimeRoot: string) => import("./execution/types.ts").RuntimeTool[];
+    createEditTool: (options: {
+        runtimeRoot: string;
+    }) => import("./execution/types.ts").RuntimeTool;
+    createListDirTool: (options: {
+        workspaceRoot: string;
+    }) => import("./execution/types.ts").RuntimeTool;
+    createReadTool: (options: {
+        runtimeRoot: string;
+    }) => import("./execution/types.ts").RuntimeTool;
+    createRuntimeTools: (input: {
+        profile?: import("./tools/registry.ts").RuntimeToolProfile;
+        runtimeRoot: string;
+        workspaceRoot?: string;
+    }) => import("./execution/types.ts").RuntimeTool[];
+    createSearchFilesTool: (options: {
+        workspaceRoot: string;
+    }) => import("./execution/types.ts").RuntimeTool;
+    createSecondaryRuntimeTools: (workspaceRoot: string) => import("./execution/types.ts").RuntimeTool[];
+    createWriteTool: (options: {
+        runtimeRoot: string;
+    }) => import("./execution/types.ts").RuntimeTool;
+    ensureRuntimeRoot: (runtimeRoot: string) => Promise<string>;
+    ensureWorkspaceRoot: (workspaceRoot: string) => Promise<string>;
+    MAX_FILE_READ_BYTES: number;
+    MAX_FILE_WRITE_BYTES: number;
+    resolveRuntimePath: (runtimeRoot: string, requestedPath: string) => Promise<string>;
+    resolveWorkspacePath: (input: {
+        workspaceRoot: string;
+        requestedPath: string;
+        kind: "read" | "write";
+    }) => Promise<import("./tools/workspace-path.ts").ResolvedWorkspacePath>;
+    normalizeProviderToolName: (name: string) => string;
+    createMessagePacket: (mode: Extract<import("./protocol.ts").PacketMode, "final" | "ask_user" | "fail">, message: string) => string;
+    createToolRequestPacket: (toolCall: import("./protocol.ts").ToolCall) => string;
+    parseZcPacket: (rawText: string) => import("./protocol.ts").ZcPacket;
+    serializeToolResult: (result: import("./protocol.ts").ToolResult) => string;
+    PacketProtocolError: typeof import("./protocol.ts").PacketProtocolError;
+    ProviderFailure: typeof import("./provider-failure.ts").ProviderFailure;
+    classifyProviderTransportError: (error: unknown) => import("./provider-failure.ts").ProviderFailure;
+    formatProviderFailureMessage: (error: import("./provider-failure.ts").ProviderFailure) => string;
+    isProviderFailure: (error: unknown) => error is import("./provider-failure.ts").ProviderFailure;
+    serializeProviderFailure: (error: import("./provider-failure.ts").ProviderFailure) => import("./provider-failure.ts").SerializedProviderFailure;
+    withProviderRecovery: (error: import("./provider-failure.ts").ProviderFailure, recovery: Partial<import("./provider-failure.ts").ProviderRecoveryState>, overrides?: Partial<Pick<import("./provider-failure.ts").ProviderFailure, "kind" | "displayMessage" | "retryable" | "sessionResetEligible">>) => import("./provider-failure.ts").ProviderFailure;
+    runBridgeRuntime: (input: import("./runtime.ts").RunRuntimeInput) => Promise<import("./runtime.ts").RuntimeOutcome>;
+    SessionBoundProviderAdapter: typeof import("./session-bound-provider.ts").SessionBoundProviderAdapter;
+};
+export type { AssistantFinalResponse, AssistantProtocolError, AssistantResponse, AssistantToolCall, AssistantToolResponse } from "./assistant-protocol.ts";
+export type { InProcessToolExecutor } from "./execution/in-process.ts";
+export type { ExecutionRequest, ExecutionResponse, RuntimeTool, ToolDefinition, ToolExecutionError, ToolExecutionResult, ToolExecutor, ToolFailurePayload, ToolSchema } from "./execution/types.ts";
+export type { VisibleModelOutputSanitizationResult } from "./output-sanitizer.ts";
+export type { PacketExtractionFailure, PacketExtractionResult, PacketExtractionSuccess } from "./packet-extractor.ts";
+export type { PacketNormalizationFailure, PacketNormalizationFailureCode, PacketNormalizationResult, PacketNormalizationStrategy, PacketNormalizationSuccess } from "./packet-normalizer.ts";
+export type { CompiledProviderMessage, CompiledProviderTurn, CompileProviderTurnInput } from "./prompt-compiler.ts";
+export type { AskUserPacket, FailPacket, FinalPacket, PacketMode, PacketProtocolError, ToolCall, ToolRequestPacket, ToolResult, ZcPacket } from "./protocol.ts";
+export type { BridgeSessionTurn, ConversationEntry, ConversationState, ProviderAdapter, ProviderTurnInput, RepairInvalidResponseInput } from "./provider.ts";
+export type { ProviderFailure, ProviderFailureCode, ProviderFailureKind, ProviderRecoveryState, SerializedProviderFailure } from "./provider-failure.ts";
+export type { RunRuntimeInput, RuntimeConfig, RuntimeEvent, RuntimeFailure, RuntimeOutcome, RuntimeTerminalMode } from "./runtime.ts";
+export type { ProviderTransport, ProviderTransportRequest, ProviderTransportResponse, SessionBindingStore, SessionBoundProviderAdapter, SessionBoundProviderAdapterOptions, UpstreamConversationBinding } from "./session-bound-provider.ts";
+export type { ResolvedWorkspacePath, RuntimeToolProfile } from "./tools/index.ts";

package/packages/runtime/dist/index.js

@@ -0,0 +1,60 @@
+import { assistantProtocolModule } from "./assistant-protocol.js";
+import { inProcessModule } from "./execution/in-process.js";
+import { executionTypesModule } from "./execution/types.js";
+import { outputSanitizerModule } from "./output-sanitizer.js";
+import { packetExtractorModule } from "./packet-extractor.js";
+import { packetNormalizerModule } from "./packet-normalizer.js";
+import { promptCompilerModule } from "./prompt-compiler.js";
+import { protocolModule } from "./protocol.js";
+import { providerFailureModule } from "./provider-failure.js";
+import { runtimeModule } from "./runtime.js";
+import { sessionBoundProviderModule } from "./session-bound-provider.js";
+import { toolNameAliasesModule } from "./tool-name-aliases.js";
+import { toolsModule } from "./tools/index.js";
+export const bridgeRuntime = {
+    AssistantProtocolError: assistantProtocolModule.AssistantProtocolError,
+    createFinalResponse: assistantProtocolModule.createFinalResponse,
+    createToolResponse: assistantProtocolModule.createToolResponse,
+    parseAndValidateAssistantResponse: assistantProtocolModule.parseAndValidateAssistantResponse,
+    parseAssistantResponse: assistantProtocolModule.parseAssistantResponse,
+    serializeAssistantResponse: assistantProtocolModule.serializeAssistantResponse,
+    validateAssistantResponse: assistantProtocolModule.validateAssistantResponse,
+    extractPacketCandidate: packetExtractorModule.extractPacketCandidate,
+    InProcessToolExecutor: inProcessModule.InProcessToolExecutor,
+    ToolExecutionError: executionTypesModule.ToolExecutionError,
+    toolFailure: executionTypesModule.toolFailure,
+    extractPacketMessage: outputSanitizerModule.extractPacketMessage,
+    looksLikeInternalControlText: outputSanitizerModule.looksLikeInternalControlText,
+    sanitizeVisibleModelOutput: outputSanitizerModule.sanitizeVisibleModelOutput,
+    normalizeProviderPacket: packetNormalizerModule.normalizeProviderPacket,
+    compileProviderTurn: promptCompilerModule.compileProviderTurn,
+    createBashTool: toolsModule.createBashTool,
+    createDefaultRuntimeTools: toolsModule.createDefaultRuntimeTools,
+    createEditTool: toolsModule.createEditTool,
+    createListDirTool: toolsModule.createListDirTool,
+    createReadTool: toolsModule.createReadTool,
+    createRuntimeTools: toolsModule.createRuntimeTools,
+    createSearchFilesTool: toolsModule.createSearchFilesTool,
+    createSecondaryRuntimeTools: toolsModule.createSecondaryRuntimeTools,
+    createWriteTool: toolsModule.createWriteTool,
+    ensureRuntimeRoot: toolsModule.ensureRuntimeRoot,
+    ensureWorkspaceRoot: toolsModule.ensureWorkspaceRoot,
+    MAX_FILE_READ_BYTES: toolsModule.MAX_FILE_READ_BYTES,
+    MAX_FILE_WRITE_BYTES: toolsModule.MAX_FILE_WRITE_BYTES,
+    resolveRuntimePath: toolsModule.resolveRuntimePath,
+    resolveWorkspacePath: toolsModule.resolveWorkspacePath,
+    normalizeProviderToolName: toolNameAliasesModule.normalizeProviderToolName,
+    createMessagePacket: protocolModule.createMessagePacket,
+    createToolRequestPacket: protocolModule.createToolRequestPacket,
+    parseZcPacket: protocolModule.parseZcPacket,
+    serializeToolResult: protocolModule.serializeToolResult,
+    PacketProtocolError: protocolModule.PacketProtocolError,
+    ProviderFailure: providerFailureModule.ProviderFailure,
+    classifyProviderTransportError: providerFailureModule.classifyProviderTransportError,
+    formatProviderFailureMessage: providerFailureModule.formatProviderFailureMessage,
+    isProviderFailure: providerFailureModule.isProviderFailure,
+    serializeProviderFailure: providerFailureModule.serializeProviderFailure,
+    withProviderRecovery: providerFailureModule.withProviderRecovery,
+    runBridgeRuntime: runtimeModule.runBridgeRuntime,
+    SessionBoundProviderAdapter: sessionBoundProviderModule.SessionBoundProviderAdapter
+};

package/packages/runtime/dist/normalizers/index.d.ts

@@ -0,0 +1,6 @@
+import type { PacketNormalizationResult } from "../packet-normalizer.ts";
+declare function normalizeGenericLegacyPacket(candidate: string): PacketNormalizationResult | null;
+export declare const normalizersModule: {
+    normalizeGenericLegacyPacket: typeof normalizeGenericLegacyPacket;
+};
+export {};

package/packages/runtime/dist/normalizers/index.js

@@ -0,0 +1,12 @@
+import { legacyPacketModule } from "./legacy-packet.js";
+const { normalizeLegacyPacket } = legacyPacketModule;
+function normalizeGenericLegacyPacket(candidate) {
+    const trimmed = candidate.trim();
+    if (!trimmed.startsWith("<packet")) {
+        return null;
+    }
+    return normalizeLegacyPacket(trimmed);
+}
+export const normalizersModule = {
+    normalizeGenericLegacyPacket
+};

package/packages/runtime/dist/normalizers/legacy-packet.d.ts

@@ -0,0 +1,6 @@
+import type { PacketNormalizationResult } from "../packet-normalizer.ts";
+declare function normalizeLegacyPacket(candidate: string): PacketNormalizationResult;
+export declare const legacyPacketModule: {
+    normalizeLegacyPacket: typeof normalizeLegacyPacket;
+};
+export {};

package/packages/runtime/dist/normalizers/legacy-packet.js

@@ -0,0 +1,131 @@
+import { protocolModule } from "../protocol.js";
+const { createMessagePacket, createToolRequestPacket } = protocolModule;
+function normalizeLegacyPacket(candidate) {
+    const rootMatch = candidate.trim().match(/^<packet\b([^>]*)>([\s\S]*)<\/packet>$/);
+    if (!rootMatch) {
+        return fail("invalid_provider_packet", 'Legacy packet normalization expects a single root <packet mode="..."> element.', []);
+    }
+    const attributes = rootMatch[1] ?? "";
+    const body = rootMatch[2] ?? "";
+    const modeMatch = attributes.match(/\bmode="([^"]+)"/);
+    if (!modeMatch) {
+        return fail("invalid_provider_packet", 'Legacy packet is missing required mode="..." attribute.', []);
+    }
+    const mode = parseMode(modeMatch[1] ?? "");
+    if (!mode) {
+        return fail("invalid_provider_packet", `Legacy packet mode "${(modeMatch[1] ?? "").trim() || "(empty)"}" is not supported.`, []);
+    }
+    if (mode === "tool_request") {
+        const toolNode = extractSingleTag(body, "tool_call");
+        if (!toolNode.ok) {
+            return toolNode;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(toolNode.inner.trim());
+        }
+        catch {
+            return fail("invalid_provider_packet", "Legacy tool_call body must contain valid JSON.", [
+                'Expected an object with string "name" and object "args" fields.'
+            ]);
+        }
+        if (!isRecord(parsed)) {
+            return fail("invalid_provider_packet", "Legacy tool_call JSON must decode to an object.", []);
+        }
+        const name = typeof parsed.name === "string" ? parsed.name.trim() : "";
+        if (!name) {
+            return fail("invalid_provider_packet", 'Legacy tool_call JSON requires a non-empty "name" field.', []);
+        }
+        if (!isRecord(parsed.args)) {
+            return fail("invalid_provider_packet", 'Legacy tool_call JSON requires an object "args" field.', []);
+        }
+        const toolCall = {
+            id: typeof parsed.id === "string" && parsed.id.trim() ? parsed.id.trim() : "call_1",
+            name,
+            args: parsed.args
+        };
+        return {
+            ok: true,
+            strategy: "legacy_packet_v1",
+            canonicalPacket: createToolRequestPacket(toolCall),
+            notes: [
+                `Normalized legacy tool_request for tool "${name}".`,
+                `Synthesized tool call id "${toolCall.id}".`
+            ]
+        };
+    }
+    const messageNode = extractSingleTag(body, "message");
+    if (!messageNode.ok) {
+        return messageNode;
+    }
+    const message = parseMessage(messageNode.inner);
+    if (!message.ok) {
+        return message;
+    }
+    return {
+        ok: true,
+        strategy: "legacy_packet_v1",
+        canonicalPacket: createMessagePacket(mode, message.value),
+        notes: [`Normalized legacy ${mode} packet into canonical zc_packet form.`]
+    };
+}
+function parseMode(input) {
+    switch (input.trim()) {
+        case "final":
+        case "tool_request":
+        case "ask_user":
+        case "fail":
+            return input.trim();
+        default:
+            return null;
+    }
+}
+function extractSingleTag(source, tagName) {
+    const expression = new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`, "g");
+    const matches = [...source.matchAll(expression)];
+    if (matches.length !== 1) {
+        return fail("invalid_provider_packet", `Legacy ${tagName === "tool_call" ? "tool_request" : "message"} packet must contain exactly one <${tagName}> element.`, []);
+    }
+    const match = matches[0];
+    const index = match.index ?? 0;
+    const fullMatch = match[0];
+    const remainder = `${source.slice(0, index)}${source.slice(index + fullMatch.length)}`;
+    if (remainder.trim().length > 0) {
+        return fail("invalid_provider_packet", `Legacy <${tagName}> packet contained unexpected content outside <${tagName}>.`, []);
+    }
+    return {
+        ok: true,
+        inner: match[1] ?? ""
+    };
+}
+function parseMessage(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("<![CDATA[") && trimmed.endsWith("]]>")) {
+        return {
+            ok: true,
+            value: trimmed.slice("<![CDATA[".length, -"]]>".length).trim()
+        };
+    }
+    if (trimmed.includes("<")) {
+        return fail("invalid_provider_packet", "Legacy message packets must contain plain text or a single CDATA section.", []);
+    }
+    return {
+        ok: true,
+        value: trimmed
+    };
+}
+function fail(code, message, notes) {
+    return {
+        ok: false,
+        strategy: "legacy_packet_v1",
+        code,
+        message,
+        notes
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export const legacyPacketModule = {
+    normalizeLegacyPacket
+};

package/packages/runtime/dist/output-sanitizer.d.ts

@@ -0,0 +1,23 @@
+type VisibleModelOutputSanitizationResult = {
+    content: string;
+    sanitized: false;
+} | {
+    content: string;
+    sanitized: true;
+    reason: string;
+};
+declare function sanitizeVisibleModelOutput(content: string, options: {
+    packetMessageReason: string;
+    documentReason: string;
+    controlReason: string;
+    fallbackMessage: string;
+    documentFallbackMessage: string;
+}): VisibleModelOutputSanitizationResult;
+declare function extractPacketMessage(content: string): string | null;
+declare function looksLikeInternalControlText(content: string): boolean;
+export declare const outputSanitizerModule: {
+    sanitizeVisibleModelOutput: typeof sanitizeVisibleModelOutput;
+    extractPacketMessage: typeof extractPacketMessage;
+    looksLikeInternalControlText: typeof looksLikeInternalControlText;
+};
+export type { VisibleModelOutputSanitizationResult };

package/packages/runtime/dist/output-sanitizer.js

@@ -0,0 +1,78 @@
+function sanitizeVisibleModelOutput(content, options) {
+    const trimmed = content.trim();
+    if (!trimmed) {
+        return {
+            content,
+            sanitized: false
+        };
+    }
+    if (/^<(?:final|tool|zc_packet|packet)\b/i.test(trimmed)) {
+        const extractedMessage = extractPacketMessage(trimmed);
+        if (extractedMessage) {
+            return {
+                content: extractedMessage,
+                sanitized: true,
+                reason: options.packetMessageReason
+            };
+        }
+        return {
+            content: options.fallbackMessage,
+            sanitized: true,
+            reason: "packet_reply_suppressed"
+        };
+    }
+    if (/\[DOCUMENT:[^\]]+\]/i.test(trimmed)) {
+        return {
+            content: options.documentFallbackMessage,
+            sanitized: true,
+            reason: options.documentReason
+        };
+    }
+    if (looksLikeInternalControlText(trimmed)) {
+        return {
+            content: options.fallbackMessage,
+            sanitized: true,
+            reason: options.controlReason
+        };
+    }
+    return {
+        content,
+        sanitized: false
+    };
+}
+function extractPacketMessage(content) {
+    const finalMatch = content.match(/<final>([\s\S]*?)<\/final>/i);
+    if (finalMatch) {
+        const finalMessage = (finalMatch[1] ?? "").trim();
+        return finalMessage || null;
+    }
+    const messageMatch = content.match(/<message>([\s\S]*?)<\/message>/i);
+    if (!messageMatch) {
+        return null;
+    }
+    const rawMessage = (messageMatch[1] ?? "").trim();
+    if (!rawMessage) {
+        return null;
+    }
+    const cdataMatch = rawMessage.match(/^<!\[CDATA\[([\s\S]*?)\]\]>$/i);
+    const value = (cdataMatch?.[1] ?? rawMessage).trim();
+    return value || null;
+}
+function looksLikeInternalControlText(content) {
+    const normalized = content.toLowerCase();
+    return (normalized.includes("use <final>...</final>") ||
+        normalized.includes('use <tool>{"name":"tool_name","arguments":{...}}</tool>') ||
+        normalized.includes("respond with exactly one block and nothing else") ||
+        normalized.includes("protocol error.") ||
+        normalized.includes("return exactly one zc_packet") ||
+        normalized.includes("respond with exactly one xml packet") ||
+        normalized.includes("continue the same task using the tool result below") ||
+        normalized.includes("do not wrap xml in explanations") ||
+        normalized.includes("your previous reply was invalid and was discarded") ||
+        normalized.includes("available tools:"));
+}
+export const outputSanitizerModule = {
+    sanitizeVisibleModelOutput,
+    extractPacketMessage,
+    looksLikeInternalControlText
+};

package/packages/runtime/dist/packet-extractor.d.ts

@@ -0,0 +1,17 @@
+type PacketExtractionSuccess = {
+    ok: true;
+    format: "zc_packet" | "provider_packet";
+    packetText: string;
+};
+type PacketExtractionFailure = {
+    ok: false;
+    code: "no_packet_found" | "multiple_packets_found";
+    message: string;
+    candidates: string[];
+};
+type PacketExtractionResult = PacketExtractionSuccess | PacketExtractionFailure;
+declare function extractPacketCandidate(rawText: string): PacketExtractionResult;
+export declare const packetExtractorModule: {
+    extractPacketCandidate: typeof extractPacketCandidate;
+};
+export type { PacketExtractionFailure, PacketExtractionResult, PacketExtractionSuccess };

package/packages/runtime/dist/packet-extractor.js

@@ -0,0 +1,43 @@
+const CANDIDATE_PATTERNS = [
+    {
+        format: "zc_packet",
+        pattern: /<zc_packet version="1">[\s\S]*?<\/zc_packet>/g
+    },
+    {
+        format: "provider_packet",
+        pattern: /<packet\b[^>]*\bmode="(?:final|tool_request|ask_user|fail)"[^>]*>[\s\S]*?<\/packet>/g
+    }
+];
+function extractPacketCandidate(rawText) {
+    const candidates = CANDIDATE_PATTERNS.flatMap(({ format, pattern }) => [...rawText.matchAll(pattern)]
+        .map((match) => ({
+        format,
+        packetText: (match[0] ?? "").trim(),
+        index: match.index ?? 0
+    }))
+        .filter((match) => match.packetText)).sort((left, right) => left.index - right.index);
+    if (candidates.length === 1) {
+        return {
+            ok: true,
+            format: candidates[0].format,
+            packetText: candidates[0].packetText
+        };
+    }
+    if (candidates.length > 1) {
+        return {
+            ok: false,
+            code: "multiple_packets_found",
+            message: `Found ${candidates.length} packet candidates in provider output.`,
+            candidates: candidates.map((candidate) => candidate.packetText)
+        };
+    }
+    return {
+        ok: false,
+        code: "no_packet_found",
+        message: "Provider output did not contain a recognized packet block.",
+        candidates: []
+    };
+}
+export const packetExtractorModule = {
+    extractPacketCandidate
+};

package/packages/runtime/dist/packet-normalizer.d.ts

@@ -0,0 +1,21 @@
+type PacketNormalizationStrategy = "canonical_passthrough" | "canonical_repaired_tool_call_close_tag" | "legacy_packet_v1";
+type PacketNormalizationFailureCode = "unsupported_provider_packet" | "invalid_provider_packet";
+type PacketNormalizationSuccess = {
+    ok: true;
+    strategy: PacketNormalizationStrategy;
+    canonicalPacket: string;
+    notes: string[];
+};
+type PacketNormalizationFailure = {
+    ok: false;
+    strategy: PacketNormalizationStrategy | "none";
+    code: PacketNormalizationFailureCode;
+    message: string;
+    notes: string[];
+};
+type PacketNormalizationResult = PacketNormalizationSuccess | PacketNormalizationFailure;
+declare function normalizeProviderPacket(_providerId: string, extractedCandidate: string): PacketNormalizationResult;
+export declare const packetNormalizerModule: {
+    normalizeProviderPacket: typeof normalizeProviderPacket;
+};
+export type { PacketNormalizationFailure, PacketNormalizationFailureCode, PacketNormalizationResult, PacketNormalizationStrategy, PacketNormalizationSuccess };