@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.2

package/dist/heart/providers/openai-codex.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAICodexProviderRuntime = createOpenAICodexProviderRuntime;
+const openai_1 = __importDefault(require("openai"));
+const config_1 = require("../config");
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const streaming_1 = require("../streaming");
+const OPENAI_CODEX_AUTH_FAILURE_MARKERS = [
+    "authentication failed",
+    "unauthorized",
+    "invalid api key",
+    "invalid x-api-key",
+    "invalid bearer token",
+];
+const OPENAI_CODEX_BACKEND_BASE_URL = "https://chatgpt.com/backend-api/codex";
+function getOpenAICodexSecretsPathForGuidance() {
+    return (0, identity_1.getAgentSecretsPath)();
+}
+function getOpenAICodexAgentNameForGuidance() {
+    return (0, identity_1.getAgentName)();
+}
+function getOpenAICodexOAuthInstructions() {
+    const agentName = getOpenAICodexAgentNameForGuidance();
+    return [
+        "Fix:",
+        `  1. Run \`npm run auth:openai-codex -- --agent ${agentName}\``,
+        "     (or run `codex login` and set the OAuth token manually)",
+        `  2. Open ${getOpenAICodexSecretsPathForGuidance()}`,
+        "  3. Confirm providers.openai-codex.oauthAccessToken is set",
+        "  4. This provider uses chatgpt.com/backend-api/codex/responses (not api.openai.com/responses).",
+    ].join("\n");
+}
+function getOpenAICodexReauthGuidance(reason) {
+    return [
+        "OpenAI Codex configuration error.",
+        reason,
+        getOpenAICodexOAuthInstructions(),
+    ].join("\n");
+}
+function isOpenAICodexAuthFailure(error) {
+    if (!(error instanceof Error))
+        return false;
+    const status = error.status;
+    if (status === 401 || status === 403)
+        return true;
+    const lower = error.message.toLowerCase();
+    return OPENAI_CODEX_AUTH_FAILURE_MARKERS.some((marker) => lower.includes(marker));
+}
+function withOpenAICodexAuthGuidance(error) {
+    const base = error instanceof Error ? error.message : String(error);
+    if (isOpenAICodexAuthFailure(error)) {
+        return new Error(getOpenAICodexReauthGuidance(`OpenAI Codex authentication failed (${base}).`));
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
+function decodeJwtPayload(token) {
+    const parts = token.split(".");
+    if (parts.length < 2)
+        return null;
+    try {
+        const padded = parts[1]
+            .replace(/-/g, "+")
+            .replace(/_/g, "/")
+            .padEnd(Math.ceil(parts[1].length / 4) * 4, "=");
+        const payload = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+        if (!payload || typeof payload !== "object" || Array.isArray(payload))
+            return null;
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+function getChatGPTAccountIdFromToken(token) {
+    const payload = decodeJwtPayload(token);
+    if (!payload)
+        return "";
+    const authClaim = payload["https://api.openai.com/auth"];
+    if (!authClaim || typeof authClaim !== "object" || Array.isArray(authClaim))
+        return "";
+    const accountId = authClaim.chatgpt_account_id;
+    if (typeof accountId !== "string")
+        return "";
+    return accountId.trim();
+}
+function createOpenAICodexProviderRuntime() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.provider_init",
+        message: "openai-codex provider init",
+        meta: { provider: "openai-codex" },
+    });
+    const codexConfig = (0, config_1.getOpenAICodexConfig)();
+    if (!(codexConfig.model && codexConfig.oauthAccessToken)) {
+        throw new Error(getOpenAICodexReauthGuidance("provider 'openai-codex' is selected in agent.json but providers.openai-codex.model/oauthAccessToken is incomplete in secrets.json."));
+    }
+    const token = codexConfig.oauthAccessToken.trim();
+    if (!token) {
+        throw new Error(getOpenAICodexReauthGuidance("OpenAI Codex OAuth access token is empty."));
+    }
+    const chatgptAccountId = getChatGPTAccountIdFromToken(token);
+    if (!chatgptAccountId) {
+        throw new Error(getOpenAICodexReauthGuidance("OpenAI Codex OAuth access token is missing a chatgpt_account_id claim required for chatgpt.com/backend-api/codex."));
+    }
+    const client = new openai_1.default({
+        apiKey: token,
+        baseURL: OPENAI_CODEX_BACKEND_BASE_URL,
+        defaultHeaders: {
+            "chatgpt-account-id": chatgptAccountId,
+            "OpenAI-Beta": "responses=experimental",
+            originator: "ouroboros",
+        },
+        timeout: 30000,
+        maxRetries: 0,
+    });
+    let nativeInput = null;
+    let nativeInstructions = "";
+    return {
+        id: "openai-codex",
+        model: codexConfig.model,
+        client,
+        resetTurnState(messages) {
+            const { instructions, input } = (0, streaming_1.toResponsesInput)(messages);
+            nativeInput = input;
+            nativeInstructions = instructions;
+        },
+        appendToolOutput(callId, output) {
+            if (!nativeInput)
+                return;
+            nativeInput.push({ type: "function_call_output", call_id: callId, output });
+        },
+        async streamTurn(request) {
+            if (!nativeInput)
+                this.resetTurnState(request.messages);
+            const params = {
+                model: this.model,
+                input: nativeInput,
+                instructions: nativeInstructions,
+                tools: (0, streaming_1.toResponsesTools)(request.activeTools),
+                reasoning: { effort: "medium", summary: "detailed" },
+                stream: true,
+                store: false,
+                include: ["reasoning.encrypted_content"],
+            };
+            if (request.toolChoiceRequired)
+                params.tool_choice = "required";
+            try {
+                const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal);
+                for (const item of result.outputItems)
+                    nativeInput.push(item);
+                return result;
+            }
+            catch (error) {
+                throw withOpenAICodexAuthGuidance(error);
+            }
+        },
+    };
+}

