@truefoundry/assistant-ui-runtime 0.1.10-rc.1 → 0.1.12

package/src/convertTurnMessages.ts

@@ -1029,10 +1029,12 @@ function projectHistoryTurns(
     const messages: ThreadMessage[] = [];
     let lastAssistantIndex: number | undefined;
     let groupRootIds: string[] = [];
+    let sandboxId: string | undefined;
 
     for (let turnIndex = 0; turnIndex < snapshot.turns.length; turnIndex++) {
         const record = snapshot.turns[turnIndex]!;
         const turnRootIds = record.rootModelMessageIds ?? [];
+        sandboxId = record.sandboxId ?? sandboxId;
 
         if (record.userText) {
             groupRootIds = [...turnRootIds];
@@ -1080,7 +1082,7 @@ function projectHistoryTurns(
         const custom = {
             ...baseCustom,
             turnId: record.id,
-            ...(record.sandboxId != null ? { sandboxId: record.sandboxId } : {}),
+            ...(sandboxId != null ? { sandboxId } : {}),
         };
 
         if (record.userText) {
@@ -1738,7 +1740,11 @@ export function turnStreamUpdateToAssistantMessage(
             unstable_annotations: [],
             unstable_data: [],
             steps: [],
-            custom: { ...update.metadata?.custom, turnId },
+            custom: {
+                ...(existing?.role === "assistant" ? existing.metadata.custom : {}),
+                ...update.metadata?.custom,
+                turnId,
+            },
         },
     };
 }

package/src/draft/truefoundryDraftThreadListAdapter.test.ts

@@ -10,7 +10,12 @@ const defaultAgentSpec: AgentSpec = {
     instructions: "You are helpful.",
 };
 
-function mockDraft(id: string, title: string | undefined, updatedAt: string): Session {
+function mockDraft(
+    id: string,
+    title: string | undefined,
+    updatedAt: string,
+    extras?: Partial<Session>,
+): Session {
     return {
         id,
         agentSpec: defaultAgentSpec,
@@ -18,6 +23,7 @@ function mockDraft(id: string, title: string | undefined, updatedAt: string): Se
         createdAt: updatedAt,
         updatedAt,
         isMutable: true,
+        ...extras,
     };
 }
 
@@ -33,10 +39,22 @@ function mockServer(partial: Partial<AgentChatServer>): AgentChatServer {
 }
 
 describe("createTrueFoundryDraftThreadListAdapter", () => {
-    it("lists draft sessions with pagination cursor", async () => {
+    it("lists sessions with pagination cursor and does not filter isMutable client-side", async () => {
         const listSessions = vi.fn().mockResolvedValue(
             mockDraftListPage(
-                [mockDraft("d1", "My draft", "2026-06-30T10:00:00.000Z")],
+                [
+                    mockDraft("d1", "My draft", "2026-06-30T10:00:00.000Z"),
+                    mockDraft("s1", "Named", "2026-06-30T09:00:00.000Z", {
+                        isMutable: false,
+                        agentName: "from-sdk",
+                        agentSpec: undefined,
+                    }),
+                    mockDraft("s2", undefined, "2026-06-30T08:00:00.000Z", {
+                        isMutable: false,
+                        agentName: "untitled-agent",
+                        agentSpec: undefined,
+                    }),
+                ],
                 "page-2",
             ),
         );
@@ -61,7 +79,7 @@ describe("createTrueFoundryDraftThreadListAdapter", () => {
             }),
         );
         expect(listSessions).toHaveBeenCalledWith(
-            expect.not.objectContaining({ agentName: expect.anything() }),
+            expect.not.objectContaining({ agentId: expect.anything() }),
         );
         expect(result.threads).toEqual([
             {
@@ -69,11 +87,47 @@ describe("createTrueFoundryDraftThreadListAdapter", () => {
                 remoteId: "d1",
                 title: "My draft",
                 lastMessageAt: new Date("2026-06-30T10:00:00.000Z"),
+                custom: { isMutable: true },
+            },
+            {
+                status: "regular",
+                remoteId: "s1",
+                title: "Named",
+                lastMessageAt: new Date("2026-06-30T09:00:00.000Z"),
+                custom: { isMutable: false, agentName: "from-sdk" },
+            },
+            {
+                status: "regular",
+                remoteId: "s2",
+                title: "untitled-agent",
+                lastMessageAt: new Date("2026-06-30T08:00:00.000Z"),
+                custom: { isMutable: false, agentName: "untitled-agent" },
             },
         ]);
         expect(result.nextCursor).toBe("page-2");
     });
 
+    it("forwards listSessionsAgentId as agentId", async () => {
+        const listSessions = vi.fn().mockResolvedValue(mockDraftListPage([]));
+        const server = mockServer({
+            listSessions,
+            createSession: vi.fn(),
+            getSession: vi.fn(),
+        });
+
+        const adapter = createTrueFoundryDraftThreadListAdapter({
+            server,
+            defaultAgentSpec,
+            listSessionsAgentId: "agent-x",
+        });
+
+        await adapter.list();
+
+        expect(listSessions).toHaveBeenCalledWith(
+            expect.objectContaining({ agentId: "agent-x" }),
+        );
+    });
+
     it("creates a draft session on initialize", async () => {
         const createSession = vi.fn().mockResolvedValue(
             mockDraft("d-new", undefined, "2026-06-30T12:00:00.000Z"),

package/src/draft/truefoundryDraftThreadListAdapter.ts

@@ -2,8 +2,11 @@ import type { RemoteThreadListAdapter } from "@assistant-ui/core";
 
 import type { AgentChatServer } from "../server/types.js";
 import type { AgentSpec } from "../server/types.js";
-import { draftSessionTitle } from "./agentSpec.js";
 import { sessionListStartTimestamp } from "../sessionListStartTimestamp.js";
+import {
+    sessionDisplayTitle,
+    sessionToThreadMetadata,
+} from "../sessionThreadMetadata.js";
 
 const THREAD_LIST_PAGE_SIZE = 20;
 
@@ -11,27 +14,25 @@ export function createTrueFoundryDraftThreadListAdapter(options: {
     server: AgentChatServer;
     defaultAgentSpec: AgentSpec;
     getAgentSpec?: () => AgentSpec;
+    /** When set, filters `listSessions` by this agent id. Omit for all chats. */
+    listSessionsAgentId?: string;
 }): RemoteThreadListAdapter {
-    const { server, defaultAgentSpec, getAgentSpec } = options;
+    const { server, defaultAgentSpec, getAgentSpec, listSessionsAgentId } = options;
 
     return {
         async list({ after } = {}) {
             const page = await server.listSessions({
+                ...(listSessionsAgentId != null ? { agentId: listSessionsAgentId } : {}),
                 limit: THREAD_LIST_PAGE_SIZE,
                 pageToken: after,
                 startTimestamp: sessionListStartTimestamp(),
             });
-            const threads = page.data
-                .filter((session) => session.isMutable)
-                .map((draft) => ({
-                    status: "regular" as const,
-                    remoteId: draft.id,
-                    title: draftSessionTitle({
-                        title: draft.title,
-                        agentSpec: draft.agentSpec ?? defaultAgentSpec,
-                    }),
-                    lastMessageAt: new Date(draft.updatedAt),
-                }));
+            const threads = page.data.map((session) =>
+                sessionToThreadMetadata(
+                    session,
+                    sessionDisplayTitle(session, defaultAgentSpec),
+                ),
+            );
             return {
                 threads,
                 nextCursor: page.nextPageToken ?? undefined,
@@ -47,15 +48,10 @@ export function createTrueFoundryDraftThreadListAdapter(options: {
 
         async fetch(remoteId) {
             const draft = await server.getSession({ sessionId: remoteId });
-            return {
-                status: "regular" as const,
-                remoteId: draft.id,
-                title: draftSessionTitle({
-                    title: draft.title,
-                    agentSpec: draft.agentSpec ?? defaultAgentSpec,
-                }),
-                lastMessageAt: new Date(draft.updatedAt),
-            };
+            return sessionToThreadMetadata(
+                draft,
+                sessionDisplayTitle(draft, defaultAgentSpec),
+            );
         },
 
         async rename() {},

package/src/index.ts

@@ -77,7 +77,9 @@ export { trueFoundryAttachmentAdapter } from "./attachmentAdapter.js";
 
 export type {
     AgentChatServer,
+    AgentBuilderCapabilitiesResponse,
     AgentBuilderServer,
+    SaveAgentRequest,
     Session,
     Turn,
     TurnState,
@@ -91,8 +93,11 @@ export type {
     UserMessage,
     UserToolApprovalEvent,
     UserToolResponseEvent,
+    ApprovalDecision,
     PreviousTurnIdInput,
     ProviderType,
+    PageParams,
+    ListSessionsOrder,
     ModelEntry,
     ModelProviderConfigBase,
     ModelProviderBase,
@@ -115,6 +120,8 @@ export type {
     ConnectorCatalogEntry,
     CreateConnectorRequest,
     UpdateConnectorRequest,
+    AuthenticateConnectorRequest,
+    ConnectorAuthenticationResult,
     ConnectorCatalogServer,
     SkillBase,
     RegistrySkill,
@@ -132,9 +139,29 @@ export type {
     SandboxBase,
     CreateSandboxRequest,
     UpdateSandboxRequest,
+    SandboxProviderConfig,
+    SandboxProviderCatalogEntry,
+    SandboxProviderBase,
+    CreateSandboxProviderRequest,
+    UpdateSandboxProviderRequest,
     SandboxCatalogServer,
     CatalogServer,
     AgentUIServerPort,
+    AgentUIServer,
+    ModelSelectorEntry,
+    SkillSelectorEntry,
+    ConnectorSelectorEntry,
+    AgentSelectorEntry,
+    SearchAgentSelectorParams,
+    ModelSelection,
+    AgentSkill,
+    ConnectorState,
+    AgentLibraryEntry,
+    SearchAgentsParams,
+    SkillMount,
+    McpServerMount,
+    ModelParams,
+    Model,
 } from "./server/index.js";
 export type {
     SandboxCreatedEvent,

package/src/plugins/truefoundry-agent-server-adapter/chatServer.ts

@@ -227,7 +227,7 @@ export function createTrueFoundryChatServer<
                 pageToken: req?.pageToken,
                 startTimestamp: req?.startTimestamp,
                 endTimestamp: req?.endTimestamp,
-                ...(req?.agentName != null ? { agentName: req.agentName } : {}),
+                ...(req?.agentId != null ? { agentName: req.agentId } : {}),
             });
             const result = await toListResult(page, (s) => toSession<TSpec>(s));
             for (const session of result.data) {

package/src/plugins/truefoundry-agent-server-adapter/cp.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 import {
+    agentSpecFromCpManifest,
     buildSaveAgentManifest,
     normalizeAgents,
     normalizeAgentSkills,
@@ -10,6 +11,7 @@ import {
     saveAgent,
     SAVE_AGENT_COLLABORATORS,
     SAVE_AGENT_METADATA_TAGS,
+    toCamelCaseDeep,
     toSnakeCaseDeep,
 } from "./cp.js";
 
@@ -273,16 +275,175 @@ describe("normalizeMcpServers", () => {
 });
 
 describe("normalizeAgents", () => {
-    it("maps name only", () => {
+    it("maps name, agentId, and agentSpec from latestVersionDetails.manifest", () => {
         expect(
             normalizeAgents({
                 data: [
-                    { name: "ask-ai-agent", id: "ag_1" },
+                    {
+                        id: "ag_1",
+                        name: "ask-ai-agent",
+                        latestVersionDetails: {
+                            manifest: {
+                                type: "truefoundry-agent",
+                                name: "ask-ai-agent",
+                                model: {
+                                    name: "openai-main/gpt-4.1",
+                                    params: {
+                                        max_tokens: 8192,
+                                        reasoning_effort: "medium",
+                                    },
+                                },
+                                instructions: "Be helpful",
+                                config: {
+                                    iteration_limit: 50,
+                                    ask_user_questions: { enabled: true },
+                                },
+                                skills: [
+                                    {
+                                        type: "truefoundry-skills-registry",
+                                        fqn: "agent-skill:tfy/skills/web:1",
+                                        preload: true,
+                                        config: { timeout_ms: 1000 },
+                                    },
+                                ],
+                                mcp_servers: [
+                                    {
+                                        name: "gmail",
+                                        enable_tools: ["@read-only"],
+                                        preload: true,
+                                        config: { locale: "en" },
+                                    },
+                                ],
+                            },
+                        },
+                    },
                     { name: "" },
                     {},
+                    {
+                        name: "try-only",
+                        // no manifest → Try still works; Edit hidden
+                    },
                 ],
             }),
-        ).toEqual([{ name: "ask-ai-agent" }]);
+        ).toEqual([
+            {
+                name: "ask-ai-agent",
+                agentId: "ag_1",
+                agentSpec: {
+                    model: {
+                        name: "openai-main/gpt-4.1",
+                        params: { maxTokens: 8192, reasoningEffort: "medium" },
+                    },
+                    instructions: "Be helpful",
+                    config: {
+                        iterationLimit: 50,
+                        askUserQuestions: { enabled: true },
+                    },
+                    skills: [
+                        {
+                            id: "agent-skill:tfy/skills/web:1",
+                            name: "agent-skill:tfy/skills/web:1",
+                            preload: true,
+                            config: { timeoutMs: 1000 },
+                        },
+                    ],
+                    mcpServers: [
+                        {
+                            id: "gmail",
+                            name: "gmail",
+                            enableTools: ["@read-only"],
+                            preload: true,
+                            config: { locale: "en" },
+                        },
+                    ],
+                },
+            },
+            { name: "try-only", agentId: "try-only" },
+        ]);
+    });
+});
+
+describe("toCamelCaseDeep", () => {
+    it("converts nested snake_case keys", () => {
+        expect(
+            toCamelCaseDeep({
+                max_tokens: 8192,
+                reasoning_effort: "medium",
+                nested: { iteration_limit: 50 },
+            }),
+        ).toEqual({
+            maxTokens: 8192,
+            reasoningEffort: "medium",
+            nested: { iterationLimit: 50 },
+        });
+    });
+});
+
+describe("agentSpecFromCpManifest", () => {
+    it("returns undefined when model.name is missing", () => {
+        expect(agentSpecFromCpManifest({ type: "truefoundry-agent" })).toBeUndefined();
+        expect(agentSpecFromCpManifest(null)).toBeUndefined();
+    });
+
+    it("preserves mount runtime fields and agent config for Edit → Save", () => {
+        const spec = agentSpecFromCpManifest({
+            type: "truefoundry-agent",
+            name: "saved",
+            model: { name: "openai-main/gpt-4.1" },
+            config: { iteration_limit: 25 },
+            skills: [
+                {
+                    type: "truefoundry-skills-registry",
+                    fqn: "agent-skill:tfy/skills/web:1",
+                    preload: false,
+                },
+            ],
+            mcp_servers: [
+                {
+                    name: "gmail",
+                    enable_tools: ["@read-only"],
+                    preload: true,
+                },
+            ],
+        });
+
+        expect(spec).toEqual({
+            model: { name: "openai-main/gpt-4.1" },
+            config: { iterationLimit: 25 },
+            skills: [
+                {
+                    id: "agent-skill:tfy/skills/web:1",
+                    name: "agent-skill:tfy/skills/web:1",
+                    preload: false,
+                },
+            ],
+            mcpServers: [
+                {
+                    id: "gmail",
+                    name: "gmail",
+                    enableTools: ["@read-only"],
+                    preload: true,
+                },
+            ],
+        });
+
+        const saved = buildSaveAgentManifest("saved", spec!);
+        expect(saved.config).toEqual({ iteration_limit: 25 });
+        expect(saved.mcp_servers).toEqual([
+            {
+                type: "truefoundry-mcp-registry",
+                name: "gmail",
+                enable_tools: ["@read-only"],
+                preload: true,
+            },
+        ]);
+        expect(saved.skills).toEqual([
+            {
+                type: "truefoundry-skills-registry",
+                fqn: "agent-skill:tfy/skills/web:1",
+                preload: false,
+            },
+        ]);
     });
 });
 
@@ -432,9 +593,11 @@ describe("saveAgent", () => {
                 }),
             }),
         );
-        const body = JSON.parse(
-            (fetchMock.mock.calls[0]?.[1] as RequestInit).body as string,
-        );
+        const [, init] = fetchMock.mock.calls[0] as unknown as [
+            string,
+            RequestInit,
+        ];
+        const body = JSON.parse(String(init.body));
         expect(body.manifest.type).toBe("truefoundry-agent");
         expect(body.manifest.name).toBe("my-agent");
         expect(body.manifest.model).toEqual({ name: "openai-main/gpt-4.1" });

package/src/plugins/truefoundry-agent-server-adapter/cp.ts

@@ -335,9 +335,126 @@ export async function listMcpServers(
 // ---------------------------------------------------------------------------
 
 type RawAgent = {
+    id?: string;
     name?: string;
+    latestVersionDetails?: {
+        manifest?: unknown;
+    };
+    /** Defensive: some payloads nest manifest at the top level. */
+    manifest?: unknown;
 };
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+function snakeToCamelKey(key: string): string {
+    return key.replace(/_([a-z])/g, (_, letter: string) => letter.toUpperCase());
+}
+
+/** Deep snake_case → camelCase (inverse of {@link toSnakeCaseDeep}). */
+export function toCamelCaseDeep(value: unknown): unknown {
+    if (Array.isArray(value)) {
+        return value.map(toCamelCaseDeep);
+    }
+    if (isRecord(value)) {
+        const out: Record<string, unknown> = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[snakeToCamelKey(k)] = toCamelCaseDeep(v);
+        }
+        return out;
+    }
+    return value;
+}
+
+/**
+ * Map a CP AgentManifest (snake_case wire) → FE AgentSpec for Edit seeding.
+ * Skills/MCP keep `{ id, name }` for draft pickers plus runtime fields
+ * (`enableTools`, `preload`, `config`) so Edit → Save does not widen tool
+ * access or wipe settings. Gateway registry shapes are restored on save via
+ * normalizeAgentSpecForGateway.
+ */
+export function agentSpecFromCpManifest(manifest: unknown): TfyAgentSpec | undefined {
+    if (!isRecord(manifest)) return undefined;
+    const modelRaw = manifest.model;
+    if (!isRecord(modelRaw) || typeof modelRaw.name !== "string" || modelRaw.name === "") {
+        return undefined;
+    }
+    const model = toCamelCaseDeep(modelRaw) as TfyAgentSpec["model"];
+
+    // Catalog-shaped mounts (`id`/`name` + runtime fields). Not yet gateway
+    // registry unions — normalizeAgentSpecForGateway restores those on save.
+    const skills: Array<Record<string, unknown>> = [];
+    if (Array.isArray(manifest.skills)) {
+        for (const row of manifest.skills) {
+            if (!isRecord(row)) continue;
+            const fqn =
+                typeof row.fqn === "string" && row.fqn !== ""
+                    ? row.fqn
+                    : typeof row.id === "string" && row.id !== ""
+                      ? row.id
+                      : null;
+            if (fqn == null) continue;
+            const camel = toCamelCaseDeep(row) as Record<string, unknown>;
+            const name =
+                typeof camel.name === "string" && camel.name !== ""
+                    ? camel.name
+                    : fqn;
+            skills.push({
+                id: fqn,
+                name,
+                ...(typeof camel.preload === "boolean"
+                    ? { preload: camel.preload }
+                    : {}),
+                ...(camel.config != null ? { config: camel.config } : {}),
+            });
+        }
+    }
+
+    const mcpServers: Array<Record<string, unknown>> = [];
+    const mcpRaw = Array.isArray(manifest.mcp_servers)
+        ? manifest.mcp_servers
+        : Array.isArray(manifest.mcpServers)
+          ? manifest.mcpServers
+          : [];
+    for (const row of mcpRaw) {
+        if (!isRecord(row)) continue;
+        const camel = toCamelCaseDeep(row) as Record<string, unknown>;
+        const name =
+            typeof camel.name === "string" && camel.name !== ""
+                ? camel.name
+                : typeof camel.id === "string" && camel.id !== ""
+                  ? camel.id
+                  : null;
+        if (name == null) continue;
+        mcpServers.push({
+            id: name,
+            name,
+            ...(Array.isArray(camel.enableTools)
+                ? { enableTools: camel.enableTools }
+                : {}),
+            ...(typeof camel.preload === "boolean"
+                ? { preload: camel.preload }
+                : {}),
+            ...(camel.config != null ? { config: camel.config } : {}),
+        });
+    }
+
+    const configRaw = manifest.config;
+    const config =
+        configRaw != null ? (toCamelCaseDeep(configRaw) as TfyAgentSpec["config"]) : undefined;
+
+    return {
+        model,
+        ...(typeof manifest.instructions === "string"
+            ? { instructions: manifest.instructions }
+            : {}),
+        ...(config != null ? { config } : {}),
+        ...(skills.length > 0 ? { skills } : {}),
+        ...(mcpServers.length > 0 ? { mcpServers } : {}),
+    } as TfyAgentSpec;
+}
+
 export function normalizeAgents(raw: unknown): TfyAgentSelectorEntry[] {
     const data =
         raw != null &&
@@ -348,7 +465,15 @@ export function normalizeAgents(raw: unknown): TfyAgentSelectorEntry[] {
     const out: TfyAgentSelectorEntry[] = [];
     for (const row of data) {
         if (row.name == null || row.name === "") continue;
-        out.push({ name: row.name });
+        const manifest = row.latestVersionDetails?.manifest ?? row.manifest;
+        const agentSpec = agentSpecFromCpManifest(manifest);
+        const agentId =
+            typeof row.id === "string" && row.id !== "" ? row.id : row.name;
+        out.push({
+            name: row.name,
+            agentId,
+            ...(agentSpec != null ? { agentSpec } : {}),
+        });
     }
     return out;
 }

package/src/plugins/truefoundry-agent-server-adapter/createTrueFoundryAgentUIServer.ts

@@ -76,6 +76,13 @@ export async function createTrueFoundryAgentUIServer<
 
         const server: TrueFoundryAgentUIServer<TSpec> = {
             ...chat,
+            getCapabilities: async () => ({
+                data: {
+                    sandbox: { enabled: true },
+                    skill: { enabled: true },
+                    settings: { enabled: true },
+                },
+            }),
             getModels: () => listEnabledModels(cp),
             getSkills: () => listAgentSkills(cp),
             getMcp: () => listMcpServers(cp),