@agent-native/core 0.141.6 → 0.144.0

package/dist/agent/production-agent.js

@@ -1883,6 +1883,23 @@ export function isCachedToolResultVisibleInContext(contextMessages, toolCall, ca
 const INTERRUPTED_TOOL_RESULT_MARKER = "Interrupted before this tool returned a result.";
 const MAX_WRITE_TOOL_INTERRUPTIONS = 2;
 const MAX_IDENTICAL_TOOL_ERRORS = 3;
+/**
+ * Same tool, same error, ANY arguments. `MAX_IDENTICAL_TOOL_ERRORS` keys on the
+ * arguments too, so it only catches a model that repeats itself verbatim — and
+ * a model that is genuinely lost does the opposite: it keeps changing the
+ * arguments. Every variation mints a fresh key, the count never reaches three,
+ * and nothing stops it. That is how a delegated turn burned five minutes
+ * against an app that answers the same question in twenty-seven seconds.
+ *
+ * Higher than the exact-repeat limit on purpose: a capable model reads a schema
+ * error and fixes its arguments within a try or two, so this must not cut off
+ * honest correction. It only fires once a tool has rejected six attempts the
+ * same way, which no amount of further guessing is going to fix.
+ *
+ * This is the floor that has to hold on ANY model. A stronger model recovering
+ * on its own is not a substitute for it — it just hides its absence.
+ */
+export const MAX_SAME_ERROR_ACROSS_ARGUMENTS = 6;
 /**
  * Identical (tool, arguments) invocations tolerated in one turn before the turn
  * is stopped, whether or not they errored.
@@ -2279,8 +2296,29 @@ async function waitForInterruptedToolLedgerEntry(opts) {
     }
     return null;
 }
+/**
+ * Collapse an error to the part that identifies the FAULT, dropping the part
+ * that merely echoes this attempt's arguments.
+ *
+ * `toolInputSchemaErrorResult` embeds `Received: {…the arguments…}` in every
+ * schema rejection, so a model that keeps changing its arguments produces a new
+ * error string every time. Any breaker keyed on the raw text then sees each
+ * attempt as a first attempt and never counts — which is precisely the
+ * keeps-guessing spiral the argument-independent breaker exists to stop. An
+ * executed counterexample ran 61 turns without it firing.
+ *
+ * Dropping the echoed input costs nothing: the fault is already named by the
+ * sentence before it, and two failures that differ ONLY in the arguments they
+ * echo are the same failure.
+ */
 function normalizeToolErrorForBreaker(error) {
-    return error.replace(/\s+/g, " ").trim();
+    return (error
+        // The argument echo, up to the next sentence boundary.
+        .replace(/Received:\s*[\s\S]*?\.\s(?=Expected:|The tool was not executed)/g, "")
+        // Bare JSON payloads some providers inline instead of a Received: span.
+        .replace(/\{[\s\S]{0,2000}?\}/g, "{}")
+        .replace(/\s+/g, " ")
+        .trim());
 }
 function rateLimitRecoveryHint(message) {
     if (!/\b(?:429|rate[-\s]?limit|rate limited|quota exceeded|too many requests|calls limit exceeded)\b/i.test(message)) {
@@ -2935,6 +2973,21 @@ export async function runAgentLoop(opts) {
     const duplicateReadOnlyToolCalls = seedDuplicateReadOnlyToolCallsFromHistory(messages, actions);
     const writeToolInterruptions = seedWriteToolInterruptionsFromHistory(messages, actions);
     const repeatedToolErrors = new Map();
+    // Keyed WITHOUT the arguments — see MAX_SAME_ERROR_ACROSS_ARGUMENTS.
+    //
+    // SEEDED from earlier chunks of this turn, like `toolCallHistory` and
+    // `toolResultHistory` above. A fresh Map here would make the limit per-CHUNK
+    // rather than per-turn, and a turn may chain up to MAX_RUN_LOOP_CONTINUATIONS
+    // (6) or MAX_BACKGROUND_RUN_LOOP_CONTINUATIONS (20) of them — so the real
+    // ceiling would be 36 or 120 identical failures, not 6, and a spiral would
+    // resume with a clean slate at every chunk boundary.
+    const repeatedToolErrorsAnyArgs = new Map();
+    for (const prior of toolResultHistory) {
+        if (!prior.isError)
+            continue;
+        const key = `${prior.name}:${normalizeToolErrorForBreaker(prior.content)}`;
+        repeatedToolErrorsAnyArgs.set(key, (repeatedToolErrorsAnyArgs.get(key) ?? 0) + 1);
+    }
     const repeatedToolCalls = new Map();
     let finalGuardRetries = 0;
     let emptyFinalResponseRetries = 0;
@@ -3721,6 +3774,24 @@ export async function runAgentLoop(opts) {
                 const errorKey = `${toolCallCacheKey(toolCall.name, toolCall.input)}:${normalizeToolErrorForBreaker(sanitizedResult)}`;
                 const count = (repeatedToolErrors.get(errorKey) ?? 0) + 1;
                 repeatedToolErrors.set(errorKey, count);
+                // Same tool, same error, arguments ignored. Catches the lost-model
+                // shape the exact-match counter above cannot: new arguments every
+                // attempt, so every attempt looks like a first attempt.
+                const anyArgsKey = `${toolCall.name}:${normalizeToolErrorForBreaker(sanitizedResult)}`;
+                const anyArgsCount = (repeatedToolErrorsAnyArgs.get(anyArgsKey) ?? 0) + 1;
+                repeatedToolErrorsAnyArgs.set(anyArgsKey, anyArgsCount);
+                if (count < MAX_IDENTICAL_TOOL_ERRORS &&
+                    anyArgsCount >= MAX_SAME_ERROR_ACROSS_ARGUMENTS) {
+                    const result = `Stopped after ${anyArgsCount} attempts at ${toolCall.name} that all failed the same way ` +
+                        `with different arguments. Last error: ${sanitizedResult}`;
+                    requestedActionStop ??= {
+                        message: `I stopped because the ${toolCall.name} action rejected ${anyArgsCount} different attempts the same way, ` +
+                            "so changing the arguments again would not have worked. Anything completed before this is saved. " +
+                            `Error: ${sanitizedResult}`,
+                        errorCode: "repeated_tool_error_across_arguments",
+                    };
+                    return result;
+                }
                 if (count < MAX_IDENTICAL_TOOL_ERRORS)
                     return sanitizedResult;
                 const result = `Stopped after ${count} identical errors from ${toolCall.name} with the same arguments. ` +
@@ -5271,6 +5342,7 @@ export async function chainServerDrivenContinuation(opts) {
         updateRunStatusIfRunning: opts.deps?.updateRunStatusIfRunning ?? updateRunStatusIfRunning,
         markRunAborted: opts.deps?.markRunAborted ?? markRunAborted,
         setRunTerminalReason: opts.deps?.setRunTerminalReason ?? setRunTerminalReason,
+        setRunError: opts.deps?.setRunError ?? setRunError,
         recordRunDiagnostic: opts.deps?.recordRunDiagnostic ?? recordRunDiagnostic,
         markBackgroundContinuationChunkTerminal: opts.deps?.markBackgroundContinuationChunkTerminal ??
             markBackgroundContinuationChunkTerminal,
@@ -5545,6 +5617,13 @@ export async function chainServerDrivenContinuation(opts) {
             await d
                 .setRunTerminalReason(runId, "background_continuation_dispatch_failed")
                 .catch(() => { });
+            // Record the cause on the row itself, not only inside diag_stage's JSON.
+            // Without this the run goes terminal with error_code and error_detail
+            // both NULL, so every dashboard and query reads it as a failure with no
+            // known cause and the real message is only findable by parsing a blob.
+            await d
+                .setRunError(runId, "background_continuation_dispatch_failed", chainErr instanceof Error ? chainErr.message : String(chainErr))
+                .catch(() => { });
         }
     }
 }

package/dist/agent/types.d.ts

@@ -275,6 +275,13 @@ export type AgentChatEvent = {
     /** Remote task to resume when status is pending/input-required. */
     taskId?: string;
     durationMs?: number;
+    /**
+     * Why the call ended, on a terminal status. Already computed for
+     * telemetry; without it here the persisted event says only that a
+     * cross-app call failed after N ms and never why, so a failed A2A call
+     * cannot be diagnosed from the database without a repro.
+     */
+    terminalCode?: string;
 } | {
     /**
      * Periodic liveness for an in-flight cross-app A2A call. Emitted by the

package/dist/cli/agent-plugin.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Import and validate the portable Agent Plugin format.
+ *
+ * The importer intentionally handles only local plugin directories. Skills are
+ * copied as inert files, and remote Streamable HTTP MCP entries are translated
+ * to the Agent-Native `mcp.config.json` shape without copying package headers.
+ * A plugin package is not a credential store and this command never executes
+ * a plugin's scripts or stdio servers.
+ */
+export declare const AGENT_PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+export declare const AGENT_PLUGIN_MCP_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+export interface AgentPluginManifest {
+    name: string;
+    version?: string;
+    description?: string;
+    author?: string | {
+        name: string;
+        url?: string;
+    };
+    homepage?: string;
+    repository?: string;
+    license?: string;
+    keywords?: string[];
+}
+export interface AgentPluginSkillFile {
+    relativePath: string;
+    content: Buffer;
+    mode: number;
+}
+export interface LoadedAgentPluginSkill {
+    name: string;
+    description: string;
+    relativePath: string;
+    directory: string;
+    files: AgentPluginSkillFile[];
+}
+export type AgentPluginMcpTransport = "streamable-http" | "sse" | "stdio";
+export interface LoadedAgentPluginMcpServer {
+    name: string;
+    type: AgentPluginMcpTransport;
+    url?: string;
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    headerCount: number;
+}
+export interface AgentPluginSkippedComponent {
+    component: "skill" | "mcp";
+    name?: string;
+    reason: string;
+}
+export interface LoadedAgentPlugin {
+    rootDir: string;
+    manifestFile: string;
+    mcpFile?: string;
+    manifest: AgentPluginManifest;
+    pluginHash: string;
+    skills: LoadedAgentPluginSkill[];
+    mcpServers: LoadedAgentPluginMcpServer[];
+    skipped: AgentPluginSkippedComponent[];
+    warnings: string[];
+}
+export interface AgentPluginImportOptions {
+    targetDir?: string;
+    force?: boolean;
+    dryRun?: boolean;
+}
+export type AgentPluginImportItemStatus = "imported" | "unchanged" | "overwritten" | "would-import" | "would-overwrite";
+export interface AgentPluginImportSkillResult {
+    name: string;
+    sourcePath: string;
+    destination: string;
+    files: number;
+    status: AgentPluginImportItemStatus;
+}
+export interface AgentPluginImportMcpResult {
+    name: string;
+    id: string;
+    url: string;
+    headersIgnored: number;
+    status: AgentPluginImportItemStatus;
+}
+export interface AgentPluginImportResult {
+    plugin: {
+        name: string;
+        version?: string;
+        hash: string;
+        sourceDir: string;
+    };
+    targetDir: string;
+    metadataPath: string;
+    mcpConfigPath: string;
+    skills: AgentPluginImportSkillResult[];
+    mcpServers: AgentPluginImportMcpResult[];
+    skipped: AgentPluginSkippedComponent[];
+    warnings: string[];
+    dryRun: boolean;
+}
+export interface ParsedAgentPluginArgs {
+    command: "import" | "help";
+    source?: string;
+    into?: string;
+    force: boolean;
+    dryRun: boolean;
+    printJson: boolean;
+    yes: boolean;
+}
+export declare function loadAgentPlugin(input: string): LoadedAgentPlugin;
+export declare function importedMcpServerId(pluginName: string, serverName: string, existingIds?: Iterable<string>): string;
+export declare function importAgentPlugin(input: string, options?: AgentPluginImportOptions): AgentPluginImportResult;
+export declare function parseAgentPluginArgs(argv: string[]): ParsedAgentPluginArgs;
+export declare function runAgentPlugin(argv: string[]): Promise<void>;