package/dist/heart/streaming.js

@@ -0,0 +1,412 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinalAnswerParser = void 0;
+exports.toResponsesInput = toResponsesInput;
+exports.toResponsesTools = toResponsesTools;
+exports.streamChatCompletion = streamChatCompletion;
+exports.streamResponsesApi = streamResponsesApi;
+const runtime_1 = require("../nerves/runtime");
+// Character-level state machine that extracts the answer value from
+// `final_answer` tool call JSON arguments as they stream in.
+// Scans for prefix `"answer":"` or `"answer": "` in the character stream,
+// then emits text handling JSON escapes, stopping at unescaped closing `"`.
+class FinalAnswerParser {
+    // Possible prefixes to match (with and without space after colon)
+    static PREFIXES = ['"answer":"', '"answer": "'];
+    // Buffer of characters seen so far (pre-activation only)
+    buf = "";
+    _active = false;
+    _complete = false;
+    inEscape = false;
+    get active() { return this._active; }
+    get complete() { return this._complete; }
+    process(delta) {
+        if (this._complete)
+            return "";
+        let out = "";
+        for (let i = 0; i < delta.length; i++) {
+            const ch = delta[i];
+            if (!this._active) {
+                this.buf += ch;
+                // Check if any prefix has been fully matched in the buffer
+                for (const prefix of FinalAnswerParser.PREFIXES) {
+                    if (this.buf.endsWith(prefix)) {
+                        this._active = true;
+                        break;
+                    }
+                }
+            }
+            else {
+                // Active: emit characters, handling JSON escapes
+                if (this.inEscape) {
+                    this.inEscape = false;
+                    switch (ch) {
+                        case '"':
+                            out += '"';
+                            break;
+                        case '\\':
+                            out += '\\';
+                            break;
+                        case 'n':
+                            out += '\n';
+                            break;
+                        case 't':
+                            out += '\t';
+                            break;
+                        case '/':
+                            out += '/';
+                            break;
+                        default:
+                            out += ch;
+                            break; // unknown escape: pass through character
+                    }
+                }
+                else if (ch === '\\') {
+                    this.inEscape = true;
+                }
+                else if (ch === '"') {
+                    this._complete = true;
+                    return out; // stop processing, closing quote found
+                }
+                else {
+                    out += ch;
+                }
+            }
+        }
+        return out;
+    }
+}
+exports.FinalAnswerParser = FinalAnswerParser;
+function toResponsesInput(messages) {
+    let instructions = "";
+    const input = [];
+    for (const msg of messages) {
+        if (msg.role === "system") {
+            if (!instructions) {
+                const sys = msg;
+                instructions = (typeof sys.content === "string" ? sys.content : "") || "";
+            }
+            continue;
+        }
+        if (msg.role === "user") {
+            const u = msg;
+            input.push({ role: "user", content: typeof u.content === "string" ? u.content : "" });
+            continue;
+        }
+        if (msg.role === "assistant") {
+            const a = msg;
+            // Restore reasoning items before content (matching API item order)
+            if (a._reasoning_items) {
+                for (const ri of a._reasoning_items) {
+                    input.push(ri);
+                }
+            }
+            if (a.content) {
+                input.push({ role: "assistant", content: typeof a.content === "string" ? a.content : "" });
+            }
+            if (a.tool_calls) {
+                for (const tc of a.tool_calls) {
+                    input.push({
+                        type: "function_call",
+                        call_id: tc.id,
+                        name: tc.function.name,
+                        arguments: tc.function.arguments,
+                        status: "completed",
+                    });
+                }
+            }
+            continue;
+        }
+        if (msg.role === "tool") {
+            const t = msg;
+            input.push({
+                type: "function_call_output",
+                call_id: t.tool_call_id,
+                output: typeof t.content === "string" ? t.content : "",
+            });
+            continue;
+        }
+    }
+    return { instructions, input };
+}
+function toResponsesTools(ccTools) {
+    return ccTools.map((t) => ({
+        type: "function",
+        name: t.function.name,
+        description: t.function.description ?? null,
+        parameters: t.function.parameters ?? null,
+        strict: false,
+    }));
+}
+async function streamChatCompletion(client, createParams, callbacks, signal) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.stream_start",
+        message: "chat completion stream start",
+        meta: {},
+    });
+    // Request usage data in the final streaming chunk
+    createParams.stream_options = { include_usage: true };
+    const response = await client.chat.completions.create(createParams, signal ? { signal } : {});
+    let content = "";
+    let toolCalls = {};
+    let streamStarted = false;
+    let usage;
+    const answerParser = new FinalAnswerParser();
+    let finalAnswerDetected = false;
+    // State machine for parsing inline <think> tags (MiniMax pattern)
+    let contentBuf = "";
+    let inThinkTag = false;
+    const OPEN_TAG = "<think>";
+    const CLOSE_TAG = "</think>";
+    function processContentBuf(flush) {
+        while (contentBuf.length > 0) {
+            if (inThinkTag) {
+                const end = contentBuf.indexOf(CLOSE_TAG);
+                if (end !== -1) {
+                    const reasoning = contentBuf.slice(0, end);
+                    if (reasoning)
+                        callbacks.onReasoningChunk(reasoning);
+                    contentBuf = contentBuf.slice(end + CLOSE_TAG.length);
+                    inThinkTag = false;
+                }
+                else {
+                    // Check if buffer ends with a partial </think> prefix
+                    if (!flush) {
+                        let retain = 0;
+                        for (let i = 1; i < CLOSE_TAG.length && i <= contentBuf.length; i++) {
+                            if (contentBuf.endsWith(CLOSE_TAG.slice(0, i)))
+                                retain = i;
+                        }
+                        if (retain > 0) {
+                            const reasoning = contentBuf.slice(0, -retain);
+                            if (reasoning)
+                                callbacks.onReasoningChunk(reasoning);
+                            contentBuf = contentBuf.slice(-retain);
+                            return;
+                        }
+                    }
+                    // All reasoning, flush it
+                    callbacks.onReasoningChunk(contentBuf);
+                    contentBuf = "";
+                }
+            }
+            else {
+                const start = contentBuf.indexOf(OPEN_TAG);
+                if (start !== -1) {
+                    const text = contentBuf.slice(0, start);
+                    if (text)
+                        callbacks.onTextChunk(text);
+                    contentBuf = contentBuf.slice(start + OPEN_TAG.length);
+                    inThinkTag = true;
+                }
+                else {
+                    // Check if buffer ends with a partial <think> prefix
+                    if (!flush) {
+                        let retain = 0;
+                        for (let i = 1; i < OPEN_TAG.length && i <= contentBuf.length; i++) {
+                            if (contentBuf.endsWith(OPEN_TAG.slice(0, i)))
+                                retain = i;
+                        }
+                        if (retain > 0) {
+                            const text = contentBuf.slice(0, -retain);
+                            if (text)
+                                callbacks.onTextChunk(text);
+                            contentBuf = contentBuf.slice(-retain);
+                            return;
+                        }
+                    }
+                    // All content, flush it
+                    callbacks.onTextChunk(contentBuf);
+                    contentBuf = "";
+                }
+            }
+        }
+    }
+    for await (const chunk of response) {
+        if (signal?.aborted)
+            break;
+        // Capture usage from final chunk (sent when stream_options.include_usage is true)
+        if (chunk.usage) {
+            const u = chunk.usage;
+            usage = {
+                input_tokens: u.prompt_tokens,
+                output_tokens: u.completion_tokens,
+                reasoning_tokens: u.completion_tokens_details?.reasoning_tokens ?? 0,
+                total_tokens: u.total_tokens,
+            };
+        }
+        const d = chunk.choices[0]?.delta;
+        if (!d)
+            continue;
+        // Handle reasoning_content (Azure AI models like DeepSeek-R1)
+        if (d.reasoning_content) {
+            if (!streamStarted) {
+                callbacks.onModelStreamStart();
+                streamStarted = true;
+            }
+            callbacks.onReasoningChunk(d.reasoning_content);
+        }
+        if (d.content) {
+            if (!streamStarted) {
+                callbacks.onModelStreamStart();
+                streamStarted = true;
+            }
+            content += d.content;
+            contentBuf += d.content;
+            processContentBuf(false);
+        }
+        if (d.tool_calls) {
+            for (const tc of d.tool_calls) {
+                if (!toolCalls[tc.index])
+                    toolCalls[tc.index] = {
+                        id: tc.id ?? "",
+                        name: tc.function?.name ?? "",
+                        arguments: "",
+                    };
+                if (tc.id)
+                    toolCalls[tc.index].id = tc.id;
+                if (tc.function?.name) {
+                    toolCalls[tc.index].name = tc.function.name;
+                    // Detect final_answer tool call on first name delta.
+                    // Only activate streaming if this is the sole tool call (index 0
+                    // and no other indices seen). Mixed calls are rejected by core.ts.
+                    if (tc.function.name === "final_answer" && !finalAnswerDetected
+                        && tc.index === 0 && Object.keys(toolCalls).length === 1) {
+                        finalAnswerDetected = true;
+                        callbacks.onClearText?.();
+                    }
+                }
+                if (tc.function?.arguments) {
+                    toolCalls[tc.index].arguments += tc.function.arguments;
+                    // Feed final_answer argument deltas to the parser for progressive
+                    // streaming, but only when it appears to be the sole tool call.
+                    if (finalAnswerDetected && toolCalls[tc.index].name === "final_answer"
+                        && Object.keys(toolCalls).length === 1) {
+                        const text = answerParser.process(tc.function.arguments);
+                        if (text)
+                            callbacks.onTextChunk(text);
+                    }
+                }
+            }
+        }
+    }
+    // Flush any remaining buffer at end of stream
+    if (contentBuf)
+        processContentBuf(true);
+    return {
+        content,
+        toolCalls: Object.values(toolCalls),
+        outputItems: [],
+        usage,
+        finalAnswerStreamed: answerParser.active,
+    };
+}
+async function streamResponsesApi(client, createParams, callbacks, signal) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.stream_start",
+        message: "responses API stream start",
+        meta: {},
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Azure Responses API not in OpenAI SDK types
+    const response = await client.responses.create(createParams, signal ? { signal } : {});
+    let content = "";
+    let streamStarted = false;
+    const toolCalls = [];
+    const outputItems = [];
+    let currentToolCall = null;
+    let usage;
+    const answerParser = new FinalAnswerParser();
+    let functionCallCount = 0;
+    let finalAnswerDetected = false;
+    for await (const event of response) {
+        if (signal?.aborted)
+            break;
+        switch (event.type) {
+            case "response.output_text.delta":
+            case "response.reasoning_summary_text.delta": {
+                if (!streamStarted) {
+                    callbacks.onModelStreamStart();
+                    streamStarted = true;
+                }
+                const delta = String(event.delta);
+                if (event.type === "response.output_text.delta") {
+                    callbacks.onTextChunk(delta);
+                    content += delta;
+                }
+                else {
+                    callbacks.onReasoningChunk(delta);
+                }
+                break;
+            }
+            case "response.output_item.added": {
+                if (event.item?.type === "function_call") {
+                    functionCallCount++;
+                    currentToolCall = {
+                        call_id: String(event.item.call_id),
+                        name: String(event.item.name),
+                        arguments: "",
+                    };
+                    // Detect final_answer function call -- clear any streamed noise.
+                    // Only activate when this is the first (and so far only) function call.
+                    // Mixed calls are rejected by core.ts; no need to stream their args.
+                    if (String(event.item.name) === "final_answer" && functionCallCount === 1) {
+                        finalAnswerDetected = true;
+                        callbacks.onClearText?.();
+                    }
+                }
+                break;
+            }
+            case "response.function_call_arguments.delta": {
+                if (currentToolCall) {
+                    currentToolCall.arguments += event.delta;
+                    // Feed final_answer argument deltas to the parser for progressive
+                    // streaming, but only when it appears to be the sole function call.
+                    if (finalAnswerDetected && currentToolCall.name === "final_answer"
+                        && functionCallCount === 1) {
+                        const text = answerParser.process(String(event.delta));
+                        if (text)
+                            callbacks.onTextChunk(text);
+                    }
+                }
+                break;
+            }
+            case "response.output_item.done": {
+                outputItems.push(event.item);
+                if (event.item?.type === "function_call") {
+                    toolCalls.push({
+                        id: String(event.item.call_id),
+                        name: String(event.item.name),
+                        arguments: String(event.item.arguments),
+                    });
+                    currentToolCall = null;
+                }
+                break;
+            }
+            case "response.completed":
+            case "response.done": {
+                const u = event.response?.usage;
+                if (u) {
+                    usage = {
+                        input_tokens: u.input_tokens,
+                        output_tokens: u.output_tokens,
+                        reasoning_tokens: u.output_tokens_details?.reasoning_tokens ?? 0,
+                        total_tokens: u.total_tokens,
+                    };
+                }
+                break;
+            }
+            default:
+                // Unknown/unhandled events silently ignored
+                break;
+        }
+    }
+    return {
+        content,
+        toolCalls,
+        outputItems,
+        usage,
+        finalAnswerStreamed: answerParser.active,
+    };
+}

