agentenkit 0.1.0

package/dist/core/stop.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimePorts } from '../ports/runtime.js';
+import type { StopResult } from '../ports/runtime.js';
+/** The whole stop mechanism (§2.1): one button, one behavior — everything
+ *  stops immediately. The engine's poller sees CANCELLED on the hot cache and
+ *  fires the abort; the durable state is the recovery truth (§3.4). */
+export declare function stop(deps: RuntimePorts, threadId: string): Promise<StopResult>;
+//# sourceMappingURL=stop.d.ts.map

package/dist/core/stop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop.d.ts","sourceRoot":"","sources":["../../src/core/stop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;uEAEuE;AACvE,wBAAsB,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAWpF"}

package/dist/core/stop.js

@@ -0,0 +1,15 @@
+import { publish, setThreadState } from './publish.js';
+/** The whole stop mechanism (§2.1): one button, one behavior — everything
+ *  stops immediately. The engine's poller sees CANCELLED on the hot cache and
+ *  fires the abort; the durable state is the recovery truth (§3.4). */
+export async function stop(deps, threadId) {
+    const thread = await deps.storage.threads.get(threadId);
+    if (thread?.state !== 'RUNNING' && thread?.state !== 'WAITING_FOR_INPUT') {
+        return { accepted: false, error: `Cannot stop thread in state ${thread?.state ?? 'unknown'}` };
+    }
+    await deps.kv.set(`agent:state:${threadId}`, 'CANCELLED');
+    await setThreadState(deps, threadId, 'CANCELLED', thread.model);
+    await publish(deps, threadId, 'STATE_CHANGE', { state: 'CANCELLED' });
+    return { accepted: true };
+}
+//# sourceMappingURL=stop.js.map

package/dist/core/stop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop.js","sourceRoot":"","sources":["../../src/core/stop.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAGvD;;uEAEuE;AACvE,MAAM,CAAC,KAAK,UAAU,IAAI,CAAC,IAAkB,EAAE,QAAgB;IAC7D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACxD,IAAI,MAAM,EAAE,KAAK,KAAK,SAAS,IAAI,MAAM,EAAE,KAAK,KAAK,mBAAmB,EAAE,CAAC;QACzE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,+BAA+B,MAAM,EAAE,KAAK,IAAI,SAAS,EAAE,EAAE,CAAC;IACjG,CAAC;IAED,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,eAAe,QAAQ,EAAE,EAAE,WAAW,CAAC,CAAC;IAC1D,MAAM,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAChE,MAAM,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC;IAEtE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAC5B,CAAC"}

package/dist/core/stream.d.ts

@@ -0,0 +1,12 @@
+/** Drain a `streamText` result, turning a provider failure into a throw.
+ *
+ *  streamText reports a failure — an aborted call included — as an `error`
+ *  part and then ends the stream NORMALLY, while its `text`/`usage`/`response`
+ *  promises never settle. Awaiting those without rethrowing hangs the caller
+ *  forever, still holding whatever it owns: for a run segment that is the
+ *  thread's run lock, which wedges every later message on the thread.
+ *
+ *  Draining fully first also means `onChunk` fires for every part that did
+ *  arrive before the failure. */
+export declare function drainOrThrow(fullStream: AsyncIterable<unknown>): Promise<void>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/core/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/core/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;iCASiC;AACjC,wBAAsB,YAAY,CAAC,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAQpF"}

package/dist/core/stream.js

@@ -0,0 +1,21 @@
+/** Drain a `streamText` result, turning a provider failure into a throw.
+ *
+ *  streamText reports a failure — an aborted call included — as an `error`
+ *  part and then ends the stream NORMALLY, while its `text`/`usage`/`response`
+ *  promises never settle. Awaiting those without rethrowing hangs the caller
+ *  forever, still holding whatever it owns: for a run segment that is the
+ *  thread's run lock, which wedges every later message on the thread.
+ *
+ *  Draining fully first also means `onChunk` fires for every part that did
+ *  arrive before the failure. */
+export async function drainOrThrow(fullStream) {
+    let streamError;
+    for await (const part of fullStream) {
+        if (part?.type === 'error' && streamError === undefined) {
+            streamError = part.error;
+        }
+    }
+    if (streamError !== undefined)
+        throw streamError;
+}
+//# sourceMappingURL=stream.js.map

