@uncensoredcode/openbridge 0.1.0

package/packages/runtime/dist/runtime.js

@@ -0,0 +1,462 @@
+import { assistantProtocolModule } from "./assistant-protocol.js";
+import { packetExtractorModule } from "./packet-extractor.js";
+import { packetNormalizerModule } from "./packet-normalizer.js";
+import { protocolModule } from "./protocol.js";
+import { providerFailureModule } from "./provider-failure.js";
+import { toolNameAliasesModule } from "./tool-name-aliases.js";
+const { parseAssistantResponse, validateAssistantResponse } = assistantProtocolModule;
+const { extractPacketCandidate } = packetExtractorModule;
+const { normalizeProviderPacket } = packetNormalizerModule;
+const { parseZcPacket, serializeToolResult } = protocolModule;
+const { normalizeProviderToolName } = toolNameAliasesModule;
+const { formatProviderFailureMessage, isProviderFailure, serializeProviderFailure, withProviderRecovery } = providerFailureModule;
+const DEFAULT_MAX_STEPS = 8;
+async function runBridgeRuntime(input) {
+    const maxSteps = input.config?.maxSteps ?? DEFAULT_MAX_STEPS;
+    const conversation = {
+        sessionHistory: input.sessionHistory ?? [],
+        entries: [
+            {
+                type: "user_message",
+                content: input.userMessage
+            }
+        ]
+    };
+    const availableTools = await input.toolExecutor.getAvailableTools();
+    for (let step = 1; step <= maxSteps; step += 1) {
+        let rawText;
+        const providerStartedAt = Date.now();
+        try {
+            rawText = await input.provider.completeTurn({
+                conversation,
+                availableTools
+            });
+        }
+        catch (error) {
+            if (isProviderFailure(error)) {
+                const serialized = serializeProviderFailure(withProviderRecovery(error, error.recovery, {
+                    displayMessage: formatProviderFailureMessage(error)
+                }));
+                return emitOutcome({
+                    mode: "fail",
+                    message: serialized.message,
+                    steps: step,
+                    conversation,
+                    failure: {
+                        source: "provider",
+                        provider: serialized
+                    }
+                }, input.config);
+            }
+            return emitOutcome({
+                mode: "fail",
+                message: `Provider adapter failed: ${error instanceof Error ? error.message : String(error)}`,
+                steps: step,
+                conversation,
+                failure: {
+                    source: "provider",
+                    provider: {
+                        kind: "permanent",
+                        code: "transport_error",
+                        message: `Provider adapter failed: ${error instanceof Error ? error.message : String(error)}`,
+                        retryable: false,
+                        sessionResetEligible: false,
+                        emptyOutput: false,
+                        recovery: {
+                            softRetryCount: 0,
+                            sessionResetCount: 0
+                        }
+                    }
+                }
+            }, input.config);
+        }
+        input.config?.onEvent?.({
+            type: "provider_response",
+            step,
+            rawText,
+            durationMs: Date.now() - providerStartedAt
+        });
+        let response;
+        try {
+            response = parseAndValidateProviderResponse(input.provider.id, rawText, availableTools);
+        }
+        catch (error) {
+            const validationError = error instanceof Error ? error.message : String(error);
+            input.config?.onEvent?.({
+                type: "main_response_invalid",
+                step,
+                error: validationError,
+                rawTextLength: rawText.length
+            });
+            input.config?.onEvent?.({
+                type: "packet_parse_failed",
+                step,
+                error: validationError
+            });
+            input.config?.onEvent?.({
+                type: "repair_attempted",
+                step
+            });
+            const repaired = await attemptResponseRepair({
+                provider: input.provider,
+                conversation,
+                availableTools,
+                invalidResponse: rawText,
+                validationError
+            });
+            if (!repaired.ok) {
+                input.config?.onEvent?.({
+                    type: "repair_failed",
+                    step,
+                    reason: repaired.failure.source === "provider" ? "provider_failure" : "protocol_invalid",
+                    error: repaired.failure.source === "protocol" ? repaired.failure.message : undefined,
+                    providerFailure: repaired.failure.source === "provider"
+                        ? {
+                            kind: repaired.failure.provider.kind,
+                            code: repaired.failure.provider.code,
+                            message: repaired.failure.provider.message
+                        }
+                        : undefined
+                });
+                if (repaired.failure.source === "provider") {
+                    return emitOutcome({
+                        mode: "fail",
+                        message: repaired.failure.provider.message,
+                        steps: step,
+                        conversation,
+                        failure: repaired.failure
+                    }, input.config);
+                }
+                return emitOutcome({
+                    mode: "fail",
+                    message: repaired.failure.message,
+                    steps: step,
+                    conversation,
+                    failure: repaired.failure
+                }, input.config);
+            }
+            rawText = repaired.rawText;
+            try {
+                response = parseAndValidateProviderResponse(input.provider.id, rawText, availableTools);
+            }
+            catch (repairError) {
+                const repairValidationError = repairError instanceof Error ? repairError.message : String(repairError);
+                input.config?.onEvent?.({
+                    type: "packet_parse_failed",
+                    step,
+                    error: repairValidationError
+                });
+                input.config?.onEvent?.({
+                    type: "repair_failed",
+                    step,
+                    reason: "protocol_invalid",
+                    error: `Invalid assistant response: ${repairValidationError}`
+                });
+                return emitOutcome({
+                    mode: "fail",
+                    message: `Invalid assistant response: ${repairValidationError}`,
+                    steps: step,
+                    conversation,
+                    failure: {
+                        source: "protocol",
+                        code: "malformed_provider_packet",
+                        message: `Invalid assistant response: ${repairValidationError}`
+                    }
+                }, input.config);
+            }
+            input.config?.onEvent?.({
+                type: "repair_valid",
+                step,
+                mode: getParsedResponseMode(response),
+                rawTextLength: rawText.length
+            });
+        }
+        input.config?.onEvent?.({
+            type: "packet_parsed",
+            step,
+            mode: getParsedResponseMode(response)
+        });
+        conversation.entries.push({
+            type: "provider_packet",
+            rawText,
+            packet: response
+        });
+        if (isAssistantToolResponse(response) || isZcToolRequest(response)) {
+            const toolCall = isZcToolRequest(response)
+                ? {
+                    id: response.toolCall.id,
+                    name: response.toolCall.name,
+                    args: response.toolCall.args
+                }
+                : {
+                    id: `call_${step}`,
+                    name: response.toolCall.name,
+                    args: response.toolCall.arguments
+                };
+            const toolStartedAt = Date.now();
+            const execution = await input.toolExecutor.executeTool({
+                call: toolCall
+            });
+            const toolResult = {
+                id: toolCall.id,
+                name: toolCall.name,
+                ok: execution.ok,
+                payload: execution.payload
+            };
+            const serializedToolResult = serializeToolResult(toolResult);
+            conversation.entries.push({
+                type: "tool_result",
+                rawText: serializedToolResult,
+                result: toolResult
+            });
+            input.config?.onEvent?.({
+                type: "tool_result",
+                step,
+                rawText: serializedToolResult,
+                result: toolResult,
+                durationMs: Date.now() - toolStartedAt
+            });
+            continue;
+        }
+        switch (getParsedResponseMode(response)) {
+            case "final":
+                return emitOutcome({
+                    mode: "final",
+                    message: extractParsedResponseMessage(response),
+                    steps: step,
+                    conversation
+                }, input.config);
+            case "ask_user":
+                return emitOutcome({
+                    mode: "ask_user",
+                    message: extractParsedResponseMessage(response),
+                    steps: step,
+                    conversation
+                }, input.config);
+            case "fail":
+                return emitOutcome({
+                    mode: "fail",
+                    message: extractParsedResponseMessage(response),
+                    steps: step,
+                    conversation
+                }, input.config);
+        }
+    }
+    return emitOutcome({
+        mode: "fail",
+        message: `Runtime exceeded max steps (${maxSteps}).`,
+        steps: maxSteps,
+        conversation,
+        failure: {
+            source: "runtime",
+            code: "max_steps_exhausted",
+            message: `Runtime exceeded max steps (${maxSteps}).`
+        }
+    }, input.config);
+}
+function repairLeadingAssistantBlock(content) {
+    const trimmed = content.trim();
+    const recovered = recoverLatestFinalBlock(trimmed);
+    if (recovered) {
+        return recovered;
+    }
+    return trimmed;
+}
+function recoverLatestFinalBlock(content) {
+    return recoverLatestTaggedBlock(content, "final")?.block ?? null;
+}
+function recoverLatestTaggedBlock(content, tag) {
+    const closeTag = `</${tag}>`;
+    const closeIndex = content.lastIndexOf(closeTag);
+    if (closeIndex < 0) {
+        return null;
+    }
+    const marker = new RegExp(`(?:<)?${tag}>`, "gi");
+    let latestMatch = null;
+    for (const match of content.matchAll(marker)) {
+        const index = match.index ?? -1;
+        if (index < 0 || index >= closeIndex) {
+            continue;
+        }
+        latestMatch = {
+            index,
+            markerLength: match[0].length
+        };
+    }
+    if (!latestMatch) {
+        return null;
+    }
+    const innerContent = content.slice(latestMatch.index + latestMatch.markerLength, closeIndex);
+    return {
+        index: latestMatch.index,
+        block: `<${tag}>${innerContent}${closeTag}`
+    };
+}
+function parseAndValidateProviderResponse(providerId, rawText, availableTools) {
+    const normalizedAssistantResponse = repairLeadingAssistantBlock(rawText);
+    try {
+        return validateAssistantResponse(normalizeAssistantToolNames(parseAssistantResponse(normalizedAssistantResponse)), availableTools);
+    }
+    catch (assistantError) {
+        const extraction = extractPacketCandidate(rawText);
+        if (!extraction.ok) {
+            throw assistantError;
+        }
+        const normalization = normalizeProviderPacket(providerId, extraction.packetText);
+        if (!normalization.ok) {
+            throw assistantError;
+        }
+        const packet = normalizeZcPacketToolNames(parseZcPacket(normalization.canonicalPacket));
+        validateZcPacketResponse(packet, availableTools);
+        return packet;
+    }
+}
+function normalizeAssistantToolNames(response) {
+    if (response.type !== "tool") {
+        return response;
+    }
+    return {
+        ...response,
+        toolCall: {
+            ...response.toolCall,
+            name: normalizeProviderToolName(response.toolCall.name)
+        }
+    };
+}
+function normalizeZcPacketToolNames(packet) {
+    if (packet.mode !== "tool_request") {
+        return packet;
+    }
+    return {
+        ...packet,
+        toolCall: {
+            ...packet.toolCall,
+            name: normalizeProviderToolName(packet.toolCall.name)
+        }
+    };
+}
+function validateZcPacketResponse(packet, availableTools) {
+    if (packet.mode !== "tool_request") {
+        return;
+    }
+    const tool = availableTools.find((candidate) => candidate.name === packet.toolCall.name);
+    if (!tool) {
+        return;
+    }
+    const argumentsRecord = packet.toolCall.args;
+    const propertyNames = Object.keys(tool.inputSchema.properties);
+    const allowedProperties = new Set(propertyNames);
+    for (const name of Object.keys(argumentsRecord)) {
+        if (!allowedProperties.has(name)) {
+            throw new Error(`Tool "${tool.name}" received unknown argument "${name}".`);
+        }
+    }
+    for (const requiredName of tool.inputSchema.required) {
+        if (!(requiredName in argumentsRecord)) {
+            throw new Error(`Tool "${tool.name}" is missing required argument "${requiredName}".`);
+        }
+    }
+    for (const propertyName of propertyNames) {
+        if (!(propertyName in argumentsRecord)) {
+            continue;
+        }
+        const property = tool.inputSchema.properties[propertyName];
+        const value = argumentsRecord[propertyName];
+        if (property.type === "string" && typeof value !== "string") {
+            throw new Error(`Tool "${tool.name}" argument "${propertyName}" must be a string.`);
+        }
+        if (property.type === "boolean" && typeof value !== "boolean") {
+            throw new Error(`Tool "${tool.name}" argument "${propertyName}" must be a boolean.`);
+        }
+    }
+}
+function isAssistantToolResponse(response) {
+    return "type" in response && response.type === "tool";
+}
+function isAssistantFinalResponse(response) {
+    return "type" in response && response.type === "final";
+}
+function isZcToolRequest(response) {
+    return "mode" in response && response.mode === "tool_request";
+}
+function getParsedResponseMode(response) {
+    if ("type" in response) {
+        return response.type;
+    }
+    return response.mode === "tool_request" ? "tool" : response.mode;
+}
+function extractParsedResponseMessage(response) {
+    if (isAssistantFinalResponse(response)) {
+        return response.message;
+    }
+    if (isAssistantToolResponse(response) || isZcToolRequest(response)) {
+        throw new Error("tool_request packets do not carry assistant text.");
+    }
+    return response.message;
+}
+function emitOutcome(outcome, config) {
+    config?.onEvent?.({
+        type: "outcome",
+        outcome
+    });
+    return outcome;
+}
+async function attemptResponseRepair(input) {
+    if (typeof input.provider.repairInvalidResponse !== "function") {
+        return {
+            ok: false,
+            failure: {
+                source: "protocol",
+                code: "malformed_provider_packet",
+                message: `Invalid assistant response: ${input.validationError}`
+            }
+        };
+    }
+    try {
+        const rawText = await input.provider.repairInvalidResponse({
+            conversation: input.conversation,
+            availableTools: input.availableTools,
+            invalidResponse: input.invalidResponse,
+            validationError: input.validationError
+        });
+        return {
+            ok: true,
+            rawText
+        };
+    }
+    catch (error) {
+        if (isProviderFailure(error)) {
+            const serialized = serializeProviderFailure(withProviderRecovery(error, error.recovery, {
+                displayMessage: formatProviderFailureMessage(error)
+            }));
+            return {
+                ok: false,
+                failure: {
+                    source: "provider",
+                    provider: serialized
+                }
+            };
+        }
+        return {
+            ok: false,
+            failure: {
+                source: "provider",
+                provider: {
+                    kind: "permanent",
+                    code: "transport_error",
+                    message: `Provider repair adapter failed: ${error instanceof Error ? error.message : String(error)}`,
+                    retryable: false,
+                    sessionResetEligible: false,
+                    emptyOutput: false,
+                    recovery: {
+                        softRetryCount: 0,
+                        sessionResetCount: 0
+                    }
+                }
+            }
+        };
+    }
+}
+export const runtimeModule = {
+    runBridgeRuntime
+};

