@truefoundry/assistant-ui-runtime 0.1.6 → 0.1.8

package/dist/plugins/truefoundry-agent-server-adapter/index.d.ts

@@ -1,6 +1,6 @@
 import { AgentSessionClient } from 'truefoundry-gateway-sdk/agents';
 import { PrivateAgentSessionClient } from 'truefoundry-gateway-sdk/agents/private';
-import { A as AgentSpec, C as CreateSessionRequest, L as ListSessionsParams, S as Session, T as Turn, a as TurnState, b as AgentChatServer, U as UpdateSessionRequest } from '../../types-BfiFf8O1.js';
+import { A as AgentSpec, w as CreateSessionRequest, y as ListSessionsParams, S as Session, d as Turn, W as TurnState, a as AgentChatServer, a0 as UpdateSessionRequest, a2 as AgentSelectorEntry, a3 as ConnectorSelectorEntry, a4 as ModelSelectorEntry, a5 as SkillSelectorEntry, f as AgentBuilderServer } from '../../types-B_z-FsDS.js';
 import { TruefoundryGatewayApi } from 'truefoundry-gateway-sdk';
 
 /**
@@ -29,10 +29,7 @@ type RuntimeSkillMount = NonNullable<NonNullable<AgentSpec["skills"]>[number]>;
 type RuntimeMcpServerMount = NonNullable<NonNullable<AgentSpec["mcpServers"]>[number]>;
 type TfySkillMount = RuntimeSkillMount & TruefoundryGatewayApi.SkillMount;
 type TfyMcpServerMount = RuntimeMcpServerMount & TruefoundryGatewayApi.McpServer;
-interface TfyAgentSpec extends AgentSpec {
-    model: TruefoundryGatewayApi.Model;
-    skills?: TfySkillMount[];
-    mcpServers?: TfyMcpServerMount[];
+interface TfyAgentSpec extends AgentSpec<TruefoundryGatewayApi.Model, TfySkillMount, TfyMcpServerMount> {
     config?: TruefoundryGatewayApi.RuntimeConfig;
     responseFormat?: TruefoundryGatewayApi.ResponseFormat;
     messages?: TruefoundryGatewayApi.AgentSpecUserMessage[];
@@ -80,11 +77,89 @@ type TfyFinishReason = TruefoundryGatewayApi.FinishReason;
 type TfyThreadState = TruefoundryGatewayApi.ThreadState;
 type TfyMcpServerInitInfo = TruefoundryGatewayApi.McpServerInitInfo;
 
+type CreateTrueFoundryChatServerOptions = {
+    apiKey: string;
+    baseUrl: string;
+    /** Optional override — otherwise constructed from apiKey/baseUrl. */
+    client?: AgentSessionClient;
+    privateClient?: PrivateAgentSessionClient;
+    deleteSession?: (req: {
+        sessionId: string;
+    }) => Promise<void>;
+};
+/**
+ * Only the spec is generic. Session/Turn/list-params are the concrete Tfy*
+ * types because the adapter builds them as fixed object literals — a generic
+ * there would type fields that nothing ever populates. The spec is safe: the
+ * gateway SDK serializes with `unrecognizedObjectKeys: "passthrough"`, so
+ * host-added spec fields survive the round trip.
+ */
+type TrueFoundryChatServer<TSpec extends TfyAgentSpec = TfyAgentSpec> = AgentChatServer<TSpec, TfySession<TSpec>, TfyCreateSessionRequest<TSpec>, TfyListSessionsParams, UpdateSessionRequest<TSpec>, TfyTurn> & {
+    /** Escape hatch for hosts that still need raw gateway clients. */
+    getGatewayClients(): {
+        client: AgentSessionClient;
+        privateClient: PrivateAgentSessionClient;
+    };
+};
+/**
+ * Wraps TrueFoundry gateway clients into a flat `AgentChatServer`.
+ * Named vs draft routing is fully internal — an in-memory session-type cache
+ * (populated by createSession/listSessions) determines which gateway client
+ * to call, falling back to a one-time probe for ids seen only in a URL.
+ */
+declare function createTrueFoundryChatServer<TSpec extends TfyAgentSpec = TfyAgentSpec>(opts: CreateTrueFoundryChatServerOptions): TrueFoundryChatServer<TSpec>;
+
+/**
+ * Control Plane HTTP for builder catalog lists + gateway URL resolution.
+ *
+ * Wire shapes are host/CP contracts (not Fern / gateway SDK). Paths match
+ * ai.tf cpApi usage — expect drift; keep normalizers defensive.
+ */
+
+interface TfyModelSelectorEntry extends ModelSelectorEntry {
+    /** Write into AgentSpec.model.name (model_fqn). */
+    apiModel: string;
+    modelId: string;
+    providerAccount?: string;
+    id?: string;
+}
+interface TfySkillSelectorEntry extends SkillSelectorEntry {
+    /** Version FQN — mount as RegisteredSkillMount.fqn. */
+    fqn: string;
+}
+interface TfyConnectorSelectorEntry extends ConnectorSelectorEntry {
+    /** Mount as RegisteredMcpServer.name. */
+    mcpName: string;
+    serverId?: string | null;
+    authenticated?: boolean;
+}
+type TfyAgentSelectorEntry = AgentSelectorEntry;
+
+type CreateTrueFoundryAgentUIServerOptions = {
+    apiKey: string;
+    /** Control Plane base URL (builder lists + optional /session for gateway resolve). */
+    cpURL: string;
+    /**
+     * Gateway base URL. When omitted, resolved via
+     * `GET {cpURL}/api/svc/v1/session` → `{cpURL}{env.LLM_GATEWAY_URL ?? "/api/llm"}/{tenantName}`.
+     * Session failure throws (no silent public-gateway fallback).
+     */
+    gatewayURL?: string;
+};
+type TrueFoundryAgentUIServer<TSpec extends TfyAgentSpec = TfyAgentSpec> = TrueFoundryChatServer<TSpec> & AgentBuilderServer<TSpec, TfyModelSelectorEntry, TfySkillSelectorEntry, TfyConnectorSelectorEntry, TfyAgentSelectorEntry, unknown>;
+/**
+ * Full pack: gateway chat + Control Plane builder lists.
+ *
+ * Same `apiKey` bearer is used for CP and gateway. Concurrent calls with the
+ * same credentials share one in-flight promise (React Strict Mode safe).
+ */
+declare function createTrueFoundryAgentUIServer<TSpec extends TfyAgentSpec = TfyAgentSpec>(opts: CreateTrueFoundryAgentUIServerOptions): Promise<TrueFoundryAgentUIServer<TSpec>>;
+
 /**
  * Point-of-use narrowing for the event half of the gateway protocol.
  *
  * `AgentChatServer` hardcodes the runtime's event types on listEvents,
- * listTurnEvents, subscribeToTurn and prepareAndExecuteTurn — there is no
+ * listTurnEvents, subscribeToTurn and createTurn — there is no
  * generic to override them from here. So instead of typing those channels,
  * hosts call these guards on the values they receive.
  *
@@ -127,36 +202,4 @@ declare function getTfyMcpInitServers(event: {
     mcpServers?: unknown;
 } | null | undefined): TfyMcpServerInitInfo[] | undefined;
 
-type CreateTrueFoundryChatServerOptions = {
-    apiKey: string;
-    baseUrl: string;
-    /** Optional override — otherwise constructed from apiKey/baseUrl. */
-    client?: AgentSessionClient;
-    privateClient?: PrivateAgentSessionClient;
-    deleteSession?: (req: {
-        sessionId: string;
-    }) => Promise<void>;
-};
-/**
- * Only the spec is generic. Session/Turn/list-params are the concrete Tfy*
- * types because the adapter builds them as fixed object literals — a generic
- * there would type fields that nothing ever populates. The spec is safe: the
- * gateway SDK serializes with `unrecognizedObjectKeys: "passthrough"`, so
- * host-added spec fields survive the round trip.
- */
-type TrueFoundryChatServer<TSpec extends TfyAgentSpec = TfyAgentSpec> = AgentChatServer<TSpec, TfySession<TSpec>, TfyCreateSessionRequest<TSpec>, TfyListSessionsParams, UpdateSessionRequest<TSpec>, TfyTurn> & {
-    /** Escape hatch for hosts that still need raw gateway clients. */
-    getGatewayClients(): {
-        client: AgentSessionClient;
-        privateClient: PrivateAgentSessionClient;
-    };
-};
-/**
- * Wraps TrueFoundry gateway clients into a flat `AgentChatServer`.
- * Named vs draft routing is fully internal — an in-memory session-type cache
- * (populated by createSession/listSessions) determines which gateway client
- * to call. No try/catch fallback, no double network calls.
- */
-declare function createTrueFoundryChatServer<TSpec extends TfyAgentSpec = TfyAgentSpec>(opts: CreateTrueFoundryChatServerOptions): TrueFoundryChatServer<TSpec>;
-
-export { type CreateTrueFoundryChatServerOptions, type RequireApprovalToolSelectorItem, type RequireApprovalToolsSelectorTag, type TfyAgentSpec, type TfyCreateSessionRequest, type TfyFinishReason, type TfyListSessionsParams, type TfyMcpServerInitInfo, type TfyMcpServerMount, type TfyMcpToolInfo, type TfyModelMessageUsage, type TfyModelParams, type TfyResponseFormat, type TfyRuntimeConfig, type TfySession, type TfySkillMount, type TfySubject, type TfySystemToolInfo, type TfyThreadState, type TfyToolInfo, type TfyTurn, type TfyTurnCancelledReason, type TfyTurnState, type TfyTurnStateDoneOutput, type ToolsSelectorItem, type ToolsSelectorTag, type TrueFoundryChatServer, createTrueFoundryChatServer, getTfyMcpInitServers, getTfyThreadState, getTfyUsage, isTfyMcpToolInfo, isTfySystemToolInfo, isTfyToolInfo };
+export { type CreateTrueFoundryAgentUIServerOptions, type CreateTrueFoundryChatServerOptions, type RequireApprovalToolSelectorItem, type RequireApprovalToolsSelectorTag, type TfyAgentSelectorEntry, type TfyAgentSpec, type TfyConnectorSelectorEntry, type TfyCreateSessionRequest, type TfyFinishReason, type TfyListSessionsParams, type TfyMcpServerInitInfo, type TfyMcpServerMount, type TfyMcpToolInfo, type TfyModelMessageUsage, type TfyModelParams, type TfyModelSelectorEntry, type TfyResponseFormat, type TfyRuntimeConfig, type TfySession, type TfySkillMount, type TfySkillSelectorEntry, type TfySubject, type TfySystemToolInfo, type TfyThreadState, type TfyToolInfo, type TfyTurn, type TfyTurnCancelledReason, type TfyTurnState, type TfyTurnStateDoneOutput, type ToolsSelectorItem, type ToolsSelectorTag, type TrueFoundryAgentUIServer, type TrueFoundryChatServer, createTrueFoundryAgentUIServer, createTrueFoundryChatServer, getTfyMcpInitServers, getTfyThreadState, getTfyUsage, isTfyMcpToolInfo, isTfySystemToolInfo, isTfyToolInfo };

