@truefoundry/trueforge-assistant-ui-runtime 0.0.0 → 0.2.0-rc.0

package/dist/server/index.d.ts

@@ -0,0 +1,1210 @@
+/**
+ * Runtime-owned turn/stream event protocol.
+ *
+ * Hosts must emit events matching these shapes.
+ */
+
+interface ToolCallFunction {
+    name: string;
+    arguments: string;
+}
+type ToolInfo = {
+    type: 'trueforge-system';
+    name: string;
+} | {
+    type: 'mcp';
+    serverId: string;
+    serverName: string;
+    name: string;
+} | {
+    type: string;
+    name?: string;
+};
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: ToolCallFunction;
+    toolInfo?: ToolInfo;
+    providerSpecificFields?: Record<string, unknown>;
+}
+/** Ref used by approval/response-required events. */
+interface ToolCallRef {
+    id: string;
+    sourceEventId: string;
+}
+interface ChunkDeltaToolCall {
+    index: number;
+    id?: string;
+    type?: 'function';
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
+    toolInfo?: ToolInfo;
+    providerSpecificFields?: Record<string, unknown>;
+}
+type ModelMessageContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'refusal';
+    refusal: string;
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+};
+interface ModelMessageEvent {
+    type: 'model.message';
+    id: string;
+    threadId: string;
+    content?: string | ModelMessageContentPart[] | null;
+    name?: string;
+    refusal?: string | null;
+    reasoningContent?: string;
+    toolCalls?: ToolCall[];
+    finishReason?: string | null;
+    createdAt: string;
+    usage?: unknown;
+}
+interface ModelMessageDeltaEvent {
+    type: 'model.message.delta';
+    id: string;
+    threadId: string;
+    content?: string | null;
+    refusal?: string | null;
+    reasoningContent?: string;
+    toolCalls?: ChunkDeltaToolCall[];
+    finishReason?: string | null;
+    createdAt?: string;
+    usage?: unknown;
+    /** Extended content-block deltas (image streaming). */
+    contentBlocks?: {
+        index: number;
+        delta: {
+            type: 'text';
+            text?: string;
+        } | {
+            type: 'image_url';
+            image_url?: {
+                url?: string;
+            };
+        };
+    }[];
+    content_blocks?: {
+        index: number;
+        delta: {
+            type: 'text';
+            text?: string;
+        } | {
+            type: 'image_url';
+            image_url?: {
+                url?: string;
+            };
+        };
+    }[];
+}
+interface ToolResponseEvent {
+    type: 'tool.response';
+    id: string;
+    threadId: string;
+    toolCallId: string;
+    content: string;
+    createdAt: string;
+}
+interface ToolApprovalRequiredEvent {
+    type: 'tool.approval_required';
+    id: string;
+    createdAt: string;
+    threadId: string;
+    toolCalls: ToolCallRef[];
+}
+interface ToolResponseRequiredEvent {
+    type: 'tool.response_required';
+    id: string;
+    createdAt: string;
+    threadId: string;
+    toolCalls: ToolCallRef[];
+}
+interface AgentInfo {
+    type?: string;
+    name: string;
+    input: string;
+    model?: string;
+}
+interface AgentParent {
+    threadId: string;
+    toolCallId: string;
+}
+interface ThreadCreatedEvent {
+    type: 'thread.created';
+    id: string;
+    threadId: string;
+    title: string;
+    agentInfo: AgentInfo;
+    parent: AgentParent;
+    createdAt: string;
+}
+interface ThreadDoneEvent {
+    type: 'thread.done';
+    id: string;
+    threadId: string;
+    title?: string;
+    createdAt: string;
+    state?: unknown;
+}
+interface McpServerAuthInfo {
+    id: string;
+    name: string;
+    authUrl: string;
+}
+interface McpAuthRequiredEvent {
+    type: 'mcp.auth_required';
+    id: string;
+    createdAt: string;
+    threadId?: string | null;
+    mcpServers: McpServerAuthInfo[];
+}
+interface SandboxCreatedEvent {
+    type: 'sandbox.created';
+    id: string;
+    createdAt: string;
+    sandboxId: string;
+    threadId: string | null;
+}
+interface McpInitializeEvent {
+    type: 'mcp.initialize';
+    id: string;
+    createdAt: string;
+    threadId: string | null;
+    [key: string]: unknown;
+}
+interface TurnCreatedEvent {
+    type: 'turn.created';
+    id: string;
+    turnId: string;
+    previousTurnId?: string | null;
+    input?: TurnInputItem[];
+    state?: {
+        status: 'running';
+    };
+    createdAt: string;
+    threadId?: string | null;
+}
+interface TurnDoneEvent {
+    type: 'turn.done';
+    id: string;
+    state: Exclude<TurnState, {
+        status: 'running';
+    }>;
+    createdAt: string;
+    threadId?: string | null;
+}
+/** Events stored in fold buckets (non-delta, non-turn-lifecycle). */
+type TurnEvent = ModelMessageEvent | ToolResponseEvent | ThreadCreatedEvent | ThreadDoneEvent | McpAuthRequiredEvent | McpInitializeEvent | SandboxCreatedEvent | ToolApprovalRequiredEvent | ToolResponseRequiredEvent;
+/** Full streaming event union (includes deltas + turn lifecycle). */
+type TurnStreamingEvent = TurnEvent | ModelMessageDeltaEvent | TurnCreatedEvent | TurnDoneEvent;
+type ActionRequiredEvent = ToolApprovalRequiredEvent | ToolResponseRequiredEvent | McpAuthRequiredEvent;
+interface TurnStreamData<TStreamEvent extends TurnStreamingEvent = TurnStreamingEvent> {
+    sequenceNumber: number;
+    event: TStreamEvent;
+}
+/** Session-level event item from `listEvents`. */
+interface SessionEventItem {
+    turnId: string;
+    event: TurnCreatedEvent | TurnDoneEvent | TurnEvent;
+}
+type DeltaEvents = ModelMessageDeltaEvent;
+
+/**
+ * FE-owned AgentUIServer contract.
+ *
+ * Rule: only methods/fields the runtime or UI invokes.
+ * Hosts extend via `T extends Base` for system-specific extras.
+ * No dependency on trueforge-gateway-sdk.
+ */
+
+interface ProviderEntry {
+    name: string;
+    logo?: string;
+}
+interface ModelProperties {
+    reasoningEfforts?: string[];
+    contextLength?: number;
+    maxOutputTokens?: number;
+}
+/** Model selector row. Host extends for apiModel, modelId, etc. */
+interface ModelSelectorEntry<TProvider extends ProviderEntry = ProviderEntry, TProperties extends ModelProperties = ModelProperties> {
+    name: string;
+    id: string;
+    provider: TProvider;
+    properties: TProperties;
+}
+/** Skill selector row. Host extends for fqn, preload, etc. */
+interface SkillSelectorEntry {
+    id: string;
+    name: string;
+    description?: string;
+}
+/** MCP connector selector row. Host extends for type, enableTools, url, etc. */
+interface ConnectorSelectorEntry {
+    id: string;
+    name: string;
+    description?: string;
+    /** When true, the connector must be authenticated before use. Omitted when the host does not report auth. */
+    requiresAuth?: boolean;
+    /** When true, the connector is already authenticated. Omitted when the host does not report auth. */
+    authenticated?: boolean;
+}
+/** Who created a resource. Optional on list DTOs when the host does not track creators. */
+interface CreatedBySubject {
+    subjectId: string;
+    subjectType: string;
+    subjectDisplayName: string;
+}
+/** Agent selector row. Host extends for metadata; `agentSpec` enables Edit. */
+interface AgentSelectorEntry {
+    name: string;
+    /** Stable id when distinct from display `name`. Falls back to `name` when omitted. */
+    agentId?: string;
+    /** Published-agent description; not part of the executable agent spec. */
+    description?: string;
+    /** Published agent spec — required for Edit; optional for Try-only hosts. */
+    agentSpec?: AgentSpec;
+    /** Creator when the host persists one; omit to hide Created-by UI. */
+    createdBySubject?: CreatedBySubject;
+}
+interface SearchAgentSelectorParams {
+    query?: string;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Mounts written to AgentSpec.skills[] / AgentSpec.mcpServers[].
+ *
+ * These are opaque to the runtime — it stores and forwards them but never reads
+ * a field, and the backend owns the shape (the gateway identifies a skill by
+ * `fqn`, with no `id` or `name` anywhere). So the base constrains only that a
+ * mount is an object; hosts intersect their concrete mount type over it, as
+ * `TfySkillMount` / `TfyMcpServerMount` do in the gateway adapter.
+ *
+ * Naming a field here would not just be unread, it would be wrong: a base with
+ * required fields rejects the backend's own payloads, and one with only optional
+ * fields is a weak type, which TypeScript rejects for a source that shares no
+ * property with it — the gateway's registry skill shares none.
+ */
+type SkillMount = object;
+type McpServerMount = object;
+interface ModelParams {
+    maxTokens?: number;
+    reasoningEffort?: string;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    parallelToolCalls?: boolean;
+}
+interface Model {
+    name: string;
+    params?: ModelParams;
+}
+interface AgentCapabilityConfig {
+    enabled?: boolean;
+}
+interface AgentSandboxConfig extends AgentCapabilityConfig {
+    fileDownloads?: boolean;
+}
+interface AgentInputTokensCompactionTrigger {
+    type: 'input_tokens';
+    value: number;
+}
+interface AgentCompactionConfig extends AgentCapabilityConfig {
+    trigger?: AgentInputTokensCompactionTrigger;
+}
+interface AgentContextManagementConfig {
+    compaction?: AgentCompactionConfig;
+    largeToolResponse?: AgentCapabilityConfig;
+}
+interface AgentRuntimeConfig {
+    iterationLimit?: number;
+    sandbox?: AgentSandboxConfig;
+    contextManagement?: AgentContextManagementConfig;
+    generativeUi?: AgentCapabilityConfig;
+    dynamicSubAgents?: AgentCapabilityConfig;
+    askUserQuestions?: AgentCapabilityConfig;
+    webSearch?: AgentCapabilityConfig;
+}
+/**
+ * SDK-owned agent definition — fields the FE reads/writes.
+ * Host widens `model` / `skills` / `mcpServers` / `config` via type params,
+ * and adds extra fields via `TSpec extends AgentSpec<...>`.
+ */
+interface AgentSpec<TModel extends Model = Model, TSkill extends SkillMount = SkillMount, TMcp extends McpServerMount = McpServerMount, TConfig extends AgentRuntimeConfig = AgentRuntimeConfig> {
+    model: TModel;
+    skills?: TSkill[];
+    mcpServers?: TMcp[];
+    config?: TConfig;
+    instructions?: string;
+    variables?: Record<string, string>;
+}
+interface Session<TSpec extends AgentSpec = AgentSpec> {
+    id: string;
+    title?: string | null;
+    agentName?: string | null;
+    agentSpec?: TSpec;
+    /** true → mutable builder + updateSession(spec) allowed. */
+    isMutable: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateSessionRequest<TSpec extends AgentSpec = AgentSpec> {
+    agentName?: string;
+    agentSpec?: TSpec;
+    title?: string;
+}
+interface UpdateSessionRequest<TSpec extends AgentSpec = AgentSpec> {
+    sessionId: string;
+    agentSpec?: TSpec;
+    title?: string;
+}
+interface ListResult<T> {
+    data: T[];
+    nextPageToken?: string;
+}
+type ListSessionsOrder = 'asc' | 'desc';
+interface PageParams {
+    limit?: number;
+    order?: ListSessionsOrder;
+    pageToken?: string;
+}
+interface ListSessionsParams extends PageParams {
+    /** Host-owned agent identity filter. Omit for all sessions (current user). */
+    agentId?: string;
+    /**
+     * When true, only sessions created by the authenticated subject.
+     * Omit to include managed-agent visibility where the host supports it.
+     */
+    createdByMe?: boolean;
+    /** Inclusive lower bound on session activity (ISO-8601). */
+    startTimestamp?: string;
+    /** Inclusive upper bound on session activity (ISO-8601). */
+    endTimestamp?: string;
+}
+type PreviousTurnIdInput = string;
+type UserMessageContent = string | ({
+    type: 'text';
+    text: string;
+} | {
+    type: 'file';
+    name: string;
+    data: string;
+})[];
+interface UserMessage {
+    type: 'user.message';
+    content: UserMessageContent;
+}
+type ApprovalDecision = {
+    status: 'allow';
+} | {
+    status: 'deny';
+    reason?: string;
+};
+interface UserToolApprovalEvent {
+    type: 'user.tool_approval';
+    threadId: string;
+    toolCallId: string;
+    approval: ApprovalDecision;
+}
+interface UserToolResponseEvent {
+    type: 'user.tool_response';
+    threadId: string;
+    toolCallId: string;
+    content: string;
+}
+type TurnInputItem = UserMessage | UserToolApprovalEvent | UserToolResponseEvent;
+interface TurnStateRunning {
+    status: 'running';
+}
+/**
+ * Aggregated token metrics on a finished turn (`turn.done.state.metrics`).
+ * Host maps wire snake_case (`total_input_tokens`, …) → camelCase here.
+ */
+interface TurnDoneMetrics {
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalTokens: number;
+    totalCacheReadTokens: number;
+    totalCacheWriteTokens: number;
+    totalReasoningTokens: number;
+}
+interface TurnStateDone {
+    status: 'done';
+    output?: unknown;
+    requiredActions?: ActionRequiredEvent[];
+    completedAt: string;
+    /** Present when the host reports per-turn token totals. */
+    metrics?: TurnDoneMetrics;
+}
+interface TurnStateCancelled {
+    status: 'cancelled';
+    reason: string;
+    completedAt: string;
+}
+interface TurnStateError {
+    status: 'error';
+    message: string;
+    completedAt: string;
+}
+type TurnState = TurnStateRunning | TurnStateDone | TurnStateCancelled | TurnStateError;
+/** Plain turn DTO — no methods. */
+interface Turn {
+    id: string;
+    sessionId: string;
+    previousTurnId?: string | null;
+    input?: TurnInputItem[];
+    state: TurnState;
+    createdAt: string;
+}
+/**
+ * Chat / session port — the runtime calls these.
+ *
+ * All session ops are flat (sessionId param). No gateway client dependency.
+ * `createTrueForgeServer` is one possible implementation (TFY adapter).
+ */
+interface AgentChatServer<TSpec extends AgentSpec = AgentSpec, TSession extends Session<TSpec> = Session<TSpec>, TCreate extends CreateSessionRequest<TSpec> = CreateSessionRequest<TSpec>, TList extends ListSessionsParams = ListSessionsParams, TUpdate extends UpdateSessionRequest<TSpec> = UpdateSessionRequest<TSpec>, TTurn extends Turn = Turn> {
+    createSession(req: TCreate): Promise<TSession>;
+    listSessions(req?: TList): Promise<ListResult<TSession>>;
+    getSession(req: {
+        sessionId: string;
+    }): Promise<TSession>;
+    updateSession(req: TUpdate): Promise<TSession>;
+    createTurn(req: {
+        sessionId: string;
+        input?: TurnInputItem[];
+        previousTurnId?: PreviousTurnIdInput;
+        abortSignal?: AbortSignal;
+        headers?: Record<string, string>;
+    }): AsyncIterable<TurnStreamData>;
+    cancelSession(req: {
+        sessionId: string;
+    }): Promise<void>;
+    deleteSession?(req: {
+        sessionId: string;
+    }): Promise<void>;
+    /**
+     * When present, thread-list `rename` persists via this method.
+     * Omitted: rename is a no-op (TrueForge Gateway does not persist titles).
+     */
+    renameSession?(req: {
+        sessionId: string;
+        title: string;
+    }): Promise<void>;
+    listTurns(req: {
+        sessionId: string;
+        limit?: number;
+        pageToken?: string;
+        order?: ListSessionsOrder;
+    }): Promise<ListResult<TTurn>>;
+    getTurn(req: {
+        sessionId: string;
+        turnId: string;
+    }): Promise<TTurn>;
+    listEvents(req: {
+        sessionId: string;
+        pageToken?: string;
+        lastTurnId?: string;
+        limit?: number;
+    }): Promise<ListResult<SessionEventItem>>;
+    /** Optional per-turn event listing (hydrate in-flight turn content). */
+    listTurnEvents?(req: {
+        sessionId: string;
+        turnId: string;
+        limit?: number;
+        pageToken?: string;
+        order?: ListSessionsOrder;
+    }): Promise<ListResult<TurnEvent>>;
+    subscribeToTurn?(req: {
+        sessionId: string;
+        turnId: string;
+        afterSequenceNumber?: number;
+        abortSignal?: AbortSignal;
+    }): AsyncIterable<TurnStreamData>;
+    /**
+     * Reads a file the agent wrote inside its sandbox. Hosts whose download route is scoped to a
+     * turn resolve the sandbox from `turnId` and ignore `sandboxId`; hosts addressing sandboxes
+     * directly use `sandboxId` when the runtime was able to recover it (optional after resume when
+     * `sandbox.created` is outside the loaded history window).
+     */
+    downloadSandboxFile?(req: {
+        sessionId: string;
+        turnId: string;
+        /** Present when a `sandbox.created` event was observed in session history or the live stream. */
+        sandboxId?: string;
+        path: string;
+    }): Promise<Blob>;
+}
+/** Request body for `AgentBuilderServer.saveAgent`. */
+interface SaveAgentRequest<TSpec extends AgentSpec = AgentSpec> {
+    agentName: string;
+    /** Published-agent description; hosts may require it when creating an agent. */
+    description?: string;
+    agentSpec: TSpec;
+    intent: 'create' | 'update';
+    /** Current mutable session to update atomically with the named agent. */
+    sessionId?: string;
+}
+interface SaveAgentResult {
+    /** Immutable id allocated by the host registry. */
+    agentId?: string;
+    /** Version id allocated by the host registry for this save. */
+    versionId?: string;
+    /** Timestamp returned when the active mutable session was updated. */
+    sessionUpdatedAt?: string;
+}
+/** MCP tool row used by the per-agent connector tool selector. */
+interface McpToolSelection {
+    id: string;
+    name: string;
+    description?: string;
+}
+/**
+ * Builder feature flags — atoms gate sandbox / skill / settings surfaces on these.
+ */
+interface AgentBuilderCapabilitiesResponse {
+    data: {
+        sandbox: {
+            enabled: boolean;
+        };
+        skill: {
+            enabled: boolean;
+            reason?: string;
+        };
+        settings?: {
+            enabled: boolean;
+        };
+        webSearch?: {
+            enabled: boolean;
+        };
+    };
+}
+/**
+ * Builder catalog + persist port — atoms call these.
+ * Passed separately from the runtime's chat server.
+ */
+interface AgentBuilderServer<TSpec extends AgentSpec = AgentSpec, TModel extends ModelSelectorEntry = ModelSelectorEntry, TSkill extends SkillSelectorEntry = SkillSelectorEntry, TMcp extends ConnectorSelectorEntry = ConnectorSelectorEntry, TAgent extends AgentSelectorEntry = AgentSelectorEntry, TSave = SaveAgentResult, TCapabilities extends AgentBuilderCapabilitiesResponse = AgentBuilderCapabilitiesResponse, TMcpTool extends McpToolSelection = McpToolSelection> {
+    getCapabilities(): Promise<TCapabilities>;
+    getModels(): Promise<TModel[]>;
+    getSkills(): Promise<TSkill[]>;
+    getMcp(): Promise<TMcp[]>;
+    getMcpConnector?(req: {
+        connectorId: string;
+    }): Promise<TMcp>;
+    getMcpTools?(req: {
+        connectorId: string;
+    }): Promise<TMcpTool[]>;
+    searchAgents(req?: SearchAgentSelectorParams): Promise<TAgent[]>;
+    saveAgent(req: SaveAgentRequest<TSpec>): Promise<TSave>;
+    deleteAgent?(req: {
+        agentName: string;
+    }): Promise<void>;
+}
+/**
+ * Provider type id. Reserved literal: `"custom"` for user-defined providers;
+ * any other string is a builtin (e.g. `"openai"`, `"anthropic"`).
+ *
+ * Note: `string | "custom"` is useless in TypeScript (`"custom"` ⊆ `string`),
+ * so this stays `string` and `"custom"` is a documented convention.
+ */
+type ProviderType = string;
+/**
+ * Model row — form "Model ID" + "Display name".
+ * Host extends for properties, etc.
+ */
+interface ModelEntry {
+    id: string;
+    name: string;
+}
+/**
+ * Write config for create/update (custom form + catalog "Save key").
+ * Host extends. `baseUrl` present iff `type === "custom"`.
+ */
+interface ModelProviderConfigBase<TModel extends ModelEntry = ModelEntry> {
+    type: ProviderType;
+    name: string;
+    /** Present iff `type === "custom"`. */
+    baseUrl?: string;
+    apiKey: string;
+    models: TModel[];
+}
+/**
+ * Configured provider card (list/read). No raw `apiKey`.
+ * Host extends for apiKeySet, timestamps, etc.
+ */
+interface ModelProviderBase<TModel extends ModelEntry = ModelEntry> {
+    id: string;
+    type: ProviderType;
+    name: string;
+    /** Present iff `type === "custom"`. */
+    baseUrl?: string;
+    models: TModel[];
+}
+/**
+ * Discovery-only catalog provider (AVAILABLE list).
+ * `type` must not be `"custom"` — custom providers use the custom form.
+ * Host extends for richer model rows.
+ */
+interface ModelProviderCatalogEntry<TModel extends ModelEntry = ModelEntry> {
+    type: ProviderType;
+    name: string;
+    models: TModel[];
+    supportedReasoningEfforts?: string[];
+    logo?: string;
+}
+/** Create — no `id`; server assigns it. Catalog path = entry + apiKey. */
+type CreateModelProviderRequest<TModel extends ModelEntry = ModelEntry> = ModelProviderConfigBase<TModel>;
+/** Update — `id` required. */
+type UpdateModelProviderRequest<TModel extends ModelEntry = ModelEntry> = ModelProviderConfigBase<TModel> & {
+    id: string;
+};
+interface ModelCatalogServer<TModel extends ModelEntry = ModelEntry, TProvider extends ModelProviderBase<TModel> = ModelProviderBase<TModel>, TCatalogProvider extends ModelProviderCatalogEntry<TModel> = ModelProviderCatalogEntry<TModel>, TCreate extends CreateModelProviderRequest<TModel> = CreateModelProviderRequest<TModel>, TUpdate extends UpdateModelProviderRequest<TModel> = UpdateModelProviderRequest<TModel>> {
+    getModelProviderCatalog(): Promise<TCatalogProvider[]>;
+    listModelProviders(): Promise<TProvider[]>;
+    createModelProvider(req: TCreate): Promise<TProvider>;
+    /** Full replace update keyed by provider `id`. */
+    updateModelProvider(req: TUpdate): Promise<TProvider>;
+    deleteModelProvider?(req: {
+        id: string;
+    }): Promise<void>;
+}
+/** Tool row on a connector detail. Host extends for schemas, etc. */
+interface ToolBase {
+    id: string;
+    name: string;
+    description: string;
+}
+/** Strict auth type id. Hosts widen branches via intersection + re-union. */
+type ConnectorAuthType = 'dcr' | 'header' | 'none';
+interface ConnectorAuthOAuth {
+    type: 'dcr';
+    authUrl?: string;
+}
+interface ConnectorAuthApiKey {
+    type: 'header';
+    apiKey?: string;
+    headerName?: string;
+}
+interface ConnectorAuthNone {
+    type: 'none';
+}
+type ConnectorAuth = ConnectorAuthOAuth | ConnectorAuthApiKey | ConnectorAuthNone;
+interface ConnectorAuthPublicOAuth {
+    type: 'dcr';
+    authUrl?: string;
+}
+interface ConnectorAuthPublicApiKey {
+    type: 'header';
+    headerName?: string;
+}
+interface ConnectorAuthPublicNone {
+    type: 'none';
+}
+type ConnectorAuthPublic = ConnectorAuthPublicOAuth | ConnectorAuthPublicApiKey | ConnectorAuthPublicNone;
+/**
+ * MCP / connector create-edit config. Host extends for extra fields, etc.
+ */
+interface ConnectorConfigBase<TAuth extends ConnectorAuth = ConnectorAuth> {
+    name: string;
+    description: string;
+    url: string;
+    auth: TAuth;
+}
+/**
+ * Connected connector row (settings/connectors). No raw `apiKey` or tools.
+ * Tools are fetched separately with `getToolsByConnectorId`.
+ * Host extends.
+ */
+interface ConnectorBase<TAuth extends ConnectorAuthPublic = ConnectorAuthPublic> {
+    id: string;
+    name: string;
+    description: string;
+    url: string;
+    auth: TAuth;
+    /** When true, UI should not show Disconnect. */
+    requiresAuth: boolean;
+    authenticated: boolean;
+}
+/** Discovery catalog entry for "+ Add MCP server". Host extends. */
+interface ConnectorCatalogEntry<TAuth extends ConnectorAuthPublic = ConnectorAuthPublic> {
+    id: string;
+    name: string;
+    description?: string;
+    url: string;
+    auth: TAuth;
+    logo?: string;
+}
+/** Create connector — no `id`; server assigns it. Host extends. */
+type CreateConnectorRequest<TAuth extends ConnectorAuth = ConnectorAuth> = ConnectorConfigBase<TAuth>;
+/** Update connector — `id` required. Host extends. */
+type UpdateConnectorRequest<TAuth extends ConnectorAuth = ConnectorAuth> = ConnectorConfigBase<TAuth> & {
+    id: string;
+};
+interface AuthenticateConnectorRequest {
+    id: string;
+    /** OAuth callback page owned by the host application. */
+    returnTo?: string;
+}
+interface ConnectorAuthenticationResult<TConnector extends ConnectorBase = ConnectorBase> {
+    connector?: TConnector;
+    status?: string;
+    authorization_endpoint?: string | undefined;
+}
+interface ConnectorCatalogServer<TTool extends ToolBase = ToolBase, TAuthWrite extends ConnectorAuth = ConnectorAuth, TAuthPublic extends ConnectorAuthPublic = ConnectorAuthPublic, TConnector extends ConnectorBase<TAuthPublic> = ConnectorBase<TAuthPublic>, TCatalogEntry extends ConnectorCatalogEntry<TAuthPublic> = ConnectorCatalogEntry<TAuthPublic>, TCreate extends CreateConnectorRequest<TAuthWrite> = CreateConnectorRequest<TAuthWrite>, TUpdate extends UpdateConnectorRequest<TAuthWrite> = UpdateConnectorRequest<TAuthWrite>> {
+    getConnectorCatalog(): Promise<TCatalogEntry[]>;
+    getConnector(req: {
+        id: string;
+    }): Promise<TConnector>;
+    listConnectors(req?: {
+        query?: string;
+    }): Promise<TConnector[]>;
+    getToolsByConnectorId(req: {
+        id: string;
+    }): Promise<TTool[]>;
+    createConnector(req: TCreate): Promise<TConnector>;
+    /** Full replace update keyed by connector `id`. */
+    updateConnector(req: TUpdate): Promise<TConnector>;
+    /**
+     * Start connector auth (e.g. OAuth).
+     * May return a connector (already authenticated / with `auth.authUrl`) or a
+     * result carrying `authorization_endpoint` for the popup flow.
+     */
+    authenticateConnector(req: AuthenticateConnectorRequest): Promise<TConnector | ConnectorAuthenticationResult<TConnector>>;
+    /** Clear connector auth. */
+    disconnectConnector(req: {
+        id: string;
+    }): Promise<TConnector>;
+    deleteConnector?(req: {
+        id: string;
+    }): Promise<void>;
+}
+/** Skill row shown in settings/skills (list + delete). Host extends for fqn, etc. */
+interface SkillBase {
+    id: string;
+    name: string;
+    description: string;
+}
+interface RegistrySkill extends SkillBase {
+    /** `SkillCatalogEntry.id` this skill was created from. */
+    catalogId: string;
+}
+type GithubSkill = SkillBase;
+type DefinedSkill = RegistrySkill | GithubSkill;
+/** Git source fields shared by catalog entries and create requests. */
+interface SkillConfigBase {
+    name: string;
+    description: string;
+    repoURL: string;
+    path: string;
+    ref: string;
+}
+interface SkillCatalogEntry extends SkillConfigBase {
+    id: string;
+}
+/** Create-skill base. Hosts may intersect extra fields and re-union. */
+type CreateSkillRequestBase = SkillConfigBase;
+interface SelectRegistrySkillRequest extends CreateSkillRequestBase {
+    /** `SkillCatalogEntry.id`, persisted so the created skill links back to it. */
+    catalogId: string;
+}
+type ImportGithubSkillRequest = CreateSkillRequestBase;
+type CreateSkillRequest = SelectRegistrySkillRequest | ImportGithubSkillRequest;
+interface SkillCatalogServer<TSkill extends SkillBase = SkillBase, TCatalogEntry extends SkillCatalogEntry = SkillCatalogEntry, TCreate extends CreateSkillRequest = CreateSkillRequest> {
+    getSkillCatalog(): Promise<TCatalogEntry[]>;
+    listSkills(req?: {
+        query?: string;
+    }): Promise<TSkill[]>;
+    createSkill(req: TCreate): Promise<TSkill>;
+    deleteSkill?(req: {
+        id: string;
+    }): Promise<void>;
+}
+/** Mutable sandbox provider settings shared by catalog rows, create, and update. */
+interface SandboxConfig {
+    execTimeoutMs: number;
+    autoStopIntervalInMinutes: number;
+    autoArchiveIntervalInMinutes: number;
+    autoDeleteIntervalInMinutes: number;
+}
+interface SandboxCatalogEntry extends SandboxConfig {
+    id: string;
+    name: string;
+    type: string;
+}
+/**
+ * Connected sandbox provider row (settings/sandboxes). No raw `apiKey`.
+ * Includes last-saved config so update forms can show previous values.
+ */
+interface SandboxBase extends SandboxConfig {
+    id: string;
+    name: string;
+    catalogId: string;
+    isConnected: boolean;
+}
+interface SandboxSnapshotSyncStatus {
+    status: 'pending' | 'ready' | 'failed';
+    statusReason?: string | null;
+}
+interface SandboxProviderListEntry<TSandbox extends SandboxBase = SandboxBase> {
+    data: TSandbox;
+    snapshotSyncStatus: SandboxSnapshotSyncStatus;
+}
+interface CreateSandboxRequest extends SandboxConfig {
+    /** `SandboxCatalogEntry.id` used to create this sandbox provider. */
+    catalogId: string;
+    name: string;
+    type: string;
+    apiKey: string;
+}
+interface UpdateSandboxRequest extends SandboxConfig {
+    id: string;
+    /** Omit to keep the existing key; send a value to rotate. */
+    apiKey?: string;
+}
+/** Host-facing aliases (trueforge-ui public names). */
+type SandboxProviderConfig = SandboxConfig;
+type SandboxProviderCatalogEntry = SandboxCatalogEntry;
+type SandboxProviderBase = SandboxBase;
+type CreateSandboxProviderRequest = CreateSandboxRequest;
+type UpdateSandboxProviderRequest = UpdateSandboxRequest;
+interface SandboxCatalogServer<TProvider extends SandboxBase = SandboxBase, TCatalogEntry extends SandboxCatalogEntry = SandboxCatalogEntry, TCreate extends CreateSandboxRequest = CreateSandboxRequest, TUpdate extends UpdateSandboxRequest = UpdateSandboxRequest, TListEntry extends SandboxProviderListEntry<TProvider> = SandboxProviderListEntry<TProvider>> {
+    getSandboxProviderCatalog(): Promise<TCatalogEntry[]>;
+    listSandboxProviders(req?: {
+        query?: string;
+    }): Promise<TListEntry[]>;
+    createSandboxProvider(req: TCreate): Promise<TProvider>;
+    updateSandboxProvider(req: TUpdate): Promise<TProvider>;
+    deleteSandboxProvider?(req: {
+        id: string;
+    }): Promise<void>;
+}
+interface WebSearchCatalogEntry {
+    id: string;
+    name: string;
+    type: string;
+}
+/**
+ * Connected web-search provider row (settings/web-search). No raw `apiKey`.
+ */
+interface WebSearchBase {
+    id: string;
+    name: string;
+    catalogId: string;
+    isConnected: boolean;
+}
+interface CreateWebSearchRequest {
+    /** `WebSearchCatalogEntry.id` used to create this web-search provider. */
+    catalogId: string;
+    name: string;
+    type: string;
+    apiKey: string;
+}
+interface UpdateWebSearchRequest {
+    id: string;
+    /** Omit to keep the existing key; send a value to set/rotate. */
+    apiKey?: string;
+}
+/** Host-facing aliases (trueforge-ui public names). */
+type WebSearchProviderCatalogEntry = WebSearchCatalogEntry;
+type WebSearchProviderBase = WebSearchBase;
+type CreateWebSearchProviderRequest = CreateWebSearchRequest;
+type UpdateWebSearchProviderRequest = UpdateWebSearchRequest;
+interface WebSearchCatalogServer<TProvider extends WebSearchBase = WebSearchBase, TCatalogEntry extends WebSearchCatalogEntry = WebSearchCatalogEntry, TCreate extends CreateWebSearchRequest = CreateWebSearchRequest, TUpdate extends UpdateWebSearchRequest = UpdateWebSearchRequest> {
+    getWebSearchProviderCatalog(): Promise<TCatalogEntry[]>;
+    listWebSearchProviders(req?: {
+        query?: string;
+    }): Promise<TProvider[]>;
+    createWebSearchProvider(req: TCreate): Promise<TProvider>;
+    updateWebSearchProvider(req: TUpdate): Promise<TProvider>;
+}
+/** Host-facing selector / compose aliases (trueforge-ui public names). */
+type ModelSelection = ModelSelectorEntry;
+type AgentSkill = SkillSelectorEntry;
+type ConnectorState = ConnectorSelectorEntry;
+type AgentLibraryEntry = AgentSelectorEntry;
+type SearchAgentsParams = SearchAgentSelectorParams;
+/**
+ * Settings management aggregate — modelCatalog + connectorCatalog + optional
+ * skill, sandbox, and web-search catalogs.
+ * Hosts may pass the whole object to an app shell, or a focused sub-port to a page.
+ */
+interface CatalogServer<TModelCatalog extends ModelCatalogServer = ModelCatalogServer, TConnectorCatalog extends ConnectorCatalogServer = ConnectorCatalogServer, TSkillCatalog extends SkillCatalogServer = SkillCatalogServer, TSandboxCatalog extends SandboxCatalogServer = SandboxCatalogServer, TWebSearchCatalog extends WebSearchCatalogServer = WebSearchCatalogServer> {
+    modelCatalog: TModelCatalog;
+    connectorCatalog: TConnectorCatalog;
+    /** Optional — omit when the host has no skills settings surface. */
+    skillCatalog?: TSkillCatalog;
+    /** Optional — omit when the host has no sandboxes settings surface. */
+    sandboxCatalog?: TSandboxCatalog;
+    /** Optional — omit when the host has no web-search settings surface. */
+    webSearchCatalog?: TWebSearchCatalog;
+}
+/**
+ * Published agent identity + spec for the agent-detail Overview (read-only).
+ * Host widens `TSpec` (and may extend this DTO) for mounts / config / extras.
+ */
+interface AgentDetail<TSpec extends AgentSpec = AgentSpec> {
+    agentId: string;
+    /** Display name (e.g. "release-notes-writer"). */
+    name: string;
+    /** Published-agent description; not part of the executable agent spec. */
+    description?: string;
+    agentSpec: TSpec;
+}
+/** Stream vs non-stream bodies for one language on the Use In Code tab. */
+interface CodeSnippetSampleCode {
+    stream: string;
+    nonStream: string;
+}
+/**
+ * One language row for Use In Code.
+ * Host maps wire `sample_code` / `non_stream` → camelCase here.
+ */
+interface CodeSnippet<TSample extends CodeSnippetSampleCode = CodeSnippetSampleCode> {
+    /** Sidebar label (e.g. "TypeScript"). */
+    labelName: string;
+    /** Highlighter / tab id (e.g. "typescript"). */
+    language: string;
+    icon?: string;
+    sampleCode: TSample;
+}
+/**
+ * Aggregated session metrics for the sessions list sidebar.
+ * Host maps wire snake_case (`total_turns`, `total_cost_in_usd`, …) → camelCase.
+ */
+interface SessionListMetrics {
+    totalTurns: number;
+    totalCostInUsd?: number;
+    totalDurationMs: number;
+}
+/**
+ * One row in the Agent Sessions list (left pane).
+ *
+ * Binding: `agentName` → named / immutable agent; `agentSpec` → mutable / draft.
+ * Host may send one, both, or neither depending on how the session was created.
+ */
+interface SessionListEntry<TSpec extends AgentSpec = AgentSpec> {
+    id: string;
+    title?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    lastActivityAt: string;
+    metrics: SessionListMetrics;
+    /** Present when bound to a published (immutable) agent. */
+    agentName?: string | null;
+    /** Present when bound to a mutable / draft agent spec. */
+    agentSpec?: TSpec;
+}
+/** Params for `AgentSessionsServer.listSessionEvents` (session event timeline). */
+interface ListSessionEventsParams extends Pick<PageParams, 'limit' | 'pageToken'> {
+    sessionId: string;
+}
+/**
+ * Optional plug-in for agent-detail UI: Overview, Use In Code, sessions list,
+ * and per-session event timeline. Omit `sessions` on `AgentUIServerPort` when
+ * the host has no agent-detail surface.
+ *
+ * Read-only — create/update/delete stay on `AgentChatServer` / `AgentBuilderServer`.
+ */
+interface AgentSessionsServer<TSpec extends AgentSpec = AgentSpec, TDetail extends AgentDetail<TSpec> = AgentDetail<TSpec>, TSnippet extends CodeSnippet = CodeSnippet, TListEntry extends SessionListEntry<TSpec> = SessionListEntry<TSpec>, TList extends ListSessionsParams = ListSessionsParams> {
+    /** Fetch published agent details by id for the Overview tab. */
+    getAgent(req: {
+        agentId: string;
+    }): Promise<TDetail>;
+    /** Fetch Use In Code snippets for the agent (one row per language). */
+    getCodeSnippets(req: {
+        agentId: string;
+    }): Promise<TSnippet[]>;
+    /**
+     * List sessions visible to the current user. Pass `agentId` to scope to one
+     * agent; `createdByMe: true` for only sessions they created. Use
+     * `startTimestamp` / `endTimestamp` for date filters.
+     */
+    listSessions(req?: TList): Promise<ListResult<TListEntry>>;
+    /**
+     * Fetch the session event timeline (right pane). Paginate with `pageToken`
+     * until exhausted; rebuild turns from `turn.created` / `turn.done` +
+     * nested `TurnEvent`s. Per-turn token metrics live on `turn.done.state.metrics`.
+     */
+    listSessionEvents(req: ListSessionEventsParams): Promise<ListResult<SessionEventItem>>;
+}
+type ScheduleStatus = 'active' | 'paused';
+type ScheduleRunStatus = 'scheduled' | 'triggered' | 'failed';
+interface Schedule {
+    id: string;
+    name: string;
+    /** Stable agent id (`AgentSelectorEntry.agentId`). */
+    agentId: string;
+    /** Display name; omit when the host only has `agentId`. */
+    agentName?: string;
+    task: string;
+    cron: string;
+    timezone: string;
+    status: ScheduleStatus;
+    lastRunAt: string | null;
+    /** Creator when the host persists one; omit to hide Created-by UI. */
+    createdBySubject?: CreatedBySubject;
+}
+/** Flat schedule-run DTO (ISO-8601 timestamps; host maps from wire Dates). */
+interface ScheduleRun {
+    id: string;
+    scheduleId: string;
+    name: string;
+    scheduledFor: string;
+    status: ScheduleRunStatus;
+    triggeredAt: string | null;
+    triggeredBy: string;
+}
+interface ListSchedulesParams extends Pick<PageParams, 'limit' | 'pageToken'> {
+    agentId?: string;
+    /** Multi-agent filter; combined with `agentId` when both are set. */
+    agentIds?: string[];
+}
+interface CreateScheduleRequest {
+    agentId: string;
+    name: string;
+    task: string;
+    cron: string;
+    timezone?: string;
+    status?: ScheduleStatus;
+}
+/** `agentId` is not on the base update body; hosts that allow rebinding can extend `TUpdate`. */
+interface UpdateScheduleRequest {
+    id: string;
+    name: string;
+    task: string;
+    cron: string;
+    timezone?: string;
+    status?: ScheduleStatus;
+}
+interface CreateScheduleRunRequest {
+    scheduleId: string;
+}
+interface ScheduleServer<TSchedule extends Schedule = Schedule, TCreate extends CreateScheduleRequest = CreateScheduleRequest, TUpdate extends UpdateScheduleRequest = UpdateScheduleRequest, TRun extends ScheduleRun = ScheduleRun> {
+    listSchedules(req?: ListSchedulesParams): Promise<ListResult<TSchedule>>;
+    getSchedule(req: {
+        id: string;
+    }): Promise<TSchedule>;
+    createSchedule(req: TCreate): Promise<TSchedule>;
+    updateSchedule(req: TUpdate): Promise<TSchedule>;
+    deleteSchedule(req: {
+        id: string;
+    }): Promise<void>;
+    listScheduleRuns(req: {
+        scheduleId: string;
+    }): Promise<TRun[]>;
+    createScheduleRun(req: CreateScheduleRunRequest): Promise<TRun>;
+}
+type PermissionResourceType = 'agent' | 'schedule' | 'session' | 'tenant';
+type ResourcePermission = 'USE' | 'MANAGE' | 'DELETE' | 'CREATE';
+interface ListPermissionsRequest {
+    resourceType: PermissionResourceType;
+    resourceIds: string[];
+}
+interface ListPermissionsResponse {
+    data: {
+        type: PermissionResourceType;
+        permissions: Record<string, ResourcePermission[]>;
+    };
+}
+interface PermissionsServer<TRequest extends ListPermissionsRequest = ListPermissionsRequest, TResponse extends ListPermissionsResponse = ListPermissionsResponse> {
+    listPermissions(req: TRequest): Promise<TResponse>;
+}
+type AgentMetricChartType = 'line';
+interface AgentMetricChartDefinition {
+    name: string;
+    displayName: string;
+    description: string;
+    chartType: AgentMetricChartType;
+}
+interface AgentMetricMeter {
+    name: string;
+    aggregateValue: number;
+    description: string;
+    unit: string;
+}
+interface AgentMetricPoint {
+    timestamp: string;
+    value: number;
+}
+interface AgentMetricGraphLine<TPoint extends AgentMetricPoint = AgentMetricPoint> {
+    name: string;
+    values: TPoint[];
+}
+interface AgentMetricGraph<TLine extends AgentMetricGraphLine = AgentMetricGraphLine> {
+    name: string;
+    displayName: string;
+    description: string;
+    unit: string;
+    chartType: AgentMetricChartType;
+    graphLines: TLine[];
+}
+interface AgentMetricChartData<TGraph extends AgentMetricGraph = AgentMetricGraph> {
+    step: string;
+    graphs: TGraph[];
+}
+interface AgentMetricRangeRequest {
+    agentId: string;
+    startTimestamp: string;
+    endTimestamp: string;
+}
+interface AgentMetricChartDataRequest extends AgentMetricRangeRequest {
+    chartName: string;
+}
+interface AgentMetricsServer<TChart extends AgentMetricChartDefinition = AgentMetricChartDefinition, TMeter extends AgentMetricMeter = AgentMetricMeter, TChartData extends AgentMetricChartData = AgentMetricChartData, TRangeRequest extends AgentMetricRangeRequest = AgentMetricRangeRequest, TChartDataRequest extends AgentMetricChartDataRequest = AgentMetricChartDataRequest> {
+    getCharts(): Promise<TChart[]>;
+    getMeters(req: TRangeRequest): Promise<TMeter[]>;
+    getChartData(req: TChartDataRequest): Promise<TChartData>;
+}
+/**
+ * Composed host port: chat + builder + optional settings catalog + optional
+ * agent-detail / sessions shell + optional schedules surface + optional metrics.
+ *
+ * `catalog` is optional — if the host passes it, settings UI can call
+ * `useCatalogServer()` / show modelCatalog, connectorCatalog, and skillCatalog;
+ * if omitted, those surfaces stay hidden.
+ *
+ * `sessions` is optional — if the host passes it, agent-detail UI can call
+ * `useAgentSessionsServer()` / Overview + sessions under an agent; if omitted,
+ * that surface stays hidden.
+ *
+ * `schedules` is optional — if the host passes it, schedules UI can call
+ * `useScheduleServer()` / list and manage schedules; if omitted, that surface
+ * stays hidden.
+ *
+ * `metrics` is optional — if the host passes it, agent-detail UI can render
+ * aggregate meter cards and time-series charts.
+ *
+ * trueforge-ui re-exports this as `AgentUIServer`.
+ */
+type AgentUIServerPort<TChat extends AgentChatServer = AgentChatServer, TBuilder extends AgentBuilderServer = AgentBuilderServer, TCatalog extends CatalogServer = CatalogServer, TSessions extends AgentSessionsServer = AgentSessionsServer, TSchedules extends ScheduleServer = ScheduleServer, TMetrics extends AgentMetricsServer = AgentMetricsServer, TPermissions extends PermissionsServer = PermissionsServer> = TChat & TBuilder & {
+    catalog?: TCatalog;
+    sessions?: TSessions;
+    schedules?: TSchedules;
+    metrics?: TMetrics;
+    permissions?: TPermissions;
+};
+/** Host-facing alias used by trueforge-ui. */
+type AgentUIServer = AgentUIServerPort;
+
+/**
+ * Local implementations of streaming delta helpers.
+ * Formerly imported from trueforge-gateway-sdk/agents.
+ */
+
+/** True for `.delta` streaming events. */
+declare function isEventDelta(event: TurnStreamingEvent): event is DeltaEvents;
+/**
+ * Merge `delta` into `base` in place (same `id` required).
+ * Currently handles `model.message.delta` → `model.message`.
+ */
+declare function mergeEventDelta(base: TurnEvent, delta: DeltaEvents): void;
+
+export { type ActionRequiredEvent, type AgentBuilderCapabilitiesResponse, type AgentBuilderServer, type AgentCapabilityConfig, type AgentChatServer, type AgentCompactionConfig, type AgentContextManagementConfig, type AgentDetail, type AgentInfo, type AgentInputTokensCompactionTrigger, type AgentLibraryEntry, type AgentMetricChartData, type AgentMetricChartDataRequest, type AgentMetricChartDefinition, type AgentMetricChartType, type AgentMetricGraph, type AgentMetricGraphLine, type AgentMetricMeter, type AgentMetricPoint, type AgentMetricRangeRequest, type AgentMetricsServer, type AgentParent, type AgentRuntimeConfig, type AgentSandboxConfig, type AgentSelectorEntry, type AgentSessionsServer, type AgentSkill, type AgentSpec, type AgentUIServer, type AgentUIServerPort, type ApprovalDecision, type AuthenticateConnectorRequest, type CatalogServer, type ChunkDeltaToolCall, type CodeSnippet, type CodeSnippetSampleCode, type ConnectorAuth, type ConnectorAuthApiKey, type ConnectorAuthNone, type ConnectorAuthOAuth, type ConnectorAuthPublic, type ConnectorAuthPublicApiKey, type ConnectorAuthPublicNone, type ConnectorAuthPublicOAuth, type ConnectorAuthType, type ConnectorAuthenticationResult, type ConnectorBase, type ConnectorCatalogEntry, type ConnectorCatalogServer, type ConnectorConfigBase, type ConnectorSelectorEntry, type ConnectorState, type CreateConnectorRequest, type CreateModelProviderRequest, type CreateSandboxProviderRequest, type CreateSandboxRequest, type CreateScheduleRequest, type CreateScheduleRunRequest, type CreateSessionRequest, type CreateSkillRequest, type CreateSkillRequestBase, type CreateWebSearchProviderRequest, type CreateWebSearchRequest, type CreatedBySubject, type DefinedSkill, type DeltaEvents, type GithubSkill, type ImportGithubSkillRequest, type ListPermissionsRequest, type ListPermissionsResponse, type ListResult, type ListSchedulesParams, type ListSessionEventsParams, type ListSessionsOrder, type ListSessionsParams, type McpAuthRequiredEvent, type McpInitializeEvent, type McpServerAuthInfo, type McpServerMount, type McpToolSelection, type Model, type ModelCatalogServer, type ModelEntry, type ModelMessageContentPart, type ModelMessageDeltaEvent, type ModelMessageEvent, type ModelParams, type ModelProperties, type ModelProviderBase, type ModelProviderCatalogEntry, type ModelProviderConfigBase, type ModelSelection, type ModelSelectorEntry, type PageParams, type PermissionResourceType, type PermissionsServer, type PreviousTurnIdInput, type ProviderEntry, type ProviderType, type RegistrySkill, type ResourcePermission, type SandboxBase, type SandboxCatalogEntry, type SandboxCatalogServer, type SandboxConfig, type SandboxCreatedEvent, type SandboxProviderBase, type SandboxProviderCatalogEntry, type SandboxProviderConfig, type SandboxProviderListEntry, type SandboxSnapshotSyncStatus, type SaveAgentRequest, type SaveAgentResult, type Schedule, type ScheduleRun, type ScheduleRunStatus, type ScheduleServer, type ScheduleStatus, type SearchAgentSelectorParams, type SearchAgentsParams, type SelectRegistrySkillRequest, type Session, type SessionEventItem, type SessionListEntry, type SessionListMetrics, type SkillBase, type SkillCatalogEntry, type SkillCatalogServer, type SkillConfigBase, type SkillMount, type SkillSelectorEntry, type ThreadCreatedEvent, type ThreadDoneEvent, type ToolApprovalRequiredEvent, type ToolBase, type ToolCall, type ToolCallFunction, type ToolCallRef, type ToolInfo, type ToolResponseEvent, type ToolResponseRequiredEvent, type Turn, type TurnCreatedEvent, type TurnDoneEvent, type TurnDoneMetrics, type TurnEvent, type TurnInputItem, type TurnState, type TurnStateCancelled, type TurnStateDone, type TurnStateError, type TurnStateRunning, type TurnStreamData, type TurnStreamingEvent, type UpdateConnectorRequest, type UpdateModelProviderRequest, type UpdateSandboxProviderRequest, type UpdateSandboxRequest, type UpdateScheduleRequest, type UpdateSessionRequest, type UpdateWebSearchProviderRequest, type UpdateWebSearchRequest, type UserMessage, type UserMessageContent, type UserToolApprovalEvent, type UserToolResponseEvent, type WebSearchBase, type WebSearchCatalogEntry, type WebSearchCatalogServer, type WebSearchProviderBase, type WebSearchProviderCatalogEntry, isEventDelta, mergeEventDelta };