package/packages/runtime/dist/session-bound-provider.d.ts

@@ -0,0 +1,52 @@
+import type { CompiledProviderMessage } from "./prompt-compiler.ts";
+import type { ProviderAdapter, ProviderTurnInput, RepairInvalidResponseInput } from "./provider.ts";
+type UpstreamConversationBinding = {
+    conversationId: string;
+    parentId: string;
+    runtimePlannerPrimed?: boolean;
+};
+interface SessionBindingStore {
+    loadBinding(providerId: string, sessionId: string): Promise<UpstreamConversationBinding | null>;
+    saveBinding(providerId: string, sessionId: string, binding: UpstreamConversationBinding): Promise<void>;
+    clearBinding(providerId: string, sessionId: string): Promise<void>;
+}
+type ProviderTransportRequest = {
+    lane: "main" | "repair";
+    providerId: string;
+    modelId: string;
+    sessionId: string;
+    requestId: string;
+    attempt: number;
+    continuation: boolean;
+    toolFollowUp: boolean;
+    providerSessionReused: boolean;
+    messages: CompiledProviderMessage[];
+    upstreamBinding: Pick<UpstreamConversationBinding, "conversationId" | "parentId"> | null;
+};
+type ProviderTransportResponse = {
+    content: string;
+    upstreamBinding?: Pick<UpstreamConversationBinding, "conversationId" | "parentId"> | null;
+};
+interface ProviderTransport {
+    completeChat(request: ProviderTransportRequest): Promise<ProviderTransportResponse>;
+}
+type SessionBoundProviderAdapterOptions = {
+    providerId: string;
+    modelId: string;
+    transport: ProviderTransport;
+    sessionBindingStore?: SessionBindingStore;
+    sessionId?: string;
+    bridgeRequestId?: string;
+    onTraceEvent?: (type: string, detail: unknown) => void;
+};
+declare class SessionBoundProviderAdapter implements ProviderAdapter {
+    #private;
+    readonly id: string;
+    constructor(options: SessionBoundProviderAdapterOptions);
+    completeTurn(input: ProviderTurnInput): Promise<string>;
+    repairInvalidResponse(input: RepairInvalidResponseInput): Promise<string>;
+}
+export declare const sessionBoundProviderModule: {
+    SessionBoundProviderAdapter: typeof SessionBoundProviderAdapter;
+};
+export type { ProviderTransport, ProviderTransportRequest, ProviderTransportResponse, SessionBindingStore, SessionBoundProviderAdapter, SessionBoundProviderAdapterOptions, UpstreamConversationBinding };