@uncensoredcode/openbridge 0.1.0

package/packages/runtime/dist/session-bound-provider.js

@@ -0,0 +1,366 @@
+import crypto from "node:crypto";
+import { promptCompilerModule } from "./prompt-compiler.js";
+import { providerFailureModule } from "./provider-failure.js";
+const { ProviderFailure, classifyProviderTransportError, withProviderRecovery } = providerFailureModule;
+const { compileProviderTurn } = promptCompilerModule;
+const MAX_SOFT_RETRIES = 1;
+const MAX_SESSION_RESETS = 1;
+class SessionBoundProviderAdapter {
+    id;
+    #modelId;
+    #transport;
+    #sessionBindingStore;
+    #sessionId;
+    #bridgeRequestId;
+    #onTraceEvent;
+    #providerTurnCount = 0;
+    constructor(options) {
+        this.id = options.providerId;
+        this.#modelId = options.modelId;
+        this.#transport = options.transport;
+        this.#sessionBindingStore = options.sessionBindingStore;
+        this.#sessionId = options.sessionId ?? `bridge-runtime:${crypto.randomUUID()}`;
+        this.#bridgeRequestId = options.bridgeRequestId ?? crypto.randomUUID();
+        this.#onTraceEvent = options.onTraceEvent;
+    }
+    async completeTurn(input) {
+        this.#providerTurnCount += 1;
+        const providerTurnId = `${this.#bridgeRequestId}:provider-turn-${this.#providerTurnCount}`;
+        const toolResultCount = input.conversation.entries.filter((entry) => entry.type === "tool_result").length;
+        const sessionHistoryTurns = input.conversation.sessionHistory?.length ?? 0;
+        let binding = this.#sessionBindingStore
+            ? await this.#sessionBindingStore.loadBinding(this.id, this.#sessionId).catch(() => null)
+            : null;
+        let forceReplay = false;
+        let softRetryCount = 0;
+        let sessionResetCount = 0;
+        while (true) {
+            const compiled = compileProviderTurn({
+                conversation: input.conversation,
+                availableTools: input.availableTools,
+                runtimePlannerPrimed: binding?.runtimePlannerPrimed === true && !forceReplay,
+                forceReplay
+            });
+            const messages = compiled.messages;
+            const continuation = compiled.summary.turnType === "follow_up";
+            const providerSessionReused = binding !== null;
+            const attempt = softRetryCount + sessionResetCount + 1;
+            const attemptStartedAt = Date.now();
+            this.#onTraceEvent?.("provider_turn_started", {
+                bridgeRequestId: this.#bridgeRequestId,
+                providerTurnId,
+                providerTurnIndex: this.#providerTurnCount,
+                bridgeSessionId: this.#sessionId,
+                providerId: this.id,
+                modelId: this.#modelId,
+                providerSessionId: binding?.conversationId ?? null,
+                providerParentId: binding?.parentId ?? null,
+                providerSessionReused,
+                continuation,
+                toolFollowUp: toolResultCount > 0,
+                toolResultCount,
+                sessionHistoryTurns,
+                replayedFromBridgeSession: compiled.summary.replayedFromBridgeSession,
+                attempt
+            });
+            try {
+                const response = await this.#transport.completeChat({
+                    lane: "main",
+                    providerId: this.id,
+                    modelId: this.#modelId,
+                    sessionId: this.#sessionId,
+                    requestId: providerTurnId,
+                    attempt,
+                    continuation,
+                    toolFollowUp: toolResultCount > 0,
+                    providerSessionReused,
+                    messages,
+                    upstreamBinding: binding
+                        ? {
+                            conversationId: binding.conversationId,
+                            parentId: binding.parentId
+                        }
+                        : null
+                });
+                this.#assertNonEmptyResponse(response.content, {
+                    hasBinding: binding !== null
+                });
+                const nextBinding = response.upstreamBinding
+                    ? {
+                        ...response.upstreamBinding,
+                        runtimePlannerPrimed: Boolean(response.upstreamBinding.parentId)
+                    }
+                    : binding;
+                if (this.#sessionBindingStore && nextBinding) {
+                    await this.#sessionBindingStore.saveBinding(this.id, this.#sessionId, nextBinding);
+                }
+                this.#onTraceEvent?.("provider_attempt_finished", {
+                    bridgeRequestId: this.#bridgeRequestId,
+                    providerTurnId,
+                    providerTurnIndex: this.#providerTurnCount,
+                    bridgeSessionId: this.#sessionId,
+                    providerId: this.id,
+                    modelId: this.#modelId,
+                    providerSessionId: nextBinding?.conversationId ?? null,
+                    providerParentId: nextBinding?.parentId ?? null,
+                    providerSessionReused,
+                    continuation,
+                    toolFollowUp: toolResultCount > 0,
+                    toolResultCount,
+                    sessionHistoryTurns,
+                    replayedFromBridgeSession: compiled.summary.replayedFromBridgeSession,
+                    attempt,
+                    latencyMs: Date.now() - attemptStartedAt,
+                    extractedOutputEmpty: false,
+                    recovery: {
+                        softRetryCount,
+                        sessionResetCount
+                    },
+                    outcome: "success"
+                });
+                return response.content;
+            }
+            catch (error) {
+                const classified = withProviderRecovery(classifyProviderTransportError(error), {
+                    softRetryCount,
+                    sessionResetCount
+                });
+                const nextAction = selectRecoveryAction(classified, {
+                    softRetryCount,
+                    sessionResetCount,
+                    hasBinding: binding !== null
+                });
+                this.#onTraceEvent?.("provider_attempt_finished", {
+                    bridgeRequestId: this.#bridgeRequestId,
+                    providerTurnId,
+                    providerTurnIndex: this.#providerTurnCount,
+                    bridgeSessionId: this.#sessionId,
+                    providerId: this.id,
+                    modelId: this.#modelId,
+                    providerSessionId: binding?.conversationId ?? null,
+                    providerParentId: binding?.parentId ?? null,
+                    providerSessionReused,
+                    continuation,
+                    toolFollowUp: toolResultCount > 0,
+                    toolResultCount,
+                    sessionHistoryTurns,
+                    replayedFromBridgeSession: compiled.summary.replayedFromBridgeSession,
+                    attempt,
+                    latencyMs: Date.now() - attemptStartedAt,
+                    extractedOutputEmpty: classified.emptyOutput,
+                    failure: {
+                        kind: classified.kind,
+                        code: classified.code
+                    },
+                    recovery: {
+                        softRetryCount,
+                        sessionResetCount
+                    },
+                    outcome: nextAction
+                });
+                if (nextAction === "soft_retry") {
+                    softRetryCount += 1;
+                    continue;
+                }
+                if (nextAction === "session_reset") {
+                    if (!this.#sessionBindingStore) {
+                        throw classified;
+                    }
+                    try {
+                        await this.#sessionBindingStore.clearBinding(this.id, this.#sessionId);
+                    }
+                    catch (resetError) {
+                        throw withProviderRecovery(new ProviderFailure({
+                            kind: "permanent",
+                            code: "session_reset_failed",
+                            message: resetError instanceof Error ? resetError.message : String(resetError),
+                            displayMessage: "Provider session reset failed.",
+                            retryable: false,
+                            sessionResetEligible: false,
+                            cause: resetError
+                        }), {
+                            softRetryCount,
+                            sessionResetCount
+                        });
+                    }
+                    sessionResetCount += 1;
+                    binding = null;
+                    forceReplay = true;
+                    this.#onTraceEvent?.("provider_session_reset", {
+                        bridgeRequestId: this.#bridgeRequestId,
+                        providerTurnId,
+                        providerTurnIndex: this.#providerTurnCount,
+                        bridgeSessionId: this.#sessionId,
+                        providerId: this.id,
+                        modelId: this.#modelId,
+                        reason: {
+                            kind: classified.kind,
+                            code: classified.code
+                        },
+                        recovery: {
+                            softRetryCount,
+                            sessionResetCount
+                        }
+                    });
+                    continue;
+                }
+                throw classified;
+            }
+        }
+    }
+    async repairInvalidResponse(input) {
+        const repairSessionId = `${this.#sessionId}:repair:${crypto.randomUUID()}`;
+        const repairRequestId = `${this.#bridgeRequestId}:provider-turn-${this.#providerTurnCount}:repair`;
+        const repairMessages = buildRepairMessages(input);
+        const toolResultCount = input.conversation.entries.filter((entry) => entry.type === "tool_result").length;
+        this.#onTraceEvent?.("provider_repair_started", {
+            bridgeRequestId: this.#bridgeRequestId,
+            providerId: this.id,
+            modelId: this.#modelId,
+            bridgeSessionId: this.#sessionId,
+            repairSessionId,
+            repairRequestId,
+            providerTurnIndex: this.#providerTurnCount
+        });
+        const startedAt = Date.now();
+        try {
+            const response = await this.#transport.completeChat({
+                lane: "repair",
+                providerId: this.id,
+                modelId: this.#modelId,
+                sessionId: repairSessionId,
+                requestId: repairRequestId,
+                attempt: 1,
+                continuation: false,
+                toolFollowUp: toolResultCount > 0,
+                providerSessionReused: false,
+                messages: repairMessages,
+                upstreamBinding: null
+            });
+            this.#assertNonEmptyResponse(response.content, {
+                hasBinding: false
+            });
+            this.#onTraceEvent?.("provider_repair_finished", {
+                bridgeRequestId: this.#bridgeRequestId,
+                providerId: this.id,
+                modelId: this.#modelId,
+                bridgeSessionId: this.#sessionId,
+                repairSessionId,
+                repairRequestId,
+                providerTurnIndex: this.#providerTurnCount,
+                latencyMs: Date.now() - startedAt,
+                contentLength: response.content.length,
+                outcome: "success"
+            });
+            return response.content;
+        }
+        catch (error) {
+            const classified = classifyProviderTransportError(error);
+            this.#onTraceEvent?.("provider_repair_failed", {
+                bridgeRequestId: this.#bridgeRequestId,
+                providerId: this.id,
+                modelId: this.#modelId,
+                bridgeSessionId: this.#sessionId,
+                repairSessionId,
+                repairRequestId,
+                providerTurnIndex: this.#providerTurnCount,
+                latencyMs: Date.now() - startedAt,
+                failure: {
+                    kind: classified.kind,
+                    code: classified.code
+                }
+            });
+            throw error;
+        }
+    }
+    #assertNonEmptyResponse(content, context) {
+        if (!content.trim()) {
+            throw new ProviderFailure({
+                kind: "transient",
+                code: "empty_response",
+                message: "Provider returned an empty response.",
+                retryable: true,
+                sessionResetEligible: context.hasBinding,
+                emptyOutput: true
+            });
+        }
+    }
+}
+function selectRecoveryAction(failure, state) {
+    if (failure.retryable && state.softRetryCount < MAX_SOFT_RETRIES) {
+        return "soft_retry";
+    }
+    if ((failure.kind === "session_corruption" || failure.sessionResetEligible) &&
+        state.sessionResetCount < MAX_SESSION_RESETS &&
+        state.hasBinding) {
+        return "session_reset";
+    }
+    return "failed";
+}
+function buildRepairMessages(input) {
+    const latestToolResult = [...input.conversation.entries]
+        .reverse()
+        .find((entry) => entry.type === "tool_result");
+    return [
+        {
+            role: "system",
+            content: [
+                "You are the bridge repair lane.",
+                "Re-emit the same intent as exactly one valid bridge packet.",
+                "Return exactly one block only.",
+                "Use <final>...</final> for assistant text.",
+                'Use <tool>{"name":"tool_name","arguments":{...}}</tool> for one tool call.',
+                "No markdown.",
+                "No backticks.",
+                "No extra text before or after the block.",
+                "If using <tool>, the JSON must contain only name and arguments.",
+                "Do not invent new intent.",
+                "Do not explain.",
+                "Do not expose reasoning.",
+                "Do not perform side effects. Only repair the packet encoding."
+            ].join("\n")
+        },
+        {
+            role: "user",
+            content: [
+                "Bridge packet protocol:",
+                "Return exactly one valid packet block.",
+                "The deterministic parser and tool schema validator are the final authority.",
+                "Available tools:",
+                renderRepairToolManifest(input.availableTools),
+                `Latest user request:\n${getRepairUserMessage(input.conversation)}`,
+                ...(latestToolResult ? [`Latest tool result:\n${latestToolResult.rawText}`] : []),
+                `Raw invalid candidate output:\n${input.invalidResponse}`,
+                `Validation error:\n${input.validationError}`,
+                "Re-emit the same intent now as exactly one valid packet."
+            ].join("\n\n")
+        }
+    ];
+}
+function getRepairUserMessage(conversation) {
+    const userEntry = conversation.entries.find((entry) => entry.type === "user_message");
+    if (!userEntry) {
+        throw new Error("Conversation state is missing the initial user message.");
+    }
+    return userEntry.content;
+}
+function renderRepairToolManifest(availableTools) {
+    if (availableTools.length === 0) {
+        return "(none)";
+    }
+    return availableTools
+        .slice()
+        .sort((left, right) => left.name.localeCompare(right.name))
+        .map((tool) => {
+        const required = tool.inputSchema.required.length > 0 ? tool.inputSchema.required.join(", ") : "(none)";
+        const properties = Object.entries(tool.inputSchema.properties)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([name, property]) => `${name}: ${property.type} - ${property.description}`)
+            .join("; ");
+        return `- ${tool.name}: ${tool.description} | required: ${required} | args: ${properties || "(none)"}`;
+    })
+        .join("\n");
+}
+export const sessionBoundProviderModule = {
+    SessionBoundProviderAdapter
+};

