@uncensoredcode/openbridge 0.1.0

package/packages/runtime/dist/provider-failure.js

@@ -0,0 +1,236 @@
+class ProviderFailure extends Error {
+    kind;
+    code;
+    displayMessage;
+    retryable;
+    sessionResetEligible;
+    emptyOutput;
+    recovery;
+    details;
+    constructor(input) {
+        super(input.message, input.cause === undefined ? undefined : { cause: input.cause });
+        this.name = "ProviderFailure";
+        this.kind = input.kind;
+        this.code = input.code;
+        this.displayMessage = input.displayMessage ?? input.message;
+        this.retryable = input.retryable ?? input.kind === "transient";
+        this.sessionResetEligible = input.sessionResetEligible ?? input.kind === "session_corruption";
+        this.emptyOutput = input.emptyOutput ?? false;
+        this.recovery = {
+            softRetryCount: input.recovery?.softRetryCount ?? 0,
+            sessionResetCount: input.recovery?.sessionResetCount ?? 0
+        };
+        this.details = input.details;
+    }
+}
+function isProviderFailure(error) {
+    return error instanceof ProviderFailure;
+}
+function serializeProviderFailure(error) {
+    return {
+        kind: error.kind,
+        code: error.code,
+        message: error.displayMessage,
+        retryable: error.retryable,
+        sessionResetEligible: error.sessionResetEligible,
+        emptyOutput: error.emptyOutput,
+        recovery: error.recovery,
+        details: error.details
+    };
+}
+function withProviderRecovery(error, recovery, overrides = {}) {
+    return new ProviderFailure({
+        kind: overrides.kind ?? error.kind,
+        code: error.code,
+        message: error.message,
+        displayMessage: overrides.displayMessage ?? error.displayMessage,
+        retryable: overrides.retryable ?? error.retryable,
+        sessionResetEligible: overrides.sessionResetEligible ?? error.sessionResetEligible,
+        emptyOutput: error.emptyOutput,
+        details: error.details,
+        recovery: {
+            softRetryCount: recovery.softRetryCount ?? error.recovery.softRetryCount,
+            sessionResetCount: recovery.sessionResetCount ?? error.recovery.sessionResetCount
+        },
+        cause: error.cause
+    });
+}
+function classifyProviderTransportError(error) {
+    if (isProviderFailure(error)) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    const details = extractSafeProviderFailureDetails(error);
+    if (normalized.includes("timed out")) {
+        return new ProviderFailure({
+            kind: "transient",
+            code: "transport_timeout",
+            message,
+            displayMessage: "Provider request timed out.",
+            retryable: true,
+            sessionResetEligible: false,
+            details,
+            cause: error
+        });
+    }
+    if (normalized.includes("no captured bridge session exists") ||
+        normalized.includes("missing the auth token")) {
+        return new ProviderFailure({
+            kind: "permanent",
+            code: "authentication_failed",
+            message,
+            displayMessage: "Provider authentication/session state is missing or expired.",
+            retryable: false,
+            sessionResetEligible: false,
+            details,
+            cause: error
+        });
+    }
+    if (normalized.includes("unauthorized") ||
+        normalized.includes("forbidden") ||
+        normalized.includes("401") ||
+        normalized.includes("403")) {
+        return new ProviderFailure({
+            kind: "permanent",
+            code: "authentication_failed",
+            message,
+            displayMessage: "Provider authentication/session state is invalid and could not be recovered.",
+            retryable: false,
+            sessionResetEligible: false,
+            details,
+            cause: error
+        });
+    }
+    if (normalized.includes("unsupported provider") ||
+        normalized.includes("invalid provider") ||
+        normalized.includes("invalid model")) {
+        return new ProviderFailure({
+            kind: "permanent",
+            code: "request_invalid",
+            message,
+            displayMessage: "Provider configuration is invalid for this request.",
+            retryable: false,
+            sessionResetEligible: false,
+            details,
+            cause: error
+        });
+    }
+    if (normalized.includes("unsupported")) {
+        return new ProviderFailure({
+            kind: "permanent",
+            code: "unsupported_request",
+            message,
+            displayMessage: "Provider does not support this request.",
+            retryable: false,
+            sessionResetEligible: false,
+            details,
+            cause: error
+        });
+    }
+    if (normalized.includes("stale") ||
+        normalized.includes("corrupt") ||
+        normalized.includes("conversation binding") ||
+        normalized.includes("parent_id") ||
+        normalized.includes("parent message")) {
+        return new ProviderFailure({
+            kind: "session_corruption",
+            code: "transport_error",
+            message,
+            displayMessage: "Provider session state became unusable.",
+            retryable: false,
+            sessionResetEligible: true,
+            details,
+            cause: error
+        });
+    }
+    return new ProviderFailure({
+        kind: "transient",
+        code: "transport_error",
+        message,
+        displayMessage: "Provider request failed.",
+        retryable: true,
+        sessionResetEligible: false,
+        details,
+        cause: error
+    });
+}
+function formatProviderFailureMessage(error) {
+    const recovery = formatRecoverySummary(error.recovery);
+    switch (error.code) {
+        case "transport_timeout":
+            return `Provider request timed out${recovery}.`;
+        case "empty_response":
+            return `Provider returned an empty response${recovery}.`;
+        case "empty_extracted_response":
+            return `Provider returned no extractable assistant content${recovery}.`;
+        case "empty_final_message":
+            return `Provider returned an empty final answer${recovery}.`;
+        case "packet_extraction_failed":
+        case "packet_normalization_failed":
+        case "packet_validation_failed":
+            return `Provider returned malformed or unusable output${recovery}.`;
+        case "authentication_failed":
+            return error.displayMessage;
+        case "request_invalid":
+            if (typeof error.details?.stage === "string" &&
+                typeof error.details?.httpStatus === "number") {
+                return `Provider request failed during ${error.details.stage} with HTTP ${error.details.httpStatus}${recovery}.`;
+            }
+            return "Provider configuration is invalid for this request.";
+        case "unsupported_request":
+            return "Provider does not support this request.";
+        case "session_reset_failed":
+            return `Provider session reset failed${recovery}.`;
+        case "transport_error":
+            if (typeof error.details?.stage === "string" &&
+                typeof error.details?.httpStatus === "number") {
+                return `Provider request failed during ${error.details.stage} with HTTP ${error.details.httpStatus}${recovery}.`;
+            }
+        default:
+            return `Provider request failed${recovery}.`;
+    }
+}
+function extractSafeProviderFailureDetails(error) {
+    if (!(error instanceof Error) || !("details" in error) || !isRecord(error.details)) {
+        return undefined;
+    }
+    const result = {};
+    if (typeof error.details.provider === "string" && error.details.provider.trim()) {
+        result.provider = error.details.provider.trim();
+    }
+    if (typeof error.details.stage === "string" && error.details.stage.trim()) {
+        result.stage = error.details.stage.trim();
+    }
+    if (typeof error.details.httpStatus === "number" && Number.isInteger(error.details.httpStatus)) {
+        result.httpStatus = error.details.httpStatus;
+    }
+    if (typeof error.details.networkCode === "string" && error.details.networkCode.trim()) {
+        result.networkCode = error.details.networkCode.trim();
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatRecoverySummary(recovery) {
+    const parts = [];
+    if (recovery.softRetryCount > 0) {
+        parts.push(`${recovery.softRetryCount} soft retr${recovery.softRetryCount === 1 ? "y" : "ies"}`);
+    }
+    if (recovery.sessionResetCount > 0) {
+        parts.push(`${recovery.sessionResetCount} provider-session reset${recovery.sessionResetCount === 1 ? "" : "s"}`);
+    }
+    if (parts.length === 0) {
+        return "";
+    }
+    return ` after ${parts.join(" and ")}`;
+}
+export const providerFailureModule = {
+    ProviderFailure,
+    isProviderFailure,
+    serializeProviderFailure,
+    withProviderRecovery,
+    classifyProviderTransportError,
+    formatProviderFailureMessage
+};

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

@@ -0,0 +1,40 @@
+import type { AssistantResponse } from "./assistant-protocol.ts";
+import type { ToolDefinition } from "./execution/types.ts";
+import type { ToolResult, ZcPacket } from "./protocol.ts";
+type BridgeSessionTurn = {
+    userMessage: string;
+    assistantMessage: string;
+    assistantMode: "final" | "ask_user";
+};
+type ConversationEntry = {
+    type: "user_message";
+    content: string;
+} | {
+    type: "provider_packet";
+    rawText: string;
+    packet: AssistantResponse | ZcPacket;
+} | {
+    type: "tool_result";
+    rawText: string;
+    result: ToolResult;
+};
+type ConversationState = {
+    sessionHistory?: BridgeSessionTurn[];
+    entries: ConversationEntry[];
+};
+type ProviderTurnInput = {
+    conversation: ConversationState;
+    availableTools: ToolDefinition[];
+};
+type RepairInvalidResponseInput = {
+    conversation: ConversationState;
+    availableTools: ToolDefinition[];
+    invalidResponse: string;
+    validationError: string;
+};
+interface ProviderAdapter {
+    readonly id: string;
+    completeTurn(input: ProviderTurnInput): Promise<string>;
+    repairInvalidResponse?(input: RepairInvalidResponseInput): Promise<string>;
+}
+export type { BridgeSessionTurn, ConversationEntry, ConversationState, ProviderAdapter, ProviderTurnInput, RepairInvalidResponseInput };

package/packages/runtime/dist/provider.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,86 @@
+import type { ToolExecutor } from "./execution/types.ts";
+import type { ToolResult } from "./protocol.ts";
+import type { BridgeSessionTurn, ConversationState, ProviderAdapter } from "./provider.ts";
+declare const serializeProviderFailure: (error: import("./provider-failure.ts").ProviderFailure) => import("./provider-failure.ts").SerializedProviderFailure;
+type RuntimeConfig = {
+    maxSteps?: number;
+    onEvent?: (event: RuntimeEvent) => void;
+};
+type RuntimeTerminalMode = "final" | "ask_user" | "fail";
+type RuntimeOutcome = {
+    mode: RuntimeTerminalMode;
+    message: string;
+    steps: number;
+    conversation: ConversationState;
+    failure?: RuntimeFailure;
+};
+type RuntimeFailure = {
+    source: "provider";
+    provider: ReturnType<typeof serializeProviderFailure>;
+} | {
+    source: "protocol";
+    code: "malformed_provider_packet";
+    message: string;
+} | {
+    source: "runtime";
+    code: "max_steps_exhausted";
+    message: string;
+};
+type RuntimeEvent = {
+    type: "provider_response";
+    step: number;
+    rawText: string;
+    durationMs: number;
+} | {
+    type: "main_response_invalid";
+    step: number;
+    error: string;
+    rawTextLength: number;
+} | {
+    type: "repair_attempted";
+    step: number;
+} | {
+    type: "repair_valid";
+    step: number;
+    mode: "final" | "tool" | "ask_user" | "fail";
+    rawTextLength: number;
+} | {
+    type: "repair_failed";
+    step: number;
+    reason: "provider_failure" | "protocol_invalid";
+    error?: string;
+    providerFailure?: {
+        kind: ReturnType<typeof serializeProviderFailure>["kind"];
+        code: ReturnType<typeof serializeProviderFailure>["code"];
+        message: string;
+    };
+} | {
+    type: "tool_result";
+    step: number;
+    rawText: string;
+    result: ToolResult;
+    durationMs: number;
+} | {
+    type: "packet_parsed";
+    step: number;
+    mode: "final" | "tool" | "ask_user" | "fail";
+} | {
+    type: "packet_parse_failed";
+    step: number;
+    error: string;
+} | {
+    type: "outcome";
+    outcome: RuntimeOutcome;
+};
+type RunRuntimeInput = {
+    userMessage: string;
+    sessionHistory?: BridgeSessionTurn[];
+    provider: ProviderAdapter;
+    toolExecutor: ToolExecutor;
+    config?: RuntimeConfig;
+};
+declare function runBridgeRuntime(input: RunRuntimeInput): Promise<RuntimeOutcome>;
+export declare const runtimeModule: {
+    runBridgeRuntime: typeof runBridgeRuntime;
+};
+export type { RunRuntimeInput, RuntimeConfig, RuntimeEvent, RuntimeFailure, RuntimeOutcome, RuntimeTerminalMode };