@standardagents/spec 0.21.0 → 0.22.0

package/dist/index.d.ts

@@ -191,6 +191,70 @@ declare function defineEffect<State = ThreadState, Args extends ToolArgs = ToolA
  */
 declare function defineEffect<State = ThreadState>(description: string, handler: Effect<State, null>): EffectDefinition<State, null>;
 
+/**
+ * Agent Skills — instance-global skill store types.
+ *
+ * Skills follow the Agent Skills standard (https://agentskills.io): a folder
+ * whose root SKILL.md opens with YAML frontmatter carrying a required `name`
+ * (lowercase kebab, ≤64 chars) and `description` (≤1024 chars), optionally
+ * accompanied by scripts, references, and assets.
+ *
+ * Runtimes store skills server-side as a GLOBAL, instance-wide library:
+ * installed once, visible to every thread, nothing persisted on a client
+ * machine. Progressive disclosure is the contract — agents see only each
+ * skill's name + description until a skill is judged applicable, at which
+ * point they load its SKILL.md body (and, when needed, read or execute its
+ * bundled files).
+ */
+/** Registry view of an installed skill (metadata only — no file contents). */
+interface SkillMetadata {
+    /** Kebab-case identifier from SKILL.md frontmatter. */
+    name: string;
+    /** What the skill does and when to use it (from frontmatter). */
+    description: string;
+    /** Optional version string from frontmatter. */
+    version?: string;
+    /** Disabled skills stay installed but are hidden from agents. */
+    enabled: boolean;
+    /** Relative paths of the skill's files (always includes SKILL.md). */
+    files: string[];
+    /** Unix seconds of the last install/update. */
+    updatedAt?: number;
+}
+/** A file being installed into a skill (relative path + full text). */
+interface SkillFileInput {
+    path: string;
+    content: string;
+}
+/**
+ * ThreadState surface for the global skill library. All operations hit the
+ * instance-wide store — there is no per-thread skill state beyond what a
+ * thread chooses to keep in its own key-value store.
+ */
+interface SkillsNamespace {
+    /** Installed skills (enabled only, unless includeDisabled). */
+    list(options?: {
+        includeDisabled?: boolean;
+    }): Promise<SkillMetadata[]>;
+    /** A skill's metadata plus its SKILL.md source (null when not installed). */
+    get(name: string): Promise<{
+        metadata: SkillMetadata;
+        skillMd: string;
+    } | null>;
+    /** Read one bundled file's text (null when the skill or file is missing). */
+    readFile(name: string, path: string): Promise<string | null>;
+    /**
+     * Install (or replace) a skill from its file set. The file set must include
+     * a root SKILL.md with valid frontmatter; the skill's identity comes from
+     * that frontmatter, never from a caller-supplied name.
+     */
+    install(files: SkillFileInput[]): Promise<SkillMetadata>;
+    /** Enable/disable an installed skill. Returns false when not installed. */
+    setEnabled(name: string, enabled: boolean): Promise<boolean>;
+    /** Uninstall a skill entirely. Returns false when not installed. */
+    remove(name: string): Promise<boolean>;
+}
+
 /**
  * Thread state types for Standard Agents.
  *
@@ -207,6 +271,21 @@ declare function defineEffect<State = ThreadState>(description: string, handler:
  * This represents the core identity of a thread, separate from its
  * operational state. Thread metadata is immutable after creation.
  */
