@astralform/js 8.0.0 → 8.4.0

package/dist/index.d.ts

@@ -73,6 +73,15 @@ interface MemoryUpdatePayload {
     key?: string | null;
     namespace?: string | null;
 }
+interface MemoryProviderErrorPayload {
+    /** The external memory provider that failed (registry slug, e.g. "mem0"). */
+    provider: string;
+    /** Which provider operation failed — "save" | "update" | "delete" | "get"
+     *  | "recall" | "ingest" | "list_visible" | … Typed as string for forward compat. */
+    op: string;
+    /** One-line "<ExceptionType>: <message>" detail, length-capped by the backend. */
+    error: string;
+}
 interface DesktopStreamPayload {
     url: string;
     sandboxId?: string | null;
@@ -117,6 +126,38 @@ interface ToolHarnessWarningPayload {
     message?: string | null;
     details?: Record<string, unknown> | null;
 }
+interface ToolProgressPayload {
+    callId: string;
+    /** Known values: "stdout" | "stderr" | "progress" | "command". Typed as string
+     *  for forward compat; the backend defaults to "progress". */
+    stream: string;
+    /** Live progress text to append; the backend newline-terminates chunks. */
+    chunk: string;
+    /** Emitting tool, e.g. "web_search" | "deep_research" | "generate_video".
+     *  Wire key is `tool`; camelCase here, like the rest of this catalog. */
+    toolName?: string | null;
+    /** Structured metadata riding alongside `chunk` for a richer UI — a search
+     *  result ({title,url,snippet}) or a research phase record. */
+    item?: Record<string, unknown> | null;
+    /** Position within `total`, when the producer emits one item per step. */
+    index?: number | null;
+    total?: number | null;
+    /** Producers splat arbitrary extra keys (`generate_video` sends `status`,
+     *  `preset`), so this payload is open-ended by design. */
+    [key: string]: unknown;
+}
+interface NestedLlmUsagePayload {
+    /** Which tool made the nested calls, e.g. "deep_research". */
+    source: string;
+    /** The parent tool call these nested calls belong to. */
+    callId: string;
+    inputTokens: number;
+    outputTokens: number;
+    cachedTokens: number;
+    cacheCreationTokens: number;
+    /** Number of nested LLM calls this event aggregates. */
+    llmCalls: number;
+}
 interface UserUnavailablePayload {
     consecutiveTimeouts: number;
     toolName?: string | null;
@@ -206,6 +247,7 @@ declare const ChatEventType: {
     readonly ContextWarning: "context_warning";
     readonly MemoryRecall: "memory_recall";
     readonly MemoryUpdate: "memory_update";
+    readonly MemoryProviderError: "memory_provider_error";
     readonly DesktopStream: "desktop_stream";
     readonly AttachmentStaged: "attachment_staged";
     readonly WorkspaceReady: "workspace_ready";
@@ -214,6 +256,8 @@ declare const ChatEventType: {
     readonly ToolApprovalGranted: "tool_approval_granted";
     readonly ToolPermissionDenied: "tool_permission_denied";
     readonly ToolHarnessWarning: "tool_harness_warning";
+    readonly ToolProgress: "tool_progress";
+    readonly NestedLlmUsage: "nested_llm_usage";
     readonly UserUnavailable: "user_unavailable";
     readonly PromptSuggestion: "prompt_suggestion";
     readonly StateChanged: "state_changed";
@@ -493,6 +537,15 @@ type ChatEvent = {
     memoryId?: string | null;
     key?: string | null;
     namespace?: string | null;
+} | {
+    type: "memory_provider_error";
+    /** The external memory provider that failed (registry slug, e.g. "mem0"). */
+    provider: string;
+    /** Which provider operation failed — "save" | "update" | "delete" | "get"
+     *  | "recall" | "ingest" | "list_visible" | … */
+    op: string;
+    /** One-line "<ExceptionType>: <message>" detail, length-capped by the backend. */
+    error: string;
 } | {
     type: "desktop_stream";
     url: string;
@@ -537,6 +590,43 @@ type ChatEvent = {
     callId: string;
     message?: string | null;
     details?: Record<string, unknown> | null;
+} | {
+    type: "tool_progress";
+    callId: string;
+    /** Known values: "stdout" | "stderr" | "progress" | "command". Typed as
+     *  string for forward compat; the backend defaults to "progress". */
+    stream: string;
+    /** Live progress text to append; the backend newline-terminates chunks. */
+    chunk: string;
+    /** Emitting tool, e.g. "web_search" | "deep_research" | "generate_video".
+     *  Every producer sends it; null only if a future one does not. The wire
+     *  key is `tool`, but this layer chooses consumer-facing names rather than
+     *  inheriting them, and every sibling tool event calls it `toolName`. */
+    toolName?: string | null;
+    /** Structured metadata riding alongside `chunk` for a richer UI — a search
+     *  result ({title,url,snippet}) or a research phase record. Null when the
+     *  producer sends none. */
+    item?: Record<string, unknown> | null;
+    /** Position within `total`, when the producer emits one item per step. */
+    index?: number | null;
+    total?: number | null;
+    /** The raw payload, verbatim. Producers send keys beyond the named ones —
+     *  `generate_video` splats arbitrary `**extra` (`status`, `preset`) — so
+     *  the named fields are a convenience, not the whole event. Read here for
+     *  anything they do not cover. */
+    data: Record<string, unknown>;
+} | {
+    type: "nested_llm_usage";
+    /** Which tool made the nested calls, e.g. "deep_research". */
+    source: string;
+    /** The parent tool call these nested calls belong to. */
+    callId: string;
+    inputTokens: number;
+    outputTokens: number;
+    cachedTokens: number;
+    cacheCreationTokens: number;
+    /** Number of nested LLM calls this event aggregates. */
+    llmCalls: number;
 } | {
     type: "user_unavailable";
     consecutiveTimeouts: number;
@@ -666,6 +756,43 @@ interface SkillInfo {
     description: string;
     isEnabled: boolean;
 }
+/**
+ * A slash command the active agent offers — the system commands (`/new`,
+ * `/goal`, `/plan`, …) followed by its enabled skills, from
+ * `GET /v1/skills/commands`.
+ *
+ * The backend builds this list once and every surface reads it, so the web
+ * composer's "/" menu and the Telegram bot's command menu cannot drift.
+ */
+interface SlashCommand {
+    /** What the user types after the slash, and what the backend parses. */
+    name: string;
+    /** Human-readable label for the menu row. May be empty. */
+    displayName: string;
+    /** One line describing what the command does. May be empty. */
+    description: string;
+    /**
+     * The argument shape a row shows after the name, e.g. `"[goal]"`. Empty
+     * when the command takes none — never undefined, so a renderer can
+     * concatenate it without a guard.
+     */
+    argsHint: string;
+    /**
+     * Which surfaces can run this command (`"web"`, `"telegram"`).
+     *
+     * Always populated, whatever surface was asked for — a scoped list has
+     * already filtered on it, so every row there names at least the surface
+     * requested. It carries information only for `"all"`, where rows that
+     * cannot run everywhere sit next to rows that can. Empty rather than
+     * undefined for the same reason as `argsHint`.
+     */
+    surfaces: string[];
+}
+/**
+ * Who will execute the commands {@link AstralformClient.listSkillCommands}
+ * returns. `"web"` is the server's default: what `POST /v1/jobs` runs itself.
+ */
+type SlashCommandSurface = "web" | "telegram" | "all";
 interface JobCreateResponse {
     job_id: string;
     conversation_id: string;
@@ -1004,6 +1131,48 @@ interface ChatStreamEvent {
     event: string;
     data: string;
 }
+/**
+ * A tool output the server declined to inline, with a handle to fetch it.
+ *
+ * Restore can ask for these with `toolOutputs: "stub"`. Only the `output` of a
+ * `tool_use` final is ever replaced — name, arguments, status, duration and the
+ * hoisted image previews all survive — so a stubbed tool call renders like a
+ * resolved one until the reader opens it.
+ */
+interface ToolOutputStub {
+    __stub: "tool_output";
+    call_id: string;
+    /**
+     * Size of the output this replaces, for a "load 240 KB" affordance.
+     *
+     * Optional because nothing in this SDK reads it, and the guard therefore
+     * does not require it: rejecting an otherwise-valid stub over a display
+     * field would drop it to "not a stub" and render the handle where the
+     * output belongs — a worse outcome than a missing size label.
+     */
+    size_bytes?: number;
+    /**
+     * The job this call belongs to. **Hand it back to `getToolOutput`.**
+     *
+     * `/events?job_id=X` deliberately returns jobs that regeneration has
+     * replaced — reading a superseded version is the whole purpose of that
+     * parameter — while the fetch route excludes them unless scoped to a job. A
+     * fetch that drops this therefore 404s on exactly the pills a
+     * version-switched read is displaying. Absent only when the event carried no
+     * job id, in which case the unscoped fetch is the correct one.
+     */
+    job_id?: string;
+}
+/**
+ * Is this tool output a stub to fetch rather than the output itself?
+ *
+ * One obvious way to ask. Left to sniff `__stub` themselves, consumers get it
+ * wrong in the direction that renders the stub object into the transcript
+ * where the result belongs.
+ */
+declare function isToolOutputStub(value: unknown): value is ToolOutputStub;
+/** How a restore asks for tool outputs. */
+type ToolOutputMode = "inline" | "stub";
 interface ConversationEvent {
     seq: number;
     event: string;
@@ -1148,6 +1317,32 @@ interface ConversationAsset {
     createdAt: string;
 }
 
+/**
+ * One turn as the conversation's job list describes it.
+ *
+ * Deliberately WIDER than `restore-plan.ts`'s `RestoreJob`, which is the
+ * narrow structural input `planRestore` needs. This is the wire shape, and
+ * typing the page with the narrow one would drop `status` and `metrics` on
+ * the floor — silently, since a narrower type is assignable.
+ */
+interface ConversationJob {
+    job_id: string;
+    status: string;
+    message_id?: string | null;
+    metrics?: Record<string, unknown>;
+}
+/** One page of turns, plus where the next older page starts. */
+interface JobsPage {
+    jobs: ConversationJob[];
+    hasMore: boolean;
+    nextBefore: string | null;
+}
+/** One page of messages, plus where the next older page starts. */
+interface MessagesPage {
+    messages: Message[];
+    hasMore: boolean;
+    nextBeforeSeq: number | null;
+}
 declare class AstralformClient {
     private readonly baseURL;
     private readonly fetchFn;
@@ -1215,6 +1410,19 @@ declare class AstralformClient {
     private request;
     /** Fetch + status handling. Always called inside `withDeadline`. */
     private send;
+    /**
+     * A GET whose response HEADERS the caller needs, not only its body.
+     *
+     * Paging metadata rides on headers (`X-Has-More`, `X-Next-Before`) because
+     * the bodies are bare lists that installed clients already parse as such.
+     * Reading them needs the `Response`, which `get<T>` discards.
+     *
+     * Note the shape: the body is parsed INSIDE the raced callback, exactly as
+     * `get`/`post`/`patch` do. See the comment above them — doing the parse
+     * outside the deadline is the original hang, and this method is not an
+     * exception to it.
+     */
+    private getWithHeaders;
     get<T>(path: string): Promise<T>;
     post<T>(path: string, body: unknown): Promise<T>;
     patch<T>(path: string, body: unknown): Promise<T>;
@@ -1237,6 +1445,38 @@ declare class AstralformClient {
     getConversations(limit?: number, offset?: number, options?: {
         repository?: string;
     }): Promise<Conversation[]>;
+    /**
+     * One page of a conversation's turns, newest-first window returned oldest-first.
+     *
+     * `hasMore` asks "are there OLDER turns beyond this page" — the only
+     * direction a restore pages in, since it starts at the tail.
+     *
+     * **Degrades on an old backend.** A server without the cursor ignores the
+     * unknown `limit` query param and returns the whole list, and its response
+     * carries neither header — which reads here as one page with nothing older,
+     * i.e. exactly today's behaviour. That is why absent headers must mean
+     * `hasMore: false` rather than an error: the fallback has to be "everything
+     * arrived", not "paging is broken".
+     */
+    getConversationJobsPage(conversationId: string, options?: {
+        limit?: number;
+        before?: string;
+    }): Promise<JobsPage>;
+    /**
+     * One page of a conversation's messages, oldest-first within the page.
+     *
+     * Deliberately NOT folded into `getMessages`: that method is public surface
+     * whose `Message[]` return type callers depend on, and the server keeps its
+     * unbounded branch for exactly the same reason.
+     *
+     * Degrades like `getConversationJobsPage` — an old server ignores `limit`
+     * and returns the whole branch with no headers, which reads as a single
+     * complete page.
+     */
+    getMessagesPage(conversationId: string, options: {
+        limit: number;
+        beforeSeq?: number;
+    }): Promise<MessagesPage>;
     getMessages(conversationId: string): Promise<Message[]>;
     /**
      * Replace the title the server generated from the conversation's first turn.
@@ -1264,7 +1504,45 @@ declare class AstralformClient {
      */
     getModels(): Promise<ModelOption[]>;
     getSkills(): Promise<SkillInfo[]>;
-    getConversationEvents(conversationId: string, jobId?: string): Promise<ConversationEvent[]>;
+    /**
+     * List the slash commands the active agent offers — the system commands
+     * followed by its enabled skills. Backs the composer's "/" menu.
+     *
+     * @param surface Who will execute them. Omit for the server's default,
+     *   `"web"`: what `POST /v1/jobs` runs itself. `"telegram"` returns the
+     *   bot's commands under Telegram-valid names; `"all"` returns every
+     *   command, including those the other surfaces filter out — `surfaces` is
+     *   set on every row either way, and is what tells them apart here.
+     *
+     * The default surface is not sent as a query parameter. The server already
+     * defaults to `web`, so omitting it keeps the request byte-identical to
+     * what clients that call the raw path send today — same reasoning as
+     * {@link getConversationEvents}'s `toolOutputs`.
+     */
+    listSkillCommands(surface?: SlashCommandSurface): Promise<SlashCommand[]>;
+    getConversationEvents(conversationId: string, jobId?: string, options?: {
+        toolOutputs?: ToolOutputMode;
+    }): Promise<ConversationEvent[]>;
+    /**
+     * The full output behind a {@link ToolOutputStub}.
+     *
+     * The safe form: the stub carries its own `job_id`, so the scoping that a
+     * version-switched read depends on cannot be dropped. See the id overload
+     * below for what that scoping is and why omitting it 404s.
+     */
+    getToolOutput(conversationId: string, stub: ToolOutputStub): Promise<unknown>;
+    /**
+     * By ids. **Pass `jobId`** — this is the form that can get it wrong.
+     *
+     * `/events?job_id=X` deliberately returns jobs that regeneration has
+     * replaced, since reading a superseded version is the whole purpose of that
+     * parameter, while this route excludes them unless scoped to a job. Omit it
+     * and the fetch 404s on exactly the pills a version-switched read is
+     * displaying. Restore fetches events per job, so that is the normal path.
+     *
+     * Prefer the overload above, which takes the stub and cannot be got wrong.
+     */
+    getToolOutput(conversationId: string, callId: string, jobId?: string): Promise<unknown>;
     submitToolResult(request: ToolResultRequest): Promise<void>;
     submitToolApproval(request: ToolApprovalRequest): Promise<void>;
     /**
@@ -1472,6 +1750,19 @@ declare class ChatSession {
      * cheaper than adding a count query to every list call.
      */
     hasMoreConversations: boolean;
+    /** True when the loaded window has OLDER turns behind it — the transcript's
+     *  analogue of `hasMoreConversations`, and what a scroll-to-top sentinel
+     *  gates on. False until a windowed load says otherwise, so a consumer that
+     *  never asks for a window never offers to page. */
+    hasMoreTurns: boolean;
+    /** Cursor for the next older MESSAGE page (`before_seq`), or null. */
+    oldestMessageSeq: number | null;
+    /** Cursor for the next older TURN page (`before`), or null. Set by the
+     *  restore that loaded the newest page; consumed by `loadEarlierTurns`. */
+    oldestTurnCursor: string | null;
+    /** Guards against a sentinel that re-fires while a page is still in flight
+     *  and stacks duplicate turns — the same guard `loadMoreConversations` uses. */
+    isLoadingEarlierTurns: boolean;
     /** True while ``loadMoreConversations`` is in flight. */
     isLoadingConversations: boolean;
     messages: Message[];
@@ -1635,7 +1926,9 @@ declare class ChatSession {
      * Load conversation context (messages) without replaying events.
      * Used before reconnectToJob — SSE replay handles event replay.
      */
-    loadConversation(id: string): Promise<void>;
+    loadConversation(id: string, options?: {
+        limit?: number;
+    }): Promise<void>;
     /**
      * Reconnect to a running job's SSE stream (e.g. after page reload).
      * Replays all events from the beginning and continues live.
@@ -1724,6 +2017,19 @@ declare class ChatSession {
      * tracking ids client-side cannot discover a row that moved into a region
      * already scanned.
      */
+    /**
+     * Put an older page of messages in FRONT of the loaded window.
+     *
+     * Pending optimistic sends stay at the tail. They are the newest thing in
+     * the session by construction — a message this browser has posted and the
+     * server has not confirmed — so sorting them in with a page of history
+     * would move an unsent bubble into the middle of the transcript.
+     *
+     * Ids already present are dropped rather than duplicated: pages are cut on a
+     * row sequence, but a turn landing mid-walk can still put one message in two
+     * pages, and a doubled prompt is more visible than a missing one.
+     */
+    prependMessages(older: Message[]): void;
     loadMoreConversations(): Promise<Conversation[]>;
     /**
      * Rename a conversation, server first.
@@ -1844,6 +2150,42 @@ type StreamManagerEvent = {
     type: "stateChange";
     state: StreamState;
     conversationId: string | null;
+} | {
+    /**
+     * An older page of turns is about to be replayed.
+     *
+     * Everything between this and `historyPageEnd` belongs BEFORE what the
+     * consumer already holds. The SDK says which turns and in what order;
+     * where they go is the consumer's business, and deliberately so — block
+     * placement is a rendering concern, and the one consumer that indexes
+     * blocks by wire path cannot merge an older page into that index anyway,
+     * because paths are allocated per job and collide across turns.
+     */
+    type: "historyPageStart";
+    conversationId: string;
+    position: "prepend";
+} | {
+    type: "historyPageEnd";
+    conversationId: string;
+    position: "prepend";
+    /** Whether anything older still remains after this page. */
+    hasMore: boolean;
+    /**
+     * Did the whole page replay?
+     *
+     * `false` when a live turn took the view over mid-walk, or a turn
+     * started. The conversation has NOT moved in either case, so the turns
+     * already emitted are sitting in the live transcript and the id on this
+     * event does not tell a consumer to drop them — while the cursor has
+     * deliberately not advanced, so the very next page request replays the
+     * same turns from the start.
+     *
+     * **A consumer must discard everything it buffered since
+     * `historyPageStart` when this is `false`.** That is cheap by
+     * construction: a page is replayed into an isolated view and merged only
+     * at this event, precisely because block paths collide across turns.
+     */
+    complete: boolean;
 } | {
     type: "conversationChanged";
     conversationId: string | null;
@@ -1876,6 +2218,19 @@ type StreamManagerEvent = {
 type EventHandler = (event: StreamManagerEvent) => void;
 declare class StreamManager {
     private session;
+    /** The oldest prompt drawn so far — where a prepended page's span ends. */
+    private oldestDrawnMessageId;
+    /**
+     * Whether restore asks for tool outputs inline or as fetch handles.
+     *
+     * ONE setting, applied to both event waves — the newest page and every
+     * `loadEarlierTurns` page. A consumer that got stubs only on scroll-up would
+     * be worse off than one that got them nowhere: the pill would resolve itself
+     * in the visible tail and need a fetch above the fold, for no stated reason.
+     *
+     * Defaults to inline, so this is inert until a consumer opts in.
+     */
+    private toolOutputs;
     private _state;
     private _activeConversationId;
     private _backgroundJobs;
@@ -1906,6 +2261,15 @@ declare class StreamManager {
     get activeConversationId(): string | null;
     get backgroundJobs(): ReadonlyMap<string, string>;
     on(handler: EventHandler): () => void;
+    /**
+     * Ask restore for stubbed tool outputs, resolved on demand.
+     *
+     * Only worth turning on by a consumer that can actually resolve a stub —
+     * see `isToolOutputStub` and `client.getToolOutput`. One that cannot does
+     * not render an empty result: it renders the stub OBJECT where the output
+     * belongs, because that is what arrives in `final.output`.
+     */
+    setToolOutputMode(mode: ToolOutputMode): void;
     private emit;
     private setState;
     private attach;
@@ -2041,6 +2405,23 @@ declare class StreamManager {
      * has returned to where it started.
      */
     private turnStarted;
+    /**
+     * Re-issue the message load UNWINDOWED after a restore stopped before it
+     * could write a turn cursor.
+     *
+     * The window is decided synchronously at restore entry, but "this restore
+     * will page" is only settled once `replayHistory` clears its first abort
+     * check. A send landing in between — nothing gates one during a restore —
+     * stops the replay with the window already installed and the cursor never
+     * written: a transcript truncated to one page that no pager can extend,
+     * which is worse than the unbounded load this path did before windowing.
+     * Reloading whole is that behaviour restored. Fire-and-forget: the load
+     * token still makes a later switch win, and the pending-send reconciliation
+     * inside `loadConversation` is what keeps the interrupting send's prompt.
+     * Only called when the conversation has NOT moved — a superseding switch
+     * announces and loads its own.
+     */
+    private reloadUnwindowed;
     /**
      * Replay a conversation's persisted history into the consumer's block view.
      *
@@ -2061,6 +2442,23 @@ declare class StreamManager {
      * what keeps a failed job list non-blocking exactly as it was when the fetch
      * lived here.
      */
+    /**
+     * Fetch and replay the next OLDER page of turns.
+     *
+     * The scroll-up half of tail-first restore: `restore` renders the newest
+     * page and clears `restoring`, and this brings back what precedes it, on
+     * demand. Full fidelity — the same per-job events wave the newest page uses,
+     * just later — so a turn paged in here is byte-identical to the same turn
+     * rendered live. That is the whole reason this defers the fetch rather than
+     * rebuilding older turns from the message list, which persists no thinking
+     * blocks and no custom events.
+     *
+     * Resolves to the number of turns emitted; 0 when there is nothing older,
+     * a page is already in flight, or the view was taken over mid-fetch.
+     */
+    /** User prompts from a slice of the message window, in plan input shape. */
+    private static userMessagesOf;
+    loadEarlierTurns(conversationId: string): Promise<number>;
     private replayHistory;
     private setActiveConversation;
 }
@@ -2149,4 +2547,4 @@ declare function isEmbeddedResource(value: unknown): value is {
  */
 declare function parseEmbeddedResource(value: unknown): EmbeddedResource | null;
 
-export { type ActiveJob, type AgentCapability, type AgentIdentity, type AgentInfo, type AgentStatus, type AssetCreatedPayload, type AstralformApiKeyConfig, AstralformClient, type AstralformConfig, AstralformError, type AstralformUserTokenConfig, type AttachmentStagedPayload, AuthenticationError, type AvailableRepositories, type AvailableRepository, type BlockDeltaPayload, CONVERSATION_PAGE_SIZE, type ChatEvent, ChatEventType, type ChatEventTypeValue, ChatSession, type ChatStorage, type ChatStreamEvent, type ChatStreamRequest, type CodeProject, ConnectionError, type ContextUpdatePayload, type ContextWarningPayload, type Conversation, type ConversationAsset, type ConversationEvent, type DesktopStreamPayload, type EffortRung, type EmbeddedResource, type FeedbackRequest, type FeedbackResponse, InMemoryStorage, type JobCreateResponse, type JobStatus, type JobSummary, LLMNotConfiguredError, type MemoryRecallPayload, type MemoryRecord, type MemoryUpdatePayload, type Message, type ModelChoiceOptions, type ModelOption, type MyToolGrantsPage, type NoteUpdatePayload, type PlanUpdatePayload, type PromptSuggestionPayload, type ProtocolAdapter, ProtocolRegistry, RateLimitError, type RateLimitErrorDetails, type RawSseEvent, type ReasoningEffort, type SendOptions, ServerError, type SkillInfo, StreamAbortedError, type StreamJobSSEOptions, StreamManager, type StreamManagerEvent, type StreamState, type SubagentStartPayload, type SubagentStopPayload, type TaskStatus, type TeamAgentSummary, type TeamSummary, type ThinkingDescriptor, type ThinkingRungOption, type TitleGeneratedPayload, type TodoItem, type TodoUpdatePayload, type ToolApprovalDecision, type ToolApprovalGrantedPayload, type ToolApprovalRequest, type ToolApprovalRequestedPayload, type ToolApprovalScope, type ToolCallRequest, type ToolDefinition, type ToolGrant, type ToolHandler, type ToolHarnessWarningPayload, type ToolPermissionDeniedPayload, ToolRegistry, type ToolResult, type ToolResultRequest, type TurnUsage, type UIComponentsConfig, type UserUnavailablePayload, VOICE_POLISH_MODES, type VoiceConfig, type VoiceLLMMode, type VoicePolishEvent, type VoicePolishMode, type VoicePolishRequest, type VoiceTranscribeOptions, type VoiceTranscript, type WireBlockDelta, type WireBlockDeltaPayload, type WireBlockKind, type WireBlockStart, type WireBlockStatus, type WireBlockStop, type WireCustomEvent, type WireErrorEvent, type WireEvent, type WireInputArgDelta, type WireInputDelta, type WireKeepalive, type WireMessageStart, type WireMessageStop, type WireOutputDelta, type WireRetryEvent, type WireSignatureDelta, type WireStallWarning, type WireStatusDelta, type WireStopReason, type WireTextDelta, type WireThinkingDelta, type WorkspaceReadyPayload, generateId, isEmbeddedResource, isVoiceLLMMode, isVoicePolishMode, mapSseToChat, parseEmbeddedResource, parseVoicePolishFrame, replayEvents, streamJobSSE, translateDelta };
+export { type ActiveJob, type AgentCapability, type AgentIdentity, type AgentInfo, type AgentStatus, type AssetCreatedPayload, type AstralformApiKeyConfig, AstralformClient, type AstralformConfig, AstralformError, type AstralformUserTokenConfig, type AttachmentStagedPayload, AuthenticationError, type AvailableRepositories, type AvailableRepository, type BlockDeltaPayload, CONVERSATION_PAGE_SIZE, type ChatEvent, ChatEventType, type ChatEventTypeValue, ChatSession, type ChatStorage, type ChatStreamEvent, type ChatStreamRequest, type CodeProject, ConnectionError, type ContextUpdatePayload, type ContextWarningPayload, type Conversation, type ConversationAsset, type ConversationEvent, type DesktopStreamPayload, type EffortRung, type EmbeddedResource, type FeedbackRequest, type FeedbackResponse, InMemoryStorage, type JobCreateResponse, type JobStatus, type JobSummary, LLMNotConfiguredError, type MemoryProviderErrorPayload, type MemoryRecallPayload, type MemoryRecord, type MemoryUpdatePayload, type Message, type ModelChoiceOptions, type ModelOption, type MyToolGrantsPage, type NestedLlmUsagePayload, type NoteUpdatePayload, type PlanUpdatePayload, type PromptSuggestionPayload, type ProtocolAdapter, ProtocolRegistry, RateLimitError, type RateLimitErrorDetails, type RawSseEvent, type ReasoningEffort, type SendOptions, ServerError, type SkillInfo, type SlashCommand, type SlashCommandSurface, StreamAbortedError, type StreamJobSSEOptions, StreamManager, type StreamManagerEvent, type StreamState, type SubagentStartPayload, type SubagentStopPayload, type TaskStatus, type TeamAgentSummary, type TeamSummary, type ThinkingDescriptor, type ThinkingRungOption, type TitleGeneratedPayload, type TodoItem, type TodoUpdatePayload, type ToolApprovalDecision, type ToolApprovalGrantedPayload, type ToolApprovalRequest, type ToolApprovalRequestedPayload, type ToolApprovalScope, type ToolCallRequest, type ToolDefinition, type ToolGrant, type ToolHandler, type ToolHarnessWarningPayload, type ToolOutputMode, type ToolOutputStub, type ToolPermissionDeniedPayload, type ToolProgressPayload, ToolRegistry, type ToolResult, type ToolResultRequest, type TurnUsage, type UIComponentsConfig, type UserUnavailablePayload, VOICE_POLISH_MODES, type VoiceConfig, type VoiceLLMMode, type VoicePolishEvent, type VoicePolishMode, type VoicePolishRequest, type VoiceTranscribeOptions, type VoiceTranscript, type WireBlockDelta, type WireBlockDeltaPayload, type WireBlockKind, type WireBlockStart, type WireBlockStatus, type WireBlockStop, type WireCustomEvent, type WireErrorEvent, type WireEvent, type WireInputArgDelta, type WireInputDelta, type WireKeepalive, type WireMessageStart, type WireMessageStop, type WireOutputDelta, type WireRetryEvent, type WireSignatureDelta, type WireStallWarning, type WireStatusDelta, type WireStopReason, type WireTextDelta, type WireThinkingDelta, type WorkspaceReadyPayload, generateId, isEmbeddedResource, isToolOutputStub, isVoiceLLMMode, isVoicePolishMode, mapSseToChat, parseEmbeddedResource, parseVoicePolishFrame, replayEvents, streamJobSSE, translateDelta };