@truefoundry/assistant-ui-runtime 0.1.5 → 0.1.6

package/src/plugins/truefoundry-agent-server-adapter/types.typecheck.ts

@@ -0,0 +1,164 @@
+/**
+ * Compile-time assertions for the mount types in `types.ts`.
+ *
+ * TfySkillMount / TfyMcpServerMount are built by indexing into the runtime's
+ * exported AgentSpec. If that indexed access ever degrades to `unknown`, the
+ * intersection becomes a silent no-op and the gateway fields disappear without
+ * any error. These assertions fail `pnpm typecheck` if that happens.
+ *
+ * Not an entry point — tsup only bundles src/index.ts.
+ */
+
+import type { AgentSpec } from "../../server/types.js";
+import type { createTrueFoundryChatServer } from "./index.js";
+import type {
+    TfyAgentSpec,
+    TfyFinishReason,
+    TfyMcpServerMount,
+    TfySkillMount,
+    TfySubject,
+    TfyTurn,
+} from "./types.js";
+
+// Both gateway source variants must survive the intersection with the base.
+export const registrySkill: TfySkillMount = {
+    type: "truefoundry-skills-registry",
+    fqn: "tfy:skill:v1",
+    preload: true,
+};
+
+export const gitSkill: TfySkillMount = {
+    type: "git",
+    url: "https://github.com/acme/skills",
+    name: "reviewer",
+    ref: "main",
+};
+
+// @ts-expect-error the type discriminant must survive the intersection
+export const skillWithoutType: TfySkillMount = { fqn: "a" };
+
+// @ts-expect-error registry variant requires fqn
+export const registrySkillWithoutFqn: TfySkillMount = {
+    type: "truefoundry-skills-registry",
+};
+
+export const registeredMcp: TfyMcpServerMount = {
+    name: "github",
+    type: "truefoundry-mcp-registry",
+    enableTools: ["@read-only"],
+    requireApprovalForTools: ["@destructive"],
+};
+
+export const inlineMcp: TfyMcpServerMount = {
+    name: "custom",
+    type: "inline",
+    url: "https://example.com/mcp",
+};
+
+// @ts-expect-error the type discriminant must survive the intersection
+export const mcpWithoutType: TfyMcpServerMount = { name: "a" };
+
+// @ts-expect-error inline variant requires url
+export const inlineMcpWithoutUrl: TfyMcpServerMount = {
+    name: "a",
+    type: "inline",
+};
+
+// The gateway's own spec — a registry skill carries neither `id` nor `name` —
+// must satisfy the runtime base. A base that rejects it makes every server
+// response unassignable, which is the regression these mounts are guarding.
+declare const gatewayShapedSpec: TfyAgentSpec;
+export const asRuntimeSpec: AgentSpec = gatewayShapedSpec;
+
+// ---------------------------------------------------------------------------
+// Generic TSpec — a host extension must reach the returned server's types,
+// and the bare (defaulted) form must keep working.
+// ---------------------------------------------------------------------------
+
+interface HostSpec extends TfyAgentSpec {
+    workspaceId: string;
+}
+
+type HostServer = ReturnType<typeof createTrueFoundryChatServer<HostSpec>>;
+type DefaultServer = ReturnType<typeof createTrueFoundryChatServer>;
+
+declare const hostSession: Awaited<ReturnType<HostServer["getSession"]>>;
+declare const defaultSession: Awaited<ReturnType<DefaultServer["getSession"]>>;
+
+// Host field is visible on the spec returned by the generic server.
+export const workspaceId: string | undefined = hostSession.agentSpec?.workspaceId;
+
+// Gateway fields still flow through alongside it.
+export const hostSkills: TfySkillMount[] | undefined = hostSession.agentSpec?.skills;
+
+// @ts-expect-error the default instantiation must NOT have the host's field
+export const leakedWorkspaceId = defaultSession.agentSpec?.workspaceId;
+
+// Host spec is accepted where the server expects one.
+export declare function createHostSession(
+    server: HostServer,
+    spec: HostSpec,
+): ReturnType<HostServer["createSession"]>;
+
+// ---------------------------------------------------------------------------
+// Turn — the gateway narrowings must not collapse back into the runtime's
+// `unknown` output / bare-`string` reason.
+// ---------------------------------------------------------------------------
+
+const subject: TfySubject = {
+    subjectId: "u-1",
+    subjectType: "user",
+    subjectSlug: "someone",
+};
+
+export const cancelledTurn: TfyTurn = {
+    id: "turn-1",
+    sessionId: "session-1",
+    state: {
+        status: "cancelled",
+        reason: "cancelled-for-next-turn",
+        completedAt: "2026-01-01T00:00:00Z",
+    },
+    createdBySubject: subject,
+    createdAt: "2026-01-01T00:00:00Z",
+};
+
+export const freeformCancelReason: TfyTurn = {
+    ...cancelledTurn,
+    // @ts-expect-error reason is one of four gateway values, not any string
+    state: { status: "cancelled", reason: "nope", completedAt: "2026-01-01T00:00:00Z" },
+};
+
+// @ts-expect-error createdBySubject is required — the gateway always sends it
+export const turnWithoutSubject: TfyTurn = {
+    id: "turn-1",
+    sessionId: "session-1",
+    state: { status: "running" },
+    createdAt: "2026-01-01T00:00:00Z",
+};
+
+declare const doneTurn: Extract<TfyTurn["state"], { status: "done" }>;
+
+// `output` is the gateway's model message; on the runtime base this is `unknown`
+// and would not permit a property access at all.
+export const doneFinishReason: TfyFinishReason | null | undefined =
+    doneTurn.output?.finishReason;
+export const doneTokens: number | undefined = doneTurn.output?.usage?.inputTokens;
+
+// ---------------------------------------------------------------------------
+// Session / request params — gateway-only fields reach the server methods.
+// ---------------------------------------------------------------------------
+
+export const sessionSubject: TfySubject = hostSession.createdBySubject;
+
+export const withMetadata: Parameters<DefaultServer["createSession"]>[0] = {
+    agentName: "agent",
+    tfyMetadata: JSON.stringify({ tenant: "acme" }),
+};
+
+export const withEndTimestamp: NonNullable<
+    Parameters<DefaultServer["listSessions"]>[0]
+> = {
+    startTimestamp: "2026-01-01T00:00:00Z",
+    endTimestamp: "2026-02-01T00:00:00Z",
+};