+/**
+ * The profile of the user a thread belongs to, as exposed by
+ * {@link ThreadState.user}. Identity fields only — never credentials.
+ */
+interface ThreadUser {
+    id: string;
+    username: string;
+    /** 'admin' | 'user' | 'api' in the reference runtime. */
+    role: string;
+    /** Explicit permission grants (runtime-defined strings), if any. */
+    permissions?: string[] | null;
+    email?: string | null;
+    display_name?: string | null;
+    avatar_url?: string | null;
+}
 interface ThreadMetadata {
     /** Unique identifier for the thread */
     id: string;
@@ -380,6 +459,51 @@ interface MessageUpdates {
     /** Updated metadata (merged with existing) */
     metadata?: Record<string, unknown>;
 }
+/**
+ * A streamed fragment of an assistant message's *visible content*.
+ *
+ * Always broadcast (no opt-in). Clients accumulate `chunk`s by `message_id` to
+ * render the answer as it generates; the authoritative final content still
+ * arrives separately as a persisted message.
+ */
+interface ThreadMessageChunkEvent {
+    type: 'message_chunk';
+    /** The assistant message these fragments belong to. */
+    message_id: string;
+    /** Message depth: 0 = top-level thread, 1+ = subagent. */
+    depth: number;
+    /** The next fragment of visible content. */
+    chunk: string;
+}
+/**
+ * A streamed fragment of a model's *internal reasoning* (chain-of-thought).
+ *
+ * OPT-IN. Unlike content, reasoning is private by default: it is only sent to
+ * sockets that explicitly subscribe by connecting with the
+ * {@link THREAD_STREAM_REASONING_PARAM} query parameter set to a truthy value
+ * (e.g. `?reasoning=1`). Standard SDK consumers therefore never receive it
+ * unless they opt in.
+ *
+ * Reasoning is ephemeral *display* output: it is streamed for live presentation
+ * only and is NOT persisted as part of the assistant message content, so it
+ * cannot be replayed from message history — a client that wants it must be
+ * subscribed while the turn runs.
+ */
+interface ThreadReasoningChunkEvent {
+    type: 'reasoning_chunk';
+    /** The assistant message this reasoning accompanies. */
+    message_id: string;
+    /** Message depth: 0 = top-level thread, 1+ = subagent. */
+    depth: number;
+    /** The next fragment of internal reasoning. */
+    chunk: string;
+}
+/**
+ * Query-parameter name a client sets (truthy) on the thread stream WebSocket to
+ * opt into receiving {@link ThreadReasoningChunkEvent}s. Absent/falsey means the
+ * server never emits reasoning to that socket.
+ */
+declare const THREAD_STREAM_REASONING_PARAM = "reasoning";
 /**
  * Storage location identifier.
  *
@@ -844,6 +968,41 @@ interface StopSessionOptions {
  * });
  * ```
  */
+/**
+ * A request forwarded from a server-side tool to a connected client (CLI) for
+ * local execution. Used by "forwarded" tools where the agent loop runs remotely
+ * but the actual operation (read a file, run a command) must happen on the
+ * user's own machine.
+ */
+interface ClientToolRequest {
+    /** Logical operation name the client knows how to perform (e.g. `read_file`). */
+    tool: string;
+    /** Arguments for the operation. */
+    args?: Record<string, unknown>;
+    /**
+     * Human-readable description of what this call will do, shown to the user when
+     * the client needs to ask for permission. Presence signals the operation may
+     * carry side effects.
+     */
+    requestPermission?: string;
+    /** Risk level 1 (safe) – 5 (dangerous). Clients slide auto-accept on this. */
+    risk?: number;
+    /** Milliseconds to wait for the client before failing the call. */
+    timeoutMs?: number;
+}
+/**
+ * The result a connected client returns for a {@link ClientToolRequest}.
+ */
+interface ClientToolResponse {
+    /** Whether the client successfully performed the operation. */
+    ok: boolean;
+    /** Text result (e.g. file contents, command output). */
+    result?: string;
+    /** Error message when `ok` is false (including a user denial). */
+    error?: string;
+    /** Optional structured payload the tool can inspect. */
+    data?: unknown;
+}
 interface ThreadState {
     /** Unique thread identifier */
     readonly threadId: string;
@@ -1206,6 +1365,51 @@ interface ThreadState {
      *   to delete the key
      */
     setValue(key: string, value: unknown): Promise<void>;
+    /**
+     * The profile of the user this thread belongs to, or `null` when the thread
+     * has no associated user (e.g. unauthenticated local development).
+     *
+     * Lets tools and hooks personalize or gate behavior per user — e.g. an
+     * entitlement hook enforcing a per-user concurrency limit, or a tool
+     * addressing the user by name. Never includes credentials.
+     *
+     * @example
+     * ```typescript
+     * const user = await state.user();
+     * if (user?.email) await notifyBillingService(user.email);
+     * ```
+     */
+    user(): Promise<ThreadUser | null>;
+    /**
+     * The instance-global Agent Skills library (https://agentskills.io format).
+     *
+     * Skills are installed once and visible to every thread; their files live
+     * server-side (never on a client machine). Agents should follow progressive
+     * disclosure: browse metadata via `skills.list()`, and load a skill's
+     * SKILL.md body with `skills.get()` only when it is applicable to the task.
+     *
+     * @example
+     * ```typescript
+     * const available = await state.skills.list();
+     * const skill = await state.skills.get('pdf-processing');
+     * const script = await state.skills.readFile('pdf-processing', 'scripts/extract.py');
+     * ```
+     */
+    skills: SkillsNamespace;
+    /**
+     * Forward a tool operation to the connected client (e.g. the coding CLI) and
+     * await its result. The agent loop runs remotely, but operations like reading
+     * a file or running a shell command must execute on the user's own machine;
+     * `callClient` bridges that gap over the thread's `bridge` WebSocket.
+     *
+     * Resolves with `{ ok: false, error }` (rather than throwing) when no client
+     * is connected, the request times out, or the user denies permission, so
+     * forwarded tools can surface a normal tool error to the model.
+     *
+     * @param request - The operation, args, and optional permission/risk metadata
+     * @returns The client's response
+     */
+    callClient(request: ClientToolRequest): Promise<ClientToolResponse>;
     /**
      * Write a file to the thread's file system.
      *
@@ -1774,6 +1978,38 @@ interface DefineToolOptions<State = ThreadState, Args extends ToolArgs | null =
      * ```
      */
     uses?: Uses;
+    /**
+     * The name of an argument whose value is a short, human-readable description
+     * of what this tool call is doing — for example `"fixing index.html"`.
+     *
+     * When set, the `tool_call_started` hook and the `tool_call_started` thread
+     * event wait until **just this argument** has finished streaming from the
+     * model — not the whole tool call — and include its value as `progress`. This
+     * lets a UI show what a tool is about to do before a large argument (such as
+     * a file's `content`) finishes generating.
+     *
+     * When unset, `tool_call_started` fires as soon as the tool call appears in
+     * the model stream (its name is known, arguments may still be incomplete).
+     *
+     * Declare the named argument early in the `args` schema and keep it short so
+     * it completes quickly. If the model never emits it, `tool_call_started`
+     * still fires once the tool call finishes, with `progress` undefined.
+     *
+     * @example
+     * ```typescript
+     * defineTool({
+     *   description: 'Write a file to the workspace',
+     *   progressArgument: 'description',
+     *   args: z.object({
+     *     description: z.string().describe('e.g. "writing index.html"'),
+     *     path: z.string(),
+     *     content: z.string(),
+     *   }),
+     *   execute: async (state, args) => { ... },
+     * });
+     * ```
+     */
+    progressArgument?: string;
 }
 /**
  * Tool definition object returned by defineTool().
@@ -1825,6 +2061,12 @@ interface ToolDefinition<State = ThreadState, Args extends ToolArgs | null = nul
      * - Qualified names (e.g., 'other_pkg:agent'): Cross-package entry point
      */
     uses?: Uses;
+    /**
+     * The name of an argument carrying a short, human-readable description of what
+     * this tool call is doing (e.g. `"fixing index.html"`). Controls when the
+     * `tool_call_started` hook/event fires — see {@link DefineToolOptions.progressArgument}.
+     */
+    progressArgument?: string;
 }
 /**
  * Defines a tool that agents can call during execution.
@@ -1939,6 +2181,12 @@ interface ProviderModelInfo {
     iconId?: string;
     /** Optional slug for additional lookups (e.g., OpenRouter endpoint queries) */
     slug?: string;
+    /** Optional cost per 1M input tokens, in USD */
+    inputPrice?: number;
+    /** Optional cost per 1M output tokens, in USD */
+    outputPrice?: number;
+    /** Optional cost per 1M cached input tokens, in USD */
+    cachedPrice?: number;
     /**
      * Optional capability hints surfaced from the provider's listing
      * payload. Populated when the provider can derive support flags
@@ -2478,6 +2726,117 @@ interface ProviderFactoryConfig {
     apiKey: string;
     baseUrl?: string;
     timeout?: number;
+    [key: string]: unknown;
+}
+/**
+ * Declarative connection-level config slot exposed by a provider factory.
+ *
+ * Slots describe values used to construct a provider client, such as
+ * credentials, API endpoints, account IDs, regions, and timeouts. They are
+ * different from `providerOptions`, which are per-model or per-request knobs.
+ */
+interface ProviderConfigSlot<T = unknown> {
+    /** Value type, used by UIs for validation and secret handling */
+    type: VariableType | 'url' | 'number' | 'boolean';
+    /** Whether this value is required to construct the provider */
+    required?: boolean;
+    /** Default literal value when no override/source provides one */
+    default?: T;
+    /** Conventional environment variable used by the built-in/default provider */
+    defaultEnv?: string;
+    /** Whether sub-providers may override this slot */
+    overridable?: boolean;
+    /** Human-readable description for setup UIs and docs */
+    description?: string;
+}
+/**
+ * Named collection of provider client config slots.
+ */
+type ProviderConfigSlots = Record<string, ProviderConfigSlot>;
+/**
+ * Value source used by `defineProvider()` sub-providers to fill base-provider
+ * config slots.
+ */
+type ProviderConfigValueSource<T = unknown> = {
+    type: 'const';
+    value: T;
+} | {
+    type: 'env';
+    name: string;
+    valueType?: VariableType | 'url' | 'number' | 'boolean';
+    required?: boolean;
+    default?: T;
+    description?: string;
+};
+/**
+ * Convenience helper for constant provider config values.
+ */
+declare function providerValue<T>(value: T): ProviderConfigValueSource<T>;
+/**
+ * Convenience helper for provider config values resolved from environment.
+ */
+declare function providerEnv<T = string>(name: string, options?: Omit<Extract<ProviderConfigValueSource<T>, {
+    type: 'env';
+}>, 'type' | 'name'>): ProviderConfigValueSource<T>;
+/**
+ * Backward-compatible alias with wording that reads naturally in provider
+ * definition files.
+ */
+declare const providerConst: typeof providerValue;
+interface ProviderOverrideContext {
+    /** Name of the defined provider being executed */
+    providerName: string;
+    /** The resolved connection config passed to the base provider */
+    config: ProviderFactoryConfig;
+    /** Base provider instance before overrides are applied */
+    baseProvider: ProviderInstance;
+}
+type MaybePromise<T> = T | Promise<T>;
+type ProviderOverride<Context, Result> = (context: ProviderOverrideContext & Context, next: () => MaybePromise<Result>) => MaybePromise<Result>;
+type ProviderSyncOverride<Context, Result> = (context: ProviderOverrideContext & Context, next: () => Result) => Result;
+/**
+ * Overrideable provider methods. Each override can replace the base behavior
+ * or call `next()` to compose with the base provider.
+ */
+interface ProviderMethodOverrides {
+    generate?: ProviderOverride<{
+        request: ProviderRequest;
+    }, ProviderResponse>;
+    stream?: ProviderOverride<{
+        request: ProviderRequest;
+    }, AsyncIterable<ProviderStreamChunk>>;
+    supportsModel?: ProviderSyncOverride<{
+        modelId: string;
+    }, boolean>;
+    getModels?: ProviderOverride<{
+        filter?: string;
+    }, ProviderModelInfo[]>;
+    getModelsPage?: ProviderOverride<{
+        query?: ProviderModelsQuery;
+    }, ProviderModelsPage>;
+    getModelCapabilities?: ProviderOverride<{
+        modelId: string;
+    }, ModelCapabilities | null>;
+    getTools?: ProviderOverride<{
+        modelId?: string;
+    }, Record<string, ToolDefinition<unknown, ToolArgs | null, ToolTenvs | null>>>;
+    getIcon?: ProviderSyncOverride<{
+        modelId?: string;
+    }, string | undefined>;
+    inspectRequest?: ProviderOverride<{
+        request: ProviderRequest;
+    }, InspectedRequest>;
+    getResponseMetadata?: ProviderOverride<{
+        summary: ResponseSummary;
+        signal?: AbortSignal;
+    }, Record<string, unknown> | null>;
+}
+interface ProviderDefinition<N extends string = string, Base extends ProviderFactoryWithOptions<ZodTypeAny> = ProviderFactoryWithOptions<ZodTypeAny>> {
+    name: N;
+    label?: string;
+    baseProvider: Base;
+    config?: Partial<Record<keyof ProviderFactoryConfig | string, ProviderConfigValueSource>>;
+    overrides?: ProviderMethodOverrides;
 }
 /**
  * Provider factory with optional typed providerOptions schema.
@@ -2502,6 +2861,10 @@ interface ProviderFactoryWithOptions<TOptions extends ZodTypeAny = ZodTypeAny> {
     (config: ProviderFactoryConfig): ProviderInstance;
     /** Zod schema for provider-specific options */
     providerOptions?: TOptions;
+    /** Connection-level config slots accepted by this provider factory */
+    configSlots?: ProviderConfigSlots;
+    /** Metadata attached to factories created with defineProvider() */
+    providerDefinition?: ProviderDefinition<string, ProviderFactoryWithOptions<TOptions>>;
 }
 /**
  * Factory function that creates provider instances.
@@ -2518,6 +2881,11 @@ interface ProviderFactoryWithOptions<TOptions extends ZodTypeAny = ZodTypeAny> {
  * ```
  */
 type ProviderFactory = ProviderFactoryWithOptions<ZodTypeAny>;
