@theokit/agents 4.23.0 → 4.24.0

package/dist/agent-handle-DNbFlkrw.d.ts

@@ -0,0 +1,227 @@
+import { ChatTransport, UIMessage, UIMessageChunk } from 'ai';
+
+/**
+ * M41 (ADR-0050 D2) — a HITL approval decision sent to settle a paused gated-tool call. Mirrors the
+ * `POST /api/agents/<name>/approve/<id>` wire body (`approve-agent.ts` `parseApprovalBody`). Defined
+ * on the client side (not imported from `server/`) as the client's view of the boundary contract.
+ */
+interface ApprovalDecision {
+    /** Whether the paused gated tool may proceed. */
+    approved: boolean;
+    /** Optional reason surfaced to the model on denial. */
+    reason?: string;
+    /** Optional small structured note (edited args, a reviewer comment) — capped server-side at 16 KiB. */
+    payload?: unknown;
+}
+/**
+ * M43 (ADR-0052) — per-request context attached uniformly across every transport.
+ *
+ * `headers` is the serializable, HTTP-native half (an auth token → request headers on `HttpTransport`);
+ * `metadata` is the structured, same-process half forwarded to the in-process runner
+ * (`InProcessTransport`) / the Tauri `invoke` (`ChannelTransport`). Threaded through the seam's existing
+ * `ChatRequestOptions` — NOT a new channel. The turn input stays the request `body`.
+ */
+interface RequestContext {
+    /** Per-request headers (e.g. auth). HTTP-native; mapped to request headers by `HttpTransport`. */
+    headers?: Record<string, string>;
+    /** Structured per-request context (tenant, provider, …) forwarded to in-process / channel runners. */
+    metadata?: unknown;
+}
+/**
+ * M41 (ADR-0050 D1/D2) — the client transport seam.
+ *
+ * It IS `ai`'s `ChatTransport<UIMessage>` (the adopted SOTA interface — we do NOT invent a parallel
+ * one) plus ONE optional method, `approve`, for TheoKit's OUT-OF-BAND HITL (the server pauses the run;
+ * the client settles it via a separate call). `ai`'s `ChatTransport` has no `approve` because its HITL
+ * is in-band (a re-sent message part); ours is out-of-band, and the settle route differs per transport
+ * (HTTP `POST /approve/<id>` vs an inline callback), so it belongs on the transport. `approve` is
+ * optional — agents without gated tools never settle an approval.
+ *
+ * `HttpTransport` (web) and `InProcessTransport` (TUI/desktop) implement this; `useAgent` drives it.
+ */
+type AgentTransport = ChatTransport<UIMessage> & {
+    approve?(approvalId: string, decision: ApprovalDecision): Promise<void>;
+};
+
+/** An inline approval request handed to the transport's resolver (structural — no server import). */
+interface InProcessApprovalRequestLike {
+    approvalId: string;
+    toolName: string;
+    opts: unknown;
+}
+/** Resolve one gated-tool approval inline (mirrors the SDK's `boolean | HitlDecision` return). */
+type InProcessAwaitApproval = (req: InProcessApprovalRequestLike) => Promise<boolean | ApprovalDecision>;
+/** The input the injected runner receives (structurally compatible with `StreamAgentTurnInProcessInput`). */
+interface InProcessRunInput {
+    message: string;
+    sessionId?: string;
+    signal?: AbortSignal;
+    awaitApproval?: InProcessAwaitApproval;
+    /** M43 — per-request context (from `sendMessages`'s `metadata`) — tenant / provider / auth for the runner. */
+    context?: unknown;
+}
+/**
+ * The in-process turn runner. The consumer binds `streamAgentTurnInProcess(mod, apiKey, …)`:
+ * `new InProcessTransport({ run: (input) => streamAgentTurnInProcess(mod, apiKey, input) })`.
+ * Injecting it keeps this client module decoupled from `server/` and makes the transport testable.
+ */
+type InProcessRunner = (input: InProcessRunInput) => AsyncGenerator<UIMessageChunk>;
+interface InProcessTransportOptions {
+    run: InProcessRunner;
+}
+/**
+ * M41 (ADR-0050 D4) — `ChatTransport` over the in-process seam (`streamAgentTurnInProcess`), for the
+ * terminal/desktop surfaces that run client + server in ONE process (no HTTP loopback).
+ *
+ * - `sendMessages`: bridge the injected runner's `AsyncGenerator<UIMessageChunk>` into a
+ *   `ReadableStream<UIMessageChunk>` (honoring `abortSignal`, which the runner forwards to the SDK).
+ * - `reconnectToStream`: always `null` — a single process has no dropped server-side stream to resume
+ *   (mirrors `ai`'s `DirectChatTransport`).
+ * - `approve`: resolve the pending inline approval by id (the run parks on `awaitApproval`). An unknown
+ *   id rejects (fail-fast, Rule 8 — never a silent resolve).
+ *
+ * Error asymmetry vs `HttpTransport` (by design, matching the `ChatTransport` contract): a runner that
+ * throws SYNCHRONOUSLY surfaces the error when the stream is READ (via `controller.error`), not from the
+ * `sendMessages` promise — whereas `HttpTransport` throws from `sendMessages` on a non-2xx response.
+ */
+declare class InProcessTransport implements AgentTransport {
+    #private;
+    constructor(options: InProcessTransportOptions);
+    sendMessages(options: Parameters<ChatTransport<UIMessage>['sendMessages']>[0]): Promise<ReadableStream<UIMessageChunk>>;
+    reconnectToStream(): Promise<ReadableStream<UIMessageChunk> | null>;
+    approve(approvalId: string, decision: ApprovalDecision): Promise<void>;
+}
+
+/** Handlers the transport hands to the injected push source for one turn. */
+interface ChannelTurnHandlers {
+    /** One pushed JSONL line (a serialized `UIMessageChunk`). */
+    onLine: (line: string) => void;
+    /** The turn ended — no more lines. */
+    onClose: () => void;
+    /** The push source failed. */
+    onError?: (err: unknown) => void;
+}
+/**
+ * The injected push source — a Tauri `Channel`/`invoke` bridge, kept STRUCTURAL so core adds no
+ * `@tauri-apps/*` dependency and the transport is testable with a fake (ADR-0051 D2). The Tauri app
+ * wires it: `new Channel()`, `channel.onmessage = onLine`, `invoke('run_agent', { message, channel })`,
+ * returning a teardown that aborts the sidecar turn.
+ */
+interface ChannelPushSource {
+    /**
+     * Start a turn; deliver each JSONL `UIMessageChunk` line to `onLine`, then `onClose`. Return a teardown.
+     * `turn.context` (M43) is the per-request context (from the seam's `metadata`) — the Tauri `invoke`
+     * forwards it to the sidecar. When no context is set it is present as `context: undefined` (the key is
+     * NOT absent) — a sidecar that checks `'context' in turn` should treat `undefined` as "no context".
+     */
+    start(turn: {
+        message: string;
+        context?: unknown;
+    }, handlers: ChannelTurnHandlers): () => void;
+    /** Optional HITL settle (another Tauri `invoke`). */
+    settle?(approvalId: string, decision: ApprovalDecision): Promise<void>;
+}
+interface ChannelTransportOptions {
+    source: ChannelPushSource;
+}
+/**
+ * M42 (ADR-0051) — `ChatTransport` over a Tauri-`Channel`-shaped push source, for the desktop webview.
+ *
+ * - `sendMessages`: start the turn via the injected source and bridge its pushed JSONL frames into a
+ *   `ReadableStream<UIMessageChunk>` (built in `start` — a Channel is push, so the stream's queue buffers
+ *   frames; ADR-0051 D3). A malformed JSONL line is SKIPPED, never fatal (ADR-0051 D4, Rule 8). `abortSignal`
+ *   tears down the source and closes the stream.
+ * - `reconnectToStream`: always `null` — the M36 sidecar runs the turn directly (no durable server stream);
+ *   this is the honest parity for a single-process push surface (ADR-0051 D5; mirrors `InProcessTransport`).
+ * - `approve`: routes to the injected `settle` (another Tauri `invoke`); absent `settle` → a typed error.
+ *
+ * The push source is INJECTED — core stays Tauri-agnostic and this transport is unit-tested with a fake.
+ */
+declare class ChannelTransport implements AgentTransport {
+    #private;
+    constructor(options: ChannelTransportOptions);
+    sendMessages(options: Parameters<ChatTransport<UIMessage>['sendMessages']>[0]): Promise<ReadableStream<UIMessageChunk>>;
+    reconnectToStream(): Promise<ReadableStream<UIMessageChunk> | null>;
+    approve(approvalId: string, decision: ApprovalDecision): Promise<void>;
+}
+
+type UseAgentStatus = 'idle' | 'streaming' | 'done' | 'error';
+/** The observable state the store exposes (stable reference between emits — `useSyncExternalStore` contract). */
+interface AgentClientState {
+    /** The CURRENT turn's assistant messages (per-turn; reset each `send`). Back-compat — unchanged since M41. */
+    messages: UIMessage[];
+    /**
+     * M46 — the full conversation: committed turns + the current turn's user message + in-flight assistant.
+     * Accumulated across sends (never reset except by `reset()`), with stable ids committed exactly once.
+     * Render this instead of hand-rolling a transcript from `messages`.
+     */
+    thread: UIMessage[];
+    status: UseAgentStatus;
+    error: Error | undefined;
+}
+/**
+ * M41 (ADR-0050 D6) — the framework-agnostic agent client store.
+ *
+ * Holds `messages`/`status`/`error`, drives an {@link AgentTransport}, and notifies subscribers on
+ * change. It is the SINGLE consolidation point: web (`HttpTransport`) and terminal/desktop
+ * (`InProcessTransport`) run the SAME store. `useAgent` is a thin React binding over it via
+ * `useSyncExternalStore`; a standalone (no-React) client (M44) can subscribe directly. Being
+ * framework-agnostic, it is unit-tested without a DOM.
+ */
+declare class AgentClient<TInput = unknown> {
+    #private;
+    constructor(transport: AgentTransport, contextResolver?: () => RequestContext | undefined);
+    /** Subscribe to state changes; returns an unsubscribe fn. */
+    subscribe: (listener: () => void) => (() => void);
+    /** The current immutable snapshot (stable reference until the next emit). */
+    getSnapshot: () => AgentClientState;
+    /** Send a typed input; opens a fresh stream (replaces prior messages). */
+    send: (input: TInput) => void;
+    /** Resume an interrupted stream via the transport's `reconnectToStream` (no-op when unavailable). */
+    reconnect: () => void;
+    /** Abort an in-flight stream (not an error — leaves messages as-is). */
+    abort: () => void;
+    /** Clear messages + error, back to idle. */
+    reset: () => void;
+    /** Settle a paused HITL approval via the transport's HITL path (HTTP POST or inline callback). */
+    approve: (approvalId: string, decision: ApprovalDecision) => Promise<void>;
+}
+
+/**
+ * M47 (ADR-M47-2) — a typed, client-safe handle for an exposed agent.
+ *
+ * It carries ONLY the HTTP `path` at runtime plus phantom `input`/`toolNames` types (never populated) — so
+ * `useAgent(chat)` / `createAgentClient(chat…)` bind with NO magic string (the path is generated from the
+ * `@Expose` exposure, not hand-typed) and NO duplicated input type (the input type flows through the phantom
+ * generic, inferred from the agent's `.input()`). This mirrors tRPC/Hono's type-only handle: the client
+ * pulls the agent's TYPE via `import type`, never its server runtime. The generated `@theo/agents` module
+ * emits one `export const <name> = agentHandle('/api/agents/<name>')` per agent, typed with the phantoms.
+ */
+interface AgentHandle<TInput = unknown, TToolNames extends string = string> {
+    /** The agent's HTTP endpoint path (e.g. `/api/agents/chat`). The only serializable/runtime-bearing field. */
+    readonly path: string;
+    /**
+     * M47 — bind this agent in-process (TUI / single-process): wraps the app's runner in an
+     * {@link InProcessTransport}. `useAgent(chat.inProcess(run))` drives the SAME agent without HTTP.
+     */
+    inProcess(run: InProcessRunner): InProcessTransport;
+    /**
+     * M47 — bind this agent over a push channel (Tauri desktop webview): wraps the source in a
+     * {@link ChannelTransport}. `createAgentClient(chat.channel(source))` drives the SAME agent.
+     */
+    channel(source: ChannelPushSource): ChannelTransport;
+    /** Phantom — the agent's `input` type, carried for `useAgent(handle).send` inference. Never populated. */
+    readonly __input?: TInput;
+    /** Phantom — the agent's tool-name union, carried end-to-end. Never populated. */
+    readonly __toolNames?: TToolNames;
+}
+/**
+ * Build an {@link AgentHandle} from an agent's HTTP path. Types are supplied by the caller/codegen. The
+ * `inProcess`/`channel` binders are methods (dropped by `JSON.stringify`, so the `{ path }` core stays
+ * serializable + client-safe) that produce the M41 transports for the non-web surfaces.
+ */
+declare function agentHandle<TInput = unknown, TToolNames extends string = string>(path: string): AgentHandle<TInput, TToolNames>;
+/** Narrow an unknown binding to an {@link AgentHandle} (has a string `path`, is not a transport). */
+declare function isAgentHandle(value: unknown): value is AgentHandle;
+
+export { type ApprovalDecision as A, type ChannelPushSource as C, type InProcessApprovalRequestLike as I, type RequestContext as R, type UseAgentStatus as U, type AgentHandle as a, type AgentTransport as b, AgentClient as c, type AgentClientState as d, ChannelTransport as e, type ChannelTransportOptions as f, type ChannelTurnHandlers as g, type InProcessAwaitApproval as h, type InProcessRunInput as i, type InProcessRunner as j, InProcessTransport as k, type InProcessTransportOptions as l, agentHandle as m, isAgentHandle as n };