package/src/private/agentSpec.ts

@@ -1,7 +1,12 @@
-import type { TruefoundryGatewayApi } from "truefoundry-gateway-sdk";
+import type { AgentSpec } from "../server/types.js";
 
-export type AgentSpec = TruefoundryGatewayApi.AgentSpec;
-export type DraftSession = TruefoundryGatewayApi.DraftSession;
+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;

package/src/private/draftSessionBridge.ts

@@ -1,7 +1,5 @@
-import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
-
+import type { AgentChatServer } from "../server/types.js";
 import type { AgentSpec } from "./agentSpec.js";
-import { getGatewayFromPrivateClient } from "./getGatewayFromPrivateClient.js";
 
 export const DRAFT_SESSION_LAST_UPDATED_AT_HEADER = "x-tfy-session-last-updated-at";
 
@@ -11,22 +9,25 @@ export type DraftSessionBridge = {
 };
 
 export function createDraftSessionBridge(
-    privateClient: PrivateAgentSessionClient,
+    server: AgentChatServer,
 ): DraftSessionBridge {
     return {
         async getDraftAgentSpec(draftSessionId) {
-            const draft = await privateClient.getDraftSession({ draftSessionId });
-            return draft.agentSpec;
+            const session = await server.getSession({ sessionId: draftSessionId });
+            if (session.agentSpec == null) {
+                throw new Error(
+                    `Session ${draftSessionId} has no agentSpec (isMutable=${session.isMutable}).`,
+                );
+            }
+            return session.agentSpec;
         },
 
         async syncAgentSpec(draftSessionId, agentSpec) {
-            // PrivateAgentSessionClient does not wrap update yet — use the low-level client.
-            const gateway = getGatewayFromPrivateClient(privateClient);
-            const response = await gateway.agents.private.draftSessions.update(
-                draftSessionId,
-                { agentSpec },
-            );
-            return response.data.updatedAt;
+            const updated = await server.updateSession({
+                sessionId: draftSessionId,
+                agentSpec,
+            });
+            return updated.updatedAt;
         },
     };
 }

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;
+    }
+}