package/dist/core/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../src/core/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;iCASiC;AACjC,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,UAAkC;IACnE,IAAI,WAAoB,CAAC;IACzB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QACpC,IAAK,IAAiC,EAAE,IAAI,KAAK,OAAO,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YACtF,WAAW,GAAI,IAA4B,CAAC,KAAK,CAAC;QACpD,CAAC;IACH,CAAC;IACD,IAAI,WAAW,KAAK,SAAS;QAAE,MAAM,WAAW,CAAC;AACnD,CAAC"}

package/dist/core/subagent.d.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import type { NestedDescriptor, ProviderOptions, ResumeInfo, SubagentsConfig } from './types.js';
+import type { RuntimePorts } from '../ports/runtime.js';
+import type { RegisteredAgent } from './agent.js';
+import { type HitlFrame } from './hitl.js';
+import { type AgentRunState } from './state.js';
+import { type LoopOutcome, type RunLedger } from './loop.js';
+/** Everything a nested run needs from the run that spawned it (§2.7). The
+ *  thread, lock, run id, abort signal and token ledger are the parent's; the
+ *  message stream, step ceiling and toolset are the child's own. */
+export interface SubagentCtx {
+    threadId: string;
+    depth: number;
+    sem: Semaphore;
+    ports: RuntimePorts;
+    /** Delegation config carried from the parent's spec (§2.7): flavor,
+     *  default model, and extra tools for every spawned child. */
+    sub: SubagentsConfig;
+    /** The registered agent whose generation args every nested run inherits
+     *  (§3.1) — its `system` and `tools` are overridden per child. */
+    agent: RegisteredAgent;
+    /** The run-wide token ledger (§2.7): a child's spend counts against the
+     *  same safety cap the main agent is checked against. */
+    ledger: RunLedger;
+    /** Dispatch ticket persisted with any park raised beneath here (§2.5). */
+    resume: ResumeInfo;
+    /** The stream this spawner writes to — `null` when it is the main agent. */
+    agentId: string | null;
+    /** Calls already waiting on an approval above this level, innermost first. */
+    frames: HitlFrame[];
+    /** This spawner's own descriptor — absent when it is the main agent. Goes
+     *  onto the frame it pushes, so an unwind can re-enter it (§2.7). */
+    descriptor?: NestedDescriptor;
+    tokenBudget?: number;
+    providerOptions?: ProviderOptions;
+    abortSignal?: AbortSignal;
+    /** The run's state, handed down unchanged (§2.10). */
+    state?: AgentRunState;
+}
+/** Run-scoped semaphore: sibling subagents queue instead of running away (§2.7) */
+export declare class Semaphore {
+    private readonly limit;
+    private active;
+    private waiters;
+    constructor(limit: number);
+    acquire(): Promise<() => void>;
+}
+export declare function spawnSubagentTool(ctx: SubagentCtx): import("ai").Tool<z.ZodObject<{
+    name: z.ZodString;
+    instructions: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    instructions: string;
+    model?: string | undefined;
+}, {
+    name: string;
+    instructions: string;
+    model?: string | undefined;
+}>, any> & {
+    execute: (args: {
+        name: string;
+        instructions: string;
+        model?: string | undefined;
+    }, options: import("ai").ToolExecutionOptions) => PromiseLike<any>;
+};
+/** Run — or RE-ENTER — a nested agent (§2.7).
+ *
+ *  Its turns live in the thread's message log under its own `agentId`, so a
+ *  child that parked is resumed from exactly where it stopped rather than
+ *  replayed from its brief. Replaying an LLM call is not a safe substitute:
+ *  the model can take a different path and never make the call the human
+ *  approved, and it re-pays for everything before the park. */
+export declare function runNestedAgent(ctx: SubagentCtx, d: NestedDescriptor, 
+/** Seeds the stream on first entry; ignored once the child has turns. */
+instructions: string | null, abortSignal: AbortSignal | undefined, frames: HitlFrame[]): Promise<LoopOutcome>;
+//# sourceMappingURL=subagent.d.ts.map

