@truefoundry/assistant-ui-runtime 0.1.4 → 0.1.6-rc.0

package/src/private/truefoundryDraftThreadListAdapter.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 
-import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
+import type { AgentChatServer, Session } from "../server/index.js";
 
 import { createTrueFoundryDraftThreadListAdapter } from "./truefoundryDraftThreadListAdapter.js";
 import type { AgentSpec } from "./agentSpec.js";
@@ -10,62 +10,57 @@ const defaultAgentSpec: AgentSpec = {
     instructions: "You are helpful.",
 };
 
-function mockDraft(id: string, title: string | undefined, updatedAt: string) {
+function mockDraft(id: string, title: string | undefined, updatedAt: string): Session {
     return {
-        type: "session/draft" as const,
         id,
         agentSpec: defaultAgentSpec,
         title,
-        createdBySubject: { type: "user" as const, id: "u1" },
         createdAt: updatedAt,
         updatedAt,
+        isMutable: true,
     };
 }
 
-function mockDraftListPage(
-    drafts: ReturnType<typeof mockDraft>[],
-    nextPageToken?: string,
-) {
+function mockDraftListPage(drafts: Session[], nextPageToken?: string) {
     return {
         data: drafts,
-        response: {
-            pagination: {
-                nextPageToken,
-                limit: 20,
-            },
-        },
+        ...(nextPageToken != null ? { nextPageToken } : {}),
     };
 }
 
+function mockServer(partial: Partial<AgentChatServer>): AgentChatServer {
+    return partial as AgentChatServer;
+}
+
 describe("createTrueFoundryDraftThreadListAdapter", () => {
     it("lists draft sessions with pagination cursor", async () => {
-        const listDraftSessions = vi.fn().mockResolvedValue(
+        const listSessions = vi.fn().mockResolvedValue(
             mockDraftListPage(
                 [mockDraft("d1", "My draft", "2026-06-30T10:00:00.000Z")],
                 "page-2",
             ),
         );
-        const privateClient = {
-            listDraftSessions,
-            createDraftSession: vi.fn(),
-            getDraftSession: vi.fn(),
-        } as unknown as PrivateAgentSessionClient;
+        const server = mockServer({
+            listSessions,
+            createSession: vi.fn(),
+            getSession: vi.fn(),
+        });
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            privateClient,
+            server,
             defaultAgentSpec,
         });
 
         const result = await adapter.list();
 
-        expect(listDraftSessions).toHaveBeenCalledWith(
+        expect(listSessions).toHaveBeenCalledWith(
             expect.objectContaining({
                 limit: 20,
                 pageToken: undefined,
                 startTimestamp: expect.any(String),
             }),
         );
-        expect(listDraftSessions).toHaveBeenCalledWith(
+        expect(listSessions).toHaveBeenCalledWith(
             expect.not.objectContaining({ agentName: expect.anything() }),
         );
         expect(result.threads).toEqual([
@@ -80,23 +75,23 @@ describe("createTrueFoundryDraftThreadListAdapter", () => {
     });
 
     it("creates a draft session on initialize", async () => {
-        const createDraftSession = vi.fn().mockResolvedValue(
+        const createSession = vi.fn().mockResolvedValue(
             mockDraft("d-new", undefined, "2026-06-30T12:00:00.000Z"),
         );
-        const privateClient = {
-            listDraftSessions: vi.fn(),
-            createDraftSession,
-            getDraftSession: vi.fn(),
-        } as unknown as PrivateAgentSessionClient;
+        const server = mockServer({
+            listSessions: vi.fn(),
+            createSession,
+            getSession: vi.fn(),
+        });
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            privateClient,
+            server,
             defaultAgentSpec,
         });
 
         const result = await adapter.initialize("local-thread-id");
 
-        expect(createDraftSession).toHaveBeenCalledWith({ agentSpec: defaultAgentSpec });
+        expect(createSession).toHaveBeenCalledWith({ agentSpec: defaultAgentSpec });
         expect(result).toEqual({ remoteId: "d-new", externalId: undefined });
     });
 
@@ -104,47 +99,47 @@ describe("createTrueFoundryDraftThreadListAdapter", () => {
         const liveAgentSpec: AgentSpec = {
             model: { name: "anthropic/claude-opus-4-8" },
             instructions: "You are helpful.",
-            mcpServers: [{ type: "truefoundry-mcp-registry", name: "github", enableTools: ["@all"] }],
-            skills: [{ fqn: "acme/skill-a:1", preload: false }],
+            mcpServers: [{ id: "github", name: "github" }],
+            skills: [{ id: "skill-a", name: "skill-a" }],
         };
-        const createDraftSession = vi.fn().mockResolvedValue(
+        const createSession = vi.fn().mockResolvedValue(
             mockDraft("d-new", undefined, "2026-06-30T12:00:00.000Z"),
         );
-        const privateClient = {
-            listDraftSessions: vi.fn(),
-            createDraftSession,
-            getDraftSession: vi.fn(),
-        } as unknown as PrivateAgentSessionClient;
+        const server = mockServer({
+            listSessions: vi.fn(),
+            createSession,
+            getSession: vi.fn(),
+        });
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            privateClient,
+            server,
             defaultAgentSpec,
             getAgentSpec: () => liveAgentSpec,
         });
 
         await adapter.initialize("local-thread-id");
 
-        expect(createDraftSession).toHaveBeenCalledWith({ agentSpec: liveAgentSpec });
+        expect(createSession).toHaveBeenCalledWith({ agentSpec: liveAgentSpec });
     });
 
     it("falls back to model name for title when draft has no title", async () => {
-        const getDraftSession = vi.fn().mockResolvedValue(
+        const getSession = vi.fn().mockResolvedValue(
             mockDraft("d1", undefined, "2026-06-30T10:00:00.000Z"),
         );
-        const privateClient = {
-            listDraftSessions: vi.fn(),
-            createDraftSession: vi.fn(),
-            getDraftSession,
-        } as unknown as PrivateAgentSessionClient;
+        const server = mockServer({
+            listSessions: vi.fn(),
+            createSession: vi.fn(),
+            getSession,
+        });
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            privateClient,
+            server,
             defaultAgentSpec,
         });
 
         const result = await adapter.fetch("d1");
 
-        expect(getDraftSession).toHaveBeenCalledWith({ draftSessionId: "d1" });
+        expect(getSession).toHaveBeenCalledWith({ sessionId: "d1" });
         expect(result.title).toBe("anthropic/claude-sonnet-4-6");
     });
 });

package/src/private/truefoundryDraftThreadListAdapter.ts

@@ -1,52 +1,58 @@
 import type { RemoteThreadListAdapter } from "@assistant-ui/core";
-import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
+import type { AgentChatServer } from "../server/types.js";
 import { draftSessionTitle, type AgentSpec } from "./agentSpec.js";
 import { sessionListStartTimestamp } from "../sessionListStartTimestamp.js";
 
 const THREAD_LIST_PAGE_SIZE = 20;
 
 export function createTrueFoundryDraftThreadListAdapter(options: {
-    privateClient: PrivateAgentSessionClient;
+    server: AgentChatServer;
     defaultAgentSpec: AgentSpec;
     getAgentSpec?: () => AgentSpec;
 }): RemoteThreadListAdapter {
-    const { privateClient, defaultAgentSpec, getAgentSpec } = options;
+    const { server, defaultAgentSpec, getAgentSpec } = options;
 
     return {
         async list({ after } = {}) {
-            const page = await privateClient.listDraftSessions({
+            const page = await server.listSessions({
                 limit: THREAD_LIST_PAGE_SIZE,
                 pageToken: after,
                 startTimestamp: sessionListStartTimestamp(),
             });
-            const threads = page.data.map((draft) => ({
-                status: "regular" as const,
-                remoteId: draft.id,
-                title: draftSessionTitle(draft),
-                lastMessageAt: new Date(draft.updatedAt),
-            }));
+            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),
+                }));
             return {
                 threads,
-                nextCursor: page.response.pagination.nextPageToken ?? undefined,
+                nextCursor: page.nextPageToken ?? undefined,
             };
         },
 
         async initialize(_threadId: string) {
-            const draft = await privateClient.createDraftSession({
+            const draft = await server.createSession({
                 agentSpec: getAgentSpec?.() ?? defaultAgentSpec,
             });
             return { remoteId: draft.id, externalId: undefined };
         },
 
         async fetch(remoteId) {
-            const draft = await privateClient.getDraftSession({
-                draftSessionId: remoteId,
-            });
+            const draft = await server.getSession({ sessionId: remoteId });
             return {
                 status: "regular" as const,
                 remoteId: draft.id,
-                title: draftSessionTitle(draft),
+                title: draftSessionTitle({
+                    title: draft.title,
+                    agentSpec: draft.agentSpec ?? defaultAgentSpec,
+                }),
                 lastMessageAt: new Date(draft.updatedAt),
             };
         },

package/src/requiredActionInputs.ts

@@ -3,7 +3,7 @@ import type {
     TurnInputItem,
     UserToolApprovalEvent,
     UserToolResponseEvent,
-} from "truefoundry-gateway-sdk/agents";
+} from "./server/index.js";
 
 import { ROOT_THREAD_ID } from "./constants.js";
 import {

package/src/requiredActionsFromActiveUpdate.test.ts

@@ -64,7 +64,7 @@ describe("requiredActionsFromActiveUpdate", () => {
         };
 
         const actions = requiredActionsFromActiveUpdate(update);
-        expect(actions.map((action) => action.type)).toEqual([
+        expect(actions?.map((action) => action.type)).toEqual([
             "tool.approval_required",
             "tool.response_required",
         ]);

package/src/server/eventUtils.ts

@@ -0,0 +1,120 @@
+/**
+ * Local implementations of streaming delta helpers.
+ * Formerly imported from truefoundry-gateway-sdk/agents.
+ */
+
+import type {
+    DeltaEvents,
+    ModelMessageDeltaEvent,
+    ModelMessageEvent,
+    ToolCall,
+    ToolInfo,
+    TurnEvent,
+    TurnStreamingEvent,
+} from "./events.js";
+
+/** True for `.delta` streaming events. */
+export function isEventDelta(event: TurnStreamingEvent): event is DeltaEvents {
+    return typeof event.type === "string" && event.type.endsWith(".delta");
+}
+
+/**
+ * Merge `delta` into `base` in place (same `id` required).
+ * Currently handles `model.message.delta` → `model.message`.
+ */
+export function mergeEventDelta(base: TurnEvent, delta: DeltaEvents): void {
+    if (base.id !== delta.id) {
+        throw new Error(
+            `Cannot merge delta into a different event: base id "${base.id}" != delta id "${delta.id}".`,
+        );
+    }
+    if (delta.type === "model.message.delta" && base.type === "model.message") {
+        mergeModelMessageDelta(base, delta);
+    }
+}
+
+function asToolInfo(value: unknown): ToolInfo | undefined {
+    if (value == null || typeof value !== "object") {
+        return undefined;
+    }
+    return value as ToolInfo;
+}
+
+function mergeModelMessageDelta(
+    base: ModelMessageEvent,
+    delta: ModelMessageDeltaEvent,
+): void {
+    if (delta.content) {
+        if (
+            base.content === undefined ||
+            base.content === null ||
+            typeof base.content === "string"
+        ) {
+            base.content = (base.content ?? "") + delta.content;
+        } else {
+            const last = base.content[base.content.length - 1];
+            if (last && last.type === "text") {
+                last.text += delta.content;
+            } else {
+                base.content.push({ type: "text", text: delta.content });
+            }
+        }
+    }
+
+    if (delta.refusal) {
+        base.refusal = (base.refusal ?? "") + delta.refusal;
+    }
+
+    if (delta.toolCalls) {
+        base.toolCalls ??= [];
+        for (const d of delta.toolCalls) {
+            let tc: ToolCall | undefined = base.toolCalls[d.index];
+            if (tc === undefined) {
+                const toolInfo = asToolInfo(d.toolInfo);
+                tc = {
+                    id: d.id ?? "",
+                    type: d.type ?? "function",
+                    function: {
+                        name: d.function?.name ?? "",
+                        arguments: "",
+                    },
+                    ...(toolInfo != null ? { toolInfo } : {}),
+                };
+                base.toolCalls[d.index] = tc;
+            }
+            if (d.id) {
+                tc.id = d.id;
+            }
+            if (d.type) {
+                tc.type = d.type;
+            }
+            if (d.function?.name) {
+                tc.function.name = d.function.name;
+            }
+            if (d.function?.arguments) {
+                tc.function.arguments += d.function.arguments;
+            }
+            const toolInfo = asToolInfo(d.toolInfo);
+            if (toolInfo != null) {
+                tc.toolInfo = toolInfo;
+            }
+            if (d.providerSpecificFields) {
+                tc.providerSpecificFields = {
+                    ...(tc.providerSpecificFields ?? {}),
+                    ...d.providerSpecificFields,
+                };
+            }
+        }
+    }
+
+    if (delta.finishReason) {
+        base.finishReason = delta.finishReason;
+    }
+    if (delta.reasoningContent) {
+        base.reasoningContent =
+            (base.reasoningContent ?? "") + delta.reasoningContent;
+    }
+    if (delta.usage) {
+        base.usage = delta.usage;
+    }
+}

package/src/server/events.ts

@@ -0,0 +1,246 @@
+/**
+ * Runtime-owned turn/stream event protocol.
+ *
+ * Hosts must emit events matching these shapes. The TFY adapter maps
+ * truefoundry-gateway-sdk events 1:1 onto these types.
+ */
+
+import type { TurnInputItem, TurnState } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Tool call shapes
+// ---------------------------------------------------------------------------
+
+export interface ToolCallFunction {
+    name: string;
+    arguments: string;
+}
+
+export type ToolInfo =
+    | { type: "truefoundry-system"; name: string }
+    | { type: "mcp"; serverId: string; serverName: string; name: string }
+    | { type: string; name?: string; [key: string]: unknown };
+
+export interface ToolCall {
+    id: string;
+    type: "function";
+    function: ToolCallFunction;
+    toolInfo?: ToolInfo;
+    providerSpecificFields?: Record<string, unknown>;
+}
+
+/** Ref used by approval/response-required events. */
+export interface ToolCallRef {
+    id: string;
+    sourceEventId: string;
+}
+
+export interface ChunkDeltaToolCall {
+    index: number;
+    id?: string;
+    type?: "function";
+    function?: { name?: string; arguments?: string };
+    toolInfo?: ToolInfo;
+    providerSpecificFields?: Record<string, unknown>;
+}
+
+// ---------------------------------------------------------------------------
+// Content events
+// ---------------------------------------------------------------------------
+
+export type ModelMessageContentPart =
+    | { type: "text"; text: string }
+    | { type: "refusal"; refusal: string }
+    | { type: "image_url"; image_url: { url: string } };
+
+export 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;
+}
+
+export 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?: Array<{
+        index: number;
+        delta:
+            | { type: "text"; text?: string }
+            | { type: "image_url"; image_url?: { url?: string } };
+    }>;
+    content_blocks?: Array<{
+        index: number;
+        delta:
+            | { type: "text"; text?: string }
+            | { type: "image_url"; image_url?: { url?: string } };
+    }>;
+}
+
+export interface ToolResponseEvent {
+    type: "tool.response";
+    id: string;
+    threadId: string;
+    toolCallId: string;
+    content: string;
+    createdAt: string;
+}
+
+export interface ToolApprovalRequiredEvent {
+    type: "tool.approval_required";
+    id: string;
+    createdAt: string;
+    threadId: string;
+    toolCalls: ToolCallRef[];
+}
+
+export interface ToolResponseRequiredEvent {
+    type: "tool.response_required";
+    id: string;
+    createdAt: string;
+    threadId: string;
+    toolCalls: ToolCallRef[];
+}
+
+export interface AgentInfo {
+    type?: string;
+    name: string;
+    input: string;
+    model?: string;
+}
+
+export interface AgentParent {
+    threadId: string;
+    toolCallId: string;
+}
+
+export interface ThreadCreatedEvent {
+    type: "thread.created";
+    id: string;
+    threadId: string;
+    title: string;
+    agentInfo: AgentInfo;
+    parent: AgentParent;
+    createdAt: string;
+}
+
+export interface ThreadDoneEvent {
+    type: "thread.done";
+    id: string;
+    threadId: string;
+    title?: string;
+    createdAt: string;
+    state?: unknown;
+}
+
+export interface McpServerAuthInfo {
+    id: string;
+    name: string;
+    authUrl: string;
+}
+
+export interface McpAuthRequiredEvent {
+    type: "mcp.auth_required";
+    id: string;
+    createdAt: string;
+    threadId?: string | null;
+    mcpServers: McpServerAuthInfo[];
+}
+
+export interface SandboxCreatedEvent {
+    type: "sandbox.created";
+    id: string;
+    createdAt: string;
+    sandboxId: string;
+    threadId: string | null;
+}
+
+export interface McpInitializeEvent {
+    type: "mcp.initialize";
+    id: string;
+    createdAt: string;
+    threadId: string | null;
+    [key: string]: unknown;
+}
+
+// ---------------------------------------------------------------------------
+// Turn lifecycle events
+// ---------------------------------------------------------------------------
+
+export interface TurnCreatedEvent {
+    type: "turn.created";
+    id: string;
+    turnId: string;
+    previousTurnId?: string | null;
+    input?: TurnInputItem[];
+    state?: { status: "running" };
+    createdAt: string;
+    threadId?: string | null;
+}
+
+export interface TurnDoneEvent {
+    type: "turn.done";
+    id: string;
+    state: Exclude<TurnState, { status: "running" }>;
+    createdAt: string;
+    threadId?: string | null;
+}
+
+// ---------------------------------------------------------------------------
+// Unions
+// ---------------------------------------------------------------------------
+
+/** Events stored in fold buckets (non-delta, non-turn-lifecycle). */
+export type TurnEvent =
+    | ModelMessageEvent
+    | ToolResponseEvent
+    | ThreadCreatedEvent
+    | ThreadDoneEvent
+    | McpAuthRequiredEvent
+    | McpInitializeEvent
+    | SandboxCreatedEvent
+    | ToolApprovalRequiredEvent
+    | ToolResponseRequiredEvent;
+
+/** Full streaming event union (includes deltas + turn lifecycle). */
+export type TurnStreamingEvent =
+    | TurnEvent
+    | ModelMessageDeltaEvent
+    | TurnCreatedEvent
+    | TurnDoneEvent;
+
+export type ActionRequiredEvent =
+    | ToolApprovalRequiredEvent
+    | ToolResponseRequiredEvent
+    | McpAuthRequiredEvent;
+
+export interface TurnStreamData<
+    TStreamEvent extends TurnStreamingEvent = TurnStreamingEvent,
+> {
+    sequenceNumber: number;
+    event: TStreamEvent;
+}
+
+/** Session-level event item from `listEvents`. */
+export interface SessionEventItem {
+    turnId: string;
+    event: TurnCreatedEvent | TurnDoneEvent | TurnEvent;
+}
+
+export type DeltaEvents = ModelMessageDeltaEvent;