+/**
+ * Define a named sub-provider that uses a base provider implementation with
+ * custom connection config sources and optional method overrides.
+ */
+declare function defineProvider<const N extends string, Base extends ProviderFactoryWithOptions<ZodTypeAny>>(definition: ProviderDefinition<N, Base>): ProviderFactoryWithOptions<Base extends ProviderFactoryWithOptions<infer S> ? S : ZodTypeAny>;
 /**
  * Extract providerOptions type from a provider factory.
  *
@@ -3128,6 +3496,29 @@ interface SubagentToolConfig<T extends string = StandardAgentSpec.Callables> {
          */
         parentCommunication?: 'implicit' | 'explicit';
     };
+    /**
+     * How this subagent reports completion back to its parent. Applies to
+     * non-resumable subagents; resumable subagents may instead set
+     * `resumable.parentCommunication`, which takes precedence when present.
+     *
+     * - `implicit` (default): the child's completion is auto-queued to the parent,
+     *   which triggers a parent turn.
+     * - `explicit`: the runtime does NOT auto-queue the child's completion, so the
+     *   parent is not woken. Use for background subagents that deliver their result
+     *   another way (e.g. writing to the parent's thread KV) and should be "picked
+     *   up" on the parent's next natural turn rather than forcing one.
+     */
+    parentCommunication?: 'implicit' | 'explicit';
+    /**
+     * Hide this subagent tool from the LLM's tool list while keeping the
+     * relationship declared, so runtime code (hooks calling
+     * `state.invokeTool()` / `queueTool()`) can still spawn it. Use for
+     * infrastructure subagents the model must never call itself (e.g. a
+     * background context-compaction agent).
+     *
+     * @default false
+     */
+    hidden?: boolean;
 }
 /**
  * Reasoning configuration for models that support extended thinking.
@@ -3730,6 +4121,55 @@ interface HookSignatures<State = ThreadState, Msg = HookMessage, ToolCall = Hook
      * ```
      */
     after_tool_call_failure: (state: State, toolCall: ToolCall, toolResult: ToolResult) => Promise<ToolResult | null>;
