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

package/dist/heart/kicks.js

@@ -0,0 +1,144 @@
+"use strict";
+// TODO: Kicks enforce "any action" but not "meaningful action". After a narration
+// kick, the model can satisfy the constraint by calling a no-op tool like
+// get_current_time({}). We need to detect trivial compliance and either re-kick
+// or discount the tool call. Ideally, the kick message would suggest a specific
+// tool call based on conversation context (what the user asked, what tools are
+// relevant) rather than just saying "call a tool". That's a bigger piece of work —
+// it requires the kick system to be context-aware.
+// See ouroboros' observation: "i'm not chickening out. i'm satisfying a crude
+// constraint. poorly."
+//
+// A kick is a self-correction. When the harness detects a malformed response,
+// it injects an assistant-role message as if the model caught its own mistake.
+//
+// Kicks are:
+//   - assistant role (self-correction, not external rebuke)
+//   - first person ("I" not "you")
+//   - forward-looking (what I'm doing next, not what I did wrong)
+//   - short (one sentence)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasToolIntent = hasToolIntent;
+exports.detectKick = detectKick;
+const KICK_MESSAGES = {
+    empty: "I sent an empty message by accident — let me try again.",
+    narration: "I narrated instead of acting. Using the tool now -- if done, calling final_answer.",
+    tool_required: "tool-required is on — I need to call a tool. use /tool-required to turn it off.",
+};
+const TOOL_INTENT_PATTERNS = [
+    // Explicit intent — "let me", "I'll", "I will"
+    /\blet me\b/i,
+    /\bi'll\b/i,
+    /\bi will\b/i,
+    /\bi would like to\b/i,
+    /\bi want to\b/i,
+    // "going to" variants
+    /\bi'm going to\b/i,
+    /\bgoing to\b/i,
+    /\bi am going to\b/i,
+    // Present continuous — "i'm checking", "i am querying"
+    /\bi'm \w+ing\b/i,
+    /\bi am \w+ing\b/i,
+    // Action announcements — "I need to", "I should", "I can"
+    /\bi need to\b/i,
+    /\bi should\b/i,
+    /\bi can\b/i,
+    // Obligation — "I have to", "I must"
+    /\bi have to\b/i,
+    /\bwe have to\b/i,
+    /\bi must\b/i,
+    /\bwe must\b/i,
+    // First person plural intent
+    /\bwe need to\b/i,
+    /\bwe should\b/i,
+    /\bwe can\b/i,
+    /\bwe'll\b/i,
+    /\bwe will\b/i,
+    /\bwe're going to\b/i,
+    /\bwe are going to\b/i,
+    /\blet's\b/i,
+    // Gerund phase shifts — "entering", "starting", "proceeding", "switching"
+    /\bentering\b/i,
+    /\bstarting with\b/i,
+    /\bproceeding\b/i,
+    /\bswitching to\b/i,
+    // Temporal narration — "first", "now I/we", "next turn", "next, I"
+    /\bfirst,?\s+i\b/i,
+    /\bnow i\b/i,
+    /\bnow we\b/i,
+    /\bnext turn\b/i,
+    /\bnext,?\s+i\b/i,
+    /\bnext,?\s+we\b/i,
+    // Sequential narration — "then I/we", "after that", "once I/we", "before I/we"
+    /\bthen i\b/i,
+    /\bthen we\b/i,
+    /\bafter that\b/i,
+    /\bonce i\b/i,
+    /\bonce we\b/i,
+    /\bbefore i\b/i,
+    /\bbefore we\b/i,
+    // Future intent — "about to", "gonna"
+    /\babout to\b/i,
+    /\bgonna\b/i,
+    // Hedged intent — "allow me to", "time to"
+    /\ballow me to\b/i,
+    /\btime to\b/i,
+    // Movement narration — "moving on", "moving to"
+    /\bmoving on\b/i,
+    /\bmoving to\b/i,
+    // Self-narration — "my next step", "my plan", "the plan is", "tool calls only"
+    /\bmy next step\b/i,
+    /\bmy plan\b/i,
+    /\bthe plan is\b/i,
+    /\btool calls only\b/i,
+    // "Continuing" at start of any line — narration filler (multiline so ^ matches after \n)
+    /^continuing\b/im,
+    // "continues" anywhere — progress narration ("The work continues", "continues to be complex")
+    /\bcontinues\b/i,
+    // "Next up" at start of text — e.g. "Next up:", "Next up, I'll..."
+    /^next up\b/i,
+];
+// Normalize curly quotes/apostrophes to straight so patterns match consistently
+function normalize(text) {
+    return text.replace(/[\u2018\u2019\u2032]/g, "'").replace(/[\u201C\u201D]/g, '"');
+}
+function hasToolIntent(text) {
+    return TOOL_INTENT_PATTERNS.some((p) => p.test(normalize(text)));
+}
+// Detect what kind of kick is needed, or null if response is fine.
+// Priority: empty > narration > tool_required
+function detectKick(content, options) {
+    const isEmpty = !content?.trim();
+    if (isEmpty) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.error",
+            component: "engine",
+            message: "empty assistant content detected",
+            meta: { reason: "empty" },
+        });
+        return { reason: "empty", message: KICK_MESSAGES.empty };
+    }
+    if (hasToolIntent(content)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.error",
+            component: "engine",
+            message: "narration-style response detected",
+            meta: { reason: "narration" },
+        });
+        return { reason: "narration", message: KICK_MESSAGES.narration };
+    }
+    if (options?.toolChoiceRequired) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.error",
+            component: "engine",
+            message: "tool-required mode response missing tool call",
+            meta: { reason: "tool_required" },
+        });
+        return { reason: "tool_required", message: KICK_MESSAGES.tool_required };
+    }
+    return null;
+}
+const runtime_1 = require("../nerves/runtime");

package/dist/heart/primitives.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARNESS_BOOTSTRAP_PHASES = void 0;
+exports.HARNESS_BOOTSTRAP_PHASES = ["bundle", "psyche", "inner-dialog"];

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