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

package/dist/heart/providers/anthropic.js

@@ -0,0 +1,329 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAnthropicProviderRuntime = createAnthropicProviderRuntime;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const config_1 = require("../config");
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const ANTHROPIC_SETUP_TOKEN_PREFIX = "sk-ant-oat01-";
+const ANTHROPIC_SETUP_TOKEN_MIN_LENGTH = 80;
+const ANTHROPIC_OAUTH_BETA_HEADER = "claude-code-20250219,oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14,interleaved-thinking-2025-05-14";
+function getAnthropicSecretsPathForGuidance() {
+    return (0, identity_1.getAgentSecretsPath)();
+}
+function getAnthropicAgentNameForGuidance() {
+    return (0, identity_1.getAgentName)();
+}
+function getAnthropicSetupTokenInstructions() {
+    const agentName = getAnthropicAgentNameForGuidance();
+    return [
+        "Fix:",
+        `  1. Run \`npm run auth:claude-setup-token -- --agent ${agentName}\``,
+        "     (or run `claude setup-token` and paste the token manually)",
+        `  2. Open ${getAnthropicSecretsPathForGuidance()}`,
+        "  3. Confirm providers.anthropic.setupToken is set",
+    ].join("\n");
+}
+function getAnthropicReauthGuidance(reason) {
+    return [
+        "Anthropic configuration error.",
+        reason,
+        getAnthropicSetupTokenInstructions(),
+    ].join("\n");
+}
+function resolveAnthropicSetupTokenCredential() {
+    const anthropicConfig = (0, config_1.getAnthropicConfig)();
+    const token = anthropicConfig.setupToken?.trim();
+    if (!token) {
+        throw new Error(getAnthropicReauthGuidance("Anthropic provider is selected but no setup-token credential was found."));
+    }
+    if (!token.startsWith(ANTHROPIC_SETUP_TOKEN_PREFIX)) {
+        throw new Error(getAnthropicReauthGuidance(`Anthropic credential is not a setup-token (expected prefix ${ANTHROPIC_SETUP_TOKEN_PREFIX}).`));
+    }
+    if (token.length < ANTHROPIC_SETUP_TOKEN_MIN_LENGTH) {
+        throw new Error(getAnthropicReauthGuidance("Anthropic setup-token looks too short."));
+    }
+    return { token };
+}
+function toAnthropicTextContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((part) => (typeof part === "object" &&
+        part !== null &&
+        part.type === "text"))
+        .map((part) => (typeof part.text === "string" ? part.text : ""))
+        .join("\n");
+}
+function parseToolCallInput(argumentsJson) {
+    if (!argumentsJson.trim())
+        return {};
+    try {
+        const parsed = JSON.parse(argumentsJson);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function toAnthropicMessages(messages) {
+    let system;
+    const converted = [];
+    for (const msg of messages) {
+        if (msg.role === "system") {
+            if (!system) {
+                const text = toAnthropicTextContent(msg.content);
+                system = text || undefined;
+            }
+            continue;
+        }
+        if (msg.role === "user") {
+            converted.push({
+                role: "user",
+                content: toAnthropicTextContent(msg.content),
+            });
+            continue;
+        }
+        if (msg.role === "assistant") {
+            const assistant = msg;
+            const blocks = [];
+            const text = toAnthropicTextContent(assistant.content);
+            if (text) {
+                blocks.push({ type: "text", text });
+            }
+            if (assistant.tool_calls) {
+                for (const toolCall of assistant.tool_calls) {
+                    blocks.push({
+                        type: "tool_use",
+                        id: toolCall.id,
+                        name: toolCall.function.name,
+                        input: parseToolCallInput(toolCall.function.arguments),
+                    });
+                }
+            }
+            if (blocks.length === 0) {
+                blocks.push({ type: "text", text: "" });
+            }
+            converted.push({ role: "assistant", content: blocks });
+            continue;
+        }
+        if (msg.role === "tool") {
+            const tool = msg;
+            converted.push({
+                role: "user",
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: tool.tool_call_id,
+                        content: toAnthropicTextContent(tool.content),
+                    },
+                ],
+            });
+        }
+    }
+    return { system, messages: converted };
+}
+function toAnthropicTools(tools) {
+    return tools.map((tool) => ({
+        name: tool.function.name,
+        description: tool.function.description ?? "",
+        input_schema: tool.function.parameters ?? { type: "object", properties: {} },
+    }));
+}
+function toAnthropicUsage(raw) {
+    const inputTokens = Number(raw.input_tokens ?? 0) || 0;
+    const cacheCreateTokens = Number(raw.cache_creation_input_tokens ?? 0) || 0;
+    const cacheReadTokens = Number(raw.cache_read_input_tokens ?? 0) || 0;
+    const outputTokens = Number(raw.output_tokens ?? 0) || 0;
+    const totalInputTokens = inputTokens + cacheCreateTokens + cacheReadTokens;
+    return {
+        input_tokens: totalInputTokens,
+        output_tokens: outputTokens,
+        reasoning_tokens: 0,
+        total_tokens: totalInputTokens + outputTokens,
+    };
+}
+function mergeAnthropicToolArguments(current, partial) {
+    if (!partial)
+        return current;
+    const trimmedCurrent = current.trim();
+    const trimmedPartial = partial.trim();
+    // If streaming restarts with a full JSON object/array fragment, trust it.
+    if (trimmedPartial.startsWith("{") || trimmedPartial.startsWith("[")) {
+        return partial;
+    }
+    // Anthropic can emit block.input as a complete object and then emit
+    // additional members as ',\"k\":v' deltas; merge those safely.
+    if (trimmedCurrent.startsWith("{") && trimmedCurrent.endsWith("}")) {
+        const inner = trimmedCurrent.slice(1, -1).trim();
+        let suffix = partial;
+        if (!inner && suffix.startsWith(",")) {
+            suffix = suffix.slice(1);
+        }
+        return `{${inner}${suffix}}`;
+    }
+    return current + partial;
+}
+function isAnthropicAuthFailure(error) {
+    if (!(error instanceof Error))
+        return false;
+    const status = error.status;
+    if (status === 401 || status === 403)
+        return true;
+    const lower = error.message.toLowerCase();
+    return (lower.includes("oauth authentication") ||
+        lower.includes("authentication failed") ||
+        lower.includes("unauthorized") ||
+        lower.includes("invalid api key"));
+}
+function withAnthropicAuthGuidance(error) {
+    const base = error instanceof Error ? error.message : String(error);
+    if (isAnthropicAuthFailure(error)) {
+        return new Error(getAnthropicReauthGuidance(`Anthropic authentication failed (${base}).`));
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
+async function streamAnthropicMessages(client, model, request) {
+    const { system, messages } = toAnthropicMessages(request.messages);
+    const anthropicTools = toAnthropicTools(request.activeTools);
+    const params = {
+        model,
+        max_tokens: 4096,
+        messages,
+        stream: true,
+    };
+    if (system)
+        params.system = system;
+    if (anthropicTools.length > 0)
+        params.tools = anthropicTools;
+    if (request.toolChoiceRequired && anthropicTools.length > 0) {
+        params.tool_choice = { type: "any" };
+    }
+    let response;
+    try {
+        response = await client.messages.create(params, request.signal ? { signal: request.signal } : {});
+    }
+    catch (error) {
+        throw withAnthropicAuthGuidance(error);
+    }
+    let content = "";
+    let streamStarted = false;
+    let usage;
+    const toolCalls = new Map();
+    try {
+        for await (const event of response) {
+            if (request.signal?.aborted)
+                break;
+            const eventType = String(event.type ?? "");
+            if (eventType === "content_block_start") {
+                const block = event.content_block;
+                if (block?.type === "tool_use") {
+                    const index = Number(event.index);
+                    const rawInput = block.input;
+                    const input = rawInput && typeof rawInput === "object"
+                        ? JSON.stringify(rawInput)
+                        : "";
+                    toolCalls.set(index, {
+                        id: String(block.id ?? ""),
+                        name: String(block.name ?? ""),
+                        arguments: input,
+                    });
+                }
+                continue;
+            }
+            if (eventType === "content_block_delta") {
+                const delta = event.delta;
+                const deltaType = String(delta?.type ?? "");
+                if (deltaType === "text_delta") {
+                    if (!streamStarted) {
+                        request.callbacks.onModelStreamStart();
+                        streamStarted = true;
+                    }
+                    const text = String(delta?.text ?? "");
+                    content += text;
+                    request.callbacks.onTextChunk(text);
+                    continue;
+                }
+                if (deltaType === "thinking_delta") {
+                    if (!streamStarted) {
+                        request.callbacks.onModelStreamStart();
+                        streamStarted = true;
+                    }
+                    request.callbacks.onReasoningChunk(String(delta?.thinking ?? ""));
+                    continue;
+                }
+                if (deltaType === "input_json_delta") {
+                    const index = Number(event.index);
+                    const existing = toolCalls.get(index);
+                    if (existing) {
+                        existing.arguments = mergeAnthropicToolArguments(existing.arguments, String(delta?.partial_json ?? ""));
+                    }
+                    continue;
+                }
+            }
+            if (eventType === "content_block_stop") {
+                const index = Number(event.index);
+                const existing = toolCalls.get(index);
+                if (existing && existing.arguments.trim().length === 0) {
+                    existing.arguments = "{}";
+                }
+                continue;
+            }
+            if (eventType === "message_delta") {
+                const rawUsage = event.usage;
+                if (rawUsage && typeof rawUsage === "object") {
+                    usage = toAnthropicUsage(rawUsage);
+                }
+            }
+        }
+    }
+    catch (error) {
+        throw withAnthropicAuthGuidance(error);
+    }
+    return {
+        content,
+        toolCalls: [...toolCalls.values()],
+        outputItems: [],
+        usage,
+    };
+}
+function createAnthropicProviderRuntime() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.provider_init",
+        message: "anthropic provider init",
+        meta: { provider: "anthropic" },
+    });
+    const anthropicConfig = (0, config_1.getAnthropicConfig)();
+    if (!(anthropicConfig.model && anthropicConfig.setupToken)) {
+        throw new Error(getAnthropicReauthGuidance("provider 'anthropic' is selected in agent.json but providers.anthropic.model/setupToken is incomplete in secrets.json."));
+    }
+    const credential = resolveAnthropicSetupTokenCredential();
+    const client = new sdk_1.default({
+        authToken: credential.token,
+        timeout: 30000,
+        maxRetries: 0,
+        defaultHeaders: {
+            "anthropic-beta": ANTHROPIC_OAUTH_BETA_HEADER,
+        },
+    });
+    return {
+        id: "anthropic",
+        model: anthropicConfig.model,
+        client,
+        resetTurnState(_messages) {
+            // Anthropic request payload is derived from canonical messages each turn.
+        },
+        appendToolOutput(_callId, _output) {
+            // Anthropic uses canonical messages for tool_result tracking.
+        },
+        streamTurn(request) {
+            return streamAnthropicMessages(client, anthropicConfig.model, request);
+        },
+    };
+}