package/dist/core/subagent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent.d.ts","sourceRoot":"","sources":["../../src/core/subagent.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,UAAU,EAEV,eAAe,EAChB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,OAAO,EAAyB,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAClE,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAE9D,OAAO,EAAW,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtE;;oEAEoE;AACpE,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,SAAS,CAAC;IACf,KAAK,EAAE,YAAY,CAAC;IACpB;kEAC8D;IAC9D,GAAG,EAAE,eAAe,CAAC;IACrB;sEACkE;IAClE,KAAK,EAAE,eAAe,CAAC;IACvB;6DACyD;IACzD,MAAM,EAAE,SAAS,CAAC;IAClB,0EAA0E;IAC1E,MAAM,EAAE,UAAU,CAAC;IACnB,4EAA4E;IAC5E,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,8EAA8E;IAC9E,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB;yEACqE;IACrE,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,sDAAsD;IACtD,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED,mFAAmF;AACnF,qBAAa,SAAS;IAGR,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,OAAO,CAAsB;gBACR,KAAK,EAAE,MAAM;IAEpC,OAAO,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC;CAoBrC;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW;;;;;;;;;;;;;;;;;;EAyHjD;AA+ED;;;;;;+DAM+D;AAC/D,wBAAsB,cAAc,CAClC,GAAG,EAAE,WAAW,EAChB,CAAC,EAAE,gBAAgB;AACnB,yEAAyE;AACzE,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,WAAW,EAAE,WAAW,GAAG,SAAS,EACpC,MAAM,EAAE,SAAS,EAAE,GAClB,OAAO,CAAC,WAAW,CAAC,CA0DtB"}

package/dist/core/subagent.js