package/dist/{bridge-entry-DMh--RZ5.d.ts → bridge-entry-Cq1aVJ_c.d.ts}

@@ -1,5 +1,5 @@
 import { ExecutionContext } from '@theokit/http';
-import { SystemPromptResolver, InlineSkill, SettingSource, MemorySettings, SkillsSettings, ContextSettings, CustomTool, PluginsSettings, Plugin, ProviderRoutingSettings, AgentDefinition as AgentDefinition$1, BudgetTracker, ModelSelection, PreToolCallContext, PreToolCallDecision, PostToolCallContext, ToolResultTransformContext, TransformContext, SessionLifecycleContext, PreUserSendContext, PreUserSendResult, PostAssistantReplyContext } from '@theokit/sdk';
+import { SystemPromptResolver, InlineSkill, SettingSource, MemorySettings, SkillsSettings, ContextSettings, PreToolCallContext, PreToolCallDecision, PostToolCallContext, ToolResultTransformContext, TransformContext, SessionLifecycleContext, PreUserSendContext, PreUserSendResult, PostAssistantReplyContext, CustomTool, PluginsSettings, Plugin, ProviderRoutingSettings, AgentDefinition as AgentDefinition$1, BudgetTracker, ModelSelection } from '@theokit/sdk';
 import { z } from 'zod';
 import { UIMessageChunk } from 'ai';
 import { RetryOptions } from '@theokit/sdk/retry';