package/dist/heart/turn-coordinator.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTurnCoordinator = createTurnCoordinator;
+const runtime_1 = require("../nerves/runtime");
+function createTurnCoordinator() {
+    const turnLocks = new Map();
+    const activeTurns = new Set();
+    const followUpBuffers = new Map();
+    return {
+        async withTurnLock(key, fn) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.turn_start",
+                message: "turn lock acquired",
+                meta: { key },
+            });
+            const prev = turnLocks.get(key) ?? Promise.resolve();
+            const run = prev.then(async () => {
+                activeTurns.add(key);
+                try {
+                    return await fn();
+                }
+                finally {
+                    activeTurns.delete(key);
+                }
+            });
+            const settled = run.then(() => undefined, () => undefined);
+            turnLocks.set(key, settled);
+            try {
+                return await run;
+            }
+            finally {
+                if (turnLocks.get(key) === settled)
+                    turnLocks.delete(key);
+            }
+        },
+        tryBeginTurn(key) {
+            if (activeTurns.has(key))
+                return false;
+            activeTurns.add(key);
+            return true;
+        },
+        endTurn(key) {
+            activeTurns.delete(key);
+        },
+        isTurnActive(key) {
+            return activeTurns.has(key);
+        },
+        enqueueFollowUp(key, followUp) {
+            const current = followUpBuffers.get(key) ?? [];
+            current.push(followUp);
+            followUpBuffers.set(key, current);
+        },
+        drainFollowUps(key) {
+            const current = followUpBuffers.get(key);
+            if (!current || current.length === 0)
+                return [];
+            followUpBuffers.delete(key);
+            return [...current];
+        },
+    };
+}

package/dist/inner-worker-entry.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Backward-compatible wrapper; unified runtime now lives at heart/agent-entry.
+require("./heart/agent-entry");