@@ -0,0 +1,261 @@
+import { randomUUID } from 'node:crypto';
+import { tool } from 'ai';
+import { z } from 'zod';
+import { publish } from './publish.js';
+import { HITL_PARKED, withHitl } from './hitl.js';
+import { withRunState } from './state.js';
+import { markPromptCaching } from './cache.js';
+import { runLoop } from './loop.js';
+/** Run-scoped semaphore: sibling subagents queue instead of running away (§2.7) */
+export class Semaphore {
+    limit;
+    active = 0;
+    waiters = [];
+    constructor(limit) {
+        this.limit = limit;
+    }
+    async acquire() {
+        await new Promise((resolve) => {
+            if (this.active < this.limit) {
+                this.active++;
+                resolve();
+            }
+            else {
+                this.waiters.push(() => {
+                    this.active++;
+                    resolve();
+                });
+            }
+        });
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.active--;
+            this.waiters.shift()?.();
+        };
+    }
+}
+export function spawnSubagentTool(ctx) {
+    return tool({
+        description: 'Delegates a self-contained task to a subagent with an isolated context',
+        parameters: z.object({
+            name: z.string().describe('Short name for the sub-task'),
+            instructions: z
+                .string()
+                .describe('Complete, self-contained brief: goal, constraints, expected output format'),
+            model: z.string().optional(),
+        }),
+        execute: async (args, opts) => {
+            const { name, instructions, model } = args;
+            const depth = ctx.depth + 1;
+            if (depth > ctx.ports.config.subagentMaxDepth) {
+                return { error: `Max subagent depth (${ctx.ports.config.subagentMaxDepth}) reached` };
+            }
+            const release = await ctx.sem.acquire();
+            try {
+                // A nested run is a run (§2.9): same table, distinguished by depth and
+                // a parent. Its id is also the agentId its messages and events carry.
+                const run = await ctx.ports.admin.runs.start({
+                    id: randomUUID(),
+                    threadId: ctx.threadId,
+                    // The spawner: another nested run, or the dispatched run itself.
+                    parentRunId: ctx.agentId ?? ctx.resume.runId ?? null,
+                    depth,
+                    agent: name,
+                    model: model ?? ctx.sub.model ?? 'gpt-4o',
+                    // A nested run's "prompt" is the brief it was delegated (§2.7).
+                    ...(ctx.ports.config.recordPayloads
+                        ? {
+                            prompt: instructions.length > ctx.ports.config.payloadCapChars
+                                ? `${instructions.slice(0, ctx.ports.config.payloadCapChars)}…`
+                                : instructions,
+                            runState: ctx.state ?? null,
+                        }
+                        : {}),
+                });
+                await publish(ctx.ports, ctx.threadId, 'SUBAGENT_STARTED', {
+                    agentId: run.id, name, depth,
+                });
+                const descriptor = {
+                    agentId: run.id,
+                    name,
+                    model: model ?? ctx.sub.model ?? 'gpt-4o',
+                    depth,
+                };
+                try {
+                    const outcome = await runNestedAgent(ctx, descriptor, instructions, opts.abortSignal ?? ctx.abortSignal, 
+                    // This call is now the innermost thing waiting on any approval the
+                    // child raises (§2.7).
+                    [
+                        {
+                            agentId: ctx.agentId,
+                            toolCallId: opts.toolCallId ?? run.id,
+                            ...(ctx.descriptor ? { nested: ctx.descriptor } : {}),
+                        },
+                        ...ctx.frames,
+                    ]);
+                    if (outcome.parked) {
+                        // The child is suspended, not finished: leave its SubagentRun
+                        // RUNNING and hand the parent the sentinel so its segment ends
+                        // too (§2.5). The child is re-entered on approval, from its own
+                        // persisted turns — it never restarts.
+                        return { [HITL_PARKED]: opts.toolCallId ?? run.id };
+                    }
+                    await closeNested(ctx, run, outcome, {
+                        state: 'COMPLETED',
+                        result: { text: outcome.text },
+                    });
+                    await publish(ctx.ports, ctx.threadId, 'SUBAGENT_COMPLETED', { agentId: run.id });
+                    // The parent receives a capped result, keeping its own context small (§2.6)
+                    return {
+                        agentId: run.id,
+                        result: outcome.text.slice(0, ctx.ports.config.subagentResultCapChars),
+                    };
+                }
+                catch (err) {
+                    const cancelled = (await ctx.ports.kv.get(`agent:state:${ctx.threadId}`)) === 'CANCELLED';
+                    const state = cancelled ? 'CANCELLED' : 'FAILED';
+                    const message = err instanceof Error ? err.message : String(err);
+                    await closeNested(ctx, run, null, { state, error: message });
+                    // Carry the reason: a bare state tells an operator a child died but
+                    // not why, and a nested run's failure is otherwise invisible.
+                    await publish(ctx.ports, ctx.threadId, 'SUBAGENT_FAILED', {
+                        agentId: run.id,
+                        state,
+                        error: message,
+                    });
+                    // A user stop tears the whole run down (§2.1), so that one keeps
+                    // propagating.
+                    if (cancelled)
+                        throw err;
+                    // Anything else is reported TO THE PARENT as the delegation's
+                    // result, the same way an approved tool's failure is reported to the
+                    // model rather than thrown (§2.5): a delegated task that went wrong
+                    // is news the agent can act on — retry, try another way, tell the
+                    // user — not a reason to kill the run it was part of.
+                    return { agentId: run.id, error: message };
+                }
+            }
+            finally {
+                release();
+            }
+        },
+    });
+}
+/** Close a nested run's record with the same detail a dispatched run gets
+ *  (§2.9): how it ended, how long it took, what it cost. */
+/** Stamp a nested run's prompt when caching is on, exactly as the main path
+ *  does. */
+function maybeCache(ports, messages) {
+    return ports.config.promptCaching ? markPromptCaching(messages) : messages;
+}
+async function closeNested(ctx, run, outcome, end) {
+    const endedAt = new Date();
+    await ctx.ports.admin.runs.patch(run.id, {
+        ...end,
+        endedAt,
+        durationMs: endedAt.getTime() - new Date(run.startedAt).getTime(),
+        ...(outcome
+            ? {
+                steps: outcome.steps,
+                inputTokens: outcome.attribution.inputTokens,
+                cachedInputTokens: outcome.attribution.cachedInputTokens,
+                outputTokens: outcome.attribution.outputTokens,
+                totalTokens: outcome.attribution.totalTokens,
+            }
+            : {}),
+    });
+}
+/** The toolset a nested run sees (§2.7): the delegation config's extra tools,
+ *  HITL-wrapped exactly like the parent's, plus nesting while depth allows.
+ *  Default is `spawnSubagent` alone — destructive tools reach a child only
+ *  when a workflow grants them. */
+function nestedTools(ctx, d, frames, abortSignal) {
+    const raw = {
+        ...(ctx.sub.tools ?? {}),
+        spawnSubagent: spawnSubagentTool({
+            ...ctx,
+            depth: d.depth,
+            agentId: d.agentId,
+            frames,
+            descriptor: d,
+            abortSignal,
+        }),
+    };
+    // A nested run's tools see the same state as its parent's (§2.10).
+    return withRunState(withHitl(ctx.ports, ctx.threadId, raw, {
+        resume: ctx.resume,
+        agentId: d.agentId,
+        frames,
+        nested: d,
+    }), ctx.state ?? {});
+}
+/** The delegation tool lets the MODEL name the child's model, so an unknown
+ *  registry key is ordinary bad input rather than a failure. `resolveModel`
+ *  throws on one (§3.3) — a `||` fallback can never catch that — so the child
+ *  falls back to the model its parent is already running on, which is
+ *  resolvable by construction. */
+function resolveNestedModel(ctx, name) {
+    try {
+        return ctx.ports.resolveModel(name);
+    }
+    catch {
+        return ctx.ports.resolveModel(ctx.resume.model);
+    }
+}
+/** Run — or RE-ENTER — a nested agent (§2.7).
+ *
+ *  Its turns live in the thread's message log under its own `agentId`, so a
+ *  child that parked is resumed from exactly where it stopped rather than
+ *  replayed from its brief. Replaying an LLM call is not a safe substitute:
+ *  the model can take a different path and never make the call the human
+ *  approved, and it re-pays for everything before the park. */
+export async function runNestedAgent(ctx, d, 
+/** Seeds the stream on first entry; ignored once the child has turns. */
+instructions, abortSignal, frames) {
+    const { ports, threadId } = ctx;
+    const persisted = await ports.storage.messages.list(threadId, { agentId: d.agentId });
+    if (persisted.length === 0) {
+        if (instructions === null) {
+            throw new Error(`Nested run ${d.agentId} has no turns and no brief to seed from`);
+        }
+        // Isolated context (§2.7): the brief is the only input — parent history
+        // is never forwarded.
+        persisted.push(await ports.storage.messages.append(threadId, {
+            role: 'user',
+            content: instructions,
+            agentId: d.agentId,
+        }));
+    }
+    const outcome = await runLoop(ports, ctx.agent, threadId, {
+        agentId: d.agentId,
+        // Its OWN run id, not its parent's: a nested run is a run (§2.7, §2.9),
+        // so its steps belong to its own record. Attributing them upward mixed
+        // two agents' steps into one timeline and made the indexes collide.
+        runId: d.agentId,
+        kind: ctx.sub.kind ?? 'stream-text',
+        model: resolveNestedModel(ctx, d.model).instance(),
+        // Stamped like the parent's (§2.6). A nested run re-sends its whole
+        // brief and history on every step, so it is exactly the shape caching
+        // is for — it was the one prompt in the system going out unstamped.
+        messages: maybeCache(ports, persisted.map((m) => ({ role: m.role, content: m.content }))),
+        tools: nestedTools(ctx, d, frames, abortSignal),
+        maxSteps: ports.config.subagentMaxSteps,
+        abortSignal: abortSignal ?? new AbortController().signal,
+        providerOptions: ctx.providerOptions,
+        tokenBudget: ctx.tokenBudget,
+        system: `You are the "${d.name}" subagent. Complete the task, then stop.`,
+        cacheSystemPrompt: ports.config.promptCaching,
+        onChunk: async (chunk) => {
+            // Namespaced into the shared thread event log → same multi-user pipeline (§2.2)
+            await publish(ports, threadId, 'SUBAGENT_CHUNK', { agentId: d.agentId, chunk });
+        },
+    }, ctx.ledger);
+    // Billing attribution per subagent (§4); the run-wide ledger was already
+    // advanced inside the loop.
+    await ports.storage.usage.record(threadId, { agentId: d.agentId, ...outcome.attribution });
+    return outcome;
+}
+//# sourceMappingURL=subagent.js.map