package/packages/runtime/dist/tool-name-aliases.d.ts

@@ -0,0 +1,5 @@
+declare function normalizeProviderToolName(name: string): string;
+export declare const toolNameAliasesModule: {
+    normalizeProviderToolName: typeof normalizeProviderToolName;
+};
+export {};

package/packages/runtime/dist/tool-name-aliases.js

@@ -0,0 +1,13 @@
+const PROVIDER_TOOL_NAME_ALIASES = {
+    execute_shell_command: "bash"
+};
+function normalizeProviderToolName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    return PROVIDER_TOOL_NAME_ALIASES[trimmed] ?? trimmed;
+}
+export const toolNameAliasesModule = {
+    normalizeProviderToolName
+};

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

@@ -0,0 +1,9 @@
+import type { RuntimeTool } from "../execution/types.ts";
+type BashToolOptions = {
+    runtimeRoot: string;
+};
+declare function createBashTool(options: BashToolOptions): RuntimeTool;
+export declare const bashModule: {
+    createBashTool: typeof createBashTool;
+};
+export {};

package/packages/runtime/dist/tools/bash.js

@@ -0,0 +1,157 @@
+import { execFile, spawn } from "node:child_process";
+import { appendFileSync, closeSync, mkdirSync, openSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { executionTypesModule } from "../execution/types.js";
+const { ToolExecutionError } = executionTypesModule;
+const execFileAsync = promisify(execFile);
+const MAX_STDIO_BYTES = 64 * 1024;
+function createBashTool(options) {
+    return {
+        definition: {
+            name: "bash",
+            description: "Run a shell command on the local system. Short-lived commands run synchronously. Long-running commands such as dev servers, watchers, and persistent processes start detached and return their pid and log path immediately.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "Shell command to execute."
+                    },
+                    description: {
+                        type: "string",
+                        description: "Optional short explanation of what the command does."
+                    },
+                    cwd: {
+                        type: "string",
+                        description: "Optional working directory. Absolute paths are allowed."
+                    }
+                },
+                required: ["command"]
+            }
+        },
+        async execute(args) {
+            const command = requireNonEmptyString(args, "command");
+            const cwd = resolveCwd(args.cwd, options.runtimeRoot);
+            if (isLikelyLongRunningBashCommand(command)) {
+                return startDetachedProcess(command, cwd, options.runtimeRoot);
+            }
+            try {
+                const { stdout, stderr } = await execFileAsync("bash", ["-lc", command], {
+                    cwd,
+                    timeout: getExecTimeoutMs(),
+                    maxBuffer: 1024 * 1024
+                });
+                return {
+                    command,
+                    cwd,
+                    exitCode: 0,
+                    timedOut: false,
+                    stdout: truncate(stdout),
+                    stderr: truncate(stderr)
+                };
+            }
+            catch (error) {
+                if (!(error instanceof Error)) {
+                    throw error;
+                }
+                const execError = error;
+                return {
+                    command,
+                    cwd,
+                    exitCode: typeof execError.code === "number" ? execError.code : null,
+                    signal: execError.signal ?? null,
+                    timedOut: execError.killed === true && execError.signal === "SIGTERM",
+                    stdout: truncate(execError.stdout ?? ""),
+                    stderr: truncate(execError.stderr ?? execError.message)
+                };
+            }
+        }
+    };
+}
+function requireNonEmptyString(args, key) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim()) {
+        return value;
+    }
+    throw new ToolExecutionError("invalid_arguments", `${key} must be a non-empty string.`);
+}
+function resolveCwd(rawValue, runtimeRoot) {
+    if (typeof rawValue !== "string" || !rawValue.trim()) {
+        return runtimeRoot;
+    }
+    return path.isAbsolute(rawValue) ? path.resolve(rawValue) : path.resolve(runtimeRoot, rawValue);
+}
+function truncate(value) {
+    return value.length > MAX_STDIO_BYTES ? `${value.slice(0, MAX_STDIO_BYTES)}\n[truncated]` : value;
+}
+function getExecTimeoutMs() {
+    return Number(process.env.BRIDGE_TOOL_EXEC_TIMEOUT_MS ?? 30000);
+}
+function isLikelyLongRunningBashCommand(command) {
+    return [
+        /\bpython3?\s+-m\s+http\.server\b/u,
+        /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?dev\b/u,
+        /\bnext\s+dev\b/u,
+        /\bvite\b/u,
+        /\bwebpack(?:-dev-server)?\s+serve\b/u,
+        /\bserve\b/u,
+        /\blive-server\b/u,
+        /\bnodemon\b/u,
+        /\buvicorn\b/u,
+        /\bflask\s+run\b/u,
+        /\brails\s+server\b/u,
+        /\bcargo\s+watch\b/u,
+        /\btail\s+-f\b/u,
+        /\bwatch\s+/u,
+        /\bsleep\s+(?:infinity|\d{3,})\b/u
+    ].some((pattern) => pattern.test(command));
+}
+function startDetachedProcess(command, cwd, runtimeRoot) {
+    const startedAt = new Date().toISOString();
+    const processRoot = ensureDetachedProcessRoot(runtimeRoot);
+    const processId = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    const logPath = path.join(processRoot, `${processId}.log`);
+    appendFileSync(logPath, `[bridge bash detached] ${startedAt}\n$ ${command}\n\n`, "utf8");
+    const logFd = openSync(logPath, "a");
+    try {
+        const child = spawn("bash", ["-lc", command], {
+            cwd,
+            detached: true,
+            stdio: ["ignore", logFd, logFd]
+        });
+        child.unref();
+        return {
+            command,
+            cwd,
+            exitCode: null,
+            timedOut: false,
+            stdout: "",
+            stderr: "",
+            detached: true,
+            pid: child.pid ?? null,
+            logPath,
+            startedAt
+        };
+    }
+    finally {
+        closeSync(logFd);
+    }
+}
+function ensureDetachedProcessRoot(runtimeRoot) {
+    const root = path.join(resolveDetachedProcessBase(runtimeRoot), "bridge-tool-processes");
+    mkdirSync(root, {
+        recursive: true
+    });
+    return root;
+}
+function resolveDetachedProcessBase(runtimeRoot) {
+    if (runtimeRoot.trim()) {
+        return runtimeRoot;
+    }
+    return os.tmpdir();
+}
+export const bashModule = {
+    createBashTool
+};

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

