gemi 0.60.0 → 0.62.0

package/dist/ai/Agent.d.ts

@@ -1,33 +1,541 @@
-export type Schema<T> = {};
-interface IAgentTool<T, U> {
-    name: string;
+import type { HttpRequest } from "../http";
+import type { AgentProvider } from "./AgentProvider";
+import type { Infer, Schema } from "./Schema";
+import type { AgentMessage, AgentStreamEvent, AgentStreamFrame, ClientTurn, FinishReason, NestedRun, PendingToolCall, ToolShapes, Usage } from "./types";
+/**
+ * Everything a tool needs from the request it is running inside.
+ *
+ * Tools are created once at module scope and shared by every request, so they
+ * cannot close over a user or an abort signal — and anything mutable stored on
+ * the tool itself would leak across requests. That is why the run's state
+ * arrives as an argument instead: the tool stays a singleton and the context is
+ * per call.
+ */
+export interface ToolContext {
+    req: HttpRequest<any, any>;
+    runId: string;
+    threadId?: string;
+    toolCallId: string;
+    /**
+     * Aborted when the user calls `stop()`. Not when the connection drops — a run
+     * outlives the request that started it so a refresh can reattach, which means
+     * a disconnect is no longer a signal to stop working.
+     */
+    signal: AbortSignal;
+    /** Which step of the tool loop this is, starting at 1. */
+    step: number;
+    /**
+     * How deep this tool is inside nested runs: 0 at the top, 1 inside a tool of
+     * an agent started by `runAgent`, and so on. Compared against `maxDepth` on
+     * `Agent.create` so a cycle — agent A with a tool that runs agent A — fails
+     * with a sentence to read instead of exhausting the stack.
+     */
+    readonly depth: number;
+    /**
+     * True when this tool is being re-entered after a sub-agent it started asked
+     * the user something and the user answered.
+     *
+     * READ THE `runAgent` NOTE BEFORE USING IT. This is the flag that lets a tool
+     * tell a first attempt from a replay, and it exists because there is nothing
+     * to tell it otherwise: the tool body ran once already.
+     */
+    readonly resumed: boolean;
+    /**
+     * Runs another agent from inside this tool, wired into the parent run.
+     *
+     * A tool can already drive a sub-agent by hand — make one, iterate it, yield
+     * its events as progress. What this does that hand-rolling cannot is join the
+     * two runs: the sub-run inherits `ctx.signal` so the parent's `stop()` reaches
+     * it; every sub-run event is re-emitted on the parent stream as
+     * `nested-event`, numbered in the parent's `seq`, so `/attach` replay stays
+     * correct through the nesting; the sub-run's usage rolls into the parent's;
+     * its transcript is recorded on the parent's `ToolCallPart.nested`; and the
+     * depth and agent-name chain travel with it, so a cycle fails fast.
+     *
+     * ESCALATION. If the sub-run ends `awaiting-input` — it has an approval tool,
+     * or it asked a question — `onPending: "escalate"` (the default) throws a
+     * `PendingEscalation` carrying the inner pending calls, which the parent run
+     * collects exactly like pending calls of its own: the parent ends
+     * `awaiting-input` with the sub-agent's questions in its list, and the client
+     * answers them with the same `approve()` / `answer()` it uses for any other.
+     * `onPending: "deny"` refuses them instead and lets the sub-run finish.
+     *
+     * THE COST, WHICH IS REAL AND WHICH YOU MUST DESIGN AROUND. A JS async
+     * generator cannot be suspended across a turn boundary: `awaiting-input` is
+     * terminal for the stream, the next turn re-enters the loop at the top and
+     * rebuilds its state from the message history, and a paused generator is not
+     * in that history and cannot be put there. So an escalating tool is
+     * RE-ENTERED FROM THE TOP on the next turn, with `ctx.resumed === true`, and
+     * `runAgent` is memoized by call index within the tool call: the Nth
+     * `runAgent` of a tool call that already completed on an earlier turn returns
+     * its persisted result immediately, calling no provider and running no
+     * sub-tool, and only the sub-run that escalated actually continues.
+     *
+     * The index is the only key there is, so a body whose `runAgent` calls sit in
+     * a branch or a loop can produce a different sequence on the replay and make
+     * index N mean two different things. That is checked, not trusted: a mismatch
+     * fails the tool call with a sentence naming both sub-runs, because pairing a
+     * user's answer with a sub-run they never saw would be invisible.
+     *
+     * Which means: CODE BEFORE AN ESCALATING `runAgent` RUNS AGAIN ON RESUME.
+     * Side effects there are repeated. Put your side effects after the
+     * `runAgent`, or make them idempotent, or branch on `ctx.resumed`. This is
+     * inherent to replay and it is the same bargain the outer tool loop already
+     * makes; it is written here in plain words rather than solved with a
+     * checkpoint API, because that is a much larger feature than this one.
+     */
+    runAgent<A extends AnyAgent>(agent: A, params?: RunAgentParams): Promise<NestedRunResult>;
+}
+/** What `ctx.runAgent` is given. `messages` and `prompt` are alternatives. */
+export interface RunAgentParams {
+    /** Prior turns for the sub-agent. Starts empty when omitted. */
+    messages?: AgentMessage[];
+    /** Sugar for a single user turn — the common case, and the whole message
+     *  list when there is no sub-conversation to continue. */
+    prompt?: string;
+    /** Appended to the sub-agent's own `instructions`, for this run only. */
+    instructions?: string;
+    /** Shown on the nested transcript, e.g. "researching pricing". */
+    label?: string;
+    /**
+     * What to do when the sub-run ends `awaiting-input`. `"escalate"` (the
+     * default) throws `PendingEscalation` so the question reaches the user;
+     * `"deny"` refuses every pending call and lets the sub-run finish, which is
+     * what a tool wants when the sub-agent is meant to be autonomous.
+     *
+     * `"deny"` is refused *in place*, inside the sub-run's own loop, so the
+     * sub-agent is told it cannot ask and takes another step rather than ending
+     * parked — and it is inherited by everything below, so a grandchild asking to
+     * escalate is overruled too. A promise that nothing from this subtree reaches
+     * the user is only worth making if the whole subtree keeps it.
+     */
+    onPending?: "escalate" | "deny";
+}
+/**
+ * What a completed sub-run gives back.
+ *
+ * `nested` is the transcript as it is recorded on the parent's tool-call part,
+ * so a tool that wants to summarize what its sub-agent did reads the same
+ * object the UI renders rather than a second representation of it.
+ */
+export interface NestedRunResult<O = unknown> {
+    runId: string;
+    /** The sub-agent's name — carried so a caller that fans out over several
+     *  agents can tell the results apart without tracking the order. */
+    agent: string;
+    messages: AgentMessage[];
+    finishReason: FinishReason;
+    usage: Usage;
+    /** Set when the sub-agent declares an `output` schema and the run finished. */
+    output?: O;
+    /** The record written to the parent's `ToolCallPart.nested`. */
+    nested: NestedRun;
+}
+/**
+ * Thrown by `ctx.runAgent` when a sub-run ends `awaiting-input`.
+ *
+ * An exception rather than a return value because it must not be mistaken for
+ * an answer: a tool that ignored an `{ escalated: true }` field would return a
+ * result to the model as if the sub-agent had finished, and the model would act
+ * on an answer nobody gave. `executeTool` lets this one propagate instead of
+ * turning it into a `tool_error`, and the step loop collects `pending` exactly
+ * like the pending calls it produced itself.
+ *
+ * `path` is the chain of tool-call ids down to the escalating call; each entry
+ * of `pending` already carries its own full path, and this is the prefix they
+ * share.
+ */
+export declare class PendingEscalation extends Error {
+    readonly pending: PendingToolCall[];
+    readonly path: string[];
+    /** The sub-run that parked, so the parent can record its transcript before
+     *  ending the turn — an escalation is a pause, not a lost run. */
+    readonly nested: NestedRun;
+    constructor(params: {
+        pending: PendingToolCall[];
+        path: string[];
+        nested: NestedRun;
+    });
+}
+/**
+ * A tool either resolves once, or yields progress and then returns.
+ *
+ * The generator form exists because a tool that takes twenty seconds is the
+ * normal case, not the exotic one, and a chat UI that shows nothing for twenty
+ * seconds looks broken. Yields become `tool-progress` events; the return value
+ * is the result the model sees.
+ */
+export type ToolExecute<Input, Output, Progress = unknown> = (input: Input, ctx: ToolContext) => Promise<Output> | AsyncGenerator<Progress, Output, void>;
+type ToolDefinitionBase<Name extends string, Input, Output> = {
+    name: Name;
+    /** The model's only description of when to reach for this. */
     description: string;
-    inputSchema: Schema<T>;
-    outputSchema: Schema<U>;
-    execute: (input: T) => Promise<U> | AsyncGenerator<U>;
-    deferred: boolean;
-    requiresApproval: boolean;
+    inputSchema: Schema<Input>;
+    /**
+     * Optional for a server tool, required for a client one — there it is what
+     * the answer is validated against before the model sees it, and what types
+     * the value the browser has to produce.
+     */
+    outputSchema?: Schema<Output>;
+    /**
+     * Withholds this tool's parameter schema from the request: the model is shown
+     * only the name and description, and pulls the rest in with the provider's
+     * `tool_search` when it decides it wants the tool (`defer_loading` on the
+     * wire).
+     *
+     * It says nothing about who runs the tool or when — it is a statement about
+     * the prompt, not about execution. What it buys is context: an agent with
+     * forty tools spends most of its prompt on schemas for tools it will not
+     * call, and deferred ones load at the end of the window, so adding one
+     * mid-conversation does not invalidate the cache.
+     *
+     * Purely an optimization, and gemi treats it as one: a provider that cannot
+     * do tool search is sent the schemas inline, and the agent behaves the same.
+     * So it is safe to set on a model that does not support it, and worth setting
+     * only for tools that are large, numerous, or rarely reached.
+     */
+    deferred?: boolean;
+};
+/**
+ * Two ways a tool's result comes to exist, and neither changes the shape of the
+ * conversation.
+ *
+ * `execute` — the server runs it.
+ * `answeredBy: "client"` — the browser produces the result: a question for the
+ *   user, or something only the page can do. The stream ends `awaiting-input`
+ *   and the answer arrives as an ordinary turn.
+ *
+ * `requiresApproval` applies to the first: the server can run the tool, but
+ * asks first. That, too, ends the stream `awaiting-input`, which is the whole
+ * reason there is no second endpoint — an approval is a question whose answer
+ * happens to be yes or no.
+ */
+export type ToolDefinition<Name extends string, Input, Output, Progress = never> = (ToolDefinitionBase<Name, Input, Output> & {
+    answeredBy?: "server";
+    execute: ToolExecute<Input, Output, Progress>;
+    requiresApproval?: boolean;
+}) | (ToolDefinitionBase<Name, Input, Output> & {
+    answeredBy: "client";
+    outputSchema: Schema<Output>;
+    execute?: never;
+    /** Meaningless here: the client answering *is* the approval. */
+    requiresApproval?: never;
+});
+/**
+ * `Progress` is inferred, never written down.
+ *
+ * It comes from the yield type of an `execute` that is an async generator, and
+ * from nothing else — a tool that returns a promise gets `never`, which is the
+ * honest statement that it cannot yield and is what makes
+ * `ToolShapesOf`'s `progress` member safe to emit unconditionally. It is
+ * carried as a fourth parameter rather than derived on demand because it has to
+ * survive the trip through `ToolNamespace`, `FlattenTools` and `ToolShapesOf`
+ * into the browser, and only a type argument does that.
+ *
+ * Structurally it lives on `execute`, which is optional, and which is also why
+ * `AnyAgentTool` must pass `any` here: `Progress` sits covariantly inside
+ * `AsyncGenerator<Progress, …>`, so a bound of `never` would make every
+ * yielding tool fail the `Extract` in `ToolShapesOf` and silently vanish from
+ * the shapes.
+ */
+export declare class AgentTool<Name extends string = string, Input = unknown, Output = unknown, Progress = never> {
+    readonly name: Name;
+    readonly description: string;
+    readonly inputSchema: Schema<Input>;
+    readonly outputSchema?: Schema<Output>;
+    readonly requiresApproval: boolean;
+    readonly deferred: boolean;
+    readonly answeredBy: "server" | "client";
+    /**
+     * There is deliberately no `namespace` here. A tool is a module-scope
+     * singleton, so a field naming its group would hold whichever agent
+     * constructed its namespace last and report that to every other one — the
+     * same global-effect-from-a-local-declaration that `ToolNamespace.deferred`
+     * avoids. Where a tool sits is a property of the agent, and it lives on the
+     * agent's `ResolvedTool`.
+     */
+    readonly execute?: ToolExecute<Input, Output, Progress>;
+    private constructor();
+    /**
+     * `const` on the params is what preserves `name` as a literal, which is what
+     * lets the browser discriminate a tool part by name.
+     */
+    static create<const Name extends string, Input, Output, Progress = never>(params: ToolDefinition<Name, Input, Output, Progress>): AgentTool<Name, Input, Output, Progress>;
+    /**
+     * Sugar for the common client tool: the agent asks the user something and
+     * waits. Equivalent to `answeredBy: "client"` with an input schema of one
+     * prompt field.
+     */
+    static ask<const Name extends string, Output>(params: {
+        name: Name;
+        description: string;
+        outputSchema: Schema<Output>;
+    }): AgentTool<Name, {
+        question: string;
+    }, Output>;
 }
-export declare class AgentTool<T, U> implements IAgentTool<T, U> {
-    name: string;
+export type AnyAgentTool = AgentTool<string, any, any, any>;
+/**
+ * A group of tools the model can search as a unit.
+ *
+ * The provider's tool search works over namespaces, and the guidance is fewer
+ * than ten functions in each — the model looks at a namespace's description to
+ * decide whether anything inside is worth loading, so the grouping is part of
+ * the prompt, not bookkeeping. A namespace is also the only place a
+ * *collection* of tools can be described; on a flat list that sentence has
+ * nowhere to go.
+ *
+ * Tool names stay globally unique within an agent, so the browser still
+ * discriminates on `name` alone and the namespace never leaks into the client's
+ * types.
+ */
+export declare class ToolNamespace<Name extends string = string, T extends readonly AnyAgentTool[] = readonly AnyAgentTool[]> {
+    readonly name: Name;
+    readonly description: string;
+    readonly tools: T;
+    /**
+     * Kept here rather than pushed onto each tool. A tool is a module-scope
+     * singleton and may be listed bare as well as inside a group; writing the
+     * group's `deferred` onto it would defer it everywhere, which is a global
+     * effect from a local declaration.
+     */
+    readonly deferred: boolean;
+    private constructor();
+    static create<const Name extends string, const T extends readonly AnyAgentTool[]>(params: {
+        name: Name;
+        /** What the model reads when deciding whether to search inside. */
+        description: string;
+        tools: T;
+        /** Defers every tool in the group, so the whole namespace costs its own
+         *  description plus one line per tool until something is loaded. */
+        deferred?: boolean;
+    }): ToolNamespace<Name, T>;
+}
+/** What an agent's `tools` may hold: tools, or namespaces of them. */
+export type ToolEntry = AnyAgentTool | ToolNamespace<string, readonly AnyAgentTool[]>;
+type FlattenTools<T extends readonly ToolEntry[]> = T[number] extends infer E ? E extends ToolNamespace<any, infer NT> ? NT[number] : E : never;
+/**
+ * The tool tuple, erased to the payload types the client is allowed to see.
+ *
+ * `progress` is emitted for every tool, `never` included, rather than only for
+ * the ones that can yield. A conditional that dropped the member would make
+ * `T[K]["progress"]` in `types.ts` resolve differently per tool, and this
+ * package compiles with `strict: false` — where `undefined extends T` is true
+ * of everything and an optional member is indistinguishable from a required
+ * one. Two inference bugs in this module already came from testing a shape
+ * under those options and believing the answer (see `OptionalSchema` in
+ * `Schema.ts`); an unconditional member has nothing to get wrong.
+ */
+export type ToolShapesOf<T extends readonly ToolEntry[]> = {
+    [K in Extract<FlattenTools<T>, AnyAgentTool> as K["name"]]: K extends AgentTool<any, infer I, infer O, infer P> ? {
+        input: I;
+        output: O;
+        progress: P;
+    } : never;
+};
+/**
+ * A skill is instructions the model can go and fetch.
+ *
+ * Inlining every skill into the system prompt costs its tokens on every request
+ * and gets worse with each skill added. So a skill is lowered to a tool: one
+ * zero-parameter function per skill, in a reserved `skills` namespace, whose
+ * description is the skill's and whose result is `instructions` plus any
+ * `files`. Only those descriptions are prompted, and a skill the model never
+ * reaches for costs a line of text.
+ *
+ * Lowering to a tool rather than to a synthetic `load_skill(name)` dispatcher
+ * is the whole trick: discovery is then the same mechanism as everything else
+ * the model chooses between, which means it runs on the provider's own
+ * tool-selection machinery instead of on a string argument gemi would have to
+ * validate, and a skill that is never loaded is a namespace entry rather than a
+ * branch in our code. It is also why `deferred` applies here unchanged — with
+ * tool search the namespace is searched, and without it the same tools are
+ * listed inline, which for zero-parameter functions costs almost nothing.
+ */
+export interface SkillDefinition<Name extends string = string> {
+    name: Name;
+    /** Read on every request — this is what the model decides to load from. */
     description: string;
-    inputSchema: Schema<T>;
-    outputSchema: Schema<U>;
-    execute: (_input: T) => Promise<Awaited<U>>;
-    deferred: boolean;
-    requiresApproval: boolean;
-    skipped: boolean;
-    static create<T, U>(params: IAgentTool<T, U>): AgentTool<T, U>;
-}
-interface CreateAgentParams<T extends AgentTool<any, any>[]> {
+    /** A thunk so a large body stays off the startup path and out of memory. */
+    instructions: string | (() => string | Promise<string>);
+    /** Paths resolved relative to the app root, appended after `instructions`. */
+    files?: string[];
+}
+export declare class Skill<Name extends string = string> {
+    readonly name: Name;
+    readonly description: string;
+    readonly instructions: string | (() => string | Promise<string>);
+    readonly files?: string[];
+    private constructor();
+    static create<const Name extends string>(params: SkillDefinition<Name>): Skill<Name>;
+}
+/** Reserved: a skill is lowered into a namespace of exactly this name. */
+export declare const SKILLS_NAMESPACE = "skills";
+export type ReasoningEffort = "minimal" | "low" | "medium" | "high";
+export interface CreateAgentParams<T extends readonly ToolEntry[], S extends readonly Skill[], O extends Schema<any> | undefined> {
     name: string;
-    tools: T;
+    /** The system prompt. Per-request additions belong on the controller, which
+     *  has the request; this is the part that is the same for everyone. */
+    instructions?: string;
+    provider: AgentProvider;
+    tools?: T;
+    /** Lowered into the reserved `skills` namespace — see `Skill`. The name is
+     *  reserved, so a namespace of your own cannot be called `skills`. */
+    skills?: S;
+    /**
+     * Makes the final assistant turn strict JSON instead of prose. Tool turns are
+     * unaffected — only the answer is constrained, which is the only place a
+     * schema can apply once there is a tool loop.
+     */
+    output?: O;
+    /** Ends the run with `finishReason: "max-steps"` rather than throwing: an
+     *  agent that loops is a bug to show, not an exception to swallow. */
+    maxSteps?: number;
+    /**
+     * How far `ctx.runAgent` may nest below this agent. Default 3.
+     *
+     * It is a limit on the *tree*, taken from the run at the root, so raising it
+     * on a sub-agent cannot deepen a run it did not start. A cycle is caught by
+     * the agent-name chain before this is reached — this is for the mutually
+     * recursive shape a name check cannot see, and for the merely runaway one.
+     */
+    maxDepth?: number;
+    reasoning?: ReasoningEffort;
+}
+/**
+ * One call per client turn — a first message and an answer to a pending
+ * approval take the same path, because they are the same thing: the next turn
+ * of a conversation.
+ */
+export interface AgentStreamParams {
+    /** Prior turns. The controller loads these from its store, or takes what the
+     *  client sent when running stateless. */
+    messages: AgentMessage[];
+    /** The client's turn: text, answers to pending calls, or both. */
+    turn?: ClientTurn;
+    req: HttpRequest<any, any>;
+    /** Aborted by an explicit `stop`, not by a disconnect. */
+    signal?: AbortSignal;
+    runId?: string;
+    threadId?: string;
+    /** Appended to the agent's own `instructions` for this request only. */
+    instructions?: string;
+    /** Per-request model choice, e.g. letting a user pick. */
+    provider?: AgentProvider;
+    maxSteps?: number;
+    reasoning?: ReasoningEffort;
+    /**
+     * Fires once for every message this run completes — the user's turn, each
+     * assistant turn, and any earlier message this turn amended by resolving a
+     * pending call. It is the controller's persistence point, and it fires
+     * whether or not anyone is still reading the stream, which is what makes a
+     * run that outlives its request useful.
+     *
+     * A message may be reported twice across runs under the same id when a
+     * pending call is resolved later; a store keyed by id should upsert.
+     */
+    onMessage?: (message: AgentMessage) => void | Promise<void>;
+    /**
+     * Set by `ctx.runAgent` and by nothing else.
+     *
+     * It rides on the public params rather than on a back door because
+     * `Agent.stream` is the only way to start a run and a sub-run is a run —
+     * giving nesting its own construction path would mean two places where a run
+     * is set up, and the second one would drift. Omitted, a run is a root: depth
+     * 0, no path, signatures over its own id.
+     */
+    nesting?: NestedContext;
+}
+/**
+ * Where a run sits inside a tree of runs. Carried down by `ctx.runAgent`.
+ *
+ * `signingRunId` and `signingPath` are the reason this is threaded rather than
+ * recomputed: a pending call a sub-agent raises is answered by the *client*,
+ * which only ever sees the root run, so the token has to be minted under the
+ * root's id and the sub-run's path from the start. Re-signing the token at each
+ * level on the way up would work too, and would throw away every signature but
+ * the outermost one — this way the run that asks the question is also the run
+ * that can check the answer, which is where the tool, its schema and its `kind`
+ * all already are.
+ */
+export type NestedContext = {
+    /** 0 at the root; `ctx.depth` inside a tool of this run. */
+    depth: number;
+    /** The `maxDepth` of the run at the root of the tree. */
+    maxDepth: number;
+    /** Agent names from the root down to and including this one, so a cycle can
+     *  be reported as the chain that caused it. */
+    chain: string[];
+    /** The root run's id: what a pending call raised here is signed under. */
+    signingRunId: string;
+    /** Tool-call ids from the root down to the call that started this run. */
+    signingPath: string[];
+    /**
+     * Inherited, and once it is `"deny"` it stays `"deny"` all the way down. A
+     * caller that asked for an autonomous sub-agent must not have a question
+     * surface from three levels below it, and the only way to promise that is to
+     * make the whole subtree refuse rather than to check at the top.
+     */
+    onPending: "escalate" | "deny";
+};
+export type AgentRunResult<T extends ToolShapes, O> = {
+    runId: string;
+    /** Everything produced this run — the controller persists these. */
+    messages: AgentMessage<T, O>[];
+    finishReason: FinishReason;
+    usage: Usage;
+    /** Set when the agent declares an `output` schema and the run finished. */
+    output?: O;
+};
+/**
+ * A run is an async iterable of events, and the SSE encoding is a method on it
+ * rather than a separate helper — so the same object serves a controller
+ * returning a `Response` and a server-side caller that just wants to await the
+ * result.
+ *
+ * A run keeps going when its request ends. That is what makes reattaching after
+ * a refresh possible, and it is why `stop()` is an explicit call rather than the
+ * client closing a socket.
+ */
+export interface AgentRun<T extends ToolShapes = ToolShapes, O = unknown> extends AsyncIterable<AgentStreamEvent<T, O>> {
+    readonly runId: string;
+    /** Numbered events, replayable from a cursor. `toResponse` is this, encoded. */
+    frames(from?: number): AsyncIterable<AgentStreamFrame<T, O>>;
+    toResponse(params?: {
+        from?: number;
+    }): Response;
+    result(): Promise<AgentRunResult<T, O>>;
+    /**
+     * Cancels the run and closes the conversation behind it: every tool call
+     * still in flight gets a `denied` result with `cause: "stopped"`, the
+     * assistant message is finalized with `finishReason: "aborted"`, and both go
+     * through `onMessage` like any other message.
+     *
+     * That last part is the point. A cancel that merely stops emitting leaves a
+     * history the provider will reject on the next turn, so the run's last act is
+     * to make the transcript valid — which is also what lets the user carry on
+     * talking instead of starting over.
+     */
+    stop(params?: {
+        reason?: string;
+    }): void;
 }
-export declare class Agent<const T extends AgentTool<any, any>[] = AgentTool<any, any>[]> {
-    tools: T;
-    skills: any[];
-    static create<const T extends AgentTool<any, any>[]>(params: CreateAgentParams<T>): Agent<T>;
-    stream(): void;
+export declare class Agent<T extends readonly ToolEntry[] = readonly ToolEntry[], S extends readonly Skill[] = readonly Skill[], O extends Schema<any> | undefined = undefined> {
+    readonly name: string;
+    readonly tools: T;
+    readonly skills: S;
+    readonly provider: AgentProvider;
+    readonly output: O;
+    readonly instructions?: string;
+    readonly maxSteps: number;
+    readonly maxDepth: number;
+    readonly reasoning?: ReasoningEffort;
+    private readonly config;
+    private constructor();
+    static create<const T extends readonly ToolEntry[], const S extends readonly Skill[], O extends Schema<any> | undefined = undefined>(params: CreateAgentParams<T, S, O>): Agent<T, S, O>;
+    stream(params: AgentStreamParams): AgentRun<ToolShapesOf<T>, OutputOf<O>>;
 }
+export type OutputOf<O> = O extends Schema<any> ? Infer<O> : never;
+export type AnyAgent = Agent<any, any, any>;
 export {};
 //# sourceMappingURL=Agent.d.ts.map

package/dist/ai/Agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Agent.d.ts","sourceRoot":"","sources":["../../ai/Agent.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC;AAE3B,UAAU,UAAU,CAAC,CAAC,EAAE,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IACxB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;IACtD,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,qBAAa,SAAS,CAAC,CAAC,EAAE,CAAC,CAAE,YAAW,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC;IACtD,IAAI,EAAE,MAAM,CAAM;IAClB,WAAW,SAAM;IACjB,WAAW,EAAS,MAAM,CAAC,CAAC,CAAC,CAAC;IAC9B,YAAY,EAAS,MAAM,CAAC,CAAC,CAAC,CAAC;IAC/B,OAAO,GAAI,QAAQ,CAAC,yBAA8B;IAClD,QAAQ,UAAQ;IAChB,gBAAgB,UAAQ;IACxB,OAAO,UAAS;IAEhB,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;CAW/D;AA8BD,UAAU,iBAAiB,CAAC,CAAC,SAAS,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,CAAC;CACV;AAED,qBAAa,KAAK,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;IAC9E,KAAK,EAAE,CAAC,CAAC;IACT,MAAM,EAAE,GAAG,EAAE,CAAC;IAEd,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAM5F,MAAM;CACP"}
+{"version":3,"file":"Agent.d.ts","sourceRoot":"","sources":["../../ai/Agent.ts"],"names":[],"mappings":"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"}

package/dist/ai/Agent.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Agent.test-d.d.ts.map

package/dist/ai/Agent.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Agent.test-d.d.ts","sourceRoot":"","sources":["../../ai/Agent.test-d.ts"],"names":[],"mappings":""}