package/dist/core/subagent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent.js","sourceRoot":"","sources":["../../src/core/subagent.ts"],"names":[],"mappings":"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"}

package/dist/core/tools.d.ts

@@ -0,0 +1,36 @@
+import { type ToolExecutionOptions } from 'ai';
+import type { z } from 'zod';
+import type { AgentRunState } from './state.js';
+/** What a tool's `execute` actually receives: the AI SDK's own options, plus
+ *  the run's state (§2.10).
+ *
+ *  The platform injects `state` at call time, but the SDK's own
+ *  `ToolExecutionOptions` has no field for it — and a plain `tool()` cannot be
+ *  told about it, because narrowing the options parameter is rejected as
+ *  unsound. Hence `agentTool`. */
+export interface ToolContext extends ToolExecutionOptions {
+    /** Whatever the caller attached to this run. Present for every tool of every
+     *  run, including a nested one and a segment resumed after an approval. */
+    state: AgentRunState;
+}
+/** `tool()` with the run state typed.
+ *
+ * ```ts
+ * const lookupInvoice = agentTool({
+ *   description: 'Find one invoice',
+ *   parameters: z.object({ invoiceId: z.string() }),
+ *   execute: async ({ invoiceId }, { state }) =>
+ *     db.invoice.findFirst({ where: { id: invoiceId, orgId: state.orgId } }),
+ * });
+ * ```
+ *
+ *  The result is an ordinary AI SDK tool — it composes with
+ *  `markRequiresConfirmation` and can be passed anywhere `tool()` can. */
+export declare function agentTool<PARAMETERS extends z.ZodTypeAny, RESULT>(spec: {
+    description?: string;
+    parameters: PARAMETERS;
+    execute: (args: z.infer<PARAMETERS>, ctx: ToolContext) => PromiseLike<RESULT>;
+}): import("ai").Tool<PARAMETERS, RESULT> & {
+    execute: (args: PARAMETERS extends import("ai").Schema<any> ? PARAMETERS["_type"] : PARAMETERS extends z.ZodTypeAny ? z.TypeOf<PARAMETERS> : never, options: ToolExecutionOptions) => PromiseLike<RESULT>;
+};
+//# sourceMappingURL=tools.d.ts.map

