@deepagents/experimental 7.10.0 → 7.10.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (63) hide show
  1. package/README.md +16 -4
  2. package/dist/index.js +862 -671
  3. package/dist/index.js.map +4 -4
  4. package/dist/zukhruf/collaboration/capability.d.ts +22 -0
  5. package/dist/zukhruf/collaboration/capability.d.ts.map +1 -0
  6. package/dist/zukhruf/collaboration/code-mode-tools.d.ts +13 -0
  7. package/dist/zukhruf/collaboration/code-mode-tools.d.ts.map +1 -0
  8. package/dist/zukhruf/collaboration/direct-messaging.d.ts +466 -0
  9. package/dist/zukhruf/collaboration/direct-messaging.d.ts.map +1 -0
  10. package/dist/zukhruf/collaboration/direct-tools.d.ts +14 -0
  11. package/dist/zukhruf/collaboration/direct-tools.d.ts.map +1 -0
  12. package/dist/zukhruf/collaboration/spawn-agent.d.ts +26 -26
  13. package/dist/zukhruf/collaboration/spawning.d.ts +325 -0
  14. package/dist/zukhruf/collaboration/spawning.d.ts.map +1 -0
  15. package/dist/zukhruf/collaboration/supervision.d.ts +478 -0
  16. package/dist/zukhruf/collaboration/supervision.d.ts.map +1 -0
  17. package/dist/zukhruf/collaboration/team.d.ts +1549 -0
  18. package/dist/zukhruf/collaboration/team.d.ts.map +1 -0
  19. package/dist/zukhruf/collaboration/tool-exposure.d.ts +29 -0
  20. package/dist/zukhruf/collaboration/tool-exposure.d.ts.map +1 -0
  21. package/dist/zukhruf/collaboration/tool-namespace.d.ts +7 -0
  22. package/dist/zukhruf/collaboration/tool-namespace.d.ts.map +1 -0
  23. package/dist/zukhruf/collaboration/wait-bounds.d.ts +12 -0
  24. package/dist/zukhruf/collaboration/wait-bounds.d.ts.map +1 -0
  25. package/dist/zukhruf/collaboration/waiting.d.ts +262 -0
  26. package/dist/zukhruf/collaboration/waiting.d.ts.map +1 -0
  27. package/dist/zukhruf/control-plane/agent-history-forker.d.ts.map +1 -1
  28. package/dist/zukhruf/control-plane/fork-turns.d.ts +4 -3
  29. package/dist/zukhruf/control-plane/fork-turns.d.ts.map +1 -1
  30. package/dist/zukhruf/index.d.ts +11 -1
  31. package/dist/zukhruf/index.d.ts.map +1 -1
  32. package/dist/zukhruf/index.js +863 -672
  33. package/dist/zukhruf/index.js.map +4 -4
  34. package/dist/zukhruf/plugins/conversation-scheduling/conversation-scheduler.d.ts +1 -1
  35. package/dist/zukhruf/plugins/conversation-scheduling/conversation-scheduler.d.ts.map +1 -1
  36. package/dist/zukhruf/plugins/conversation-scheduling/index.js +142 -141
  37. package/dist/zukhruf/plugins/conversation-scheduling/index.js.map +4 -4
  38. package/dist/zukhruf/plugins/conversation-scheduling/pg-boss.wake-scheduler.d.ts +1 -1
  39. package/dist/zukhruf/plugins/conversation-scheduling/pg-boss.wake-scheduler.d.ts.map +1 -1
  40. package/dist/zukhruf/plugins/conversation-scheduling/wake-scheduler.d.ts +1 -1
  41. package/dist/zukhruf/plugins/conversation-scheduling/wake-scheduler.d.ts.map +1 -1
  42. package/dist/zukhruf/plugins/schedules/index.js +141 -140
  43. package/dist/zukhruf/plugins/schedules/index.js.map +4 -4
  44. package/dist/zukhruf/plugins/schedules/scheduled-tasks.d.ts +1 -1
  45. package/dist/zukhruf/plugins/schedules/scheduled-tasks.d.ts.map +1 -1
  46. package/dist/zukhruf/plugins/uploads/http.js +2 -9
  47. package/dist/zukhruf/plugins/uploads/http.js.map +2 -2
  48. package/dist/zukhruf/queue/turn-queue.d.ts +2 -2
  49. package/dist/zukhruf/queue/turn-queue.d.ts.map +1 -1
  50. package/dist/zukhruf/runtime/agent-runtime.d.ts +5 -4
  51. package/dist/zukhruf/runtime/agent-runtime.d.ts.map +1 -1
  52. package/dist/zukhruf/runtime/agent-turn-executor.d.ts +3 -3
  53. package/dist/zukhruf/runtime/agent-turn-executor.d.ts.map +1 -1
  54. package/dist/zukhruf/runtime/approval-controller.d.ts +3 -3
  55. package/dist/zukhruf/runtime/approval-controller.d.ts.map +1 -1
  56. package/dist/zukhruf/runtime/conversation-status/projector.d.ts.map +1 -1
  57. package/dist/zukhruf/runtime/plugin/plugin-manager.d.ts +3 -5
  58. package/dist/zukhruf/runtime/plugin/plugin-manager.d.ts.map +1 -1
  59. package/package.json +5 -4
  60. package/dist/zukhruf/collaboration/collaboration-tools.d.ts +0 -1832
  61. package/dist/zukhruf/collaboration/collaboration-tools.d.ts.map +0 -1
  62. package/dist/zukhruf/multi-agent-config.d.ts +0 -37
  63. package/dist/zukhruf/multi-agent-config.d.ts.map +0 -1