package/dist/plugins/truefoundry-agent-server-adapter/index.js

@@ -1,4 +1,5 @@
 import {
+  createTrueFoundryAgentUIServer,
   createTrueFoundryChatServer,
   getTfyMcpInitServers,
   getTfyThreadState,
@@ -6,8 +7,9 @@ import {
   isTfyMcpToolInfo,
   isTfySystemToolInfo,
   isTfyToolInfo
-} from "../../chunk-Q2SHKMLM.js";
+} from "../../chunk-CXBZ6WLZ.js";
 export {
+  createTrueFoundryAgentUIServer,
   createTrueFoundryChatServer,
   getTfyMcpInitServers,
   getTfyThreadState,

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
-import { r as TurnStreamingEvent, D as DeltaEvents, c as TurnEvent } from '../types-BfiFf8O1.js';
-export { t as ActionRequiredEvent, h as AgentBuilderServer, b as AgentChatServer, u as AgentInfo, v as AgentParent, w as AgentSelectorEntry, A as AgentSpec, x as ApprovalDecision, y as ChunkDeltaToolCall, z as ConnectorSelectorEntry, C as CreateSessionRequest, i as ListResult, B as ListSessionsOrder, L as ListSessionsParams, M as McpAuthRequiredEvent, E as McpInitializeEvent, F as McpServerAuthInfo, G as McpServerMount, H as Model, I as ModelMessageContentPart, J as ModelMessageDeltaEvent, j as ModelMessageEvent, K as ModelParams, N as ModelSelectorEntry, O as PageParams, P as PreviousTurnIdInput, k as SandboxCreatedEvent, Q as SearchAgentSelectorParams, S as Session, l as SessionEventItem, R as SkillMount, V as SkillSelectorEntry, d as ThreadCreatedEvent, W as ThreadDoneEvent, m as ToolApprovalRequiredEvent, n as ToolCall, X as ToolCallFunction, Y as ToolCallRef, Z as ToolInfo, _ as ToolResponseEvent, o as ToolResponseRequiredEvent, T as Turn, $ as TurnCreatedEvent, a0 as TurnDoneEvent, g as TurnInputItem, a as TurnState, a1 as TurnStateCancelled, p as TurnStateDone, a2 as TurnStateError, a3 as TurnStateRunning, q as TurnStreamData, U as UpdateSessionRequest, s as UserMessage, a4 as UserMessageContent, f as UserToolApprovalEvent, e as UserToolResponseEvent } from '../types-BfiFf8O1.js';
+import { Z as TurnStreamingEvent, a6 as DeltaEvents, T as TurnEvent } from '../types-B_z-FsDS.js';
+export { a7 as ActionRequiredEvent, f as AgentBuilderServer, a as AgentChatServer, a8 as AgentInfo, a9 as AgentParent, a2 as AgentSelectorEntry, A as AgentSpec, g as AgentUIServerPort, aa as ApprovalDecision, C as CatalogServer, ab as ChunkDeltaToolCall, h as ConnectorAuth, i as ConnectorAuthApiKey, j as ConnectorAuthNone, k as ConnectorAuthOAuth, l as ConnectorAuthPublic, m as ConnectorAuthPublicApiKey, n as ConnectorAuthPublicNone, o as ConnectorAuthPublicOAuth, p as ConnectorAuthType, q as ConnectorBase, r as ConnectorCatalogEntry, s as ConnectorCatalogServer, t as ConnectorConfigBase, a3 as ConnectorSelectorEntry, u as CreateConnectorRequest, v as CreateModelProviderRequest, w as CreateSessionRequest, x as CreateSkillRequest, L as ListResult, ac as ListSessionsOrder, y as ListSessionsParams, M as McpAuthRequiredEvent, ad as McpInitializeEvent, ae as McpServerAuthInfo, af as McpServerMount, ag as Model, z as ModelCatalogServer, B as ModelEntry, ah as ModelMessageContentPart, ai as ModelMessageDeltaEvent, D as ModelMessageEvent, aj as ModelParams, E as ModelProviderBase, F as ModelProviderCatalogEntry, G as ModelProviderConfigBase, a4 as ModelSelectorEntry, ak as PageParams, P as PreviousTurnIdInput, H as ProviderType, I as SandboxCreatedEvent, al as SearchAgentSelectorParams, S as Session, J as SessionEventItem, K as SkillBase, N as SkillCatalogServer, am as SkillMount, a5 as SkillSelectorEntry, b as ThreadCreatedEvent, an as ThreadDoneEvent, O as ToolApprovalRequiredEvent, Q as ToolBase, R as ToolCall, ao as ToolCallFunction, ap as ToolCallRef, aq as ToolInfo, ar as ToolResponseEvent, V as ToolResponseRequiredEvent, d as Turn, as as TurnCreatedEvent, at as TurnDoneEvent, e as TurnInputItem, W as TurnState, au as TurnStateCancelled, X as TurnStateDone, av as TurnStateError, aw as TurnStateRunning, Y as TurnStreamData, _ as UpdateConnectorRequest, $ as UpdateModelProviderRequest, a0 as UpdateSessionRequest, a1 as UserMessage, ax as UserMessageContent, c as UserToolApprovalEvent, U as UserToolResponseEvent } from '../types-B_z-FsDS.js';
 
 /**
  * Local implementations of streaming delta helpers.

package/dist/{types-BfiFf8O1.d.ts → types-B_z-FsDS.d.ts}

@@ -279,17 +279,15 @@ interface Model {
 }
 /**
  * SDK-owned agent definition — fields the FE reads/writes.
- * Host adds additional fields via `TSpec extends AgentSpec`.
+ * Host widens `model` / `skills` / `mcpServers` via type params, and adds
+ * extra fields via `TSpec extends AgentSpec<...>`.
  */
-interface AgentSpec {
-    model: Model;
-    skills?: SkillMount[];
-    mcpServers?: McpServerMount[];
+interface AgentSpec<TModel extends Model = Model, TSkill extends SkillMount = SkillMount, TMcp extends McpServerMount = McpServerMount> {
+    model: TModel;
+    skills?: TSkill[];
+    mcpServers?: TMcp[];
     instructions?: string;
-    messages?: unknown[];
     variables?: Record<string, string>;
-    responseFormat?: unknown;
-    config?: unknown;
 }
 interface Session<TSpec extends AgentSpec = AgentSpec> {
     id: string;
@@ -400,7 +398,7 @@ interface AgentChatServer<TSpec extends AgentSpec = AgentSpec, TSession extends
         sessionId: string;
     }): Promise<TSession>;
     updateSession(req: TUpdate): Promise<TSession>;
-    prepareAndExecuteTurn(req: {
+    createTurn(req: {
         sessionId: string;
         input?: TurnInputItem[];
         previousTurnId?: PreviousTurnIdInput;
@@ -464,5 +462,205 @@ interface AgentBuilderServer<TSpec extends AgentSpec = AgentSpec, TModel extends
         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[];
+}
+/** 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;
+}
+/** Strict auth type id. Hosts widen branches via intersection + re-union. */
+type ConnectorAuthType = "oauth" | "apiKey" | "none";
+type ConnectorAuthOAuth = {
+    type: "oauth";
+    authUrl?: string;
+};
+type ConnectorAuthApiKey = {
+    type: "apiKey";
+    apiKey?: string;
+    headerName?: string;
+};
+type ConnectorAuthNone = {
+    type: "none";
+};
+type ConnectorAuth = ConnectorAuthOAuth | ConnectorAuthApiKey | ConnectorAuthNone;
+type ConnectorAuthPublicOAuth = {
+    type: "oauth";
+    authUrl: string;
+};
+type ConnectorAuthPublicApiKey = {
+    type: "apiKey";
+    headerName?: string;
+};
+type 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;
+    url: string;
+    auth: TAuth;
+}
+/**
+ * Connected connector row (settings/connectors). No raw `apiKey`.
+ * Host extends.
+ */
+interface ConnectorBase<TTool extends ToolBase = ToolBase, 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;
+    tools: TTool[];
+}
+/** 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;
+}
+/** 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 ConnectorCatalogServer<TTool extends ToolBase = ToolBase, TAuthWrite extends ConnectorAuth = ConnectorAuth, TAuthPublic extends ConnectorAuthPublic = ConnectorAuthPublic, TConnector extends ConnectorBase<TTool, TAuthPublic> = ConnectorBase<TTool, TAuthPublic>, TCatalogEntry extends ConnectorCatalogEntry<TAuthPublic> = ConnectorCatalogEntry<TAuthPublic>, TCreate extends CreateConnectorRequest<TAuthWrite> = CreateConnectorRequest<TAuthWrite>, TUpdate extends UpdateConnectorRequest<TAuthWrite> = UpdateConnectorRequest<TAuthWrite>> {
+    getConnectorCatalog(): Promise<TCatalogEntry[]>;
+    listConnectors(req?: {
+        query?: string;
+    }): Promise<TConnector[]>;
+    createConnector(req: TCreate): Promise<TConnector>;
+    /** Full replace update keyed by connector `id`. */
+    updateConnector(req: TUpdate): Promise<TConnector>;
+    /**
+     * Start connector auth (e.g. OAuth).
+     * For oauth, the returned connector's `auth.authUrl` is the authorize URL.
+     */
+    authenticateConnector(req: {
+        id: string;
+    }): Promise<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;
+}
+/** Create-skill request. Host extends for branch, auth, etc. */
+interface CreateSkillRequest {
+    repo: string;
+    directory: string;
+}
+interface SkillCatalogServer<TSkill extends SkillBase = SkillBase, TCreate extends CreateSkillRequest = CreateSkillRequest> {
+    listSkills(req?: {
+        query?: string;
+    }): Promise<TSkill[]>;
+    createSkill(req: TCreate): Promise<TSkill>;
+    deleteSkill?(req: {
+        id: string;
+    }): Promise<void>;
+}
+/**
+ * Settings management aggregate — modelCatalog + connectorCatalog + optional skillCatalog.
+ * 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> {
+    modelCatalog: TModelCatalog;
+    connectorCatalog: TConnectorCatalog;
+    /** Optional — omit when the host has no skills settings surface. */
+    skillCatalog?: TSkillCatalog;
+}
+/**
+ * Composed host port: chat + builder + optional settings catalog.
+ * Agent-ui's `AgentUIServer` mirrors this shape; named differently here to
+ * avoid colliding with that package's local type name.
+ *
+ * `catalog` is optional — if the host passes it, settings UI can call
+ * `useCatalogServer()` / show modelCatalog, connectorCatalog, and skillCatalog;
+ * if omitted, those surfaces stay hidden.
+ */
+type AgentUIServerPort<TChat extends AgentChatServer = AgentChatServer, TBuilder extends AgentBuilderServer = AgentBuilderServer, TCatalog extends CatalogServer = CatalogServer> = TChat & TBuilder & {
+    catalog?: TCatalog;
+};
 
