@ouro.bot/cli 0.1.0-alpha.2 → 0.1.0-alpha.200

package/dist/heart/providers/anthropic.js

@@ -1,13 +1,50 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAnthropicMessages = toAnthropicMessages;
+exports.classifyAnthropicError = classifyAnthropicError;
 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 streaming_1 = require("../streaming");
+const model_capabilities_1 = require("../model-capabilities");
 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";
@@ -21,10 +58,10 @@ 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)",
+        `  1. Run \`ouro auth --agent ${agentName}\``,
         `  2. Open ${getAnthropicSecretsPathForGuidance()}`,
         "  3. Confirm providers.anthropic.setupToken is set",
+        "  4. After reauth, retry the failed ouro command or reconnect this session.",
     ].join("\n");
 }
 function getAnthropicReauthGuidance(reason) {
@@ -92,12 +129,27 @@ function toAnthropicMessages(messages) {
         if (msg.role === "assistant") {
             const assistant = msg;
             const blocks = [];
+            // Restore thinking blocks before text/tool_use blocks
+            const thinkingBlocks = assistant._thinking_blocks;
+            if (thinkingBlocks) {
+                for (const tb of thinkingBlocks) {
+                    if (tb.type === "thinking") {
+                        blocks.push({ type: "thinking", thinking: tb.thinking, signature: tb.signature });
+                    }
+                    else {
+                        blocks.push({ type: "redacted_thinking", data: tb.data });
+                    }
+                }
+            }
             const text = toAnthropicTextContent(assistant.content);
             if (text) {
                 blocks.push({ type: "text", text });
             }
             if (assistant.tool_calls) {
                 for (const toolCall of assistant.tool_calls) {
+                    /* v8 ignore next -- type narrowing: OpenAI SDK only emits function tool_calls @preserve */
+                    if (toolCall.type !== "function")
+                        continue;
                     blocks.push({
                         type: "tool_use",
                         id: toolCall.id,
@@ -169,6 +221,29 @@ function mergeAnthropicToolArguments(current, partial) {
     }
     return current + partial;
 }
+/* v8 ignore start -- shared network error utility, tested via classification tests @preserve */
+function isNetworkError(error) {
+    const code = error.code || "";
+    if (["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "EPIPE",
+        "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "ECONNABORTED"].includes(code))
+        return true;
+    const msg = error.message || "";
+    return msg.includes("fetch failed") || msg.includes("socket hang up") || msg.includes("getaddrinfo");
+}
+/* v8 ignore stop */
+function classifyAnthropicError(error) {
+    const status = error.status;
+    if (status === 401 || status === 403 || isAnthropicAuthFailure(error))
+        return "auth-failure";
+    if (status === 429)
+        return "rate-limit";
+    if (status === 529 || (status && status >= 500))
+        return "server-error";
+    if (isNetworkError(error))
+        return "network-error";
+    return "unknown";
+}
+/* v8 ignore start -- auth detection: only called from classifyAnthropicError which always passes Error @preserve */
 function isAnthropicAuthFailure(error) {
     if (!(error instanceof Error))
         return false;
@@ -181,40 +256,52 @@ function isAnthropicAuthFailure(error) {
         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));
-}
+/* v8 ignore stop */
 async function streamAnthropicMessages(client, model, request) {
     const { system, messages } = toAnthropicMessages(request.messages);
     const anthropicTools = toAnthropicTools(request.activeTools);
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(model);
+    const maxTokens = modelCaps.maxOutputTokens ?? 16384;
     const params = {
         model,
-        max_tokens: 4096,
+        max_tokens: maxTokens,
         messages,
         stream: true,
+        thinking: { type: "adaptive" },
+        output_config: { effort: request.reasoningEffort ?? "medium" },
     };
-    if (system)
-        params.system = system;
+    // The Anthropic API requires a Claude Code identification block in the system
+    // prompt when using OAuth setup tokens (sk-ant-oat01). Without it, Opus/Sonnet
+    // 4.6 requests are rejected with 400. This is the API's validation that the
+    // token is being used by a Claude Code client.
+    const claudeCodePreamble = { type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude." };
+    if (system) {
+        params.system = [claudeCodePreamble, { type: "text", text: system }];
+    }
+    else {
+        params.system = [claudeCodePreamble];
+    }
     if (anthropicTools.length > 0)
         params.tools = anthropicTools;
     if (request.toolChoiceRequired && anthropicTools.length > 0) {
-        params.tool_choice = { type: "any" };
+        // Thinking (adaptive or enabled) only supports tool_choice "auto" or "none".
+        // "any" forces tool use which is incompatible with extended thinking.
+        params.tool_choice = params.thinking ? { type: "auto" } : /* v8 ignore next -- no-thinking path: thinking always set for 4.6 models @preserve */ { type: "any" };
     }
     let response;
     try {
         response = await client.messages.create(params, request.signal ? { signal: request.signal } : {});
     }
     catch (error) {
-        throw withAnthropicAuthGuidance(error);
+        throw error instanceof Error ? error : new Error(String(error));
     }
     let content = "";
     let streamStarted = false;
     let usage;
     const toolCalls = new Map();
+    const thinkingBlocks = new Map();
+    const redactedBlocks = new Map();
+    const answerStreamer = new streaming_1.SettleStreamer(request.callbacks, request.eagerSettleStreaming);
     try {
         for await (const event of response) {
             if (request.signal?.aborted)
@@ -222,17 +309,29 @@ async function streamAnthropicMessages(client, model, request) {
             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 index = Number(event.index);
+                if (block?.type === "thinking") {
+                    thinkingBlocks.set(index, { type: "thinking", thinking: "", signature: "" });
+                }
+                else if (block?.type === "redacted_thinking") {
+                    redactedBlocks.set(index, { type: "redacted_thinking", data: String(block.data ?? "") });
+                }
+                else if (block?.type === "tool_use") {
                     const rawInput = block.input;
                     const input = rawInput && typeof rawInput === "object"
                         ? JSON.stringify(rawInput)
                         : "";
+                    const name = String(block.name ?? "");
                     toolCalls.set(index, {
                         id: String(block.id ?? ""),
-                        name: String(block.name ?? ""),
+                        name,
                         arguments: input,
                     });
+                    // Activate eager streaming for sole settle tool call
+                    /* v8 ignore next -- settle streaming activation, tested via SettleStreamer unit tests @preserve */
+                    if (name === "settle" && toolCalls.size === 1) {
+                        answerStreamer.activate();
+                    }
                 }
                 continue;
             }
@@ -254,14 +353,31 @@ async function streamAnthropicMessages(client, model, request) {
                         request.callbacks.onModelStreamStart();
                         streamStarted = true;
                     }
-                    request.callbacks.onReasoningChunk(String(delta?.thinking ?? ""));
+                    const thinkingText = String(delta?.thinking ?? "");
+                    request.callbacks.onReasoningChunk(thinkingText);
+                    const thinkingIndex = Number(event.index);
+                    const thinkingBlock = thinkingBlocks.get(thinkingIndex);
+                    if (thinkingBlock)
+                        thinkingBlock.thinking += thinkingText;
+                    continue;
+                }
+                if (deltaType === "signature_delta") {
+                    const sigIndex = Number(event.index);
+                    const sigBlock = thinkingBlocks.get(sigIndex);
+                    if (sigBlock)
+                        sigBlock.signature += String(delta?.signature ?? "");
                     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 ?? ""));
+                        const partialJson = String(delta?.partial_json ?? "");
+                        existing.arguments = mergeAnthropicToolArguments(existing.arguments, partialJson);
+                        /* v8 ignore next -- settle delta streaming, tested via SettleStreamer unit tests @preserve */
+                        if (existing.name === "settle" && toolCalls.size === 1) {
+                            answerStreamer.processDelta(partialJson);
+                        }
                     }
                     continue;
                 }
@@ -283,16 +399,25 @@ async function streamAnthropicMessages(client, model, request) {
         }
     }
     catch (error) {
-        throw withAnthropicAuthGuidance(error);
+        throw error instanceof Error ? error : /* v8 ignore next -- defensive: stream errors are always Error @preserve */ new Error(String(error));
     }
+    // Collect all thinking blocks (regular + redacted) sorted by index to preserve ordering
+    const allThinkingIndices = [...thinkingBlocks.keys(), ...redactedBlocks.keys()].sort((a, b) => a - b);
+    const outputItems = allThinkingIndices.map((idx) => {
+        const tb = thinkingBlocks.get(idx);
+        if (tb)
+            return tb;
+        return redactedBlocks.get(idx);
+    });
     return {
         content,
         toolCalls: [...toolCalls.values()],
-        outputItems: [],
+        outputItems,
         usage,
+        settleStreamed: answerStreamer.streamed,
     };
 }
-function createAnthropicProviderRuntime() {
+function createAnthropicProviderRuntime(model) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.provider_init",
@@ -300,30 +425,68 @@ function createAnthropicProviderRuntime() {
         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."));
+    if (!anthropicConfig.setupToken) {
+        throw new Error(getAnthropicReauthGuidance("provider 'anthropic' is selected in agent.json but providers.anthropic.setupToken is missing in secrets.json."));
     }
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(model);
+    const capabilities = new Set();
+    if (modelCaps.reasoningEffort)
+        capabilities.add("reasoning-effort");
     const credential = resolveAnthropicSetupTokenCredential();
-    const client = new sdk_1.default({
-        authToken: credential.token,
-        timeout: 30000,
-        maxRetries: 0,
-        defaultHeaders: {
-            "anthropic-beta": ANTHROPIC_OAUTH_BETA_HEADER,
-        },
-    });
+    const refreshToken = anthropicConfig.refreshToken;
+    const expiresAt = anthropicConfig.expiresAt;
+    function createClient(token) {
+        return new sdk_1.default({
+            authToken: token,
+            timeout: 30000,
+            maxRetries: 0,
+            defaultHeaders: {
+                "anthropic-beta": ANTHROPIC_OAUTH_BETA_HEADER,
+                "anthropic-dangerous-direct-browser-access": "true",
+                "user-agent": "claude-cli/2.1.2 (external, cli)",
+                "x-app": "cli",
+            },
+        });
+    }
+    let currentToken = credential.token;
+    let client = createClient(currentToken);
+    /* v8 ignore start -- token refresh: dynamic import + ensureFreshToken, tested via integration @preserve */
+    async function ensureClient() {
+        try {
+            const { ensureFreshToken } = await Promise.resolve().then(() => __importStar(require("./anthropic-token")));
+            const { getAgentName } = await Promise.resolve().then(() => __importStar(require("../identity")));
+            const freshToken = await ensureFreshToken(currentToken, refreshToken, expiresAt, getAgentName());
+            if (freshToken !== currentToken) {
+                currentToken = freshToken;
+                client = createClient(freshToken);
+            }
+        }
+        catch {
+            // refresh failed — use existing client
+        }
+        return client;
+    }
+    /* v8 ignore stop */
     return {
         id: "anthropic",
-        model: anthropicConfig.model,
-        client,
+        model,
+        /* v8 ignore next -- getter: returns mutable client ref @preserve */
+        get client() { return client; },
+        capabilities,
+        supportedReasoningEfforts: modelCaps.reasoningEffort,
         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);
+        async streamTurn(request) {
+            const freshClient = await ensureClient();
+            return streamAnthropicMessages(freshClient, model, request);
+        },
+        /* v8 ignore next 3 -- delegation: classification logic tested via classifyAnthropicError @preserve */
+        classifyError(error) {
+            return classifyAnthropicError(error);
         },
     };
 }

package/dist/heart/providers/azure.js

@@ -1,35 +1,137 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyAzureError = classifyAzureError;
+exports.createAzureTokenProvider = createAzureTokenProvider;
 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() {
+const model_capabilities_1 = require("../model-capabilities");
+const COGNITIVE_SERVICES_SCOPE = "https://cognitiveservices.azure.com/.default";
+/* v8 ignore start -- shared network error utility, tested via classification tests @preserve */
+function isNetworkError(error) {
+    const code = error.code || "";
+    if (["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "EPIPE",
+        "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "ECONNABORTED"].includes(code))
+        return true;
+    const msg = error.message || "";
+    return msg.includes("fetch failed") || msg.includes("socket hang up") || msg.includes("getaddrinfo");
+}
+/* v8 ignore stop */
+function classifyAzureError(error) {
+    const status = error.status;
+    if (status === 401 || status === 403)
+        return "auth-failure";
+    if (status === 429)
+        return "rate-limit";
+    if (status && status >= 500)
+        return "server-error";
+    if (isNetworkError(error))
+        return "network-error";
+    return "unknown";
+}
+// @azure/identity is imported dynamically (below) rather than at the top level
+// because it's a heavy package (~30+ transitive deps) and we only need it when
+// using the managed-identity auth path. API-key users and other providers
+// shouldn't pay the cold-start cost.
+function createAzureTokenProvider(managedIdentityClientId) {
+    let credential = null;
+    return async () => {
+        try {
+            if (!credential) {
+                const { DefaultAzureCredential } = await Promise.resolve().then(() => __importStar(require("@azure/identity")));
+                const credentialOptions = managedIdentityClientId
+                    ? { managedIdentityClientId }
+                    : undefined;
+                credential = new DefaultAzureCredential(credentialOptions);
+            }
+            const tokenResponse = await credential.getToken(COGNITIVE_SERVICES_SCOPE);
+            return tokenResponse.token;
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            throw new Error(`Azure OpenAI authentication failed: ${detail}\n` +
+                "To fix this, either:\n" +
+                "  1. Set providers.azure.apiKey in secrets.json, or\n" +
+                "  2. Run 'az login' to authenticate with your Azure account (for local dev), or\n" +
+                "  3. Attach a managed identity to your App Service and set providers.azure.managedIdentityClientId in secrets.json (for deployed environments)");
+        }
+    };
+}
+function createAzureProviderRuntime(model) {
+    const azureConfig = (0, config_1.getAzureConfig)();
+    const useApiKey = !!azureConfig.apiKey;
+    const authMethod = useApiKey ? "key" : "managed-identity";
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.provider_init",
         message: "azure provider init",
-        meta: { provider: "azure" },
+        meta: { provider: "azure", authMethod },
     });
-    const azureConfig = (0, config_1.getAzureConfig)();
-    if (!(azureConfig.apiKey && azureConfig.endpoint && azureConfig.deployment && azureConfig.modelName)) {
+    if (!(azureConfig.endpoint && azureConfig.deployment)) {
         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,
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(model);
+    const capabilities = new Set();
+    if (modelCaps.reasoningEffort)
+        capabilities.add("reasoning-effort");
+    const clientOptions = {
         endpoint: azureConfig.endpoint.replace(/\/openai.*$/, ""),
         deployment: azureConfig.deployment,
         apiVersion: azureConfig.apiVersion,
         timeout: 30000,
         maxRetries: 0,
-    });
+    };
+    if (useApiKey) {
+        clientOptions.apiKey = azureConfig.apiKey;
+    }
+    else {
+        const managedIdentityClientId = azureConfig.managedIdentityClientId || undefined;
+        clientOptions.azureADTokenProvider = createAzureTokenProvider(managedIdentityClientId);
+    }
+    const client = new openai_1.AzureOpenAI(clientOptions);
     let nativeInput = null;
     let nativeInstructions = "";
     return {
         id: "azure",
-        model: azureConfig.modelName,
+        model,
         client,
+        capabilities,
+        supportedReasoningEfforts: modelCaps.reasoningEffort,
         resetTurnState(messages) {
             const { instructions, input } = (0, streaming_1.toResponsesInput)(messages);
             nativeInput = input;
@@ -48,7 +150,7 @@ function createAzureProviderRuntime() {
                 input: nativeInput,
                 instructions: nativeInstructions,
                 tools: (0, streaming_1.toResponsesTools)(request.activeTools),
-                reasoning: { effort: "medium", summary: "detailed" },
+                reasoning: { effort: request.reasoningEffort ?? "medium", summary: "detailed" },
                 stream: true,
                 store: false,
                 include: ["reasoning.encrypted_content"],
@@ -57,10 +159,14 @@ function createAzureProviderRuntime() {
                 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);
+            const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal, request.eagerSettleStreaming);
             for (const item of result.outputItems)
                 nativeInput.push(item);
             return result;
         },
+        /* v8 ignore next 3 -- delegation: classification logic tested via classifyAzureError @preserve */
+        classifyError(error) {
+            return classifyAzureError(error);
+        },
     };
 }