package/dist/core/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/core/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,oBAAoB,EAAE,MAAM,IAAI,CAAC;AACrD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;kCAMkC;AAClC,MAAM,WAAW,WAAY,SAAQ,oBAAoB;IACvD;+EAC2E;IAC3E,KAAK,EAAE,aAAa,CAAC;CACtB;AAED;;;;;;;;;;;;0EAY0E;AAC1E,wBAAgB,SAAS,CAAC,UAAU,SAAS,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,GAAG,EAAE,WAAW,KAAK,WAAW,CAAC,MAAM,CAAC,CAAC;CAC/E;;EAUA"}

package/dist/core/tools.js

@@ -0,0 +1,22 @@
+import { tool } from 'ai';
+/** `tool()` with the run state typed.
+ *
+ * ```ts
+ * const lookupInvoice = agentTool({
+ *   description: 'Find one invoice',
+ *   parameters: z.object({ invoiceId: z.string() }),
+ *   execute: async ({ invoiceId }, { state }) =>
+ *     db.invoice.findFirst({ where: { id: invoiceId, orgId: state.orgId } }),
+ * });
+ * ```
+ *
+ *  The result is an ordinary AI SDK tool — it composes with
+ *  `markRequiresConfirmation` and can be passed anywhere `tool()` can. */
+export function agentTool(spec) {
+    const { execute, ...rest } = spec;
+    return tool({
+        ...rest,
+        execute: ((args, options) => execute(args, options)),
+    });
+}
+//# sourceMappingURL=tools.js.map

package/dist/core/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../src/core/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAA6B,MAAM,IAAI,CAAC;AAiBrD;;;;;;;;;;;;0EAY0E;AAC1E,MAAM,UAAU,SAAS,CAA0C,IAIlE;IACC,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;IAClC,OAAO,IAAI,CAAC;QACV,GAAG,IAAI;QACP,OAAO,EAAE,CAAC,CAAC,IAAyB,EAAE,OAA6B,EAAE,EAAE,CACrE,OAAO,CAAC,IAAI,EAAE,OAAsB,CAAC,CAGf;KACzB,CAAC,CAAC;AACL,CAAC"}