+    /**
+     * Called when a tool call STARTS — before the tool executes, while the model
+     * may still be generating the rest of the call. Fires exactly once per tool
+     * call. Observational: the return value is ignored.
+     *
+     * Timing depends on whether the tool declares a `progressArgument`:
+     * - **With** `progressArgument`: fires as soon as *just that argument* has
+     *   finished streaming (not the whole call), passing its value as `progress`.
+     *   This lets a UI show "fixing index.html" before a large `content` argument
+     *   finishes generating.
+     * - **Without** `progressArgument`: fires as soon as the tool call appears in
+     *   the stream — its name is known but `toolCall.function.arguments` may be an
+     *   incomplete JSON fragment (or empty), and `progress` is undefined.
+     *
+     * Conforming runtimes also broadcast a `tool_call_started` thread event to
+     * connected clients with `{ id, name, progress }` at the same moment.
+     *
+     * @param state - Thread state
+     * @param toolCall - The starting tool call; `function.arguments` may be incomplete
+     * @param progress - The declared progress-argument value, when available
+     *
+     * @example
+     * ```typescript
+     * defineHook({
+     *   hook: 'tool_call_started',
+     *   id: 'log_tool_start',
+     *   execute: async (state, toolCall, progress) => {
+     *     console.log(`▸ ${toolCall.function.name}${progress ? `: ${progress}` : ''}`);
+     *   },
+     * });
+     * ```
+     */
+    tool_call_started: (state: State, toolCall: ToolCall, progress?: string) => Promise<void>;
+    /**
+     * Called when a tool call is DONE — after it has executed, with its result,
+     * regardless of success or failure. Fires once per tool call. Observational:
+     * the return value is ignored.
+     *
+     * This complements `after_tool_call_success` / `after_tool_call_failure`,
+     * which can additionally *modify* the stored result; `tool_call_done` is a
+     * single unified observation point that always fires. Conforming runtimes
+     * also broadcast a `tool_call_done` thread event to connected clients with
+     * `{ id, name, status }` at the same moment.
+     *
+     * @param state - Thread state
+     * @param toolCall - The completed tool call
+     * @param toolResult - The tool's result (`status` is `'success'` or `'error'`)
+     */
+    tool_call_done: (state: State, toolCall: ToolCall, toolResult: ToolResult) => Promise<void>;
 }
 /**
  * Valid hook names.
@@ -4621,4 +5061,4 @@ interface PackedExports {
     __meta: PackedMeta;
 }
 
-export { type AgentDefinition, type AgentType, type AttachmentRef, type CodeExecution, type CodeExecutionError, type CodeExecutionLog, type CodeExecutionOptions, type CodeExecutionResult, type CodeExecutionStatus, type ContentPart, type Controller, type ControllerContext, type ControllerReturn, type DefineToolOptions, type DefinitionLoader, type Effect, type EffectDefinition, type EmptyUsesState, type EnvValueType, type ExecutionState, type FileChunk, type FilePart, type FileRecord, type FileStats, type FileStorage, type FindResult, type GetMessagesOptions, type GlobalNamespaceContext, type GrepResult, type HookContext, type HookDefinition, type HookDefinitionOptions, type HookDefinitionResult, type HookMessage, type HookName, type HookSignatures, type HookToolCall, type HookToolResult, type ImageContent, type ImagePart, type ImageUrlPart, type InferProviderOptions, type InjectMessageInput, type InspectedRequest, type LLMMessage, type LLMProviderInterface, type MarkedThreadEndpoint, type Message, type MessageUpdates, type MessagesResult, type ModelCapabilities, type ModelDefinition, type ModelProvider, type NamespaceContext, type PackageSignature, type PackedExports, type PackedMeta, type PackedMetadata, type PackedNamespaceContext, type PromptContent, type PromptDefinition, type PromptEnvPart, type PromptIncludePart, type PromptInput, type PromptPart, type PromptTextPart, type PromptToolConfig, type ProviderAssistantMessage, type ProviderAttachment, ProviderError, type ProviderErrorCode, type ProviderExecutedToolResult, type ProviderFactory, type ProviderFactoryConfig, type ProviderFactoryWithOptions, type ProviderFinishReason, type ProviderGeneratedImage, type ProviderInstance, type ProviderMessage, type ProviderMessageContent, type ProviderModelInfo, type ProviderModelsPage, type ProviderModelsQuery, type ProviderReasoningDetail, type ProviderRequest, type ProviderResponse, type ProviderStreamChunk, type ProviderSystemMessage, type ProviderTool, type ProviderToolCallPart, type ProviderToolMessage, type ProviderToolResultContent, type ProviderUsage, type ProviderUserMessage, type ProviderWebSearchResult, type QueueMessageInput, type ReadFileStreamOptions, type ReaddirResult, type ReasoningConfig, type ResolveUsesState, type ResponseSummary, type ScheduledEffect, type SessionToolBinding, type SessionToolConfig, type SetEnvOptions, type SideConfig, type StopSessionOptions, type StructuredPrompt, type SubagentRegistryEntry, type SubagentToolConfig, type SubpromptConfig, THREAD_ENDPOINT_SYMBOL, type TenvRawShape, type TextContent, type TextPart, type ThreadEndpointHandler, type ThreadEndpointRouteParams, type ThreadMetadata, type ThreadState, type Tool, type ToolArgs, type ToolArgsNode, type ToolArgsRawShape, type ToolAttachment, type ToolConfig, type ToolContent, type ToolDefinition, type ToolResult, type ToolTenvs, type ToolVariables, type UsesAwareExecute, type UsesConstrainedState, type VariableDefinition, type VariableType, type VirtualModuleLoader, type VirtualModuleRegistry, type WriteFileOptions, belongsToPackage, defineAgent, defineController, defineEffect, defineHook, defineModel, definePrompt, defineThreadEndpoint, defineTool, isPacked, isThreadEndpoint, isVisibleInNamespace, mapReasoningLevel, validateToolName };
+export { type AgentDefinition, type AgentType, type AttachmentRef, type ClientToolRequest, type ClientToolResponse, type CodeExecution, type CodeExecutionError, type CodeExecutionLog, type CodeExecutionOptions, type CodeExecutionResult, type CodeExecutionStatus, type ContentPart, type Controller, type ControllerContext, type ControllerReturn, type DefineToolOptions, type DefinitionLoader, type Effect, type EffectDefinition, type EmptyUsesState, type EnvValueType, type ExecutionState, type FileChunk, type FilePart, type FileRecord, type FileStats, type FileStorage, type FindResult, type GetMessagesOptions, type GlobalNamespaceContext, type GrepResult, type HookContext, type HookDefinition, type HookDefinitionOptions, type HookDefinitionResult, type HookMessage, type HookName, type HookSignatures, type HookToolCall, type HookToolResult, type ImageContent, type ImagePart, type ImageUrlPart, type InferProviderOptions, type InjectMessageInput, type InspectedRequest, type LLMMessage, type LLMProviderInterface, type MarkedThreadEndpoint, type Message, type MessageUpdates, type MessagesResult, type ModelCapabilities, type ModelDefinition, type ModelProvider, type NamespaceContext, type PackageSignature, type PackedExports, type PackedMeta, type PackedMetadata, type PackedNamespaceContext, type PromptContent, type PromptDefinition, type PromptEnvPart, type PromptIncludePart, type PromptInput, type PromptPart, type PromptTextPart, type PromptToolConfig, type ProviderAssistantMessage, type ProviderAttachment, type ProviderConfigSlot, type ProviderConfigSlots, type ProviderConfigValueSource, type ProviderDefinition, ProviderError, type ProviderErrorCode, type ProviderExecutedToolResult, type ProviderFactory, type ProviderFactoryConfig, type ProviderFactoryWithOptions, type ProviderFinishReason, type ProviderGeneratedImage, type ProviderInstance, type ProviderMessage, type ProviderMessageContent, type ProviderMethodOverrides, type ProviderModelInfo, type ProviderModelsPage, type ProviderModelsQuery, type ProviderOverride, type ProviderOverrideContext, type ProviderReasoningDetail, type ProviderRequest, type ProviderResponse, type ProviderStreamChunk, type ProviderSyncOverride, type ProviderSystemMessage, type ProviderTool, type ProviderToolCallPart, type ProviderToolMessage, type ProviderToolResultContent, type ProviderUsage, type ProviderUserMessage, type ProviderWebSearchResult, type QueueMessageInput, type ReadFileStreamOptions, type ReaddirResult, type ReasoningConfig, type ResolveUsesState, type ResponseSummary, type ScheduledEffect, type SessionToolBinding, type SessionToolConfig, type SetEnvOptions, type SideConfig, type SkillFileInput, type SkillMetadata, type SkillsNamespace, type StopSessionOptions, type StructuredPrompt, type SubagentRegistryEntry, type SubagentToolConfig, type SubpromptConfig, THREAD_ENDPOINT_SYMBOL, THREAD_STREAM_REASONING_PARAM, type TenvRawShape, type TextContent, type TextPart, type ThreadEndpointHandler, type ThreadEndpointRouteParams, type ThreadMessageChunkEvent, type ThreadMetadata, type ThreadReasoningChunkEvent, type ThreadState, type ThreadUser, type Tool, type ToolArgs, type ToolArgsNode, type ToolArgsRawShape, type ToolAttachment, type ToolConfig, type ToolContent, type ToolDefinition, type ToolResult, type ToolTenvs, type ToolVariables, type UsesAwareExecute, type UsesConstrainedState, type VariableDefinition, type VariableType, type VirtualModuleLoader, type VirtualModuleRegistry, type WriteFileOptions, belongsToPackage, defineAgent, defineController, defineEffect, defineHook, defineModel, definePrompt, defineProvider, defineThreadEndpoint, defineTool, isPacked, isThreadEndpoint, isVisibleInNamespace, mapReasoningLevel, providerConst, providerEnv, providerValue, validateToolName };