package/dist/heart/providers/azure.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAzureProviderRuntime = createAzureProviderRuntime;
+const openai_1 = require("openai");
+const config_1 = require("../config");
+const runtime_1 = require("../../nerves/runtime");
+const streaming_1 = require("../streaming");
+function createAzureProviderRuntime() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.provider_init",
+        message: "azure provider init",
+        meta: { provider: "azure" },
+    });
+    const azureConfig = (0, config_1.getAzureConfig)();
+    if (!(azureConfig.apiKey && azureConfig.endpoint && azureConfig.deployment && azureConfig.modelName)) {
+        throw new Error("provider 'azure' is selected in agent.json but providers.azure is incomplete in secrets.json.");
+    }
+    const client = new openai_1.AzureOpenAI({
+        apiKey: azureConfig.apiKey,
+        endpoint: azureConfig.endpoint.replace(/\/openai.*$/, ""),
+        deployment: azureConfig.deployment,
+        apiVersion: azureConfig.apiVersion,
+        timeout: 30000,
+        maxRetries: 0,
+    });
+    let nativeInput = null;
+    let nativeInstructions = "";
+    return {
+        id: "azure",
+        model: azureConfig.modelName,
+        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.traceId)
+                params.metadata = { trace_id: request.traceId };
+            if (request.toolChoiceRequired)
+                params.tool_choice = "required";
+            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;
+        },
+    };
+}

