@gea-ai/agent-sdk 0.1.260910-alpha.2 → 0.1.260911-alpha.0

package/README.md

@@ -7,3 +7,59 @@ npm install @gea-ai/agent-sdk
 ```
 
 [Developer documentation](https://musegea.com/developers/agent-development)
+
+## Model identity and output limits
+
+Set an optional per-model-call output budget on the Agent definition:
+
+```ts
+import { defineAgent } from "@gea-ai/agent-sdk";
+
+export default defineAgent({
+  name: "Research assistant",
+  slug: "research",
+  model: "creative-reasoning-1.5",
+  maxOutputTokens: 32_000,
+});
+```
+
+`maxOutputTokens` must be a positive integer. Omit it to retain the engine/provider default. It applies to each model call in the default AI SDK engine and `agentCore`, subject to the provider's supported limits; it is not a total task budget. Each private or referenced Agent uses its own definition, while self copies use the source definition. Agent Core's explicit per-step `generation.max_output_tokens` may override this baseline for that step.
+
+The default AI SDK engine resolves Anthropic capabilities from the upstream model identity. The approved gateway aliases `creative-reasoning-1.5` and `crr-a-pro-20260724` resolve to Claude Sonnet 5 and Opus 5 respectively. Gateway requests retain the configured routing ID; public model IDs and usage attribution are unchanged. The installed Anthropic adapter supplies their default output budget (currently 128,000 tokens) and reasoning behavior. Explicit AI SDK output limits still apply; unknown model IDs retain the adapter's compatibility fallback.
+
+Native Workers request the catalog target from the AI binding, so public aliases can use the same recognition. This requires updating Worker Runtime and rebuilding the Agent with the new SDK. Existing SDK bundles retain their descriptor format. The hosted AI SDK proxy resolves target identity on the server; the optional `agentCore` engine keeps its existing protocol.
+
+## Background Agent tasks
+
+Declare private definitions in `subagents/<name>/agent.ts` with their own `AGENTS.md`, tools, skills and connectors. They run in independent Sessions and may declare further subagents. Only top-level definitions become public Worker entrypoints.
+
+References are explicit default exports from `subagents/<alias>.ts`:
+
+```ts
+import { defineAgentReference, defineRemoteAgent } from "@gea-ai/agent-sdk";
+
+// Same Worker: slug is checked against the CLI-generated WorkerAgentRegistry.
+const sales = defineAgentReference({
+  slug: "sales",
+  description: "Sales analysis",
+});
+// Same Project: uses the Studio Agent slug and the caller's environment.
+const legal = defineRemoteAgent({
+  slug: "legal-advisor",
+  description: "Legal review",
+});
+// URL: a GEA Agent protocol endpoint. The key stays in runtime environment configuration.
+const external = defineRemoteAgent({
+  url: "https://legal.example.com/gea/agents/advisor",
+  description: "Legal review",
+  auth: { bearerTokenEnv: "LEGAL_AGENT_KEY" },
+});
+```
+
+Each reference file default-exports one reference. All targets use `agent({ target: "alias", message, agentId? })`; callers only see their own declared aliases. Include `agentTool()` in the root's tools to additionally allow self copies by omitting `target`. Named delegation follows each node's own declarations; child invocations cannot create another unnamed copy.
+
+The tool returns `{ status: "working", taskId, agentId }`. `task_update({ message })` reports progress, and `task_cancel({ taskId })` requests cancellation. The host continues idle parent conversations when updates arrive. A child task finishes after its descendants and notification inbox settle, including any final summary turn. Continue an idle child with its returned `agentId` and the same target.
+
+URL targets implement GEA task create/status/cancel endpoints. New calls and continuations follow the deployment selected by the URL, retaining history while using its current model, instructions and tools. Accepted tasks finish on their selected version. URL credentials are explicitly configured; source credentials and principals are not forwarded. Pure local development uses URLs for cross-Worker calls because it has no hosted Project identity.
+
+This requires matching SDK, CLI, server and Worker Runtime support and rebuilding immutable bundles. Task Sessions opt into `durable-object-worker-namespace-v1`; existing ordinary Session storage is unchanged. Channel wakeups, approval relay, active-child steering and execution recovery after a host crash remain deferred.

package/dist/agent-call.d.ts

@@ -0,0 +1,613 @@
+import { type AgentWorkerToolInitialization } from "@gea-ai/contract/agent-worker-tools";
+import type { AgentHostBinding } from "./agent-worker";
+/** The host opens a fresh Worker invocation; only its visible answer returns to the caller. */
+export declare function createWorkerAgentTool(input: {
+    agents: NonNullable<AgentWorkerToolInitialization["agents"]>;
+    host: AgentHostBinding;
+    canCopy?: boolean;
+}): ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: import("ai").FlexibleSchema<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }>;
+    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            agentId?: string | undefined;
+            message: string;
+            target: string | undefined;
+        };
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            agentId?: string | undefined;
+            message: string;
+            target: string | undefined;
+        };
+        output: NoInfer<{
+            status: "working";
+            taskId: string;
+            agentId: string;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: import("ai").FlexibleSchema<{
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }> | undefined;
+    execute: import("ai").ToolExecuteFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, {
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    description?: string | ((options: {
+        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
+        experimental_sandbox?: import("ai").Experimental_SandboxSession;
+    }) => string) | undefined;
+    strict?: boolean;
+    inputExamples?: {
+        input: NoInfer<{
+            agentId?: string | undefined;
+            message: string;
+            target: string | undefined;
+        }>;
+    }[] | undefined;
+    id?: never;
+    isProviderExecuted?: never;
+    args?: never;
+    supportsDeferredResults?: never;
+} & {
+    type?: undefined | 'function';
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, {
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: import("ai").FlexibleSchema<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }>;
+    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            agentId?: string | undefined;
+            message: string;
+            target: string | undefined;
+        };
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            agentId?: string | undefined;
+            message: string;
+            target: string | undefined;
+        };
+        output: NoInfer<{
+            status: "working";
+            taskId: string;
+            agentId: string;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: import("ai").FlexibleSchema<{
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }> | undefined;
+    execute: import("ai").ToolExecuteFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, {
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    description?: string | ((options: {
+        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
+        experimental_sandbox?: import("ai").Experimental_SandboxSession;
+    }) => string) | undefined;
+    strict?: boolean;
+    inputExamples?: {
+        input: NoInfer<{
+            agentId?: string | undefined;
+            message: string;
+            target: string | undefined;
+        }>;
+    }[] | undefined;
+    id?: never;
+    isProviderExecuted?: never;
+    args?: never;
+    supportsDeferredResults?: never;
+} & {
+    type: 'dynamic';
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, {
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: import("ai").FlexibleSchema<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }>;
+    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            agentId?: string | undefined;
+            message: string;
+            target: string | undefined;
+        };
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            agentId?: string | undefined;
+            message: string;
+            target: string | undefined;
+        };
+        output: NoInfer<{
+            status: "working";
+            taskId: string;
+            agentId: string;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: import("ai").FlexibleSchema<{
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }> | undefined;
+    execute: import("ai").ToolExecuteFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, {
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    type: 'provider';
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    description?: never;
+    strict?: never;
+    inputExamples?: never;
+} & {
+    isProviderExecuted: false;
+    supportsDeferredResults?: never;
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, {
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: import("ai").FlexibleSchema<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }>;
+    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            agentId?: string | undefined;
+            message: string;
+            target: string | undefined;
+        };
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            agentId?: string | undefined;
+            message: string;
+            target: string | undefined;
+        };
+        output: NoInfer<{
+            status: "working";
+            taskId: string;
+            agentId: string;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: import("ai").FlexibleSchema<{
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }> | undefined;
+    execute: import("ai").ToolExecuteFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, {
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    type: 'provider';
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    description?: never;
+    strict?: never;
+    inputExamples?: never;
+} & {
+    isProviderExecuted: true;
+    supportsDeferredResults?: boolean;
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        agentId?: string | undefined;
+        message: string;
+        target: string | undefined;
+    }, {
+        status: "working";
+        taskId: string;
+        agentId: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+});
+export declare function createWorkerTaskTool(input: {
+    kind: "cancel" | "update";
+    host: AgentHostBinding;
+}): ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: import("ai").FlexibleSchema<{
+        taskId: string;
+    } | {
+        message: string;
+    }>;
+    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            taskId: string;
+        } | {
+            message: string;
+        };
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            taskId: string;
+        } | {
+            message: string;
+        };
+        output: NoInfer<{
+            status: string;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: import("ai").FlexibleSchema<{
+        status: string;
+    }> | undefined;
+    execute: import("ai").ToolExecuteFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, {
+        status: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    description?: string | ((options: {
+        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
+        experimental_sandbox?: import("ai").Experimental_SandboxSession;
+    }) => string) | undefined;
+    strict?: boolean;
+    inputExamples?: {
+        input: NoInfer<{
+            taskId: string;
+        } | {
+            message: string;
+        }>;
+    }[] | undefined;
+    id?: never;
+    isProviderExecuted?: never;
+    args?: never;
+    supportsDeferredResults?: never;
+} & {
+    type?: undefined | 'function';
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, {
+        status: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: import("ai").FlexibleSchema<{
+        taskId: string;
+    } | {
+        message: string;
+    }>;
+    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            taskId: string;
+        } | {
+            message: string;
+        };
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            taskId: string;
+        } | {
+            message: string;
+        };
+        output: NoInfer<{
+            status: string;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: import("ai").FlexibleSchema<{
+        status: string;
+    }> | undefined;
+    execute: import("ai").ToolExecuteFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, {
+        status: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    description?: string | ((options: {
+        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
+        experimental_sandbox?: import("ai").Experimental_SandboxSession;
+    }) => string) | undefined;
+    strict?: boolean;
+    inputExamples?: {
+        input: NoInfer<{
+            taskId: string;
+        } | {
+            message: string;
+        }>;
+    }[] | undefined;
+    id?: never;
+    isProviderExecuted?: never;
+    args?: never;
+    supportsDeferredResults?: never;
+} & {
+    type: 'dynamic';
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, {
+        status: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: import("ai").FlexibleSchema<{
+        taskId: string;
+    } | {
+        message: string;
+    }>;
+    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            taskId: string;
+        } | {
+            message: string;
+        };
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            taskId: string;
+        } | {
+            message: string;
+        };
+        output: NoInfer<{
+            status: string;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: import("ai").FlexibleSchema<{
+        status: string;
+    }> | undefined;
+    execute: import("ai").ToolExecuteFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, {
+        status: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    type: 'provider';
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    description?: never;
+    strict?: never;
+    inputExamples?: never;
+} & {
+    isProviderExecuted: false;
+    supportsDeferredResults?: never;
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, {
+        status: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: import("ai").FlexibleSchema<{
+        taskId: string;
+    } | {
+        message: string;
+    }>;
+    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            taskId: string;
+        } | {
+            message: string;
+        };
+    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            taskId: string;
+        } | {
+            message: string;
+        };
+        output: NoInfer<{
+            status: string;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: import("ai").FlexibleSchema<{
+        status: string;
+    }> | undefined;
+    execute: import("ai").ToolExecuteFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, {
+        status: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    type: 'provider';
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    description?: never;
+    strict?: never;
+    inputExamples?: never;
+} & {
+    isProviderExecuted: true;
+    supportsDeferredResults?: boolean;
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        taskId: string;
+    } | {
+        message: string;
+    }, {
+        status: string;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+});
+export declare function readWorkerAgentResponse(response: Response): Promise<{
+    status: "completed";
+    text: string;
+}>;
+//# sourceMappingURL=agent-call.d.ts.map

package/dist/agent-call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-call.d.ts","sourceRoot":"","sources":["../src/agent-call.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,6BAA6B,EACnC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,+FAA+F;AAC/F,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,MAAM,EAAE,WAAW,CAAC,6BAA6B,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC7D,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BA;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC1B,IAAI,EAAE,gBAAgB,CAAC;CACxB;;;;;gBACwC,MAAM;;iBAAgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCpE;AAED,wBAAsB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ;YAkC7C,WAAW;;GAC7B"}