@copilotkit/core 1.55.0-next.7

package/dist/index.d.cts

@@ -0,0 +1,1374 @@
+import * as _ag_ui_client0 from "@ag-ui/client";
+import { AbstractAgent, AgentSubscriber, BaseEvent, Context, HttpAgent, HttpAgentConfig, Message, RunAgentInput, RunAgentParameters, RunAgentResult, State, Tool, ToolCall } from "@ag-ui/client";
+import { IntelligenceRuntimeInfo, IntelligenceRuntimeInfo as IntelligenceRuntimeInfo$1, RuntimeLicenseStatus, RuntimeLicenseStatus as RuntimeLicenseStatus$1, RuntimeMode, RuntimeMode as RuntimeMode$1, StandardSchemaV1 } from "@copilotkit/shared";
+import { Observable, OperatorFunction } from "rxjs";
+
+//#region src/types.d.ts
+/**
+ * Status of a tool call execution
+ */
+declare enum ToolCallStatus {
+  InProgress = "inProgress",
+  Executing = "executing",
+  Complete = "complete"
+}
+type CopilotRuntimeTransport = "rest" | "single";
+/**
+ * Context passed to a frontend tool handler
+ */
+type FrontendToolHandlerContext = {
+  toolCall: ToolCall;
+  agent: AbstractAgent;
+  /** Aborted when `stopAgent()` is called. Handlers can check `signal.aborted`
+   *  or pass the signal to fetch/setTimeout to cooperatively cancel. */
+  signal?: AbortSignal;
+};
+type FrontendTool<T extends Record<string, unknown> = Record<string, unknown>> = {
+  name: string;
+  description?: string;
+  parameters?: StandardSchemaV1<any, T>;
+  handler?: (args: T, context: FrontendToolHandlerContext) => Promise<unknown>;
+  followUp?: boolean;
+  /**
+   * Optional agent ID to constrain this tool to a specific agent.
+   * If specified, this tool will only be available to the specified agent.
+   */
+  agentId?: string;
+  /**
+   * Whether this tool is available to the agent.
+   * Set to false to hide the tool from the agent without unregistering it.
+   * Defaults to true when not specified.
+   */
+  available?: boolean;
+};
+type Suggestion = {
+  title: string;
+  message: string; /** Indicates whether this suggestion is still being generated. */
+  isLoading: boolean;
+};
+type SuggestionAvailability = "before-first-message" | "after-first-message" | "always" | "disabled";
+type DynamicSuggestionsConfig = {
+  /**
+   * A prompt or instructions for the GPT to generate suggestions.
+   */
+  instructions: string;
+  /**
+   * The minimum number of suggestions to generate. Defaults to `1`.
+   * @default 1
+   */
+  minSuggestions?: number;
+  /**
+   * The maximum number of suggestions to generate. Defaults to `3`.
+   * @default 1
+   */
+  maxSuggestions?: number;
+  /**
+   * When the suggestions are available. Defaults to "after-first-message".
+   */
+  available?: SuggestionAvailability;
+  /**
+   * The agent ID of the provider of the suggestions. Defaults to `"default"`.
+   */
+  providerAgentId?: string;
+  /**
+   * The agent ID of the consumer of the suggestions. Defaults to `"*"` (all agents).
+   */
+  consumerAgentId?: string;
+};
+type StaticSuggestionsConfig = {
+  /**
+   * The suggestions to display.
+   */
+  suggestions: Omit<Suggestion, "isLoading">[];
+  /**
+   * When the suggestions are available. Defaults to "before-first-message".
+   */
+  available?: SuggestionAvailability;
+  /**
+   * The agent ID of the consumer of the suggestions. Defaults to `"*"` (all agents).
+   */
+  consumerAgentId?: string;
+};
+type SuggestionsConfig = DynamicSuggestionsConfig | StaticSuggestionsConfig;
+//#endregion
+//#region src/core/agent-registry.d.ts
+interface CopilotKitCoreAddAgentParams {
+  id: string;
+  agent: AbstractAgent;
+}
+/**
+ * Manages agent registration, lifecycle, and runtime connectivity for CopilotKitCore.
+ * Handles both local development agents and remote runtime agents.
+ */
+declare class AgentRegistry {
+  private core;
+  private _agents;
+  private localAgents;
+  private remoteAgents;
+  private _runtimeUrl?;
+  private _runtimeVersion?;
+  private _runtimeConnectionStatus;
+  private _runtimeTransport;
+  private _audioFileTranscriptionEnabled;
+  private _runtimeMode;
+  private _intelligence?;
+  private _a2uiEnabled;
+  private _licenseStatus?;
+  constructor(core: CopilotKitCore);
+  /**
+   * Get all agents as a readonly record
+   */
+  get agents(): Readonly<Record<string, AbstractAgent>>;
+  get runtimeUrl(): string | undefined;
+  get runtimeVersion(): string | undefined;
+  get runtimeConnectionStatus(): CopilotKitCoreRuntimeConnectionStatus;
+  get runtimeTransport(): CopilotRuntimeTransport;
+  get audioFileTranscriptionEnabled(): boolean;
+  get runtimeMode(): RuntimeMode$1;
+  get intelligence(): IntelligenceRuntimeInfo$1 | undefined;
+  get a2uiEnabled(): boolean;
+  get licenseStatus(): RuntimeLicenseStatus$1 | undefined;
+  /**
+   * Initialize agents from configuration
+   */
+  initialize(agents: Record<string, AbstractAgent>): void;
+  /**
+   * Set the runtime URL and update connection
+   */
+  setRuntimeUrl(runtimeUrl: string | undefined): void;
+  setRuntimeTransport(runtimeTransport: CopilotRuntimeTransport): void;
+  /**
+   * Set all agents at once (for development use)
+   */
+  setAgents__unsafe_dev_only(agents: Record<string, AbstractAgent>): void;
+  /**
+   * Add a single agent (for development use)
+   */
+  addAgent__unsafe_dev_only({
+    id,
+    agent
+  }: CopilotKitCoreAddAgentParams): void;
+  /**
+   * Remove an agent by ID (for development use)
+   */
+  removeAgent__unsafe_dev_only(id: string): void;
+  /**
+   * Get an agent by ID
+   */
+  getAgent(id: string): AbstractAgent | undefined;
+  /**
+   * Apply current headers to an agent
+   */
+  applyHeadersToAgent(agent: AbstractAgent): void;
+  /**
+   * Apply current headers to all agents
+   */
+  applyHeadersToAgents(agents: Record<string, AbstractAgent>): void;
+  /**
+   * Apply current credentials to an agent
+   */
+  applyCredentialsToAgent(agent: AbstractAgent): void;
+  /**
+   * Apply current credentials to all agents
+   */
+  applyCredentialsToAgents(agents: Record<string, AbstractAgent>): void;
+  /**
+   * Update runtime connection and fetch remote agents
+   */
+  private updateRuntimeConnection;
+  private fetchRuntimeInfo;
+  /**
+   * Assign agent IDs to a record of agents
+   */
+  private assignAgentIds;
+  /**
+   * Validate and assign an agent ID
+   */
+  private validateAndAssignAgentId;
+  /**
+   * Notify subscribers of runtime status changes
+   */
+  private notifyRuntimeStatusChanged;
+  /**
+   * Notify subscribers of agent changes
+   */
+  private notifyAgentsChanged;
+}
+//#endregion
+//#region src/core/run-handler.d.ts
+interface CopilotKitCoreRunAgentParams {
+  agent: AbstractAgent;
+  forwardedProps?: Record<string, unknown>;
+}
+interface CopilotKitCoreConnectAgentParams {
+  agent: AbstractAgent;
+}
+interface CopilotKitCoreGetToolParams {
+  toolName: string;
+  agentId?: string;
+}
+/**
+ * Parameters for programmatic tool execution via `copilotkit.runTool()`.
+ */
+interface CopilotKitCoreRunToolParams {
+  /** Name of the registered frontend tool to execute. */
+  name: string;
+  /** Optional agent ID. If omitted, uses the default agent lookup. */
+  agentId?: string;
+  /** Parameters to pass to the tool handler. */
+  parameters?: Record<string, unknown>;
+  /**
+   * Whether to trigger an LLM follow-up after tool execution.
+   * - `false` (default): execute tool, add messages to history, done.
+   * - `"generate"`: after execution, trigger another agent run so the LLM responds to the tool result.
+   * - Any other string: add a user message with this text, then trigger another agent run.
+   */
+  followUp?: string | false;
+}
+/**
+ * Result of programmatic tool execution via `copilotkit.runTool()`.
+ */
+interface CopilotKitCoreRunToolResult {
+  /** The unique ID of the tool call. */
+  toolCallId: string;
+  /** The stringified result from the tool handler. */
+  result: string;
+  /** Error message if the handler failed. */
+  error?: string;
+}
+/**
+ * Handles agent execution, tool calling, and agent connectivity for CopilotKitCore.
+ * Manages the complete lifecycle of agent runs including tool execution and follow-ups.
+ */
+declare class RunHandler {
+  private core;
+  private _tools;
+  /**
+   * Tracks whether the current run (including in-flight tool execution)
+   * has been aborted via `stopAgent()` or `agent.abortRun()`. Created
+   * fresh in `runAgent()`, aborted by `abortCurrentRun()`.
+   */
+  private _runAbortController;
+  /**
+   * Tracks recursive `runAgent` depth so that the abort controller and
+   * `agent.abortRun()` intercept are only set up / torn down at the
+   * top-level call, not on follow-up recursive calls from
+   * `processAgentResult`.
+   */
+  private _runDepth;
+  constructor(core: CopilotKitCore);
+  /**
+   * Abort the current run. Called by `CopilotKitCore.stopAgent()` to signal
+   * that in-flight tool handlers should stop and `processAgentResult` should
+   * not start a follow-up run.
+   */
+  abortCurrentRun(): void;
+  /**
+   * Typed access to CopilotKitCore's internal ("friend") methods.
+   * Centralises the single unavoidable cast so call-sites stay clean.
+   */
+  private get _internal();
+  /**
+   * Get all tools as a readonly array
+   */
+  get tools(): Readonly<FrontendTool<any>[]>;
+  /**
+   * Initialize with tools
+   */
+  initialize(tools: FrontendTool<any>[]): void;
+  /**
+   * Add a tool to the registry
+   */
+  addTool<T extends Record<string, unknown> = Record<string, unknown>>(tool: FrontendTool<T>): void;
+  /**
+   * Remove a tool by name and optionally by agentId
+   */
+  removeTool(id: string, agentId?: string): void;
+  /**
+   * Get a tool by name and optionally by agentId.
+   * If agentId is provided, it will first look for an agent-specific tool,
+   * then fall back to a global tool with the same name.
+   */
+  getTool(params: CopilotKitCoreGetToolParams): FrontendTool<any> | undefined;
+  /**
+   * Set all tools at once. Replaces existing tools.
+   */
+  setTools(tools: FrontendTool<any>[]): void;
+  /**
+   * Connect an agent (establish initial connection)
+   */
+  connectAgent({
+    agent
+  }: CopilotKitCoreConnectAgentParams): Promise<RunAgentResult>;
+  /**
+   * Run an agent
+   */
+  runAgent({
+    agent,
+    forwardedProps
+  }: CopilotKitCoreRunAgentParams): Promise<RunAgentResult>;
+  /**
+   * Process agent result and execute tools
+   */
+  private processAgentResult;
+  /**
+   * Shared handler execution logic used by executeSpecificTool, executeWildcardTool, and runTool.
+   * Handles arg parsing, subscriber notifications, handler invocation, result stringification,
+   * and error handling.
+   */
+  private executeToolHandler;
+  /**
+   * Execute a specific tool
+   */
+  private executeSpecificTool;
+  /**
+   * Execute a wildcard tool.
+   * Wildcard tools receive args wrapped as `{toolName, args}`, which differs from
+   * specific tools, so this method keeps its own arg-wrapping logic rather than
+   * delegating to `executeToolHandler`.
+   */
+  private executeWildcardTool;
+  /**
+   * Programmatically execute a registered frontend tool without going through an LLM turn.
+   * The handler runs, render components show up in the UI, and both the tool call and
+   * result messages are added to `agent.messages`.
+   */
+  runTool(params: CopilotKitCoreRunToolParams): Promise<CopilotKitCoreRunToolResult>;
+  /**
+   * Build frontend tools for an agent
+   */
+  buildFrontendTools(agentId?: string): Tool[];
+  /**
+   * Create an agent error subscriber
+   */
+  private createAgentErrorSubscriber;
+}
+/**
+ * Ensures parsed tool arguments are a plain object.
+ * Throws for non-object values so the caller's catch block can emit
+ * a structured TOOL_ARGUMENT_PARSE_FAILED error.
+ *
+ * @internal Exported for testing only.
+ */
+declare function ensureObjectArgs(parsed: unknown, toolName: string): Record<string, unknown>;
+/**
+ * Parses raw tool call arguments into a validated object.
+ *
+ * Some LLM providers (e.g. @ai-sdk/openai-compatible) may send empty string "",
+ * null, or undefined instead of "{}". This function normalises those cases to an
+ * empty object so callers don't crash on JSON.parse("").
+ *
+ * A debug-level warning is emitted when the fallback triggers so silent coercion
+ * is observable in logs.
+ *
+ * @internal Exported for testing only.
+ */
+declare function parseToolArguments(rawArgs: unknown, toolName: string): Record<string, unknown>;
+//#endregion
+//#region src/core/core.d.ts
+/** Configuration options for `CopilotKitCore`. */
+interface CopilotKitCoreConfig {
+  /** The endpoint of the CopilotRuntime. */
+  runtimeUrl?: string;
+  /** Transport style for CopilotRuntime endpoints. Defaults to REST. */
+  runtimeTransport?: CopilotRuntimeTransport;
+  /** Mapping from agent name to its `AbstractAgent` instance. For development only - production requires CopilotRuntime. */
+  agents__unsafe_dev_only?: Record<string, AbstractAgent>;
+  /** Headers appended to every HTTP request made by `CopilotKitCore`. */
+  headers?: Record<string, string>;
+  /** Credentials mode for fetch requests (e.g., "include" for HTTP-only cookies). */
+  credentials?: RequestCredentials;
+  /** Properties sent as `forwardedProps` to the AG-UI agent. */
+  properties?: Record<string, unknown>;
+  /** Ordered collection of frontend tools available to the core. */
+  tools?: FrontendTool<any>[];
+  /** Suggestions config for the core. */
+  suggestionsConfig?: SuggestionsConfig[];
+}
+interface CopilotKitCoreStopAgentParams {
+  agent: AbstractAgent;
+}
+type CopilotKitCoreGetSuggestionsResult = {
+  suggestions: Suggestion[];
+  isLoading: boolean;
+};
+declare enum CopilotKitCoreErrorCode {
+  RUNTIME_INFO_FETCH_FAILED = "runtime_info_fetch_failed",
+  AGENT_CONNECT_FAILED = "agent_connect_failed",
+  AGENT_RUN_FAILED = "agent_run_failed",
+  AGENT_RUN_FAILED_EVENT = "agent_run_failed_event",
+  AGENT_RUN_ERROR_EVENT = "agent_run_error_event",
+  TOOL_ARGUMENT_PARSE_FAILED = "tool_argument_parse_failed",
+  TOOL_HANDLER_FAILED = "tool_handler_failed",
+  TOOL_NOT_FOUND = "tool_not_found",
+  AGENT_NOT_FOUND = "agent_not_found",
+  /**
+   * Emitted when an agent run fails because the thread is already locked
+   * by another active run.
+   *
+   * @example
+   * ```tsx
+   * <CopilotKitProvider
+   *   onError={({ code, error, context }) => {
+   *     if (code === "agent_thread_locked") {
+   *       // Show "Agent is busy, retry?" UI
+   *     }
+   *   }}
+   * />
+   * ```
+   */
+  AGENT_THREAD_LOCKED = "agent_thread_locked",
+  TRANSCRIPTION_FAILED = "transcription_failed",
+  TRANSCRIPTION_SERVICE_NOT_CONFIGURED = "transcription_service_not_configured",
+  TRANSCRIPTION_INVALID_AUDIO = "transcription_invalid_audio",
+  TRANSCRIPTION_RATE_LIMITED = "transcription_rate_limited",
+  TRANSCRIPTION_AUTH_FAILED = "transcription_auth_failed",
+  TRANSCRIPTION_NETWORK_ERROR = "transcription_network_error"
+}
+interface CopilotKitCoreSubscriber {
+  onRuntimeConnectionStatusChanged?: (event: {
+    copilotkit: CopilotKitCore;
+    status: CopilotKitCoreRuntimeConnectionStatus;
+  }) => void | Promise<void>;
+  onToolExecutionStart?: (event: {
+    copilotkit: CopilotKitCore;
+    toolCallId: string;
+    agentId: string;
+    toolName: string;
+    args: unknown;
+  }) => void | Promise<void>;
+  onToolExecutionEnd?: (event: {
+    copilotkit: CopilotKitCore;
+    toolCallId: string;
+    agentId: string;
+    toolName: string;
+    result: string;
+    error?: string;
+  }) => void | Promise<void>;
+  onAgentsChanged?: (event: {
+    copilotkit: CopilotKitCore;
+    agents: Readonly<Record<string, AbstractAgent>>;
+  }) => void | Promise<void>;
+  onContextChanged?: (event: {
+    copilotkit: CopilotKitCore;
+    context: Readonly<Record<string, Context>>;
+  }) => void | Promise<void>;
+  onSuggestionsConfigChanged?: (event: {
+    copilotkit: CopilotKitCore;
+    suggestionsConfig: Readonly<Record<string, SuggestionsConfig>>;
+  }) => void | Promise<void>;
+  onSuggestionsChanged?: (event: {
+    copilotkit: CopilotKitCore;
+    agentId: string;
+    suggestions: Suggestion[];
+  }) => void | Promise<void>;
+  onSuggestionsStartedLoading?: (event: {
+    copilotkit: CopilotKitCore;
+    agentId: string;
+  }) => void | Promise<void>;
+  onSuggestionsFinishedLoading?: (event: {
+    copilotkit: CopilotKitCore;
+    agentId: string;
+  }) => void | Promise<void>;
+  onPropertiesChanged?: (event: {
+    copilotkit: CopilotKitCore;
+    properties: Readonly<Record<string, unknown>>;
+  }) => void | Promise<void>;
+  onHeadersChanged?: (event: {
+    copilotkit: CopilotKitCore;
+    headers: Readonly<Record<string, string>>;
+  }) => void | Promise<void>;
+  onError?: (event: {
+    copilotkit: CopilotKitCore;
+    error: Error;
+    code: CopilotKitCoreErrorCode;
+    context: Record<string, any>;
+  }) => void | Promise<void>;
+}
+interface CopilotKitCoreSubscription {
+  unsubscribe: () => void;
+}
+declare enum CopilotKitCoreRuntimeConnectionStatus {
+  Disconnected = "disconnected",
+  Connected = "connected",
+  Connecting = "connecting",
+  Error = "error"
+}
+/**
+ * Internal interface for delegate classes to access CopilotKitCore methods.
+ * This provides type safety while allowing controlled access to private functionality.
+ */
+interface CopilotKitCoreFriendsAccess {
+  notifySubscribers(handler: (subscriber: CopilotKitCoreSubscriber) => void | Promise<void>, errorMessage: string): Promise<void>;
+  emitError(params: {
+    error: Error;
+    code: CopilotKitCoreErrorCode;
+    context?: Record<string, any>;
+  }): Promise<void>;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly credentials: RequestCredentials | undefined;
+  readonly properties: Readonly<Record<string, unknown>>;
+  readonly context: Readonly<Record<string, Context>>;
+  buildFrontendTools(agentId?: string): _ag_ui_client0.Tool[];
+  getAgent(id: string): AbstractAgent | undefined;
+  readonly suggestionEngine: {
+    clearSuggestions(agentId: string): void;
+    reloadSuggestions(agentId: string): void;
+  };
+  /**
+   * Called before each follow-up agent run (after tool execution).
+   * See CopilotKitCore.waitForPendingFrameworkUpdates for details.
+   */
+  waitForPendingFrameworkUpdates(): Promise<void>;
+}
+declare class CopilotKitCore {
+  private _headers;
+  private _credentials?;
+  private _properties;
+  private subscribers;
+  private agentRegistry;
+  private contextStore;
+  private suggestionEngine;
+  private runHandler;
+  private stateManager;
+  constructor({
+    runtimeUrl,
+    runtimeTransport,
+    headers,
+    credentials,
+    properties,
+    agents__unsafe_dev_only,
+    tools,
+    suggestionsConfig
+  }: CopilotKitCoreConfig);
+  /**
+   * Internal method used by delegate classes and subclasses to notify subscribers
+   */
+  protected notifySubscribers(handler: (subscriber: CopilotKitCoreSubscriber) => void | Promise<void>, errorMessage: string): Promise<void>;
+  /**
+   * Internal method used by delegate classes to emit errors
+   */
+  private emitError;
+  /**
+   * Snapshot accessors
+   */
+  get context(): Readonly<Record<string, Context>>;
+  get agents(): Readonly<Record<string, AbstractAgent>>;
+  get tools(): Readonly<FrontendTool<any>[]>;
+  get runtimeUrl(): string | undefined;
+  setRuntimeUrl(runtimeUrl: string | undefined): void;
+  get runtimeTransport(): CopilotRuntimeTransport;
+  setRuntimeTransport(runtimeTransport: CopilotRuntimeTransport): void;
+  get runtimeVersion(): string | undefined;
+  get headers(): Readonly<Record<string, string>>;
+  get credentials(): RequestCredentials | undefined;
+  get properties(): Readonly<Record<string, unknown>>;
+  get runtimeConnectionStatus(): CopilotKitCoreRuntimeConnectionStatus;
+  get audioFileTranscriptionEnabled(): boolean;
+  get runtimeMode(): RuntimeMode;
+  get intelligence(): IntelligenceRuntimeInfo | undefined;
+  get a2uiEnabled(): boolean;
+  get licenseStatus(): RuntimeLicenseStatus | undefined;
+  /**
+   * Configuration updates
+   */
+  setHeaders(headers: Record<string, string>): void;
+  setCredentials(credentials: RequestCredentials | undefined): void;
+  setProperties(properties: Record<string, unknown>): void;
+  /**
+   * Agent management (delegated to AgentRegistry)
+   */
+  setAgents__unsafe_dev_only(agents: Record<string, AbstractAgent>): void;
+  addAgent__unsafe_dev_only(params: CopilotKitCoreAddAgentParams): void;
+  removeAgent__unsafe_dev_only(id: string): void;
+  getAgent(id: string): AbstractAgent | undefined;
+  /**
+   * Context management (delegated to ContextStore)
+   */
+  addContext(context: Context): string;
+  removeContext(id: string): void;
+  /**
+   * Suggestions management (delegated to SuggestionEngine)
+   */
+  addSuggestionsConfig(config: SuggestionsConfig): string;
+  removeSuggestionsConfig(id: string): void;
+  reloadSuggestions(agentId: string): void;
+  clearSuggestions(agentId: string): void;
+  getSuggestions(agentId: string): CopilotKitCoreGetSuggestionsResult;
+  /**
+   * Tool management (delegated to RunHandler)
+   */
+  addTool<T extends Record<string, unknown> = Record<string, unknown>>(tool: FrontendTool<T>): void;
+  removeTool(id: string, agentId?: string): void;
+  getTool(params: CopilotKitCoreGetToolParams): FrontendTool<any> | undefined;
+  setTools(tools: FrontendTool<any>[]): void;
+  /**
+   * Subscription lifecycle
+   */
+  subscribe(subscriber: CopilotKitCoreSubscriber): CopilotKitCoreSubscription;
+  /**
+   * Agent connectivity (delegated to RunHandler)
+   */
+  connectAgent(params: CopilotKitCoreConnectAgentParams): Promise<_ag_ui_client0.RunAgentResult>;
+  stopAgent(params: CopilotKitCoreStopAgentParams): void;
+  runAgent(params: CopilotKitCoreRunAgentParams): Promise<_ag_ui_client0.RunAgentResult>;
+  /**
+   * Programmatically execute a registered frontend tool without going through an LLM turn.
+   * The handler runs, render components show up in the UI, and both the tool call and
+   * result messages are added to `agent.messages`.
+   */
+  runTool(params: CopilotKitCoreRunToolParams): Promise<CopilotKitCoreRunToolResult>;
+  /**
+   * State management (delegated to StateManager)
+   */
+  getStateByRun(agentId: string, threadId: string, runId: string): State | undefined;
+  getRunIdForMessage(agentId: string, threadId: string, messageId: string): string | undefined;
+  getRunIdsForThread(agentId: string, threadId: string): string[];
+  /**
+   * Internal method used by RunHandler to build frontend tools
+   */
+  private buildFrontendTools;
+  /**
+   * Called before each follow-up agent run (after tool execution).
+   *
+   * When a frontend tool handler calls framework state setters (e.g. React's
+   * setState), those updates are batched and deferred — they do not take effect
+   * until the framework's scheduler runs (React uses MessageChannel).
+   * useAgentContext registers context via useLayoutEffect, which runs
+   * synchronously after React commits that deferred batch.
+   *
+   * Without yielding here, the follow-up runAgent reads the context store
+   * synchronously while the deferred updates are still pending, producing stale
+   * context for the next agent turn.
+   *
+   * Override in framework-specific subclasses to yield to the framework
+   * scheduler before the follow-up run. The base implementation is a no-op
+   * because non-React environments have no deferred state to flush.
+   */
+  waitForPendingFrameworkUpdates(): Promise<void>;
+}
+//#endregion
+//#region src/core/context-store.d.ts
+/**
+ * Manages context storage and lifecycle for CopilotKitCore.
+ * Context represents additional information available to agents during execution.
+ */
+declare class ContextStore {
+  private core;
+  private _context;
+  constructor(core: CopilotKitCore);
+  /**
+   * Get all context entries as a readonly record
+   */
+  get context(): Readonly<Record<string, Context>>;
+  /**
+   * Add a new context entry
+   * @returns The ID of the created context entry
+   */
+  addContext({
+    description,
+    value
+  }: Context): string;
+  /**
+   * Remove a context entry by ID
+   */
+  removeContext(id: string): void;
+  /**
+   * Notify all subscribers of context changes
+   */
+  private notifySubscribers;
+}
+//#endregion
+//#region src/core/suggestion-engine.d.ts
+/**
+ * Manages suggestion generation, streaming, and lifecycle for CopilotKitCore.
+ * Handles both dynamic (AI-generated) and static suggestions.
+ */
+declare class SuggestionEngine {
+  private core;
+  private _suggestionsConfig;
+  private _suggestions;
+  private _runningSuggestions;
+  constructor(core: CopilotKitCore);
+  /**
+   * Initialize with suggestion configs
+   */
+  initialize(suggestionsConfig: SuggestionsConfig[]): void;
+  /**
+   * Add a suggestion configuration
+   * @returns The ID of the created config
+   */
+  addSuggestionsConfig(config: SuggestionsConfig): string;
+  /**
+   * Remove a suggestion configuration by ID
+   */
+  removeSuggestionsConfig(id: string): void;
+  /**
+   * Reload suggestions for a specific agent
+   * This triggers generation of new suggestions based on current configs
+   */
+  reloadSuggestions(agentId: string): void;
+  /**
+   * Clear all suggestions for a specific agent
+   */
+  clearSuggestions(agentId: string): void;
+  /**
+   * Get current suggestions for an agent
+   */
+  getSuggestions(agentId: string): CopilotKitCoreGetSuggestionsResult;
+  /**
+   * Generate suggestions using a provider agent
+   */
+  private generateSuggestions;
+  /**
+   * Finalize suggestions by marking them as no longer loading
+   */
+  private finalizeSuggestions;
+  /**
+   * Extract suggestions from messages (called during streaming)
+   */
+  extractSuggestions(messages: Message[], suggestionId: string, consumerAgentId: string, isRunning: boolean): void;
+  /**
+   * Notify subscribers of suggestions config changes
+   */
+  private notifySuggestionsConfigChanged;
+  /**
+   * Notify subscribers of suggestions changes
+   */
+  private notifySuggestionsChanged;
+  /**
+   * Notify subscribers that suggestions started loading
+   */
+  private notifySuggestionsStartedLoading;
+  /**
+   * Notify subscribers that suggestions finished loading
+   */
+  private notifySuggestionsFinishedLoading;
+  /**
+   * Check if suggestions should be shown based on availability and message count
+   */
+  private shouldShowSuggestions;
+  /**
+   * Add static suggestions directly without AI generation
+   */
+  private addStaticSuggestions;
+}
+//#endregion
+//#region src/core/state-manager.d.ts
+/**
+ * Manages state and message tracking by run for CopilotKitCore.
+ * Tracks agent state snapshots and message-to-run associations.
+ */
+declare class StateManager {
+  private core;
+  private stateByRun;
+  private messageToRun;
+  private agentSubscriptions;
+  constructor(core: CopilotKitCore);
+  /**
+   * Initialize state tracking for an agent
+   */
+  initialize(): void;
+  /**
+   * Subscribe to an agent's events to track state and messages
+   */
+  subscribeToAgent(agent: AbstractAgent): void;
+  /**
+   * Unsubscribe from an agent's events
+   */
+  unsubscribeFromAgent(agentId: string): void;
+  /**
+   * Get state for a specific run
+   * Returns a deep copy to prevent external mutations
+   */
+  getStateByRun(agentId: string, threadId: string, runId: string): State | undefined;
+  /**
+   * Get runId associated with a message
+   */
+  getRunIdForMessage(agentId: string, threadId: string, messageId: string): string | undefined;
+  /**
+   * Get all states for an agent's thread
+   */
+  getStatesForThread(agentId: string, threadId: string): Map<string, State>;
+  /**
+   * Get all run IDs for an agent's thread
+   */
+  getRunIdsForThread(agentId: string, threadId: string): string[];
+  /**
+   * Handle run started event
+   */
+  private handleRunStarted;
+  /**
+   * Handle run finished event
+   */
+  private handleRunFinished;
+  /**
+   * Handle state snapshot event
+   */
+  private handleStateSnapshot;
+  /**
+   * Handle state delta event
+   */
+  private handleStateDelta;
+  /**
+   * Handle messages snapshot event
+   */
+  private handleMessagesSnapshot;
+  /**
+   * Handle new message event
+   */
+  private handleNewMessage;
+  /**
+   * Save state for a specific run
+   */
+  private saveState;
+  /**
+   * Associate a message with a run
+   */
+  private associateMessageWithRun;
+  /**
+   * Clear all state for an agent
+   */
+  clearAgentState(agentId: string): void;
+  /**
+   * Clear all state for a thread
+   */
+  clearThreadState(agentId: string, threadId: string): void;
+}
+//#endregion
+//#region src/agent.d.ts
+type ResolvedRuntimeMode = RuntimeMode$1 | "pending";
+interface ProxiedCopilotRuntimeAgentConfig extends Omit<HttpAgentConfig, "url"> {
+  runtimeUrl?: string;
+  transport?: CopilotRuntimeTransport;
+  credentials?: RequestCredentials;
+  runtimeMode?: ResolvedRuntimeMode;
+  intelligence?: IntelligenceRuntimeInfo$1;
+}
+declare class ProxiedCopilotRuntimeAgent extends HttpAgent {
+  #private;
+  runtimeUrl?: string;
+  credentials?: RequestCredentials;
+  private transport;
+  private singleEndpointUrl?;
+  private runtimeMode;
+  private intelligence?;
+  private delegate?;
+  private runtimeInfoPromise?;
+  constructor(config: ProxiedCopilotRuntimeAgentConfig);
+  detachActiveRun(): Promise<void>;
+  abortRun(): void;
+  connectAgent(parameters?: RunAgentParameters, subscriber?: AgentSubscriber): Promise<RunAgentResult>;
+  connect(input: RunAgentInput): Observable<BaseEvent>;
+  run(input: RunAgentInput): Observable<BaseEvent>;
+  clone(): ProxiedCopilotRuntimeAgent;
+  private resolveDelegate;
+  private ensureRuntimeMode;
+  private fetchRuntimeInfo;
+  private createSingleRouteRequestInit;
+  private createIntelligenceDelegate;
+  private syncDelegate;
+}
+//#endregion
+//#region src/utils/markdown.d.ts
+declare function completePartialMarkdown(input: string): string;
+//#endregion
+//#region src/intelligence-agent.d.ts
+interface IntelligenceAgentSharedState {
+  lastSeenEventIds: Map<string, string>;
+}
+declare class AgentThreadLockedError extends Error {
+  constructor(threadId?: string);
+}
+interface IntelligenceAgentConfig {
+  /** Phoenix websocket URL, e.g. "ws://localhost:4000/socket" */
+  url: string;
+  /** Runtime REST URL, e.g. "http://localhost:4000" */
+  runtimeUrl: string;
+  /** Agent identifier for REST endpoints */
+  agentId: string;
+  /** Optional params sent on socket connect (e.g. auth token) */
+  socketParams?: Record<string, string>;
+  /** Optional headers sent with REST requests */
+  headers?: Record<string, string>;
+  /** Optional credentials mode for fetch requests */
+  credentials?: RequestCredentials;
+}
+declare class IntelligenceAgent extends AbstractAgent {
+  private config;
+  private socket;
+  private activeChannel;
+  private runId;
+  private sharedState;
+  constructor(config: IntelligenceAgentConfig, sharedState?: IntelligenceAgentSharedState);
+  clone(): IntelligenceAgent;
+  /**
+   * Override of AbstractAgent.connectAgent that removes the `verifyEvents` step.
+   *
+   * Background: AbstractAgent's connectAgent pipeline runs events through
+   * `verifyEvents`, which validates that the stream follows the AG-UI protocol
+   * lifecycle — specifically, it expects a RUN_STARTED event before any content
+   * events and a RUN_FINISHED/RUN_ERROR event to complete the stream.
+   *
+   * IntelligenceAgent uses long-lived WebSocket connections rather than
+   * request-scoped SSE streams. When connecting to replay historical messages
+   * for an existing thread, the connection semantics don't map to a single
+   * agent run start/stop cycle. The replayed events may not include
+   * RUN_STARTED/RUN_FINISHED bookends (or may contain events from multiple
+   * past runs), which causes verifyEvents to either never complete or to
+   * error out.
+   *
+   * This override replicates the base connectAgent implementation exactly,
+   * substituting only `transformChunks` (which is still needed for message
+   * reassembly) and omitting `verifyEvents`.
+   *
+   * TODO: Remove this override once AG-UI's AbstractAgent supports opting out
+   * of verifyEvents for transports with different connection life-cycles.
+   */
+  connectAgent(parameters?: RunAgentParameters, subscriber?: AgentSubscriber): Promise<RunAgentResult>;
+  abortRun(): void;
+  /**
+   * Trigger the run via REST, then join the realtime thread channel and relay
+   * server-pushed AG-UI events to the Observable subscriber.
+   */
+  run(input: RunAgentInput): Observable<BaseEvent>;
+  /**
+   * Reconnect to an existing thread by fetching websocket credentials and
+   * joining the realtime thread channel.
+   */
+  protected connect(input: RunAgentInput): Observable<BaseEvent>;
+  /**
+   * Tear down a specific channel + socket pair that belongs to one pipeline.
+   * Only nulls instance references when they still point to the owned resource,
+   * so a concurrent pipeline's resources are never clobbered.
+   */
+  private cleanupOwned;
+  private cleanup;
+  private requestJoinCredentials$;
+  private requestConnectPlan$;
+  private normalizeConnectPlan;
+  private observeThread$;
+  private joinThreadChannel$;
+  private observeSocketHealth$;
+  private observeThreadEvents$;
+  private observeChannelEvent$;
+  private createThreadNotifications;
+  private buildRuntimeUrl;
+  private createThreadChannelDescriptor;
+  private getLastSeenEventId;
+  private getReconnectCursor;
+  private hasLocalThreadMessages;
+  private updateLastSeenEventId;
+  private setLastSeenEventId;
+  /**
+   * Keep `this.runId` in sync with the backend's actual run ID.
+   *
+   * During a `connect` (resume) flow the client generates a fresh `runId`
+   * via `prepareRunAgentInput`, but the backend is running under its own
+   * run ID.  If the client later sends `STOP_RUN_EVENT` with the wrong
+   * `runId`, the gateway's runner channel will not match it and the agent
+   * keeps running.  Extracting the run ID from live events fixes this.
+   *
+   * The runner normalises events to `run_id` (snake_case) before pushing
+   * to the gateway, so we check both `runId` and `run_id`.
+   */
+  private updateRunIdFromEvent;
+  private readEventId;
+}
+//#endregion
+//#region src/utils/micro-redux.d.ts
+/**
+ * The minimal action shape used by this micro-redux implementation.
+ */
+interface AnyAction {
+  type: string;
+}
+/**
+ * A typed action creator function with a `type` literal and runtime matcher.
+ */
+type ActionCreator<Type extends string, Args extends unknown[] = unknown[], Action extends AnyAction & {
+  type: Type;
+} = {
+  type: Type;
+}> = ((...args: Args) => Action) & {
+  type: Type;
+  match(action: AnyAction): action is Action;
+};
+/**
+ * Extracts the action type produced by an action creator.
+ */
+type ActionFromCreator<T> = T extends ((...args: any[]) => infer A) ? A : never;
+/**
+ * Extracts a union of actions produced by a tuple/array of action creators.
+ */
+type ActionFromCreators<Creators extends readonly ActionCreator<string, any[], any>[]> = ActionFromCreator<Creators[number]>;
+/**
+ * A reducer transforms state in response to actions.
+ */
+type Reducer<State, Action extends AnyAction = AnyAction> = (state: State | undefined, action: Action) => State;
+/**
+ * A selector derives a value from state.
+ */
+type Selector<State, Result> = (state: State) => Result;
+/**
+ * Marker config for action creators that accept no payload.
+ */
+interface EmptyActionConfig {
+  readonly kind: "empty";
+}
+declare const PROPS_MARKER: unique symbol;
+/**
+ * Marker config for action creators that require payload props.
+ */
+interface PropsActionConfig<Props extends Record<string, unknown>> {
+  readonly kind: "props";
+  readonly [PROPS_MARKER]?: Props;
+}
+/**
+ * Supported action creator config node in an action group.
+ */
+type ActionConfig = EmptyActionConfig | PropsActionConfig<Record<string, unknown>>;
+/**
+ * Shape of an action group declaration object.
+ */
+type ActionGroupConfig = Record<string, ActionConfig>;
+/**
+ * Maps an action group declaration to a strongly typed action-creator object.
+ */
+type ActionGroupResult<Source extends string, Config extends ActionGroupConfig> = { [K in keyof Config & string]: Config[K] extends PropsActionConfig<infer P> ? ActionCreator<`[${Source}] ${K}`, [P], {
+  type: `[${Source}] ${K}`;
+} & P> : ActionCreator<`[${Source}] ${K}`, [], {
+  type: `[${Source}] ${K}`;
+}> };
+interface OnReducerEntry<State, Action extends AnyAction = AnyAction, Creators extends readonly ActionCreator<string, any[], any>[] = readonly ActionCreator<string, any[], any>[]> {
+  creators: Creators;
+  reducer: (state: State, action: Action) => State;
+}
+type ActionFromOnReducerEntry<TEntry> = TEntry extends OnReducerEntry<any, infer TAction, any> ? TAction : never;
+/**
+ * Effect contract for streams that emit actions to dispatch.
+ */
+interface DispatchingEffect<State, InputAction extends AnyAction = AnyAction, OutputAction extends AnyAction = AnyAction> {
+  run: (actions$: Observable<InputAction>, state$: Observable<State>) => Observable<OutputAction>;
+  dispatch: true;
+}
+/**
+ * Effect contract for side-effect-only streams whose emissions are ignored.
+ */
+interface NonDispatchingEffect<State, InputAction extends AnyAction = AnyAction> {
+  run: (actions$: Observable<InputAction>, state$: Observable<State>) => Observable<unknown>;
+  dispatch: false;
+}
+/**
+ * Union of supported effect shapes.
+ */
+type Effect<State, InputAction extends AnyAction = AnyAction, OutputAction extends AnyAction = AnyAction> = DispatchingEffect<State, InputAction, OutputAction> | NonDispatchingEffect<State, InputAction>;
+/**
+ * Lifecycle actions dispatched by the store.
+ */
+type StoreLifecycleAction = {
+  type: "@@micro-redux/init";
+} | {
+  type: "@@micro-redux/stop";
+};
+/**
+ * Options for a dispatching effect.
+ */
+interface DispatchingEffectOptions {
+  dispatch?: true;
+}
+/**
+ * Options for a non-dispatching effect.
+ */
+interface NonDispatchingEffectOptions {
+  dispatch: false;
+}
+/**
+ * Declares a payload-based action config for `createActionGroup`.
+ *
+ * @example
+ * ```ts
+ * const actions = createActionGroup("User", {
+ *   loaded: props<{ id: string }>(),
+ * });
+ * ```
+ */
+declare function props<Props extends Record<string, unknown>>(): PropsActionConfig<Props>;
+/**
+ * Declares a no-payload action config for `createActionGroup`.
+ *
+ * @example
+ * ```ts
+ * const actions = createActionGroup("User", {
+ *   reset: empty(),
+ * });
+ * ```
+ */
+declare function empty(): EmptyActionConfig;
+/**
+ * Creates a namespaced group of typed action creators.
+ *
+ * Action types are formatted as: `[Source] actionName`.
+ */
+declare function createActionGroup<const Source extends string, const Config extends ActionGroupConfig>(source: Source, config: Config): ActionGroupResult<Source, Config>;
+/**
+ * Registers one reducer handler for one or more action creators.
+ *
+ * @throws Error when called without at least one action creator and reducer.
+ */
+declare function on<State, const Creators extends readonly ActionCreator<string, any[], any>[], Action extends ActionFromCreators<Creators>>(...args: [...creators: Creators, reducer: (state: State, action: Action) => State]): OnReducerEntry<State, Action, Creators>;
+/**
+ * Creates a reducer from an initial state and `on(...)` handler entries.
+ *
+ * Unknown action types return the current state unchanged.
+ */
+declare function createReducer<State, const Entries extends readonly OnReducerEntry<any, any, any>[]>(initialState: State, ...entries: Entries): Reducer<State, ActionFromOnReducerEntry<Entries[number]>>;
+/**
+ * Creates a memoized selector from a single projector.
+ */
+declare function createSelector<State, Result>(projector: (state: State) => Result): Selector<State, Result>;
+/**
+ * Creates a memoized selector from input selectors and a projector.
+ *
+ * Memoization uses one-entry caching over the latest input selector values.
+ */
+declare function createSelector<State, const Selectors extends readonly Selector<State, unknown>[], Result>(...args: [...selectors: Selectors, projector: (...inputs: { [K in keyof Selectors]: ReturnType<Selectors[K]> }) => Result]): Selector<State, Result>;
+/**
+ * RxJS operator that maps state emissions through a selector and suppresses
+ * unchanged projected values via reference equality.
+ */
+declare function select<State, Result>(selector: Selector<State, Result>): OperatorFunction<State, Result>;
+/**
+ * RxJS operator that filters an action stream by action creators and narrows
+ * the output action type to the matched creator union.
+ *
+ * @throws Error when called without at least one action creator.
+ */
+declare function ofType<const Creators extends readonly ActionCreator<string, any[], AnyAction>[]>(...creators: Creators): OperatorFunction<AnyAction, ActionFromCreators<Creators>>;
+/**
+ * Creates a dispatching effect. Emitted actions are automatically dispatched.
+ */
+declare function createEffect<State, InputAction extends AnyAction, OutputAction extends AnyAction>(factory: (actions$: Observable<InputAction>, state$: Observable<State>) => Observable<OutputAction>, options?: DispatchingEffectOptions): DispatchingEffect<State, InputAction, OutputAction>;
+/**
+ * Creates a non-dispatching effect. Emitted values are ignored.
+ */
+declare function createEffect<State, InputAction extends AnyAction>(factory: (actions$: Observable<InputAction>, state$: Observable<State>) => Observable<unknown>, options: NonDispatchingEffectOptions): NonDispatchingEffect<State, InputAction>;
+/**
+ * Store interface returned by `createStore`.
+ */
+interface Store<State, Action extends AnyAction = AnyAction> {
+  dispatch(action: Action): void;
+  getState(): State;
+  readonly state$: Observable<State>;
+  readonly actions$: Observable<Action | StoreLifecycleAction>;
+  select<Result>(selector: Selector<State, Result>): Observable<Result>;
+  init(): void;
+  stop(): void;
+}
+/**
+ * Creates a small observable store with reducer + effects.
+ *
+ * Behavior:
+ * - `init()` starts effects and dispatches `@@micro-redux/init`.
+ * - `stop()` dispatches `@@micro-redux/stop` and unsubscribes all effects.
+ * - Effect action observation is scheduled on `asapScheduler` to avoid
+ *   synchronous re-entrancy in the effect loop.
+ * - Any effect error triggers fail-fast teardown and errors both `actions$`
+ *   and `state$`.
+ */
+declare function createStore<State, Action extends AnyAction = AnyAction>(options: {
+  reducer: Reducer<State, Action | StoreLifecycleAction>;
+  effects?: Array<Effect<State, Action | StoreLifecycleAction, Action>>;
+}): Store<State, Action>;
+//#endregion
+//#region src/utils/phoenix-observable.d.ts
+/**
+ * Minimal Phoenix push contract used by the observable adapters.
+ */
+interface ɵPhoenixPushLike {
+  receive(status: string, callback: (payload?: unknown) => unknown): unknown;
+}
+/**
+ * Minimal Phoenix channel contract used by the observable adapters.
+ */
+interface ɵPhoenixChannelLike {
+  on(event: string, callback: (payload: unknown) => void): number;
+  off(event: string, ref?: number): void;
+  onError?(callback: (reason?: unknown) => void): unknown;
+  join(params?: Record<string, unknown>): ɵPhoenixPushLike;
+  push?(event: string, payload: unknown): ɵPhoenixPushLike;
+  leave(): void;
+}
+/**
+ * Minimal Phoenix socket contract used by the observable adapters.
+ */
+interface ɵPhoenixSocketLike {
+  connect(): void;
+  disconnect(): void;
+  channel(topic: string, params?: Record<string, unknown>): ɵPhoenixChannelLike;
+  onError(callback: (error?: unknown) => void): unknown;
+  onOpen(callback: () => void): unknown;
+}
+/**
+ * Socket lifecycle notifications exposed by {@link ɵphoenixSocket$}.
+ */
+type ɵPhoenixSocketSignal = {
+  type: "open";
+} | {
+  type: "error";
+  error?: unknown;
+};
+/**
+ * Terminal outcomes of a Phoenix channel join attempt.
+ */
+type ɵPhoenixJoinOutcome = {
+  type: "joined";
+} | {
+  type: "error";
+  response?: unknown;
+} | {
+  type: "timeout";
+};
+/**
+ * Active Phoenix socket session plus its derived lifecycle stream.
+ */
+interface ɵPhoenixSocketSession {
+  socket: ɵPhoenixSocketLike;
+  signals$: Observable<ɵPhoenixSocketSignal>;
+}
+/**
+ * Active Phoenix channel session plus its derived join-outcome stream.
+ */
+interface ɵPhoenixChannelSession {
+  channel: ɵPhoenixChannelLike;
+  joinOutcome$: Observable<ɵPhoenixJoinOutcome>;
+}
+/**
+ * Options for creating a cold Phoenix socket session stream.
+ */
+interface ɵPhoenixSocketOptions {
+  url: string;
+  options?: Record<string, unknown>;
+}
+/**
+ * Options for creating a cold Phoenix channel session stream from a socket stream.
+ */
+interface ɵPhoenixChannelOptions {
+  socket$: Observable<ɵPhoenixSocketSession>;
+  topic: string;
+  params?: Record<string, unknown>;
+  leaveOnUnsubscribe?: boolean;
+}
+/**
+ * Create a cold Phoenix socket session.
+ *
+ * The socket is constructed and connected on subscription, and disconnected on
+ * teardown. Each subscription creates an isolated socket instance.
+ */
+declare function ɵphoenixSocket$(options: ɵPhoenixSocketOptions): Observable<ɵPhoenixSocketSession>;
+/**
+ * Create a cold Phoenix channel session from a socket session stream.
+ *
+ * A channel is created and joined for each active socket session. If the
+ * upstream socket session changes, the previous channel is left before the
+ * next one becomes active.
+ */
+declare function ɵphoenixChannel$(options: ɵPhoenixChannelOptions): Observable<ɵPhoenixChannelSession>;
+/**
+ * Observe a named Phoenix channel event as an observable payload stream.
+ */
+declare function ɵobservePhoenixEvent$<T>(channel: ɵPhoenixChannelLike, eventName: string): Observable<T>;
+/**
+ * Flatten channel sessions into their join-outcome stream.
+ */
+declare function ɵobservePhoenixJoinOutcome$(channel$: Observable<ɵPhoenixChannelSession>): Observable<ɵPhoenixJoinOutcome>;
+/**
+ * Complete when a channel joins successfully, or error if the join fails.
+ */
+declare function ɵjoinPhoenixChannel$(channel$: Observable<ɵPhoenixChannelSession>): Observable<never>;
+/**
+ * Flatten socket sessions into their lifecycle signal stream.
+ */
+declare function ɵobservePhoenixSocketSignals$(socket$: Observable<ɵPhoenixSocketSession>): Observable<ɵPhoenixSocketSignal>;
+/**
+ * Error after a socket emits the configured number of consecutive error
+ * signals, resetting the counter after each successful open signal.
+ */
+declare function ɵobservePhoenixSocketHealth$(socketSignals$: Observable<ɵPhoenixSocketSignal>, maxConsecutiveErrors: number): Observable<never>;
+//#endregion
+//#region src/threads.d.ts
+interface ThreadRecord {
+  id: string;
+  organizationId: string;
+  agentId: string;
+  createdById: string;
+  name: string | null;
+  archived: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+interface ThreadRuntimeContext {
+  runtimeUrl: string;
+  headers: Record<string, string>;
+  wsUrl?: string;
+  agentId: string;
+  includeArchived?: boolean;
+  limit?: number;
+}
+type ThreadMetadataEvent = {
+  operation: "created" | "renamed" | "archived" | "unarchived" | "updated";
+  threadId: string;
+  userId: string;
+  organizationId: string;
+  occurredAt: string;
+  thread: ThreadRecord;
+} | {
+  operation: "deleted";
+  threadId: string;
+  userId: string;
+  organizationId: string;
+  occurredAt: string;
+  deleted: {
+    id: string;
+  };
+};
+interface ThreadEnvironment {
+  fetch: typeof fetch;
+}
+interface ThreadState {
+  threads: ThreadRecord[];
+  isLoading: boolean;
+  isFetchingNextPage: boolean;
+  error: Error | null;
+  context: ThreadRuntimeContext | null;
+  sessionId: number;
+  metadataCredentialsRequested: boolean;
+  metadataJoinCode: string | null;
+  nextCursor: string | null;
+}
+interface ThreadStore {
+  start(): void;
+  stop(): void;
+  setContext(context: ThreadRuntimeContext | null): void;
+  fetchNextPage(): void;
+  renameThread(threadId: string, name: string): Promise<void>;
+  archiveThread(threadId: string): Promise<void>;
+  deleteThread(threadId: string): Promise<void>;
+  getState(): ThreadState;
+  select: Store<ThreadState>["select"];
+}
+declare function createThreadStore(environment: ThreadEnvironment): ThreadStore;
+type ɵThread = ThreadRecord;
+type ɵThreadRuntimeContext = ThreadRuntimeContext;
+type ɵThreadMetadataEvent = ThreadMetadataEvent;
+type ɵThreadEnvironment = ThreadEnvironment;
+type ɵThreadStore = ThreadStore;
+declare const ɵthreadAdapterEvents: any;
+declare const ɵselectThreads: any;
+declare const ɵselectThreadsIsLoading: any;
+declare const ɵselectThreadsError: any;
+declare const ɵselectHasNextPage: any;
+declare const ɵselectIsFetchingNextPage: any;
+//#endregion
+export { ActionConfig, ActionCreator, ActionFromCreator, ActionFromCreators, ActionGroupConfig, ActionGroupResult, AgentRegistry, AgentThreadLockedError, AnyAction, ContextStore, CopilotKitCore, type CopilotKitCoreAddAgentParams, CopilotKitCoreConfig, type CopilotKitCoreConnectAgentParams, CopilotKitCoreErrorCode, CopilotKitCoreFriendsAccess, CopilotKitCoreGetSuggestionsResult, type CopilotKitCoreGetToolParams, type CopilotKitCoreRunAgentParams, type CopilotKitCoreRunToolParams, type CopilotKitCoreRunToolResult, CopilotKitCoreRuntimeConnectionStatus, CopilotKitCoreStopAgentParams, CopilotKitCoreSubscriber, CopilotKitCoreSubscription, CopilotRuntimeTransport, DispatchingEffect, DispatchingEffectOptions, DynamicSuggestionsConfig, Effect, EmptyActionConfig, FrontendTool, FrontendToolHandlerContext, IntelligenceAgent, IntelligenceAgentConfig, type IntelligenceRuntimeInfo, NonDispatchingEffect, NonDispatchingEffectOptions, PropsActionConfig, ProxiedCopilotRuntimeAgent, ProxiedCopilotRuntimeAgentConfig, Reducer, RunHandler, type RuntimeLicenseStatus, type RuntimeMode, Selector, StateManager, StaticSuggestionsConfig, Store, StoreLifecycleAction, Suggestion, SuggestionAvailability, SuggestionEngine, SuggestionsConfig, ToolCallStatus, completePartialMarkdown, createActionGroup, createEffect, createReducer, createSelector, createStore, empty, ensureObjectArgs, ofType, on, parseToolArguments, props, select, ɵPhoenixChannelLike, ɵPhoenixChannelOptions, ɵPhoenixChannelSession, ɵPhoenixJoinOutcome, ɵPhoenixPushLike, ɵPhoenixSocketLike, ɵPhoenixSocketOptions, ɵPhoenixSocketSession, ɵPhoenixSocketSignal, ɵThread, ɵThreadEnvironment, ɵThreadMetadataEvent, ɵThreadRuntimeContext, ɵThreadStore, createThreadStore as ɵcreateThreadStore, ɵjoinPhoenixChannel$, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
+//# sourceMappingURL=index.d.cts.map