@@ -721,6 +721,59 @@ interface AgentRouteContext {
 /** Generate HTTP routes for a single agent. Returns Web Standard handlers. */
 declare function generateAgentRoutes(ctx: AgentRouteContext): AgentRoute[];
 
+/**
+ * M82 — the typed shape of `AgentBuilder.create().hooks({...})`.
+ *
+ * ## Por que este tipo mora aqui
+ *
+ * Até o M82 a assinatura era `Readonly<Record<string, unknown>>`: qualquer chave era aceita e cada
+ * handler recebia `ctx: unknown`. O consumidor que quisesse tipo tinha de declarar o seu — e foi
+ * exatamente o que o agent-builder fez, com um alias local de cinco handlers, quatro deles com
+ * `ctx: unknown` porque não havia de onde importar os contextos.
+ *
+ * É a mesma classe que o M81 fechou com `discoverSubagents`: conhecimento do framework reimplementado
+ * no app porque o framework não o publicava. O tipo nasce onde o conhecimento mora.
+ *
+ * ## Sobre `transform_tool_result`
+ *
+ * Este é o ÚNICO canal de estágio-de-tool cujo retorno o SDK aplica — `#runTransform` dobra o valor
+ * devolvido; `#runFireAndForget`, usado por `post_tool_call`, descarta. Desde o M82 seu contexto
+ * carrega `toolCalls`, de modo que uma política com escopo (por nome de tool) possa AGIR sobre o
+ * resultado em vez de apenas observá-lo.
+ */
+
+/**
+ * Handlers de ciclo de vida chaveados por `HookName`.
+ *
+ * Cada campo é opcional: um agente registra só os eventos que lhe interessam. `.hooks()` aceita a
+ * UNIÃO deste tipo com o shape solto de antes (ADR-4 do M82), então não é preciso index signature
+ * implícita para o valor passar no call site — o estreitamento é gradual, não uma quebra.
+ */
+interface HookHandlers {
+    /**
+     * Roda ANTES da tool. Devolver `{ block: true, message }` VETA a chamada — é o único hook com
+     * poder de veto.
+     */
+    pre_tool_call?: (ctx: PreToolCallContext) => Promise<PreToolCallDecision | undefined> | PreToolCallDecision | undefined;
+    /**
+     * Roda DEPOIS da tool, com `{name, args, result}`. Fire-and-forget: o retorno é **descartado**
+     * pelo SDK. Para AGIR sobre o resultado use {@link transform_tool_result}.
+     */
+    post_tool_call?: (ctx: PostToolCallContext) => Promise<void> | void;
+    /**
+     * Dobra os resultados de tool do turn antes de eles subirem ao modelo. Desde o M82 o contexto traz
+     * `toolCalls` — plural, porque o seam recebe o LOTE do turn; correlacione por
+     * `toolUseId === id`.
+     */
+    transform_tool_result?: <T>(results: T, ctx: ToolResultTransformContext) => Promise<T> | T;
+    /** Dobra o texto do modelo antes de ele ser consumido. Sem tool call envolvida. */
+    transform_llm_output?: (output: string, ctx: TransformContext) => Promise<string> | string;
+    on_session_start?: (ctx: SessionLifecycleContext) => Promise<void> | void;
+    on_session_end?: (ctx: SessionLifecycleContext) => Promise<void> | void;
+    pre_user_send?: (ctx: PreUserSendContext) => Promise<PreUserSendResult | undefined> | PreUserSendResult | undefined;
+    post_assistant_reply?: (ctx: PostAssistantReplyContext) => Promise<void> | void;
+}
+
 /**
  * M2 (theokit-ai-first) — `defineAgent`, the zero-config imperative agent surface.
  *
@@ -810,7 +863,7 @@ interface DefineAgentConfig<TInput extends z.ZodType = z.ZodType> {
      * the builder's `hooks()`; converted into a code plugin at `build()` and never reaching the SDK
      * under this name — the plugin is the TRANSPORT, this is the contract callers write against.
      */
-    hooks?: Readonly<Record<string, unknown>>;
+    hooks?: HookHandlers | Readonly<Record<string, unknown>>;
     /**
      * MCP servers available to the agent — the builder-chain equivalent of the `@MCP` class
      * decorator. Each key is a server name; the value is the server configuration. Forwarded
@@ -1058,61 +1111,6 @@ declare function presentUIMessageStream(events: AsyncIterable<AgentStreamEvent>,
     textId: string;
 }): AsyncGenerator<UIMessageChunk, void, unknown>;
 
-/**
- * M82 — the typed shape of `AgentBuilder.create().hooks({...})`.
- *
- * ## Por que este tipo mora aqui
- *
- * Até o M82 a assinatura era `Readonly<Record<string, unknown>>`: qualquer chave era aceita e todo
- * handler recebia `ctx: unknown`. O consumidor que quisesse tipo tinha de declarar o seu — e foi
- * exatamente o que o agent-builder fez, com um alias local de cinco handlers, quatro deles com
- * `ctx: unknown` porque não havia de onde importar os contextos.
- *
- * É a mesma classe que o M81 fechou com `discoverSubagents`: conhecimento do framework reimplementado
- * no app porque o framework não o publicava. O tipo nasce onde o conhecimento mora.
- *
- * ## Sobre `transform_tool_result`
- *
- * Este é o ÚNICO canal de estágio-de-tool cujo retorno o SDK aplica — `#runTransform` dobra o valor
- * devolvido; `#runFireAndForget`, usado por `post_tool_call`, descarta. Desde o M82 seu contexto
- * carrega `toolCalls`, de modo que uma política com escopo (por nome de tool) possa AGIR sobre o
- * resultado em vez de apenas observá-lo.
- */
-
-/**
- * Handlers de ciclo de vida chaveados por `HookName`.
- *
- * TYPE ALIAS, não interface: só aliases ganham index signature implícita, e é isso que mantém o
- * valor atribuível ao parâmetro solto de `.hooks()` sem cast no call site (ADR-4 do M82 — o
- * estreitamento é gradual, não uma quebra).
- *
- * Todo campo é opcional: um agente registra só os eventos que lhe interessam.
- */
-type HookHandlers = {
-    /**
-     * Roda ANTES da tool. Devolver `{ block: true, message }` VETA a chamada — é o único hook com
-     * poder de veto.
-     */
-    pre_tool_call?: (ctx: PreToolCallContext) => Promise<PreToolCallDecision | undefined> | PreToolCallDecision | undefined;
-    /**
-     * Roda DEPOIS da tool, com `{name, args, result}`. Fire-and-forget: o retorno é **descartado**
-     * pelo SDK. Para AGIR sobre o resultado use {@link transform_tool_result}.
-     */
-    post_tool_call?: (ctx: PostToolCallContext) => Promise<void> | void;
-    /**
-     * Dobra os resultados de tool do turn antes de eles subirem ao modelo. Desde o M82 o contexto traz
-     * `toolCalls` — plural, porque o seam recebe o LOTE do turn; correlacione por
-     * `toolUseId === id`.
-     */
-    transform_tool_result?: <T>(results: T, ctx: ToolResultTransformContext) => Promise<T> | T;
-    /** Dobra o texto do modelo antes de ele ser consumido. Sem tool call envolvida. */
-    transform_llm_output?: (output: string, ctx: TransformContext) => Promise<string> | string;
-    on_session_start?: (ctx: SessionLifecycleContext) => Promise<void> | void;
-    on_session_end?: (ctx: SessionLifecycleContext) => Promise<void> | void;
-    pre_user_send?: (ctx: PreUserSendContext) => Promise<PreUserSendResult | undefined> | PreUserSendResult | undefined;
-    post_assistant_reply?: (ctx: PostAssistantReplyContext) => Promise<void> | void;
-};
-
 /**
  * M8 — `AgentBuilder.create()`, the fluent agent builder with accumulative **type-state**.
  *
@@ -2111,4 +2109,4 @@ declare function agentsPlugin(opts: AgentsPluginOptions): {
     register(app: PluginApp): void;
 };
 
-export { type FileEditEvent as $, type ApprovalOptions as A, type ArtifactChunkEvent as B, type CompiledAgentOptions as C, type DelegationResult as D, type ArtifactStartEvent as E, type BackgroundDelegation as F, type Guardrail as G, type HumanInTheLoopOptions as H, type BeforeToolCallContext as I, BudgetExceededError as J, type BudgetOptions as K, type LoopStrategy as L, type MainLoopMeta as M, type CheckpointSavedEvent as N, type CompiledContextWindow as O, ContextualTool as P, CostBudgetExceededError as Q, type ReflectionStrategy as R, type StreamEvent as S, type ToolOptions as T, DEFAULT_MAX_ITERATIONS as U, type DefineAgentConfig as V, type DelegateFn as W, type DelegateOptions as X, DelegationError as Y, type DoneEvent as Z, type ErrorEvent as _, type CompiledTool as a, generateAgentRoutes as a$, type GuardrailAction as a0, type GuardrailPhase as a1, type GuardrailResult as a2, GuardrailViolationError as a3, type HitlDecision as a4, type HookHandlers as a5, type InferAgentInput as a6, type InferAgentToolNames as a7, type IterationEvent as a8, type LLMCallContext as a9, type TimeoutAction as aA, type ToolCallEvent as aB, type ToolCallVeto as aC, type ToolHooks as aD, type ToolHooksPlugin as aE, type ToolResultEvent as aF, type ToolWalkResult as aG, type ToolboxOptions as aH, type ToolboxWalkResult as aI, agentsPlugin as aJ, buildModelSelection as aK, compileAgentDefinition as aL, compileAgentModule as aM, compileContextWindow as aN, compileProjectContext as aO, compileSkills as aP, compileTools as aQ, createAgentExecutionContext as aR, createApiErrorHandler as aS, createSdkAgentStream as aT, createThinkTagExtractor as aU, createToolHooksPlugin as aV, delegate as aW, delegateBackground as aX, delegateWithScoring as aY, extractThinkTagStream as aZ, generateAgentManifest as a_, type LoopFinishReason as aa, type LoopOutcome as ab, type LoopStrategyConfig as ac, type MainLoopOptions as ad, type McpApprovalSpec as ae, type McpRegistryConfig as af, type McpRequestContext as ag, type McpSelection as ah, type PartialToolCallEvent as ai, type PolicyHandler as aj, type ProcessInputContext as ak, type ReflectionContext as al, type ReflectionResult as am, type ReflectionStrategyConfig as an, type RunStartedEvent as ao, type ScoreVerdict as ap, type ScoredDelegation as aq, type Scorer as ar, type SdkAgentHandle as as, type SdkMessage as at, type Segment as au, type SkillsRequestContext as av, type SkillsSelection as aw, type StateUpdateEvent as ax, type TextDeltaEvent as ay, type ThinkingEvent as az, type ReasoningEffort as b, isAgentContext as b0, isAgentDefinition as b1, isApprovalRequired as b2, isDone as b3, isError as b4, isPartialToolCall as b5, isTextDelta as b6, isToolCall as b7, isToolResult as b8, ladderReflectionStrategy as b9, loopStrategyConfigSchema as ba, mcpRegistry as bb, mcpToolApprovals as bc, noopReflectionStrategy as bd, presentUIMessageStream as be, projectContextMetadataOnlyKnobs as bf, reflectionStrategyConfigSchema as bg, resolveEnabledSkills as bh, resolveLoopStrategy as bi, resolveMcpServers as bj, runWithApiErrorHandling as bk, streamAgentResponse as bl, streamAgentUIMessages as bm, toAgentFactory as bn, translateSdkEvent as bo, type RoundStreamFactory as c, type ContextWindowOptions as d, type SkillsOptions as e, type AgentManifestEntry as f, AGENT_BRAND as g, type AfterToolCallContext as h, AgentBuilder as i, type AgentDefinition as j, AgentDefinitionError as k, type AgentExecutionContext as l, type AgentManifest as m, type AgentManifestSource as n, type AgentManifestTool as o, type AgentOptions as p, type AgentRoute as q, type AgentRouteContext as r, type AgentRunInfo as s, type AgentStreamEvent as t, type AgentTurnMetadata as u, type AgentsPluginOptions as v, type ApiErrorContext as w, type ApiErrorDecision as x, type ApiErrorPolicy as y, type ApprovalRequiredEvent as z };
+export { type DoneEvent as $, type ApprovalOptions as A, type ApiErrorPolicy as B, type CompiledAgentOptions as C, type DelegationResult as D, type ApprovalRequiredEvent as E, type ArtifactChunkEvent as F, type Guardrail as G, type HumanInTheLoopOptions as H, type ArtifactStartEvent as I, type BackgroundDelegation as J, type BeforeToolCallContext as K, type LoopStrategy as L, type MainLoopMeta as M, BudgetExceededError as N, type BudgetOptions as O, type CheckpointSavedEvent as P, type CompiledContextWindow as Q, type ReflectionStrategy as R, type StreamEvent as S, type ToolOptions as T, ContextualTool as U, CostBudgetExceededError as V, DEFAULT_MAX_ITERATIONS as W, type DefineAgentConfig as X, type DelegateFn as Y, type DelegateOptions as Z, DelegationError as _, type CompiledTool as a, generateAgentManifest as a$, type ErrorEvent as a0, type FileEditEvent as a1, type GuardrailAction as a2, type GuardrailPhase as a3, type GuardrailResult as a4, GuardrailViolationError as a5, type HookHandlers as a6, type InferAgentInput as a7, type InferAgentToolNames as a8, type IterationEvent as a9, type ThinkingEvent as aA, type TimeoutAction as aB, type ToolCallEvent as aC, type ToolCallVeto as aD, type ToolHooks as aE, type ToolHooksPlugin as aF, type ToolResultEvent as aG, type ToolWalkResult as aH, type ToolboxOptions as aI, type ToolboxWalkResult as aJ, agentsPlugin as aK, buildModelSelection as aL, compileAgentDefinition as aM, compileAgentModule as aN, compileContextWindow as aO, compileProjectContext as aP, compileSkills as aQ, compileTools as aR, createAgentExecutionContext as aS, createApiErrorHandler as aT, createSdkAgentStream as aU, createThinkTagExtractor as aV, createToolHooksPlugin as aW, delegate as aX, delegateBackground as aY, delegateWithScoring as aZ, extractThinkTagStream as a_, type LLMCallContext as aa, type LoopFinishReason as ab, type LoopOutcome as ac, type LoopStrategyConfig as ad, type MainLoopOptions as ae, type McpApprovalSpec as af, type McpRegistryConfig as ag, type McpRequestContext as ah, type McpSelection as ai, type PartialToolCallEvent as aj, type PolicyHandler as ak, type ProcessInputContext as al, type ReflectionContext as am, type ReflectionResult as an, type ReflectionStrategyConfig as ao, type RunStartedEvent as ap, type ScoreVerdict as aq, type ScoredDelegation as ar, type Scorer as as, type SdkAgentHandle as at, type SdkMessage as au, type Segment as av, type SkillsRequestContext as aw, type SkillsSelection as ax, type StateUpdateEvent as ay, type TextDeltaEvent as az, type ReasoningEffort as b, generateAgentRoutes as b0, isAgentContext as b1, isAgentDefinition as b2, isApprovalRequired as b3, isDone as b4, isError as b5, isPartialToolCall as b6, isTextDelta as b7, isToolCall as b8, isToolResult as b9, ladderReflectionStrategy as ba, loopStrategyConfigSchema as bb, mcpRegistry as bc, mcpToolApprovals as bd, noopReflectionStrategy as be, presentUIMessageStream as bf, projectContextMetadataOnlyKnobs as bg, reflectionStrategyConfigSchema as bh, resolveEnabledSkills as bi, resolveLoopStrategy as bj, resolveMcpServers as bk, runWithApiErrorHandling as bl, streamAgentResponse as bm, toAgentFactory as bn, translateSdkEvent as bo, type RoundStreamFactory as c, type ContextWindowOptions as d, type SkillsOptions as e, type AgentManifestEntry as f, type HitlDecision as g, AGENT_BRAND as h, type AfterToolCallContext as i, AgentBuilder as j, type AgentDefinition as k, AgentDefinitionError as l, type AgentExecutionContext as m, type AgentManifest as n, type AgentManifestSource as o, type AgentManifestTool as p, type AgentOptions as q, type AgentRoute as r, streamAgentUIMessages as s, type AgentRouteContext as t, type AgentRunInfo as u, type AgentStreamEvent as v, type AgentTurnMetadata as w, type AgentsPluginOptions as x, type ApiErrorContext as y, type ApiErrorDecision as z };

package/dist/bridge.d.ts

@@ -1,4 +1,4 @@
-export { g as AGENT_BRAND, h as AfterToolCallContext, i as AgentBuilder, j as AgentDefinition, k as AgentDefinitionError, l as AgentExecutionContext, m as AgentManifest, f as AgentManifestEntry, n as AgentManifestSource, o as AgentManifestTool, q as AgentRoute, r as AgentRouteContext, s as AgentRunInfo, t as AgentStreamEvent, u as AgentTurnMetadata, v as AgentsPluginOptions, w as ApiErrorContext, x as ApiErrorDecision, y as ApiErrorPolicy, z as ApprovalRequiredEvent, B as ArtifactChunkEvent, E as ArtifactStartEvent, F as BackgroundDelegation, I as BeforeToolCallContext, J as BudgetExceededError, N as CheckpointSavedEvent, C as CompiledAgentOptions, O as CompiledContextWindow, a as CompiledTool, P as ContextualTool, V as DefineAgentConfig, W as DelegateFn, X as DelegateOptions, Y as DelegationError, D as DelegationResult, Z as DoneEvent, _ as ErrorEvent, $ as FileEditEvent, a6 as InferAgentInput, a7 as InferAgentToolNames, a8 as IterationEvent, a9 as LLMCallContext, ae as McpApprovalSpec, af as McpRegistryConfig, ag as McpRequestContext, ah as McpSelection, ai as PartialToolCallEvent, ak as ProcessInputContext, ao as RunStartedEvent, ap as ScoreVerdict, aq as ScoredDelegation, ar as Scorer, as as SdkAgentHandle, at as SdkMessage, au as Segment, ax as StateUpdateEvent, S as StreamEvent, ay as TextDeltaEvent, az as ThinkingEvent, aB as ToolCallEvent, aC as ToolCallVeto, aD as ToolHooks, aE as ToolHooksPlugin, aF as ToolResultEvent, aG as ToolWalkResult, aI as ToolboxWalkResult, aJ as agentsPlugin, aK as buildModelSelection, aL as compileAgentDefinition, aM as compileAgentModule, aN as compileContextWindow, aO as compileProjectContext, aP as compileSkills, aQ as compileTools, aR as createAgentExecutionContext, aS as createApiErrorHandler, aT as createSdkAgentStream, aU as createThinkTagExtractor, aV as createToolHooksPlugin, aW as delegate, aX as delegateBackground, aY as delegateWithScoring, aZ as extractThinkTagStream, a_ as generateAgentManifest, a$ as generateAgentRoutes, b0 as isAgentContext, b1 as isAgentDefinition, b2 as isApprovalRequired, b3 as isDone, b4 as isError, b5 as isPartialToolCall, b6 as isTextDelta, b7 as isToolCall, b8 as isToolResult, bb as mcpRegistry, bc as mcpToolApprovals, be as presentUIMessageStream, bf as projectContextMetadataOnlyKnobs, bj as resolveMcpServers, bk as runWithApiErrorHandling, bl as streamAgentResponse, bm as streamAgentUIMessages, bn as toAgentFactory, bo as translateSdkEvent } from './bridge-entry-DMh--RZ5.js';
+export { h as AGENT_BRAND, i as AfterToolCallContext, j as AgentBuilder, k as AgentDefinition, l as AgentDefinitionError, m as AgentExecutionContext, n as AgentManifest, f as AgentManifestEntry, o as AgentManifestSource, p as AgentManifestTool, r as AgentRoute, t as AgentRouteContext, u as AgentRunInfo, v as AgentStreamEvent, w as AgentTurnMetadata, x as AgentsPluginOptions, y as ApiErrorContext, z as ApiErrorDecision, B as ApiErrorPolicy, E as ApprovalRequiredEvent, F as ArtifactChunkEvent, I as ArtifactStartEvent, J as BackgroundDelegation, K as BeforeToolCallContext, N as BudgetExceededError, P as CheckpointSavedEvent, C as CompiledAgentOptions, Q as CompiledContextWindow, a as CompiledTool, U as ContextualTool, X as DefineAgentConfig, Y as DelegateFn, Z as DelegateOptions, _ as DelegationError, D as DelegationResult, $ as DoneEvent, a0 as ErrorEvent, a1 as FileEditEvent, a7 as InferAgentInput, a8 as InferAgentToolNames, a9 as IterationEvent, aa as LLMCallContext, af as McpApprovalSpec, ag as McpRegistryConfig, ah as McpRequestContext, ai as McpSelection, aj as PartialToolCallEvent, al as ProcessInputContext, ap as RunStartedEvent, aq as ScoreVerdict, ar as ScoredDelegation, as as Scorer, at as SdkAgentHandle, au as SdkMessage, av as Segment, ay as StateUpdateEvent, S as StreamEvent, az as TextDeltaEvent, aA as ThinkingEvent, aC as ToolCallEvent, aD as ToolCallVeto, aE as ToolHooks, aF as ToolHooksPlugin, aG as ToolResultEvent, aH as ToolWalkResult, aJ as ToolboxWalkResult, aK as agentsPlugin, aL as buildModelSelection, aM as compileAgentDefinition, aN as compileAgentModule, aO as compileContextWindow, aP as compileProjectContext, aQ as compileSkills, aR as compileTools, aS as createAgentExecutionContext, aT as createApiErrorHandler, aU as createSdkAgentStream, aV as createThinkTagExtractor, aW as createToolHooksPlugin, aX as delegate, aY as delegateBackground, aZ as delegateWithScoring, a_ as extractThinkTagStream, a$ as generateAgentManifest, b0 as generateAgentRoutes, b1 as isAgentContext, b2 as isAgentDefinition, b3 as isApprovalRequired, b4 as isDone, b5 as isError, b6 as isPartialToolCall, b7 as isTextDelta, b8 as isToolCall, b9 as isToolResult, bc as mcpRegistry, bd as mcpToolApprovals, bf as presentUIMessageStream, bg as projectContextMetadataOnlyKnobs, bk as resolveMcpServers, bl as runWithApiErrorHandling, bm as streamAgentResponse, s as streamAgentUIMessages, bn as toAgentFactory, bo as translateSdkEvent } from './bridge-entry-Cq1aVJ_c.js';
 import '@theokit/http';
 import '@theokit/sdk';
 import 'zod';

package/dist/bridge.js

@@ -43,7 +43,7 @@ import {
   streamAgentUIMessages,
   toAgentFactory,
   translateSdkEvent
-} from "./chunk-IB7I44PO.js";
+} from "./chunk-2L5DI75P.js";
 import "./chunk-7QVYU63E.js";
 export {
   AGENT_BRAND,

package/dist/{chunk-IB7I44PO.js → chunk-2L5DI75P.js}

@@ -3508,4 +3508,4 @@ export {
   generateAgentManifest,
   agentsPlugin
 };
-//# sourceMappingURL=chunk-IB7I44PO.js.map
+//# sourceMappingURL=chunk-2L5DI75P.js.map