@agent-native/core 0.98.17 → 0.99.0

package/dist/mcp/builtin-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtin-tools.d.ts","sourceRoot":"","sources":["../../src/mcp/builtin-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAKhE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAqDnD,KAAK,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AA8kChE;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,WAAW,CAAC,EAAE,iBAAiB,GAC9B,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAU7B"}
+{"version":3,"file":"builtin-tools.d.ts","sourceRoot":"","sources":["../../src/mcp/builtin-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAKhE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AA6DnD,KAAK,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AA0uChE;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,WAAW,CAAC,EAAE,iBAAiB,GAC9B,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAU7B"}

package/dist/mcp/builtin-tools.js

@@ -71,7 +71,14 @@ const ASK_APP_TERMINAL_STATES = new Set([
     "completed",
     "failed",
     "canceled",
+    "input-required",
 ]);
+class AskAppInlineDeadlineError extends Error {
+    constructor() {
+        super("ask_app inline wait deadline reached");
+        this.name = "AskAppInlineDeadlineError";
+    }
+}
 function safeAppPath(raw) {
     if (typeof raw !== "string" || !raw.trim())
         return null;
@@ -185,8 +192,18 @@ function askAppTaskResult(route, task) {
             error: response || `ask_app task ${status}.`,
         };
     }
+    if (status === "input-required") {
+        const inputRequired = response || "The agent needs additional input before it can continue.";
+        return {
+            ...base,
+            response: inputRequired,
+            inputRequired,
+            message: inputRequired,
+        };
+    }
     return {
         ...base,
+        pollAfterMs: ASK_APP_POLL_INTERVAL_MS,
         poll: {
             tool: "ask_app_status",
             arguments: { app: route.app, taskId: task.id },
@@ -195,7 +212,39 @@ function askAppTaskResult(route, task) {
             `taskId "${task.id}" to retrieve the final response.`,
     };
 }
-async function createA2AClientForAskApp(origin) {
+/**
+ * Same shape as `askAppTaskResult`, but built from an in-process
+ * `ask-app-inline-tasks.ts` snapshot instead of an A2A `Task` — used by the
+ * no-origin fallback (no A2A task exists to describe). Kept field-for-field
+ * identical so `ask_app` / `ask_app_status` callers can't tell which backing
+ * store answered.
+ */
+function askAppInlineTaskResult(selfId, taskId, inline, note) {
+    const base = {
+        app: selfId,
+        routedVia: "local",
+        taskId,
+        status: inline.status,
+        ...(note ? { note } : {}),
+    };
+    if (inline.status === "completed") {
+        return { ...base, response: inline.response || "(no response)" };
+    }
+    if (inline.status === "failed") {
+        return { ...base, error: inline.error || "ask_app task failed." };
+    }
+    return {
+        ...base,
+        pollAfterMs: ASK_APP_POLL_INTERVAL_MS,
+        poll: {
+            tool: "ask_app_status",
+            arguments: { app: selfId, taskId },
+        },
+        message: `ask_app is still ${inline.status}. Call ask_app_status with ` +
+            `taskId "${taskId}" to retrieve the final response.`,
+    };
+}
+async function createA2AClientForAskApp(origin, requestOrigin, deadline) {
     const { A2AClient } = await import("../a2a/client.js");
     const { resolveA2ACallerAuth } = await import("../a2a/caller-auth.js");
     const auth = await resolveA2ACallerAuth();
@@ -204,9 +253,14 @@ async function createA2AClientForAskApp(origin) {
         metadata.userEmail = auth.userEmail;
     if (auth.orgDomain)
         metadata.orgDomain = auth.orgDomain;
+    if (requestOrigin)
+        metadata.requestOrigin = requestOrigin;
+    const remainingMs = deadline == null ? null : deadline - Date.now();
     return {
         client: new A2AClient(origin, auth.apiKey, {
-            requestTimeoutMs: ASK_APP_A2A_REQUEST_TIMEOUT_MS,
+            requestTimeoutMs: remainingMs == null
+                ? ASK_APP_A2A_REQUEST_TIMEOUT_MS
+                : Math.max(1, Math.min(ASK_APP_A2A_REQUEST_TIMEOUT_MS, remainingMs)),
             ...(auth.apiKeyFallbacks
                 ? { fallbackApiKeys: auth.apiKeyFallbacks }
                 : {}),
@@ -214,31 +268,52 @@ async function createA2AClientForAskApp(origin) {
         metadata,
     };
 }
-async function waitForA2ATask(client, initialTask, maxWaitMs) {
-    if (maxWaitMs <= 0 || isTerminalTask(initialTask))
+async function runBeforeAskAppDeadline(operation, deadline) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0)
+        throw new AskAppInlineDeadlineError();
+    let timeout;
+    try {
+        return await Promise.race([
+            operation(),
+            new Promise((_resolve, reject) => {
+                timeout = setTimeout(() => reject(new AskAppInlineDeadlineError()), remainingMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+async function waitForA2ATask(client, initialTask, deadline) {
+    if (deadline == null || isTerminalTask(initialTask))
         return initialTask;
-    const deadline = Date.now() + maxWaitMs;
     let current = initialTask;
     while (!isTerminalTask(current)) {
         const remaining = deadline - Date.now();
         if (remaining <= 0)
             return current;
         await new Promise((resolve) => setTimeout(resolve, Math.min(ASK_APP_POLL_INTERVAL_MS, remaining)));
+        if (Date.now() >= deadline)
+            return current;
         try {
-            current = await client.getTask(initialTask.id);
+            current = await runBeforeAskAppDeadline(() => client.getTask(initialTask.id), deadline);
         }
-        catch {
-            // Transient status fetch failures should not turn a successfully
-            // submitted durable task into a failed MCP call.
+        catch (err) {
+            if (err instanceof AskAppInlineDeadlineError)
+                return current;
+            if (!isTransientAskAppStatusError(err))
+                throw err;
             if (Date.now() >= deadline)
                 return current;
-            continue;
         }
     }
     return current;
 }
 async function submitAskAppA2ATask(route, message, maxWaitMs) {
-    const { client, metadata } = await createA2AClientForAskApp(route.origin);
+    const deadline = maxWaitMs > 0 ? Date.now() + maxWaitMs : undefined;
+    const { client, metadata } = await createA2AClientForAskApp(route.origin, route.requestOrigin, deadline);
     const task = await client.send({
         role: "user",
         parts: [{ type: "text", text: message }],
@@ -246,7 +321,7 @@ async function submitAskAppA2ATask(route, message, maxWaitMs) {
         async: true,
         metadata,
     });
-    const finalOrRunning = await waitForA2ATask(client, task, maxWaitMs);
+    const finalOrRunning = await waitForA2ATask(client, task, deadline);
     return askAppTaskResult(route, finalOrRunning);
 }
 async function fetchAskAppA2ATask(route, taskId) {
@@ -625,7 +700,12 @@ function createEmbedSessionTool(requestMeta) {
  */
 async function routeAskOverA2A(origin, id, message, options) {
     if (options?.durable) {
-        return submitAskAppA2ATask({ app: id, origin: agentNativeA2AEndpoint(origin), routedVia: "a2a" }, message, options.maxWaitMs ?? ASK_APP_DEFAULT_INLINE_WAIT_MS);
+        return submitAskAppA2ATask({
+            app: id,
+            origin: agentNativeA2AEndpoint(origin),
+            routedVia: "a2a",
+            requestOrigin: options.requestOrigin ?? origin,
+        }, message, options.maxWaitMs ?? ASK_APP_DEFAULT_INLINE_WAIT_MS);
     }
     const { callAgent } = await import("../a2a/client.js");
     const { resolveA2ACallerAuth } = await import("../a2a/caller-auth.js");
@@ -639,6 +719,7 @@ async function routeAskOverA2A(origin, id, message, options) {
         userEmail: auth.userEmail,
         orgDomain: auth.orgDomain,
         orgSecret: auth.orgSecret,
+        requestOrigin: options?.requestOrigin,
         // Bound the wait — cross-app A2A polls async by default.
         timeoutMs: 5 * 60_000,
     });
@@ -652,7 +733,12 @@ async function resolveAskAppStatusRoute(config, requestedApp, requestMeta) {
         if (!selfEndpointUrl) {
             throw new Error("ask_app_status requires a running app origin for local tasks.");
         }
-        return { app: selfId, origin: selfEndpointUrl, routedVia: "local" };
+        return {
+            app: selfId,
+            origin: selfEndpointUrl,
+            routedVia: "local",
+            requestOrigin: requestMeta?.origin,
+        };
     }
     const targetApp = await resolveTargetAppOrigin(config, requestedApp);
     if (targetApp) {
@@ -660,6 +746,7 @@ async function resolveAskAppStatusRoute(config, requestedApp, requestMeta) {
             app: targetApp.id,
             origin: agentNativeA2AEndpoint(targetApp.origin),
             routedVia: "a2a",
+            requestOrigin: targetApp.origin,
         };
     }
     const orgApps = await fetchOrgApps({ selfId }).catch(() => []);
@@ -669,6 +756,7 @@ async function resolveAskAppStatusRoute(config, requestedApp, requestMeta) {
             app: dirMatch.id,
             origin: agentNativeA2AEndpoint(dirMatch.a2aUrl),
             routedVia: "a2a",
+            requestOrigin: dirMatch.url,
         };
     }
     throw new Error(`No reachable ask_app task route for app "${requestedApp}".`);
@@ -726,6 +814,7 @@ function askAppTool(config, requestMeta) {
                     return await routeAskOverA2A(targetApp.origin, targetApp.id, message, {
                         durable: useDurableA2A,
                         maxWaitMs,
+                        requestOrigin: targetApp.origin,
                     });
                 }
                 catch (err) {
@@ -748,6 +837,7 @@ function askAppTool(config, requestMeta) {
                         return await routeAskOverA2A(dirMatch.a2aUrl, dirMatch.id, message, {
                             durable: useDurableA2A,
                             maxWaitMs,
+                            requestOrigin: dirMatch.url,
                         });
                     }
                     catch (err) {
@@ -780,16 +870,34 @@ function askAppTool(config, requestMeta) {
                     app: selfId,
                     origin: localA2AEndpointUrl,
                     routedVia: "local",
+                    requestOrigin: requestMeta?.origin,
                     ...(note ? { note } : {}),
                 }, message, maxWaitMs);
             }
-            const response = await config.askAgent(message);
-            return {
-                app: selfId,
-                routedVia: "local",
-                ...(note ? { note } : {}),
-                response,
-            };
+            // No derivable app origin at all (e.g. stdio / no request context) —
+            // there is no `/_agent-native/a2a` endpoint to submit a durable task
+            // to either. Bound the wait against a process-local task map instead
+            // of awaiting config.askAgent() unbounded, so a slow agent run can't
+            // hold this MCP call open indefinitely. Settling in time keeps the
+            // original response shape; timing out returns the same still-working
+            // poll payload the A2A path would, using the same taskId contract
+            // (see ask-app-inline-tasks.ts).
+            const { startAskAppInlineTask } = await import("./ask-app-inline-tasks.js");
+            const inline = await startAskAppInlineTask(config.askAgent, message, maxWaitMs);
+            if (inline.status === "completed") {
+                return {
+                    app: selfId,
+                    routedVia: "local",
+                    ...(note ? { note } : {}),
+                    response: inline.response || "(no response)",
+                };
+            }
+            if (inline.status === "failed") {
+                // Settled with an error inside the bounded wait — surface it the
+                // same way the old unbounded `await config.askAgent(message)` did.
+                throw new Error(inline.error || "ask_app task failed.");
+            }
+            return askAppInlineTaskResult(selfId, inline.taskId, inline, note);
         },
     };
 }
@@ -811,6 +919,18 @@ function askAppStatusTool(config, requestMeta) {
             const taskId = String(args.taskId ?? "").trim();
             if (!taskId)
                 throw new Error("ask_app_status requires 'taskId'.");
+            // The no-derivable-origin ask_app fallback tracks its tasks in a
+            // process-local map, not the durable A2A store. Check it FIRST —
+            // before any origin requirement — so a taskId minted by that fallback
+            // never has to satisfy `resolveAskAppStatusRoute`'s "running app
+            // origin" check. Falls through to the normal A2A route when the id
+            // isn't one of these (never started here, evicted, or an ordinary A2A
+            // task id).
+            const { getAskAppInlineTask } = await import("./ask-app-inline-tasks.js");
+            const inline = getAskAppInlineTask(taskId);
+            if (inline) {
+                return askAppInlineTaskResult(currentAppId(config), taskId, inline);
+            }
             const requestedApp = String(args.app ?? "").trim();
             const route = await resolveAskAppStatusRoute(config, requestedApp, requestMeta);
             return fetchAskAppA2ATask(route, taskId);