@@ -10,14 +10,14 @@ export declare function createSpawnAgentTool(options?: {
10
10
  agent_type: string;
11
11
  task_name: string;
12
12
  message: string;
13
- fork_turns: string;
13
+ fork_turns?: string | undefined;
14
14
  }>;
15
15
  contextSchema?: import("ai").FlexibleSchema<AgentToolContext> | undefined;
16
16
  needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
17
17
  agent_type: string;
18
18
  task_name: string;
19
19
  message: string;
20
- fork_turns: string;
20
+ fork_turns?: string | undefined;
21
21
  }, NoInfer<AgentToolContext>> | undefined;
22
22
  onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<AgentToolContext>>) => void | PromiseLike<void>) | undefined;
23
23
  onInputDelta?: ((options: {
@@ -28,7 +28,7 @@ export declare function createSpawnAgentTool(options?: {
28
28
  agent_type: string;
29
29
  task_name: string;
30
30
  message: string;
31
- fork_turns: string;
31
+ fork_turns?: string | undefined;
32
32
  };
33
33
  } & import("ai").ToolExecutionOptions<NoInfer<AgentToolContext>>) => void | PromiseLike<void>) | undefined;
34
34
  toModelOutput?: ((options: {
@@ -37,7 +37,7 @@ export declare function createSpawnAgentTool(options?: {
37
37
  agent_type: string;
38
38
  task_name: string;
39
39
  message: string;
40
- fork_turns: string;
40
+ fork_turns?: string | undefined;
41
41
  };
42
42
  output: NoInfer<{
43
43
  task_name: string;
@@ -51,7 +51,7 @@ export declare function createSpawnAgentTool(options?: {
51
51
  agent_type: string;
52
52
  task_name: string;
53
53
  message: string;
54
- fork_turns: string;
54
+ fork_turns?: string | undefined;
55
55
  }, {
56
56
  task_name: string;
57
57
  }, NoInfer<AgentToolContext>>;
@@ -66,7 +66,7 @@ export declare function createSpawnAgentTool(options?: {
66
66
  agent_type: string;
67
67
  task_name: string;
68
68
  message: string;
69
- fork_turns: string;
69
+ fork_turns?: string | undefined;
70
70
  }>;
71
71
  }[] | undefined;
72
72
  id?: never;
@@ -80,7 +80,7 @@ export declare function createSpawnAgentTool(options?: {
80
80
  agent_type: string;
81
81
  task_name: string;
82
82
  message: string;
83
- fork_turns: string;
83
+ fork_turns?: string | undefined;
84
84
  }, {
85
85
  task_name: string;
86
86
  }, NoInfer<AgentToolContext>>;
@@ -93,14 +93,14 @@ export declare function createSpawnAgentTool(options?: {
93
93
  agent_type: string;
94
94
  task_name: string;
95
95
  message: string;
96
- fork_turns: string;
96
+ fork_turns?: string | undefined;
97
97
  }>;
98
98
  contextSchema?: import("ai").FlexibleSchema<AgentToolContext> | undefined;
99
99
  needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
100
100
  agent_type: string;
101
101
  task_name: string;
102
102
  message: string;
103
- fork_turns: string;
103
+ fork_turns?: string | undefined;
104
104
  }, NoInfer<AgentToolContext>> | undefined;
105
105
  onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<AgentToolContext>>) => void | PromiseLike<void>) | undefined;
106
106
  onInputDelta?: ((options: {
@@ -111,7 +111,7 @@ export declare function createSpawnAgentTool(options?: {
111
111
  agent_type: string;
112
112
  task_name: string;
113
113
  message: string;
114
- fork_turns: string;
114
+ fork_turns?: string | undefined;
115
115
  };
116
116
  } & import("ai").ToolExecutionOptions<NoInfer<AgentToolContext>>) => void | PromiseLike<void>) | undefined;
117
117
  toModelOutput?: ((options: {
@@ -120,7 +120,7 @@ export declare function createSpawnAgentTool(options?: {
120
120
  agent_type: string;
121
121
  task_name: string;
122
122
  message: string;
123
- fork_turns: string;
123
+ fork_turns?: string | undefined;
124
124
  };
125
125
  output: NoInfer<{
126
126
  task_name: string;
@@ -134,7 +134,7 @@ export declare function createSpawnAgentTool(options?: {
134
134
  agent_type: string;
135
135
  task_name: string;
136
136
  message: string;
137
- fork_turns: string;
137
+ fork_turns?: string | undefined;
138
138
  }, {
139
139
  task_name: string;
140
140
  }, NoInfer<AgentToolContext>>;
@@ -149,7 +149,7 @@ export declare function createSpawnAgentTool(options?: {
149
149
  agent_type: string;
150
150
  task_name: string;
151
151
  message: string;
152
- fork_turns: string;
152
+ fork_turns?: string | undefined;
153
153
  }>;
154
154
  }[] | undefined;
155
155
  id?: never;
@@ -163,7 +163,7 @@ export declare function createSpawnAgentTool(options?: {
163
163
  agent_type: string;
164
164
  task_name: string;
165
165
  message: string;
166
- fork_turns: string;
166
+ fork_turns?: string | undefined;
167
167
  }, {
168
168
  task_name: string;
169
169
  }, NoInfer<AgentToolContext>>;
@@ -176,14 +176,14 @@ export declare function createSpawnAgentTool(options?: {
176
176
  agent_type: string;
177
177
  task_name: string;
178
178
  message: string;
179
- fork_turns: string;
179
+ fork_turns?: string | undefined;
180
180
  }>;
181
181
  contextSchema?: import("ai").FlexibleSchema<AgentToolContext> | undefined;
182
182
  needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
183
183
  agent_type: string;
184
184
  task_name: string;
185
185
  message: string;
186
- fork_turns: string;
186
+ fork_turns?: string | undefined;
187
187
  }, NoInfer<AgentToolContext>> | undefined;
188
188
  onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<AgentToolContext>>) => void | PromiseLike<void>) | undefined;
189
189
  onInputDelta?: ((options: {
@@ -194,7 +194,7 @@ export declare function createSpawnAgentTool(options?: {
194
194
  agent_type: string;
195
195
  task_name: string;
196
196
  message: string;
197
- fork_turns: string;
197
+ fork_turns?: string | undefined;
198
198
  };
199
199
  } & import("ai").ToolExecutionOptions<NoInfer<AgentToolContext>>) => void | PromiseLike<void>) | undefined;
200
200
  toModelOutput?: ((options: {
@@ -203,7 +203,7 @@ export declare function createSpawnAgentTool(options?: {
203
203
  agent_type: string;
204
204
  task_name: string;
205
205
  message: string;
206
- fork_turns: string;
206
+ fork_turns?: string | undefined;
207
207
  };
208
208
  output: NoInfer<{
209
209
  task_name: string;
@@ -217,7 +217,7 @@ export declare function createSpawnAgentTool(options?: {
217
217
  agent_type: string;
218
218
  task_name: string;
219
219
  message: string;
220
- fork_turns: string;
220
+ fork_turns?: string | undefined;
221
221
  }, {
222
222
  task_name: string;
223
223
  }, NoInfer<AgentToolContext>>;
@@ -236,7 +236,7 @@ export declare function createSpawnAgentTool(options?: {
236
236
  agent_type: string;
237
237
  task_name: string;
238
238
  message: string;
239
- fork_turns: string;
239
+ fork_turns?: string | undefined;
240
240
  }, {
241
241
  task_name: string;
242
242
  }, NoInfer<AgentToolContext>>;
@@ -249,14 +249,14 @@ export declare function createSpawnAgentTool(options?: {
249
249
  agent_type: string;
250
250
  task_name: string;
251
251
  message: string;
252
- fork_turns: string;
252
+ fork_turns?: string | undefined;
253
253
  }>;
254
254
  contextSchema?: import("ai").FlexibleSchema<AgentToolContext> | undefined;
255
255
  needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
256
256
  agent_type: string;
257
257
  task_name: string;
258
258
  message: string;
259
- fork_turns: string;
259
+ fork_turns?: string | undefined;
260
260
  }, NoInfer<AgentToolContext>> | undefined;
261
261
  onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<AgentToolContext>>) => void | PromiseLike<void>) | undefined;
262
262
  onInputDelta?: ((options: {
@@ -267,7 +267,7 @@ export declare function createSpawnAgentTool(options?: {
267
267
  agent_type: string;
268
268
  task_name: string;
269
269
  message: string;
270
- fork_turns: string;
270
+ fork_turns?: string | undefined;
271
271
  };
272
272
  } & import("ai").ToolExecutionOptions<NoInfer<AgentToolContext>>) => void | PromiseLike<void>) | undefined;
273
273
  toModelOutput?: ((options: {
@@ -276,7 +276,7 @@ export declare function createSpawnAgentTool(options?: {
276
276
  agent_type: string;
277
277
  task_name: string;
278
278
  message: string;
279
- fork_turns: string;
279
+ fork_turns?: string | undefined;
280
280
  };
281
281
  output: NoInfer<{
282
282
  task_name: string;
@@ -290,7 +290,7 @@ export declare function createSpawnAgentTool(options?: {
290
290
  agent_type: string;
291
291
  task_name: string;
292
292
  message: string;
293
- fork_turns: string;
293
+ fork_turns?: string | undefined;
294
294
  }, {
295
295
  task_name: string;
296
296
  }, NoInfer<AgentToolContext>>;
@@ -309,7 +309,7 @@ export declare function createSpawnAgentTool(options?: {
309
309
  agent_type: string;
310
310
  task_name: string;
311
311
  message: string;
312
- fork_turns: string;
312
+ fork_turns?: string | undefined;
313
313
  }, {
314
314
  task_name: string;
315
315
  }, NoInfer<AgentToolContext>>;
@@ -0,0 +1,325 @@
1
+ import type { Capability, Guidance, Role, ToolNamer } from './capability.ts';
2
+ /** Creates agents: `spawn_agent`. Every other capability acts on its agents. */
3
+ export declare class Spawning implements Capability {
4
+ readonly tools: {
5
+ spawn_agent: ({
6
+ deferLoading?: boolean;
7
+ title?: string;
8
+ providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
9
+ metadata?: import("@ai-sdk/provider").JSONObject;
10
+ inputSchema: import("ai").FlexibleSchema<{
11
+ agent_type: string;
12
+ task_name: string;
13
+ message: string;
14
+ fork_turns?: string | undefined;
15
+ }>;
16
+ contextSchema?: import("ai").FlexibleSchema<import("./agent-tool-context.ts").AgentToolContext> | undefined;
17
+ needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
18
+ agent_type: string;
19
+ task_name: string;
20
+ message: string;
21
+ fork_turns?: string | undefined;
22
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>> | undefined;
23
+ onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
24
+ onInputDelta?: ((options: {
25
+ inputTextDelta: string;
26
+ } & import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
27
+ onInputAvailable?: ((options: {
28
+ input: {
29
+ agent_type: string;
30
+ task_name: string;
31
+ message: string;
32
+ fork_turns?: string | undefined;
33
+ };
34
+ } & import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
35
+ toModelOutput?: ((options: {
36
+ toolCallId: string;
37
+ input: {
38
+ agent_type: string;
39
+ task_name: string;
40
+ message: string;
41
+ fork_turns?: string | undefined;
42
+ };
43
+ output: NoInfer<{
44
+ task_name: string;
45
+ }>;
46
+ }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
47
+ } & {
48
+ outputSchema?: import("ai").FlexibleSchema<{
49
+ task_name: string;
50
+ }> | undefined;
51
+ execute: import("ai").ToolExecuteFunction<{
52
+ agent_type: string;
53
+ task_name: string;
54
+ message: string;
55
+ fork_turns?: string | undefined;
56
+ }, {
57
+ task_name: string;
58
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>>;
59
+ } & {
60
+ description?: string | ((options: {
61
+ context: NoInfer<import("./agent-tool-context.ts").AgentToolContext>;
62
+ experimental_sandbox?: import("ai").Experimental_SandboxSession;
63
+ }) => string) | undefined;
64
+ strict?: boolean;
65
+ inputExamples?: {
66
+ input: NoInfer<{
67
+ agent_type: string;
68
+ task_name: string;
69
+ message: string;
70
+ fork_turns?: string | undefined;
71
+ }>;
72
+ }[] | undefined;
73
+ id?: never;
74
+ isProviderExecuted?: never;
75
+ args?: never;
76
+ supportsDeferredResults?: never;
77
+ } & {
78
+ type?: undefined | 'function';
79
+ } & {
80
+ execute: import("ai").ToolExecuteFunction<{
81
+ agent_type: string;
82
+ task_name: string;
83
+ message: string;
84
+ fork_turns?: string | undefined;
85
+ }, {
86
+ task_name: string;
87
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>>;
88
+ }) | ({
89
+ deferLoading?: boolean;
90
+ title?: string;
91
+ providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
92
+ metadata?: import("@ai-sdk/provider").JSONObject;
93
+ inputSchema: import("ai").FlexibleSchema<{
94
+ agent_type: string;
95
+ task_name: string;
96
+ message: string;
97
+ fork_turns?: string | undefined;
98
+ }>;
99
+ contextSchema?: import("ai").FlexibleSchema<import("./agent-tool-context.ts").AgentToolContext> | undefined;
100
+ needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
101
+ agent_type: string;
102
+ task_name: string;
103
+ message: string;
104
+ fork_turns?: string | undefined;
105
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>> | undefined;
106
+ onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
107
+ onInputDelta?: ((options: {
108
+ inputTextDelta: string;
109
+ } & import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
110
+ onInputAvailable?: ((options: {
111
+ input: {
112
+ agent_type: string;
113
+ task_name: string;
114
+ message: string;
115
+ fork_turns?: string | undefined;
116
+ };
117
+ } & import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
118
+ toModelOutput?: ((options: {
119
+ toolCallId: string;
120
+ input: {
121
+ agent_type: string;
122
+ task_name: string;
123
+ message: string;
124
+ fork_turns?: string | undefined;
125
+ };
126
+ output: NoInfer<{
127
+ task_name: string;
128
+ }>;
129
+ }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
130
+ } & {
131
+ outputSchema?: import("ai").FlexibleSchema<{
132
+ task_name: string;
133
+ }> | undefined;
134
+ execute: import("ai").ToolExecuteFunction<{
135
+ agent_type: string;
136
+ task_name: string;
137
+ message: string;
138
+ fork_turns?: string | undefined;
139
+ }, {
140
+ task_name: string;
141
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>>;
142
+ } & {
143
+ description?: string | ((options: {
144
+ context: NoInfer<import("./agent-tool-context.ts").AgentToolContext>;
145
+ experimental_sandbox?: import("ai").Experimental_SandboxSession;
146
+ }) => string) | undefined;
147
+ strict?: boolean;
148
+ inputExamples?: {
149
+ input: NoInfer<{
150
+ agent_type: string;
151
+ task_name: string;
152
+ message: string;
153
+ fork_turns?: string | undefined;
154
+ }>;
155
+ }[] | undefined;
156
+ id?: never;
157
+ isProviderExecuted?: never;
158
+ args?: never;
159
+ supportsDeferredResults?: never;
160
+ } & {
161
+ type: 'dynamic';
162
+ } & {
163
+ execute: import("ai").ToolExecuteFunction<{
164
+ agent_type: string;
165
+ task_name: string;
166
+ message: string;
167
+ fork_turns?: string | undefined;
168
+ }, {
169
+ task_name: string;
170
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>>;
171
+ }) | ({
172
+ deferLoading?: boolean;
173
+ title?: string;
174
+ providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
175
+ metadata?: import("@ai-sdk/provider").JSONObject;
176
+ inputSchema: import("ai").FlexibleSchema<{
177
+ agent_type: string;
178
+ task_name: string;
179
+ message: string;
180
+ fork_turns?: string | undefined;
181
+ }>;
182
+ contextSchema?: import("ai").FlexibleSchema<import("./agent-tool-context.ts").AgentToolContext> | undefined;
183
+ needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
184
+ agent_type: string;
185
+ task_name: string;
186
+ message: string;
187
+ fork_turns?: string | undefined;
188
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>> | undefined;
189
+ onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
190
+ onInputDelta?: ((options: {
191
+ inputTextDelta: string;
192
+ } & import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
193
+ onInputAvailable?: ((options: {
194
+ input: {
195
+ agent_type: string;
196
+ task_name: string;
197
+ message: string;
198
+ fork_turns?: string | undefined;
199
+ };
200
+ } & import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
201
+ toModelOutput?: ((options: {
202
+ toolCallId: string;
203
+ input: {
204
+ agent_type: string;
205
+ task_name: string;
206
+ message: string;
207
+ fork_turns?: string | undefined;
208
+ };
209
+ output: NoInfer<{
210
+ task_name: string;
211
+ }>;
212
+ }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
213
+ } & {
214
+ outputSchema?: import("ai").FlexibleSchema<{
215
+ task_name: string;
216
+ }> | undefined;
217
+ execute: import("ai").ToolExecuteFunction<{
218
+ agent_type: string;
219
+ task_name: string;
220
+ message: string;
221
+ fork_turns?: string | undefined;
222
+ }, {
223
+ task_name: string;
224
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>>;
225
+ } & {
226
+ type: 'provider';
227
+ id: `${string}.${string}`;
228
+ args: Record<string, unknown>;
229
+ description?: never;
230
+ strict?: never;
231
+ inputExamples?: never;
232
+ } & {
233
+ isProviderExecuted: false;
234
+ supportsDeferredResults?: never;
235
+ } & {
236
+ execute: import("ai").ToolExecuteFunction<{
237
+ agent_type: string;
238
+ task_name: string;
239
+ message: string;
240
+ fork_turns?: string | undefined;
241
+ }, {
242
+ task_name: string;
243
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>>;
244
+ }) | ({
245
+ deferLoading?: boolean;
246
+ title?: string;
247
+ providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
248
+ metadata?: import("@ai-sdk/provider").JSONObject;
249
+ inputSchema: import("ai").FlexibleSchema<{
250
+ agent_type: string;
251
+ task_name: string;
252
+ message: string;
253
+ fork_turns?: string | undefined;
254
+ }>;
255
+ contextSchema?: import("ai").FlexibleSchema<import("./agent-tool-context.ts").AgentToolContext> | undefined;
256
+ needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
257
+ agent_type: string;
258
+ task_name: string;
259
+ message: string;
260
+ fork_turns?: string | undefined;
261
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>> | undefined;
262
+ onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
263
+ onInputDelta?: ((options: {
264
+ inputTextDelta: string;
265
+ } & import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
266
+ onInputAvailable?: ((options: {
267
+ input: {
268
+ agent_type: string;
269
+ task_name: string;
270
+ message: string;
271
+ fork_turns?: string | undefined;
272
+ };
273
+ } & import("ai").ToolExecutionOptions<NoInfer<import("./agent-tool-context.ts").AgentToolContext>>) => void | PromiseLike<void>) | undefined;
274
+ toModelOutput?: ((options: {
275
+ toolCallId: string;
276
+ input: {
277
+ agent_type: string;
278
+ task_name: string;
279
+ message: string;
280
+ fork_turns?: string | undefined;
281
+ };
282
+ output: NoInfer<{
283
+ task_name: string;
284
+ }>;
285
+ }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
286
+ } & {
287
+ outputSchema?: import("ai").FlexibleSchema<{
288
+ task_name: string;
289
+ }> | undefined;
290
+ execute: import("ai").ToolExecuteFunction<{
291
+ agent_type: string;
292
+ task_name: string;
293
+ message: string;
294
+ fork_turns?: string | undefined;
295
+ }, {
296
+ task_name: string;
297
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>>;
298
+ } & {
299
+ type: 'provider';
300
+ id: `${string}.${string}`;
301
+ args: Record<string, unknown>;
302
+ description?: never;
303
+ strict?: never;
304
+ inputExamples?: never;
305
+ } & {
306
+ isProviderExecuted: true;
307
+ supportsDeferredResults?: boolean;
308
+ } & {
309
+ execute: import("ai").ToolExecuteFunction<{
310
+ agent_type: string;
311
+ task_name: string;
312
+ message: string;
313
+ fork_turns?: string | undefined;
314
+ }, {
315
+ task_name: string;
316
+ }, NoInfer<import("./agent-tool-context.ts").AgentToolContext>>;
317
+ });
318
+ };
319
+ /** `usageHintText` is appended to the `spawn_agent` description. */
320
+ constructor({ usageHintText }?: {
321
+ usageHintText?: string;
322
+ });
323
+ guidance(role: Role, name: ToolNamer): Guidance;
324
+ }
325
+ //# sourceMappingURL=spawning.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"spawning.d.ts","sources":["../../../src/zukhruf/collaboration/spawning.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG7E,gFAAgF;AAChF,qBAAa,QAAS,YAAW,UAAU;IACzC,QAAQ,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAC;IAEf,oEAAoE;IACpE,YAAY,EAAE,aAAa,EAAE,GAAE;QAAE,aAAa,CAAC,EAAE,MAAM,CAAA;KAAO,EAE7D;IAED,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,GAAG,QAAQ,CAgB9C;CACF"}