@@ -0,0 +1,9 @@
+import type { RuntimeTool } from "../execution/types.ts";
+type EditToolOptions = {
+    runtimeRoot: string;
+};
+declare function createEditTool(options: EditToolOptions): RuntimeTool;
+export declare const editModule: {
+    createEditTool: typeof createEditTool;
+};
+export {};

package/packages/runtime/dist/tools/edit.js

@@ -0,0 +1,94 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { executionTypesModule } from "../execution/types.js";
+import { runtimePathModule } from "./runtime-path.js";
+import { textFileModule } from "./text-file.js";
+const { ToolExecutionError } = executionTypesModule;
+const { assertTextContent, MAX_FILE_READ_BYTES, MAX_FILE_WRITE_BYTES, readTextFileWithinLimit, writeTextFileAtomic } = textFileModule;
+const { resolveRuntimePath } = runtimePathModule;
+function createEditTool(options) {
+    return {
+        definition: {
+            name: "edit",
+            description: "Replace one exact text span in an existing UTF-8 text file.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Absolute path or path relative to the runtime root."
+                    },
+                    oldText: {
+                        type: "string",
+                        description: "Exact text to replace. Matching is whitespace-sensitive."
+                    },
+                    newText: {
+                        type: "string",
+                        description: "Replacement text."
+                    }
+                },
+                required: ["path", "oldText", "newText"]
+            }
+        },
+        async execute(args) {
+            const resolvedPath = await resolveRuntimePath(options.runtimeRoot, requireString(args, "path"));
+            const oldText = requireString(args, "oldText");
+            const newText = requireString(args, "newText", false);
+            const { content } = await readTextFileWithinLimit({
+                absolutePath: resolvedPath,
+                relativePath: resolvedPath,
+                maxBytes: MAX_FILE_READ_BYTES,
+                operation: "read"
+            });
+            const matchCount = countExactOccurrences(content, oldText);
+            if (matchCount === 0) {
+                throw new ToolExecutionError("not_found", `Exact text was not found in "${resolvedPath}".`);
+            }
+            if (matchCount > 1) {
+                throw new ToolExecutionError("ambiguous_match", `Exact text matched ${matchCount} times in "${resolvedPath}". Refine oldText to one exact occurrence.`);
+            }
+            const nextContent = content.replace(oldText, newText);
+            const bytesWritten = assertTextContent(nextContent, resolvedPath, MAX_FILE_WRITE_BYTES);
+            try {
+                await mkdir(path.dirname(resolvedPath), { recursive: true });
+                await writeTextFileAtomic(resolvedPath, nextContent);
+                return {
+                    path: resolvedPath,
+                    replaced: 1,
+                    bytesWritten
+                };
+            }
+            catch (error) {
+                if (error instanceof ToolExecutionError) {
+                    throw error;
+                }
+                throw new ToolExecutionError("io_error", `Unable to edit file "${resolvedPath}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    };
+}
+function countExactOccurrences(content, search) {
+    let count = 0;
+    let startIndex = 0;
+    while (true) {
+        const matchIndex = content.indexOf(search, startIndex);
+        if (matchIndex < 0) {
+            return count;
+        }
+        count += 1;
+        startIndex = matchIndex + search.length;
+    }
+}
+function requireString(args, key, requireNonEmpty = true) {
+    const value = args[key];
+    if (typeof value !== "string") {
+        throw new ToolExecutionError("invalid_arguments", `${key} must be a string.`);
+    }
+    if (requireNonEmpty && !value.length) {
+        throw new ToolExecutionError("invalid_arguments", `${key} must be a non-empty string.`);
+    }
+    return value;
+}
+export const editModule = {
+    createEditTool
+};