-export type { TurnCreatedEvent as $, AgentSpec as A, ListSessionsOrder as B, CreateSessionRequest as C, DeltaEvents as D, McpInitializeEvent as E, McpServerAuthInfo as F, McpServerMount as G, Model as H, ModelMessageContentPart as I, ModelMessageDeltaEvent as J, ModelParams as K, ListSessionsParams as L, McpAuthRequiredEvent as M, ModelSelectorEntry as N, PageParams as O, PreviousTurnIdInput as P, SearchAgentSelectorParams as Q, SkillMount as R, Session as S, Turn as T, UpdateSessionRequest as U, SkillSelectorEntry as V, ThreadDoneEvent as W, ToolCallFunction as X, ToolCallRef as Y, ToolInfo as Z, ToolResponseEvent as _, TurnState as a, TurnDoneEvent as a0, TurnStateCancelled as a1, TurnStateError as a2, TurnStateRunning as a3, UserMessageContent as a4, AgentChatServer as b, TurnEvent as c, ThreadCreatedEvent as d, UserToolResponseEvent as e, UserToolApprovalEvent as f, TurnInputItem as g, AgentBuilderServer as h, ListResult as i, ModelMessageEvent as j, SandboxCreatedEvent as k, SessionEventItem as l, ToolApprovalRequiredEvent as m, ToolCall as n, ToolResponseRequiredEvent as o, TurnStateDone as p, TurnStreamData as q, TurnStreamingEvent as r, UserMessage as s, ActionRequiredEvent as t, AgentInfo as u, AgentParent as v, AgentSelectorEntry as w, ApprovalDecision as x, ChunkDeltaToolCall as y, ConnectorSelectorEntry as z };
+export type { UpdateModelProviderRequest as $, AgentSpec as A, ModelEntry as B, CatalogServer as C, ModelMessageEvent as D, ModelProviderBase as E, ModelProviderCatalogEntry as F, ModelProviderConfigBase as G, ProviderType as H, SandboxCreatedEvent as I, SessionEventItem as J, SkillBase as K, ListResult as L, McpAuthRequiredEvent as M, SkillCatalogServer as N, ToolApprovalRequiredEvent as O, PreviousTurnIdInput as P, ToolBase as Q, ToolCall as R, Session as S, TurnEvent as T, UserToolResponseEvent as U, ToolResponseRequiredEvent as V, TurnState as W, TurnStateDone as X, TurnStreamData as Y, TurnStreamingEvent as Z, UpdateConnectorRequest as _, AgentChatServer as a, UpdateSessionRequest as a0, UserMessage as a1, AgentSelectorEntry as a2, ConnectorSelectorEntry as a3, ModelSelectorEntry as a4, SkillSelectorEntry as a5, DeltaEvents as a6, ActionRequiredEvent as a7, AgentInfo as a8, AgentParent as a9, ApprovalDecision as aa, ChunkDeltaToolCall as ab, ListSessionsOrder as ac, McpInitializeEvent as ad, McpServerAuthInfo as ae, McpServerMount as af, Model as ag, ModelMessageContentPart as ah, ModelMessageDeltaEvent as ai, ModelParams as aj, PageParams as ak, SearchAgentSelectorParams as al, SkillMount as am, ThreadDoneEvent as an, ToolCallFunction as ao, ToolCallRef as ap, ToolInfo as aq, ToolResponseEvent as ar, TurnCreatedEvent as as, TurnDoneEvent as at, TurnStateCancelled as au, TurnStateError as av, TurnStateRunning as aw, UserMessageContent as ax, ThreadCreatedEvent as b, UserToolApprovalEvent as c, Turn as d, TurnInputItem as e, AgentBuilderServer as f, AgentUIServerPort as g, ConnectorAuth as h, ConnectorAuthApiKey as i, ConnectorAuthNone as j, ConnectorAuthOAuth as k, ConnectorAuthPublic as l, ConnectorAuthPublicApiKey as m, ConnectorAuthPublicNone as n, ConnectorAuthPublicOAuth as o, ConnectorAuthType as p, ConnectorBase as q, ConnectorCatalogEntry as r, ConnectorCatalogServer as s, ConnectorConfigBase as t, CreateConnectorRequest as u, CreateModelProviderRequest as v, CreateSessionRequest as w, CreateSkillRequest as x, ListSessionsParams as y, ModelCatalogServer as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truefoundry/assistant-ui-runtime",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "TrueFoundry Gateway agent runtime adapter for assistant-ui",
   "license": "Apache-2.0",
   "repository": {

package/src/convertTurnMessages.ts

@@ -516,6 +516,10 @@ function attachRunningTurn(
     if (runningTurn == null) {
         return snapshot;
     }
+    // Session-level history excludes the running turn. Apply continuation inputs
+    // from the turn listing so answered approvals / ask-user prompts are not
+    // restored as pending while reconnecting to that turn after a refresh.
+    applyUserToolResponsesToFold(snapshot.fold, runningTurn.input ?? []);
     const pendingUserText = extractTurnUserText(runningTurn.input);
     return replaceSessionSnapshot(snapshot, {
         runningTurn,

package/src/{private → draft}/agentSpec.ts

@@ -1,33 +1,30 @@
 import type { AgentSpec } from "../server/types.js";
 
-export type { AgentSpec } from "../server/types.js";
-
 /** @deprecated Use Session with isMutable: true instead. Kept for title helper. */
 export type DraftSession = {
     title?: string | null;
     agentSpec: AgentSpec;
 };
 
-export type AgentSpecUpdate = {
-    instructions?: string;
-    model?: Partial<AgentSpec["model"]> & {
-        params?: Partial<NonNullable<AgentSpec["model"]["params"]>>;
-    };
-    mcpServers?: AgentSpec["mcpServers"];
-    skills?: AgentSpec["skills"];
-    messages?: AgentSpec["messages"];
-    variables?: AgentSpec["variables"];
-    responseFormat?: AgentSpec["responseFormat"];
-    config?: AgentSpec["config"];
+/** Partial update — host fields flow through when `TSpec` is widened. */
+export type AgentSpecUpdate<TSpec extends AgentSpec = AgentSpec> = {
+    [K in keyof TSpec]?: K extends "model"
+        ? Omit<Partial<TSpec["model"]>, "params"> & {
+              params?: Partial<NonNullable<TSpec["model"]["params"]>>;
+          }
+        : TSpec[K];
 };
 
-export function mergeAgentSpec(base: AgentSpec, update: AgentSpecUpdate): AgentSpec {
+export function mergeAgentSpec<TSpec extends AgentSpec>(
+    base: TSpec,
+    update: AgentSpecUpdate<TSpec>,
+): TSpec {
     const { model: modelUpdate, ...rest } = update;
 
-    const next: AgentSpec = {
+    const next = {
         ...base,
         ...rest,
-    };
+    } as TSpec;
 
     if (modelUpdate != null) {
         next.model = {
@@ -38,7 +35,7 @@ export function mergeAgentSpec(base: AgentSpec, update: AgentSpecUpdate): AgentS
                 modelUpdate.params != null
                     ? { ...base.model.params, ...modelUpdate.params }
                     : base.model.params,
-        };
+        } as TSpec["model"];
     }
 
     return next;

package/src/{private → draft}/draftSessionBridge.ts

@@ -1,5 +1,4 @@
-import type { AgentChatServer } from "../server/types.js";
-import type { AgentSpec } from "./agentSpec.js";
+import type { AgentChatServer, AgentSpec } from "../server/types.js";
 
 export const DRAFT_SESSION_LAST_UPDATED_AT_HEADER = "x-tfy-session-last-updated-at";
 

package/src/{private → draft}/truefoundryDraftThreadListAdapter.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, it, vi } from "vitest";
 import type { AgentChatServer, Session } from "../server/index.js";
 
 import { createTrueFoundryDraftThreadListAdapter } from "./truefoundryDraftThreadListAdapter.js";
-import type { AgentSpec } from "./agentSpec.js";
+import type { AgentSpec } from "../server/types.js";
 
 const defaultAgentSpec: AgentSpec = {
     model: { name: "anthropic/claude-sonnet-4-6" },

package/src/{private → draft}/truefoundryDraftThreadListAdapter.ts

@@ -1,7 +1,8 @@
 import type { RemoteThreadListAdapter } from "@assistant-ui/core";
 
 import type { AgentChatServer } from "../server/types.js";
-import { draftSessionTitle, type AgentSpec } from "./agentSpec.js";
+import type { AgentSpec } from "../server/types.js";
+import { draftSessionTitle } from "./agentSpec.js";
 import { sessionListStartTimestamp } from "../sessionListStartTimestamp.js";
 
 const THREAD_LIST_PAGE_SIZE = 20;
@@ -60,7 +61,10 @@ export function createTrueFoundryDraftThreadListAdapter(options: {
         async rename() {},
         async archive() {},
         async unarchive() {},
-        async delete() {},
+        async delete(remoteId) {
+            if (typeof server.deleteSession !== "function") return;
+            await server.deleteSession({ sessionId: remoteId });
+        },
 
         async generateTitle() {
             return new ReadableStream();

package/src/{private → draft}/useDraftAgentSpec.ts

@@ -2,11 +2,8 @@
 
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 
-import {
-    mergeAgentSpec,
-    type AgentSpec,
-    type AgentSpecUpdate,
-} from "./agentSpec.js";
+import type { AgentSpec } from "../server/types.js";
+import { mergeAgentSpec, type AgentSpecUpdate } from "./agentSpec.js";
 import type { DraftSessionBridge } from "./draftSessionBridge.js";
 
 const SPEC_SYNC_DEBOUNCE_MS = 400;
@@ -22,6 +19,7 @@ export type UseDraftAgentSpecOptions = {
 export type UseDraftAgentSpecResult = {
     agentSpec: AgentSpec | null;
     draftSessionId: string | undefined;
+    isSpecLoading: boolean;
     isSpecSyncing: boolean;
     specError: unknown | null;
     updateAgentSpec: (update: AgentSpecUpdate) => void;
@@ -37,6 +35,7 @@ export function useDraftAgentSpec({
 }: UseDraftAgentSpecOptions): UseDraftAgentSpecResult {
     const enabled = draftBridge != null;
     const [agentSpec, setAgentSpec] = useState<AgentSpec>(defaultAgentSpec);
+    const [isSpecLoading, setIsSpecLoading] = useState(false);
     const [isSpecSyncing, setIsSpecSyncing] = useState(false);
     const [specError, setSpecError] = useState<unknown | null>(null);
 
@@ -86,6 +85,7 @@ export function useDraftAgentSpec({
             setAgentSpec(defaultAgentSpec);
             localDirtyRef.current = false;
             setSpecError(null);
+            setIsSpecLoading(false);
             return;
         }
 
@@ -94,6 +94,7 @@ export function useDraftAgentSpec({
         }
 
         let cancelled = false;
+        setIsSpecLoading(true);
         void (async () => {
             try {
                 const loaded = await draftBridge.getDraftAgentSpec(draftSessionId);
@@ -106,21 +107,29 @@ export function useDraftAgentSpec({
                     scheduleSpecSyncRef.current?.(draftSessionId, agentSpecRef.current);
                     localDirtyRef.current = false;
                     setSpecError(null);
+                    setIsSpecLoading(false);
                     return;
                 }
 
                 setAgentSpec(loaded);
                 setSpecError(null);
+                setIsSpecLoading(false);
             } catch (error) {
                 if (!cancelled) {
                     onError?.(error);
                     setSpecError(error);
+                    setIsSpecLoading(false);
                 }
             }
         })();
 
         return () => {
             cancelled = true;
+            // The cancelled load can no longer clear the flag itself. Releasing it
+            // here keeps it from sticking when the next run early-returns on an
+            // already-loaded draft; a run that starts a fresh load re-raises it in
+            // the same commit.
+            setIsSpecLoading(false);
         };
     }, [defaultAgentSpec, draftBridge, draftSessionId, enabled, onError]);
 
@@ -232,6 +241,7 @@ export function useDraftAgentSpec({
         () => ({
             agentSpec: enabled ? agentSpec : null,
             draftSessionId: enabled ? draftSessionId : undefined,
+            isSpecLoading: enabled ? isSpecLoading : false,
             isSpecSyncing: enabled ? isSpecSyncing : false,
             specError: enabled ? specError : null,
             updateAgentSpec,
@@ -241,6 +251,7 @@ export function useDraftAgentSpec({
             agentSpec,
             draftSessionId,
             enabled,
+            isSpecLoading,
             isSpecSyncing,
             specError,
             takeTurnHeaderTimestamp,

package/src/draftAgentConfig.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 
-import { mergeAgentSpec, type AgentSpec } from "./private/agentSpec.js";
+import { mergeAgentSpec } from "./draft/agentSpec.js";
+import type { AgentSpec } from "./server/types.js";
 import {
     resolveTrueFoundryAgentConfig,
     resolveTrueFoundryAgentRuntimeOptions,