package/dist/heart/providers/minimax.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMinimaxProviderRuntime = createMinimaxProviderRuntime;
+const openai_1 = __importDefault(require("openai"));
+const config_1 = require("../config");
+const runtime_1 = require("../../nerves/runtime");
+const streaming_1 = require("../streaming");
+function createMinimaxProviderRuntime() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.provider_init",
+        message: "minimax provider init",
+        meta: { provider: "minimax" },
+    });
+    const minimaxConfig = (0, config_1.getMinimaxConfig)();
+    if (!minimaxConfig.apiKey) {
+        throw new Error("provider 'minimax' is selected in agent.json but providers.minimax.apiKey is missing in secrets.json.");
+    }
+    const client = new openai_1.default({
+        apiKey: minimaxConfig.apiKey,
+        baseURL: "https://api.minimaxi.chat/v1",
+        timeout: 30000,
+        maxRetries: 0,
+    });
+    return {
+        id: "minimax",
+        model: minimaxConfig.model,
+        client,
+        resetTurnState(_messages) {
+            // No provider-owned turn state for chat-completions providers.
+        },
+        appendToolOutput(_callId, _output) {
+            // Chat-completions providers rely on canonical messages only.
+        },
+        streamTurn(request) {
+            const params = {
+                messages: request.messages,
+                tools: request.activeTools,
+                stream: true,
+            };
+            if (this.model)
+                params.model = this.model;
+            if (request.traceId)
+                params.metadata = { trace_id: request.traceId };
+            if (request.toolChoiceRequired)
+                params.tool_choice = "required";
+            return (0, streaming_1.streamChatCompletion)(this.client, params, request.callbacks, request.signal);
+        },
+    };
+}

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);
+            }
+        },
+    };
+}