@ouro.bot/cli 0.1.0-alpha.50 → 0.1.0-alpha.52

package/changelog.json

@@ -1,6 +1,24 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.52",
+      "changes": [
+        "Trusted 1:1 chats can now act live across active group threads: the harness resolves candidate target chats, carries explicit trust context into the model, and delivers messages into the right live BlueBubbles or Teams session instead of only queueing for later.",
+        "People discovered through a relevant live group are now bootstrapped as acquaintances with shared-group context, so the agent gets a socially truthful model of who is merely unknown versus who is known through the current group.",
+        "Cross-chat work now returns a truthful outcome back to the asking chat, and bridge suggestions can span different outward relationships when one live piece of work is clearly happening across them."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.51",
+      "changes": [
+        "Agents can now adjust their own reasoning depth mid-conversation via a new set_reasoning_effort tool, with effort levels derived from a central model capabilities registry.",
+        "Anthropic extended thinking is now enabled with adaptive effort, thinking blocks are captured during streaming (including signatures and redacted blocks), persisted on conversation history, and faithfully round-tripped across turns.",
+        "Anthropic max_tokens now uses the model's actual output ceiling from the registry instead of a hardcoded 4096, removing artificial response length constraints.",
+        "Codex assistant messages are now annotated with phase labels (commentary vs final_answer) so GPT-5.4 can distinguish intermediate reasoning from completed responses in its own history.",
+        "Azure and Codex reasoning effort is now dynamic from the agent loop instead of hardcoded to medium."
+      ]
+    },
     {
       "version": "0.1.0-alpha.50",
       "changes": [

package/dist/heart/active-work.js

@@ -5,6 +5,7 @@ exports.buildActiveWorkFrame = buildActiveWorkFrame;
 exports.formatActiveWorkFrame = formatActiveWorkFrame;
 const runtime_1 = require("../nerves/runtime");
 const state_machine_1 = require("./bridges/state-machine");
+const target_resolution_1 = require("./target-resolution");
 function activityPriority(source) {
     return source === "friend-facing" ? 0 : 1;
 }
@@ -31,16 +32,28 @@ function hasSharedObligationPressure(input) {
         || summarizeLiveTasks(input.taskBoard).length > 0;
 }
 function suggestBridgeForActiveWork(input) {
-    const candidateSessions = input.friendSessions
-        .filter((session) => !input.currentSession
-        || session.friendId !== input.currentSession.friendId
-        || session.channel !== input.currentSession.channel
-        || session.key !== input.currentSession.key)
-        .sort(compareActivity);
-    const targetSession = candidateSessions[0] ?? null;
-    if (!targetSession || !hasSharedObligationPressure(input)) {
+    const targetCandidates = (input.targetCandidates ?? [])
+        .filter((candidate) => {
+        if (candidate.delivery.mode === "blocked") {
+            return false;
+        }
+        if (candidate.activitySource !== "friend-facing" || candidate.channel === "inner") {
+            return false;
+        }
+        if (!input.currentSession) {
+            return true;
+        }
+        return !(candidate.friendId === input.currentSession.friendId
+            && candidate.channel === input.currentSession.channel
+            && candidate.key === input.currentSession.key);
+    })
+        .sort((a, b) => {
+        return b.lastActivityMs - a.lastActivityMs;
+    });
+    if (!hasSharedObligationPressure(input) || targetCandidates.length !== 1) {
         return null;
     }
+    const targetSession = targetCandidates[0];
     const activeBridge = input.bridges.find(isActiveBridge) ?? null;
     if (activeBridge) {
         const alreadyAttached = activeBridge.attachedSessions.some((session) => session.friendId === targetSession.friendId
@@ -53,14 +66,14 @@ function suggestBridgeForActiveWork(input) {
             kind: "attach-existing",
             bridgeId: activeBridge.id,
             targetSession,
-            reason: "same-friend-shared-work",
+            reason: "shared-work-candidate",
         };
     }
     return {
         kind: "begin-new",
         targetSession,
         objectiveHint: input.currentObligation?.trim() || "keep this shared work aligned",
-        reason: "same-friend-shared-work",
+        reason: "shared-work-candidate",
     };
 }
 function formatSessionLabel(session) {
@@ -95,13 +108,14 @@ function buildActiveWorkFrame(input) {
             freshestForCurrentFriend: friendSessions[0] ?? null,
             otherLiveSessionsForCurrentFriend: friendSessions,
         },
+        targetCandidates: input.targetCandidates ?? [],
         bridgeSuggestion: suggestBridgeForActiveWork({
             currentSession: input.currentSession,
             currentObligation: input.currentObligation,
             mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
             bridges: input.bridges,
             taskBoard: input.taskBoard,
-            friendSessions,
+            targetCandidates: input.targetCandidates,
         }),
     };
     (0, runtime_1.emitNervesEvent)({
@@ -144,6 +158,13 @@ function formatActiveWorkFrame(frame) {
     if (frame.friendActivity?.freshestForCurrentFriend) {
         lines.push(`freshest friend-facing session: ${formatSessionLabel(frame.friendActivity.freshestForCurrentFriend)}`);
     }
+    const targetCandidatesBlock = frame.targetCandidates && frame.targetCandidates.length > 0
+        ? (0, target_resolution_1.formatTargetSessionCandidates)(frame.targetCandidates)
+        : "";
+    if (targetCandidatesBlock) {
+        lines.push("");
+        lines.push(targetCandidatesBlock);
+    }
     if (frame.bridgeSuggestion) {
         if (frame.bridgeSuggestion.kind === "attach-existing") {
             lines.push(`suggested bridge: attach ${frame.bridgeSuggestion.bridgeId} -> ${formatSessionLabel(frame.bridgeSuggestion.targetSession)}`);

package/dist/heart/core.js

@@ -331,7 +331,12 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     // so turn execution remains consistent and non-fatal.
     if (channel) {
         try {
-            const refreshed = await (0, prompt_1.buildSystem)(channel, options, currentContext);
+            const buildSystemOptions = {
+                ...options,
+                providerCapabilities: providerRuntime.capabilities,
+                supportedReasoningEfforts: providerRuntime.supportedReasoningEfforts,
+            };
+            const refreshed = await (0, prompt_1.buildSystem)(channel, buildSystemOptions, currentContext);
             upsertSystemPrompt(messages, refreshed);
         }
         catch (error) {
@@ -362,13 +367,22 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let completion;
     let sawSteeringFollowUp = false;
     let mustResolveBeforeHandoffActive = options?.mustResolveBeforeHandoff === true;
+    let currentReasoningEffort = "medium";
     // Prevent MaxListenersExceeded warning — each iteration adds a listener
     try {
         require("events").setMaxListeners(50, signal);
     }
     catch { /* unsupported */ }
     const toolPreferences = currentContext?.friend?.toolPreferences;
-    const baseTools = options?.tools ?? (0, tools_1.getToolsForChannel)(channel ? (0, channel_1.getChannelCapabilities)(channel) : undefined, toolPreferences && Object.keys(toolPreferences).length > 0 ? toolPreferences : undefined, currentContext);
+    const baseTools = options?.tools ?? (0, tools_1.getToolsForChannel)(channel ? (0, channel_1.getChannelCapabilities)(channel) : undefined, toolPreferences && Object.keys(toolPreferences).length > 0 ? toolPreferences : undefined, currentContext, providerRuntime.capabilities);
+    // Augment tool context with reasoning effort controls from provider
+    const augmentedToolContext = options?.toolContext
+        ? {
+            ...options.toolContext,
+            supportedReasoningEfforts: providerRuntime.supportedReasoningEfforts,
+            setReasoningEffort: (level) => { currentReasoningEffort = level; },
+        }
+        : undefined;
     // Rebase provider-owned turn state from canonical messages at user-turn start.
     // This prevents stale provider caches from replaying prior-turn context.
     providerRuntime.resetTurnState(messages);
@@ -412,6 +426,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 signal,
                 traceId,
                 toolChoiceRequired,
+                reasoningEffort: currentReasoningEffort,
             });
             // Track usage from the latest API call
             if (result.usage)
@@ -435,6 +450,17 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             if (reasoningItems.length > 0) {
                 msg._reasoning_items = reasoningItems;
             }
+            // Store thinking blocks (Anthropic) on the assistant message for round-tripping
+            const thinkingItems = result.outputItems.filter((item) => "type" in item && (item.type === "thinking" || item.type === "redacted_thinking"));
+            if (thinkingItems.length > 0) {
+                msg._thinking_blocks = thinkingItems;
+            }
+            // Phase annotation for Codex provider
+            const hasPhaseAnnotation = providerRuntime.capabilities.has("phase-annotation");
+            const isSoleFinalAnswer = result.toolCalls.length === 1 && result.toolCalls[0].name === "final_answer";
+            if (hasPhaseAnnotation) {
+                msg.phase = isSoleFinalAnswer ? "final_answer" : "commentary";
+            }
             if (!result.toolCalls.length) {
                 // No tool calls — accept response as-is.
                 // (Kick detection disabled; tool_choice: required + final_answer
@@ -444,7 +470,6 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             }
             else {
                 // Check for final_answer sole call: intercept before tool execution
-                const isSoleFinalAnswer = result.toolCalls.length === 1 && result.toolCalls[0].name === "final_answer";
                 if (isSoleFinalAnswer) {
                     // Extract answer from the tool call arguments.
                     // Supports: {"answer":"text","intent":"..."} or "text" (JSON string).
@@ -536,7 +561,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     let success;
                     try {
                         const execToolFn = options?.execTool ?? tools_1.execTool;
-                        toolResult = await execToolFn(tc.name, args, options?.toolContext);
+                        toolResult = await execToolFn(tc.name, args, augmentedToolContext ?? options?.toolContext);
                         success = true;
                     }
                     catch (e) {

package/dist/heart/cross-chat-delivery.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deliverCrossChatMessage = deliverCrossChatMessage;
+const types_1 = require("../mind/friends/types");
+const runtime_1 = require("../nerves/runtime");
+function buildPendingEnvelope(request, agentName, now) {
+    return {
+        from: agentName,
+        friendId: request.friendId,
+        channel: request.channel,
+        key: request.key,
+        content: request.content,
+        timestamp: now,
+    };
+}
+function queueForLater(request, deps, detail) {
+    deps.queuePending(buildPendingEnvelope(request, deps.agentName, (deps.now ?? Date.now)()));
+    return {
+        status: "queued_for_later",
+        detail,
+    };
+}
+function isExplicitlyAuthorized(request) {
+    return request.intent === "explicit_cross_chat"
+        && Boolean(request.authorizingSession)
+        && (0, types_1.isTrustedLevel)(request.authorizingSession?.trustLevel);
+}
+async function deliverCrossChatMessage(request, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.cross_chat_delivery_start",
+        message: "resolving cross-chat delivery",
+        meta: {
+            friendId: request.friendId,
+            channel: request.channel,
+            key: request.key,
+            intent: request.intent,
+            authorizingTrustLevel: request.authorizingSession?.trustLevel ?? null,
+        },
+    });
+    if (request.intent === "generic_outreach") {
+        const result = queueForLater(request, deps, "generic outreach stays queued until the target session is next active");
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "queued generic outreach for later delivery",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    if (!isExplicitlyAuthorized(request)) {
+        const result = {
+            status: "blocked",
+            detail: "explicit cross-chat delivery requires a trusted asking session",
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "blocked explicit cross-chat delivery",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    const deliverer = deps.deliverers?.[request.channel];
+    if (!deliverer) {
+        const result = queueForLater(request, deps, "live delivery unavailable right now; queued for the next active turn");
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "queued explicit cross-chat delivery because no live deliverer was available",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    try {
+        const direct = await deliverer(request);
+        if (direct.status === "delivered_now" || direct.status === "blocked" || direct.status === "failed") {
+            const result = {
+                status: direct.status,
+                detail: direct.detail,
+            };
+            (0, runtime_1.emitNervesEvent)({
+                level: result.status === "failed" ? "error" : result.status === "blocked" ? "warn" : "info",
+                component: "engine",
+                event: "engine.cross_chat_delivery_end",
+                message: "completed direct cross-chat delivery resolution",
+                meta: {
+                    friendId: request.friendId,
+                    channel: request.channel,
+                    key: request.key,
+                    status: result.status,
+                },
+            });
+            return result;
+        }
+        const result = queueForLater(request, deps, direct.detail.trim() || "live delivery unavailable right now; queued for the next active turn");
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "queued explicit cross-chat delivery after adapter reported unavailability",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        const result = {
+            status: "failed",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "cross-chat delivery threw unexpectedly",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+                reason: result.detail,
+            },
+        });
+        return result;
+    }
+}

package/dist/heart/model-capabilities.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_CAPABILITIES = void 0;
+exports.getModelCapabilities = getModelCapabilities;
+const runtime_1 = require("../nerves/runtime");
+exports.MODEL_CAPABILITIES = {
+    "claude-opus-4-6": {
+        reasoningEffort: ["low", "medium", "high", "max"],
+        thinkingFormat: "anthropic",
+        maxOutputTokens: 128000,
+    },
+    "claude-sonnet-4-6": {
+        reasoningEffort: ["low", "medium", "high"],
+        thinkingFormat: "anthropic",
+        maxOutputTokens: 64000,
+    },
+    "gpt-5.4": {
+        reasoningEffort: ["low", "medium", "high"],
+        phase: true,
+        maxOutputTokens: 100000,
+    },
+    "gpt-5.3-codex": {
+        reasoningEffort: ["low", "medium", "high"],
+        phase: true,
+        maxOutputTokens: 100000,
+    },
+};
+const EMPTY_CAPABILITIES = Object.freeze({});
+function getModelCapabilities(modelId) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.model_capabilities_lookup",
+        message: `model capabilities lookup: ${modelId}`,
+        meta: { modelId, found: modelId in exports.MODEL_CAPABILITIES },
+    });
+    const entry = exports.MODEL_CAPABILITIES[modelId];
+    if (entry)
+        return entry;
+    return { ...EMPTY_CAPABILITIES };
+}

package/dist/heart/providers/anthropic.js

@@ -3,12 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAnthropicMessages = toAnthropicMessages;
 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";
@@ -93,6 +95,18 @@ 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 });
@@ -195,11 +209,14 @@ function withAnthropicAuthGuidance(error) {
 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", effort: request.reasoningEffort ?? "medium" },
     };
     if (system)
         params.system = system;
@@ -219,6 +236,8 @@ async function streamAnthropicMessages(client, model, request) {
     let streamStarted = false;
     let usage;
     const toolCalls = new Map();
+    const thinkingBlocks = new Map();
+    const redactedBlocks = new Map();
     const answerStreamer = new streaming_1.FinalAnswerStreamer(request.callbacks);
     try {
         for await (const event of response) {
@@ -227,8 +246,14 @@ 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)
@@ -265,7 +290,19 @@ 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") {
@@ -301,10 +338,18 @@ async function streamAnthropicMessages(client, model, request) {
     catch (error) {
         throw withAnthropicAuthGuidance(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,
         finalAnswerStreamed: answerStreamer.streamed,
     };
@@ -320,6 +365,10 @@ function createAnthropicProviderRuntime() {
     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 modelCaps = (0, model_capabilities_1.getModelCapabilities)(anthropicConfig.model);
+    const capabilities = new Set();
+    if (modelCaps.reasoningEffort)
+        capabilities.add("reasoning-effort");
     const credential = resolveAnthropicSetupTokenCredential();
     const client = new sdk_1.default({
         authToken: credential.token,
@@ -333,6 +382,8 @@ function createAnthropicProviderRuntime() {
         id: "anthropic",
         model: anthropicConfig.model,
         client,
+        capabilities,
+        supportedReasoningEfforts: modelCaps.reasoningEffort,
         resetTurnState(_messages) {
             // Anthropic request payload is derived from canonical messages each turn.
         },

package/dist/heart/providers/azure.js

@@ -5,6 +5,7 @@ const openai_1 = require("openai");
 const config_1 = require("../config");
 const runtime_1 = require("../../nerves/runtime");
 const streaming_1 = require("../streaming");
+const model_capabilities_1 = require("../model-capabilities");
 function createAzureProviderRuntime() {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
@@ -16,6 +17,10 @@ function createAzureProviderRuntime() {
     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 modelCaps = (0, model_capabilities_1.getModelCapabilities)(azureConfig.modelName);
+    const capabilities = new Set();
+    if (modelCaps.reasoningEffort)
+        capabilities.add("reasoning-effort");
     const client = new openai_1.AzureOpenAI({
         apiKey: azureConfig.apiKey,
         endpoint: azureConfig.endpoint.replace(/\/openai.*$/, ""),
@@ -30,6 +35,8 @@ function createAzureProviderRuntime() {
         id: "azure",
         model: azureConfig.modelName,
         client,
+        capabilities,
+        supportedReasoningEfforts: modelCaps.reasoningEffort,
         resetTurnState(messages) {
             const { instructions, input } = (0, streaming_1.toResponsesInput)(messages);
             nativeInput = input;
@@ -48,7 +55,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"],

package/dist/heart/providers/minimax.js

@@ -8,6 +8,7 @@ const openai_1 = __importDefault(require("openai"));
 const config_1 = require("../config");
 const runtime_1 = require("../../nerves/runtime");
 const streaming_1 = require("../streaming");
+const model_capabilities_1 = require("../model-capabilities");
 function createMinimaxProviderRuntime() {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
@@ -19,6 +20,8 @@ function createMinimaxProviderRuntime() {
     if (!minimaxConfig.apiKey) {
         throw new Error("provider 'minimax' is selected in agent.json but providers.minimax.apiKey is missing in secrets.json.");
     }
+    // Registry consulted; MiniMax models return empty defaults (no capabilities to derive)
+    (0, model_capabilities_1.getModelCapabilities)(minimaxConfig.model);
     const client = new openai_1.default({
         apiKey: minimaxConfig.apiKey,
         baseURL: "https://api.minimaxi.chat/v1",
@@ -29,6 +32,7 @@ function createMinimaxProviderRuntime() {
         id: "minimax",
         model: minimaxConfig.model,
         client,
+        capabilities: new Set(),
         resetTurnState(_messages) {
             // No provider-owned turn state for chat-completions providers.
         },

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

@@ -9,6 +9,7 @@ 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 OPENAI_CODEX_AUTH_FAILURE_MARKERS = [
     "authentication failed",
     "unauthorized",
@@ -106,6 +107,12 @@ function createOpenAICodexProviderRuntime() {
     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 modelCaps = (0, model_capabilities_1.getModelCapabilities)(codexConfig.model);
+    const capabilities = new Set();
+    if (modelCaps.reasoningEffort)
+        capabilities.add("reasoning-effort");
+    if (modelCaps.phase)
+        capabilities.add("phase-annotation");
     const client = new openai_1.default({
         apiKey: token,
         baseURL: OPENAI_CODEX_BACKEND_BASE_URL,
@@ -123,6 +130,8 @@ function createOpenAICodexProviderRuntime() {
         id: "openai-codex",
         model: codexConfig.model,
         client,
+        capabilities,
+        supportedReasoningEfforts: modelCaps.reasoningEffort,
         resetTurnState(messages) {
             const { instructions, input } = (0, streaming_1.toResponsesInput)(messages);
             nativeInput = input;
@@ -141,7 +150,7 @@ function createOpenAICodexProviderRuntime() {
                 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"],

package/dist/heart/streaming.js

@@ -185,7 +185,10 @@ function toResponsesInput(messages) {
                 }
             }
             if (a.content) {
-                input.push({ role: "assistant", content: typeof a.content === "string" ? a.content : "" });
+                const assistantItem = { role: "assistant", content: typeof a.content === "string" ? a.content : "" };
+                if (a.phase)
+                    assistantItem.phase = a.phase;
+                input.push(assistantItem);
             }
             if (a.tool_calls) {
                 for (const tc of a.tool_calls) {