@agent-native/core 0.93.0 → 0.94.1

package/dist/agent/production-agent.js

@@ -16,7 +16,7 @@ import { canUseDeployCredentialFallbackForRequest, getProviderCredentialAuthFail
 import { readBody } from "../server/h3-helpers.js";
 import { getRequestRunContext, ensureRequestRunContext, getRequestContext, getRequestOrgId, getRequestUserEmail, runWithRequestContext, } from "../server/request-context.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
-import { isReasoningEffort, normalizeReasoningEffortForModel, stepDownReasoningEffort, } from "../shared/reasoning-effort.js";
+import { isReasoningEffort, normalizeReasoningEffortForRequest, stepDownReasoningEffort, } from "../shared/reasoning-effort.js";
 import { actionPreparationContinuationNote } from "./action-continuation-guidance.js";
 import { applyContextDirectives } from "./context-xray/apply-directives.js";
 import { loadContextDirectives } from "./context-xray/directives-store.js";
@@ -1493,6 +1493,130 @@ export function actionsToEngineTools(actions) {
     }
     return tools;
 }
+/**
+ * Execute one externally-selected tool through the exact same guarded runtime
+ * as a normal model-selected tool call. Realtime voice and other duplex
+ * transports use this instead of calling `ActionEntry.run` directly, which
+ * would bypass approvals, schema validation, timeouts, the tool journal,
+ * result redaction, mutation ordering, and refresh notifications.
+ */
+export async function executeAgentToolCall(options) {
+    const entry = options.actions[options.name];
+    if (!entry || entry.agentTool === false) {
+        return {
+            status: "failed",
+            output: `Unknown or unavailable tool: ${options.name}`,
+        };
+    }
+    let streamCalls = 0;
+    const engine = {
+        name: "agent-native:single-tool",
+        label: "Agent Native tool runtime",
+        defaultModel: "agent-native:single-tool",
+        supportedModels: ["agent-native:single-tool"],
+        capabilities: {
+            thinking: false,
+            promptCaching: false,
+            vision: false,
+            computerUse: false,
+            parallelToolCalls: false,
+        },
+        async *stream() {
+            streamCalls += 1;
+            if (streamCalls === 1) {
+                yield {
+                    type: "assistant-content",
+                    parts: [
+                        {
+                            type: "tool-call",
+                            id: options.callId,
+                            name: options.name,
+                            input: options.input ?? {},
+                        },
+                    ],
+                };
+                yield { type: "stop", reason: "tool_use" };
+                return;
+            }
+            yield {
+                type: "assistant-content",
+                parts: [{ type: "text", text: "Tool execution complete." }],
+            };
+            yield { type: "stop", reason: "end_turn" };
+        },
+    };
+    const events = [];
+    const send = (event) => {
+        events.push(event);
+        options.send?.(event);
+    };
+    const controller = options.signal ? null : new AbortController();
+    const signal = options.signal ?? controller.signal;
+    const tools = actionsToEngineTools(options.actions);
+    try {
+        await runAgentLoop({
+            engine,
+            model: engine.defaultModel,
+            systemPrompt: "Execute the selected Agent Native tool call.",
+            tools,
+            availableTools: tools,
+            messages: [
+                {
+                    role: "user",
+                    content: [
+                        {
+                            type: "text",
+                            text: `Execute the ${options.name} tool call.`,
+                        },
+                    ],
+                },
+            ],
+            actions: options.actions,
+            send,
+            signal,
+            ownerEmail: options.ownerEmail,
+            orgId: options.orgId,
+            executionMode: "act",
+            maxIterations: 2,
+            threadId: options.threadId,
+            turnId: options.turnId,
+            approvedToolCalls: options.approvedToolCalls,
+        });
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            output: sanitizeToolErrorValue(error),
+        };
+    }
+    const approval = events.find((event) => event.type === "approval_required" && event.tool === options.name);
+    const completed = [...events]
+        .reverse()
+        .find((event) => event.type === "tool_done" && event.tool === options.name);
+    if (approval) {
+        return {
+            status: "approval_required",
+            approvalKey: approval.approvalKey,
+            output: completed?.result ?? `Awaiting human approval to run ${options.name}.`,
+        };
+    }
+    if (!completed) {
+        return {
+            status: "failed",
+            output: `The ${options.name} tool did not return a result.`,
+        };
+    }
+    if (completed.isError) {
+        return { status: "failed", output: completed.result };
+    }
+    return {
+        status: "completed",
+        output: completed.result,
+        ...(typeof completed.completedSideEffect === "boolean"
+            ? { completedSideEffect: completed.completedSideEffect }
+            : {}),
+    };
+}
 export function filterInitialEngineTools(tools, initialToolNames) {
     if (!initialToolNames)
         return tools;
@@ -2567,9 +2691,11 @@ export async function runAgentLoop(opts) {
                     effectiveMaxOutputTokens =
                         resolveEmptyResponseRetryMaxOutputTokens(model);
                     effectiveReasoningEffort = stepDownReasoningEffort(effectiveReasoningEffort);
+                    send({ type: "clear" });
                     appendAgentLoopContinuation(messages, "max_tokens");
                     continue;
                 }
+                send({ type: "clear" });
                 send({
                     type: "text",
                     text: "The model returned an empty response. This usually means reasoning used the full output-token budget. Try again, or pick a different model from the model menu.",
@@ -4254,6 +4380,9 @@ function progressStepFromAgentChatEvent(event) {
             return null;
     }
 }
+export function resolveAgentRequestReasoningEffort({ model, requestEffort, configuredEffort, }) {
+    return normalizeReasoningEffortForRequest(model, isReasoningEffort(requestEffort) ? requestEffort : configuredEffort);
+}
 export function createProductionAgentHandler(options) {
     // Undefined = let each engine pick its own defaultModel at request time.
     const configuredModel = options.model;
@@ -4542,9 +4671,11 @@ export function createProductionAgentHandler(options) {
         // DIAGNOSTIC-ONLY: stored-model resolution finished.
         workerStep("model_done");
         const model = normalizeModelForEngine(engine, modelCandidate);
-        const reasoningEffort = normalizeReasoningEffortForModel(model, isReasoningEffort(requestEffort)
-            ? requestEffort
-            : options.reasoningEffort);
+        const reasoningEffort = resolveAgentRequestReasoningEffort({
+            model,
+            requestEffort,
+            configuredEffort: options.reasoningEffort,
+        });
         options.onEngineResolved?.(engine, model);
         // One-line per-turn resolution log so it's obvious in dev which engine
         // is actually handling the request. `requestEngine` is what the client