@agent-native/core 0.91.2 → 0.92.0

package/dist/agent/production-agent.js

@@ -497,15 +497,31 @@ function createPlanModeBashAction(entry) {
         },
     };
 }
+function createPlanModeBlockedAction(name, entry, reason) {
+    return {
+        ...entry,
+        allowInPlanMode: false,
+        readOnly: true,
+        tool: {
+            ...entry.tool,
+            description: `${entry.tool.description}\n\nPlan mode blocked: ${reason ?? "not available while planning"}.`,
+        },
+        run: async () => planModeBlockedMessage(name, reason),
+    };
+}
 export function createPlanModeActionRegistry(actions) {
     const filtered = {};
     for (const [name, entry] of Object.entries(actions)) {
         if (name === TOOL_SEARCH_ACTION_NAME)
             continue;
-        if (entry.allowInPlanMode === false)
+        if (entry.allowInPlanMode === false) {
+            filtered[name] = createPlanModeBlockedAction(name, entry, "not available while planning");
             continue;
-        if (PLAN_MODE_BLOCKED_READONLY_TOOLS.has(name))
+        }
+        if (PLAN_MODE_BLOCKED_READONLY_TOOLS.has(name)) {
+            filtered[name] = createPlanModeBlockedAction(name, entry, "not available while planning");
             continue;
+        }
         const allowedActions = PLAN_MODE_ALLOWED_ACTIONS[name];
         if (allowedActions) {
             filtered[name] = createPlanModeGuardedAction(name, entry, allowedActions);
@@ -522,6 +538,9 @@ export function createPlanModeActionRegistry(actions) {
         if (entry.readOnly === true) {
             filtered[name] = entry;
         }
+        else {
+            filtered[name] = createPlanModeBlockedAction(name, entry, "write or side-effecting tool");
+        }
     }
     if (actions[TOOL_SEARCH_ACTION_NAME]) {
         filtered[TOOL_SEARCH_ACTION_NAME] = createToolSearchEntry(() => filtered);
@@ -1393,7 +1412,8 @@ function isReusableReadOnlyToolResult(part) {
     const lower = part.content.trim().toLowerCase();
     if (!lower)
         return false;
-    return !(lower.startsWith("error running ") ||
+    return !(lower.startsWith("invalid action parameters for ") ||
+        lower.startsWith("error running ") ||
         lower.includes("run aborted") ||
         lower.includes("tool call timed out") ||
         lower.includes("stale_run") ||
@@ -1465,13 +1485,68 @@ export function actionsToEngineTools(actions) {
     }
     return tools;
 }
-function filterInitialEngineTools(tools, initialToolNames) {
+export function filterInitialEngineTools(tools, initialToolNames) {
     if (!initialToolNames)
         return tools;
     const names = new Set(initialToolNames);
     names.add(TOOL_SEARCH_ACTION_NAME);
+    for (const tool of tools) {
+        if (isDefaultLeanInitialToolName(tool.name)) {
+            names.add(tool.name);
+        }
+    }
     return tools.filter((tool) => names.has(tool.name));
 }
+const DEFAULT_LEAN_INITIAL_TOOL_NAMES = new Set([
+    // Broad provider/API/corpus primitives should be callable as soon as the
+    // prompt teaches them; waiting for a discovery round-trip caused prod runs to
+    // waste turns on provider work that was described but not loaded.
+    "data-source-status",
+    "provider-api-catalog",
+    "provider-api-docs",
+    "provider-api-request",
+    "provider-corpus-job",
+    "provider-corpus-jobs",
+    "query-staged-dataset",
+    "list-staged-datasets",
+    "delete-staged-dataset",
+    "run-code",
+    "get-code-execution",
+    "list-extensions",
+    "get-extension",
+    "update-extension",
+    "list-extension-history",
+    "get-extension-history-version",
+    // Common first-class integration shortcuts. These are included only when the
+    // current app/mode registry actually exposes them.
+    "bigquery",
+    "search-bigquery-schema",
+    "bigquery-table-info",
+    "ga4",
+    "amplitude",
+    "prometheus",
+    "grafana",
+    "sentry",
+    "stripe",
+    "account-deep-dive",
+    "slack-messages",
+    "hubspot-deals",
+    "hubspot-records",
+    "hubspot-pipelines",
+    "hubspot-metrics",
+    "gong-calls",
+    "github-repo-files",
+    "jira",
+    "jira-search",
+    "gcloud",
+    "notion-search",
+    "pylon-search",
+]);
+function isDefaultLeanInitialToolName(name) {
+    if (DEFAULT_LEAN_INITIAL_TOOL_NAMES.has(name))
+        return true;
+    return (name.startsWith("provider-api-") || name.startsWith("provider-corpus-"));
+}
 function extractToolSearchResultNames(value) {
     if (!value || typeof value !== "object")
         return [];
@@ -1781,7 +1856,7 @@ function toolInputSchemaErrorResult(toolName, input, error) {
 const rawToolInputAjv = new Ajv({
     strict: false,
     allErrors: true,
-    coerceTypes: false,
+    coerceTypes: true,
     useDefaults: false,
     removeAdditional: false,
 });
@@ -2695,43 +2770,6 @@ export async function runAgentLoop(opts) {
                     };
                 }
             }
-            const cacheKey = actionEntry.readOnly === true
-                ? toolCallCacheKey(toolCall.name, toolCall.input)
-                : null;
-            if (cacheKey && readOnlyToolResultCache.has(cacheKey)) {
-                const repeats = (duplicateReadOnlyToolCalls.get(cacheKey) ?? 0) + 1;
-                duplicateReadOnlyToolCalls.set(cacheKey, repeats);
-                const previousResult = readOnlyToolResultCache.get(cacheKey) ?? "";
-                const result = `Skipped duplicate read-only call to ${toolCall.name}: identical input already ran in this turn. ` +
-                    `Use the previous result already in the conversation instead of calling this tool again.\n\n` +
-                    `Previous result:\n${previousResult}`;
-                send({
-                    type: "tool_start",
-                    tool: toolCall.name,
-                    input: toolCall.input,
-                });
-                send({
-                    type: "tool_done",
-                    tool: toolCall.name,
-                    input: toolCall.input,
-                    result,
-                    completedSideEffect: false,
-                });
-                recordToolResult(result, false);
-                if (repeats >= 3) {
-                    requestedActionStop ??= {
-                        message: "I stopped because the agent kept asking for the same read-only context it already had. Please send the request again if you want me to retry from a fresh turn.",
-                        errorCode: "duplicate_read_only_tool",
-                    };
-                }
-                return {
-                    type: "tool-result",
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.name,
-                    toolInput: wireToolInput,
-                    content: result,
-                };
-            }
             const DEFAULT_TOOL_RESULT_CHARS = 50_000;
             // Default action tools should not undercut durable/background runs. The
             // run-manager still aborts foreground hosted runs around 40s, while
@@ -2932,6 +2970,38 @@ export async function runAgentLoop(opts) {
                     isError: true,
                 };
             }
+            const cacheKey = actionEntry.readOnly === true
+                ? toolCallCacheKey(toolCall.name, toolCall.input)
+                : null;
+            if (cacheKey && readOnlyToolResultCache.has(cacheKey)) {
+                const repeats = (duplicateReadOnlyToolCalls.get(cacheKey) ?? 0) + 1;
+                duplicateReadOnlyToolCalls.set(cacheKey, repeats);
+                const previousResult = readOnlyToolResultCache.get(cacheKey) ?? "";
+                const result = `Skipped duplicate read-only call to ${toolCall.name}: identical input already ran in this turn. ` +
+                    `Use the previous result already in the conversation instead of calling this tool again.\n\n` +
+                    `Previous result:\n${previousResult}`;
+                send({
+                    type: "tool_done",
+                    tool: toolCall.name,
+                    input: toolCall.input,
+                    result,
+                    completedSideEffect: false,
+                });
+                recordToolResult(result, false);
+                if (repeats >= 3) {
+                    requestedActionStop ??= {
+                        message: "I stopped because the agent kept asking for the same read-only context it already had. Please send the request again if you want me to retry from a fresh turn.",
+                        errorCode: "duplicate_read_only_tool",
+                    };
+                }
+                return {
+                    type: "tool-result",
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    toolInput: wireToolInput,
+                    content: result,
+                };
+            }
             if (opts.executionMode === "plan" &&
                 !isPlanModeToolCallAllowed(toolCall.name, toolCall.input, actionEntry)) {
                 const result = planModeBlockedMessage(toolCall.name);