@truefoundry/assistant-ui-runtime 0.1.17 → 0.1.18

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

@@ -0,0 +1,145 @@
+/**
+ * CP provider-account metadata → ModelSelectorEntry.properties.reasoningEfforts.
+ *
+ * Source: GET /api/svc/v1/provider-accounts/providers
+ * Join key: `${providerSlug}/${modelId}` (NOT model_fqn).
+ * Host (ai.tf) uses the same rules for the draft reasoning-effort picker.
+ */
+
+export type ModelParamDef = {
+    key: string;
+    type?: string;
+    defaultValue?: string | number | boolean | null;
+    maxValue?: number;
+    minValue?: number;
+    /** Legacy — prefer `supportedValues` from the real API. */
+    options?: string[];
+    supportedValues?: string[];
+};
+
+export type ModelMetadata = {
+    thinking?: boolean;
+    removeParams?: string[];
+    params?: ModelParamDef[];
+    features?: string[];
+    limits?: {
+        context_window?: number;
+        max_output_tokens?: number;
+        max_tokens?: number;
+    };
+    /** Provider-wide defaults; reasoning_effort often lives only here. */
+    defaultProviderParams?: {
+        params?: ModelParamDef[];
+    };
+};
+
+const DEFAULT_EFFORT_LEVELS: readonly string[] = [
+    "minimal",
+    "low",
+    "medium",
+    "high",
+] as const;
+
+const EFFORT_SET = new Set([
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+]);
+
+/** Canonical metadata key: `<providerSlug>/<modelId>` (NOT model_fqn). */
+export function metadataKey(providerSlug: string, modelId: string): string {
+    return `${providerSlug}/${modelId}`;
+}
+
+function providerSlugFromType(type: string | undefined): string | null {
+    if (type == null) return null;
+    const prefix = "provider-account/";
+    if (!type.startsWith(prefix)) return null;
+    const slug = type.slice(prefix.length).trim();
+    return slug.length > 0 ? slug : null;
+}
+
+function findReasoningEffortParam(
+    meta: ModelMetadata | undefined,
+): ModelParamDef | undefined {
+    const fromModel = meta?.params?.find((p) => p.key === "reasoning_effort");
+    if (fromModel != null) return fromModel;
+    return meta?.defaultProviderParams?.params?.find(
+        (p) => p.key === "reasoning_effort",
+    );
+}
+
+/**
+ * Show efforts when thinking is on, reasoning_effort is not removed, and the
+ * provider slug is not exact `"openai"` (azure-openai / openai-main still show).
+ */
+export function showsReasoningEffort(
+    meta: ModelMetadata | undefined,
+    providerSlug: string,
+): boolean {
+    if (providerSlug === "openai") return false;
+    if (meta == null) return false;
+    if (meta.thinking !== true) return false;
+    if (meta.removeParams?.includes("reasoning_effort")) return false;
+    return true;
+}
+
+export function getEffortOptions(meta: ModelMetadata | undefined): string[] {
+    const param = findReasoningEffortParam(meta);
+    const raw = param?.supportedValues ?? param?.options;
+    if (raw == null || raw.length === 0) return [...DEFAULT_EFFORT_LEVELS];
+    const filtered = raw.filter((v) => EFFORT_SET.has(v));
+    return filtered.length > 0 ? filtered : [...DEFAULT_EFFORT_LEVELS];
+}
+
+/** Options for the selector, or undefined when the picker should stay hidden. */
+export function reasoningEffortsForModel(
+    meta: ModelMetadata | undefined,
+    providerSlug: string,
+): string[] | undefined {
+    if (!showsReasoningEffort(meta, providerSlug)) return undefined;
+    return getEffortOptions(meta);
+}
+
+type RawIntegration = {
+    type?: string;
+    metadata?: Record<string, ModelMetadata>;
+};
+
+type RawProvider = {
+    type?: string;
+    integrations?: RawIntegration[];
+};
+
+function providersFromJson(json: unknown): RawProvider[] {
+    if (Array.isArray(json)) return json as RawProvider[];
+    if (json != null && typeof json === "object") {
+        const obj = json as Record<string, unknown>;
+        for (const key of ["data", "providers", "result"] as const) {
+            const value = obj[key];
+            if (Array.isArray(value)) return value as RawProvider[];
+        }
+    }
+    return [];
+}
+
+/** Build a map keyed by `<providerSlug>/<modelId>` from the providers API. */
+export function buildMetadataMap(raw: unknown): Map<string, ModelMetadata> {
+    const map = new Map<string, ModelMetadata>();
+    for (const provider of providersFromJson(raw)) {
+        const slug = providerSlugFromType(provider.type);
+        if (slug == null) continue;
+        for (const integration of provider.integrations ?? []) {
+            const metadata = integration.metadata;
+            if (metadata == null) continue;
+            for (const [modelId, meta] of Object.entries(metadata)) {
+                if (!modelId.trim()) continue;
+                map.set(metadataKey(slug, modelId), meta);
+            }
+        }
+    }
+    return map;
+}

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

@@ -7,11 +7,13 @@ import {
 } from "./normalizeAgentSpec.js";
 
 describe("normalizeMcpMount", () => {
-    it("passes through registry mounts", () => {
+    it("rebuilds registry mounts and strips FE id / url", () => {
         expect(
             normalizeMcpMount({
                 type: "truefoundry-mcp-registry",
                 name: "g-calendar",
+                id: "fe-row-id",
+                url: "https://should-not-leak.example",
                 enableTools: ["@all"],
             }),
         ).toEqual({
@@ -21,12 +23,27 @@ describe("normalizeMcpMount", () => {
         });
     });
 
-    it("maps UI {id,name} catalog rows to registry mounts", () => {
+    it("defaults enableTools to [@all] when missing on typed registry mounts", () => {
+        expect(
+            normalizeMcpMount({
+                type: "truefoundry-mcp-registry",
+                name: "github",
+                id: "fe-row-id",
+            }),
+        ).toEqual({
+            type: "truefoundry-mcp-registry",
+            name: "github",
+            enableTools: ["@all"],
+        });
+    });
+
+    it("maps UI {id,name} catalog rows to registry mounts with enableTools [@all]", () => {
         expect(
             normalizeMcpMount({ id: "deepwiki-mcp", name: "deepwiki-mcp" }),
         ).toEqual({
             type: "truefoundry-mcp-registry",
             name: "deepwiki-mcp",
+            enableTools: ["@all"],
         });
     });
 
@@ -47,14 +64,53 @@ describe("normalizeMcpMount", () => {
             config: { locale: "en" },
         });
     });
+
+    it("forwards optional tool selectors without widening enableTools", () => {
+        expect(
+            normalizeMcpMount({
+                type: "truefoundry-mcp-registry",
+                name: "github",
+                enableTools: ["list_issues"],
+                disableTools: ["delete_repo"],
+                preloadTools: ["@read-only"],
+                requireApprovalForTools: ["@destructive"],
+            }),
+        ).toEqual({
+            type: "truefoundry-mcp-registry",
+            name: "github",
+            enableTools: ["list_issues"],
+            disableTools: ["delete_repo"],
+            preloadTools: ["@read-only"],
+            requireApprovalForTools: ["@destructive"],
+        });
+    });
+
+    it("rebuilds inline mounts without FE id", () => {
+        expect(
+            normalizeMcpMount({
+                type: "inline",
+                name: "custom",
+                url: "https://example.com/mcp",
+                id: "fe-row-id",
+                enableTools: ["@all"],
+            }),
+        ).toEqual({
+            type: "inline",
+            name: "custom",
+            url: "https://example.com/mcp",
+            enableTools: ["@all"],
+        });
+    });
 });
 
 describe("normalizeSkillMount", () => {
-    it("passes through registry mounts", () => {
+    it("rebuilds registry mounts and strips FE id / display name", () => {
         expect(
             normalizeSkillMount({
                 type: "truefoundry-skills-registry",
                 fqn: "agent-skill:truefoundry/skills/web:1",
+                id: "fe-row-id",
+                name: "Web Search",
                 preload: false,
             }),
         ).toEqual({
@@ -91,6 +147,27 @@ describe("normalizeSkillMount", () => {
             config: { timeoutMs: 1000 },
         });
     });
+
+    it("rebuilds git mounts without FE id", () => {
+        expect(
+            normalizeSkillMount({
+                type: "git",
+                url: "https://github.com/acme/skills",
+                name: "reviewer",
+                ref: "main",
+                path: "skills/reviewer",
+                id: "fe-row-id",
+                preload: true,
+            }),
+        ).toEqual({
+            type: "git",
+            url: "https://github.com/acme/skills",
+            name: "reviewer",
+            ref: "main",
+            path: "skills/reviewer",
+            preload: true,
+        });
+    });
 });
 
 describe("normalizeAgentSpecForGateway", () => {
@@ -107,7 +184,11 @@ describe("normalizeAgentSpecForGateway", () => {
         });
 
         expect(next.mcpServers).toEqual([
-            { type: "truefoundry-mcp-registry", name: "gmail" },
+            {
+                type: "truefoundry-mcp-registry",
+                name: "gmail",
+                enableTools: ["@all"],
+            },
         ]);
         expect(next.skills).toEqual([
             {

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

@@ -6,12 +6,39 @@ function isRecord(value: unknown): value is Record<string, unknown> {
     return value != null && typeof value === "object" && !Array.isArray(value);
 }
 
+function nonEmptyString(value: unknown): string | null {
+    return typeof value === "string" && value !== "" ? value : null;
+}
+
+/** Optional BaseMcpServer fields shared by registry + inline mounts. */
+function mcpOptionalFields(raw: Record<string, unknown>): Record<string, unknown> {
+    return {
+        ...(Array.isArray(raw.enableTools) ? { enableTools: raw.enableTools } : {}),
+        ...(Array.isArray(raw.disableTools) ? { disableTools: raw.disableTools } : {}),
+        ...(Array.isArray(raw.preloadTools) ? { preloadTools: raw.preloadTools } : {}),
+        ...(Array.isArray(raw.requireApprovalForTools)
+            ? { requireApprovalForTools: raw.requireApprovalForTools }
+            : {}),
+        ...(typeof raw.preload === "boolean" ? { preload: raw.preload } : {}),
+        ...(raw.config != null ? { config: raw.config } : {}),
+    };
+}
+
+function skillOptionalFields(raw: Record<string, unknown>): Record<string, unknown> {
+    return {
+        ...(typeof raw.preload === "boolean" ? { preload: raw.preload } : {}),
+        ...(raw.config != null ? { config: raw.config } : {}),
+    };
+}
+
 /**
  * agent-ui-sdk DraftCompositeSelector writes catalog rows as `{ id, name }`.
  * Gateway AgentSpec mounts need discriminated registry shapes — without
  * `type` (and skill `fqn`), Fern serialization throws JsonError before PATCH.
  *
  * Our CP catalog sets skill `id` = version fqn and MCP `id` = server name.
+ * Always rebuild allowlisted fields so FE `id` / display `name` / registry
+ * `url` never leak onto the wire.
  */
 export function normalizeMcpMount(
     raw: unknown,
@@ -19,26 +46,37 @@ export function normalizeMcpMount(
     if (!isRecord(raw)) {
         throw new Error("mcpServers entry must be an object");
     }
-    if (raw.type === "truefoundry-mcp-registry" || raw.type === "inline") {
-        return raw as unknown as TruefoundryGatewayApi.McpServer;
+
+    if (raw.type === "inline") {
+        const name = nonEmptyString(raw.name);
+        const url = nonEmptyString(raw.url);
+        if (name == null || url == null) {
+            throw new Error("inline mcpServers entry needs name and url");
+        }
+        return {
+            type: "inline",
+            name,
+            url,
+            ...mcpOptionalFields(raw),
+        } as unknown as TruefoundryGatewayApi.McpServer;
     }
+
     const name =
-        (typeof raw.name === "string" && raw.name !== "" ? raw.name : null) ??
-        (typeof raw.mcpName === "string" && raw.mcpName !== ""
-            ? raw.mcpName
-            : null) ??
-        (typeof raw.id === "string" && raw.id !== "" ? raw.id : null);
+        nonEmptyString(raw.name) ??
+        nonEmptyString(raw.mcpName) ??
+        nonEmptyString(raw.id);
     if (name == null) {
         throw new Error(
             "mcpServers entry needs name, mcpName, or id to mount as registry MCP",
         );
     }
+
     return {
         type: "truefoundry-mcp-registry",
         name,
-        ...(Array.isArray(raw.enableTools) ? { enableTools: raw.enableTools } : {}),
-        ...(typeof raw.preload === "boolean" ? { preload: raw.preload } : {}),
-        ...(raw.config != null ? { config: raw.config } : {}),
+        ...mcpOptionalFields(raw),
+        // Always set after the spread so missing enableTools defaults to [@all].
+        enableTools: Array.isArray(raw.enableTools) ? raw.enableTools : ["@all"],
     } as unknown as TruefoundryGatewayApi.McpServer;
 }
 
@@ -48,12 +86,25 @@ export function normalizeSkillMount(
     if (!isRecord(raw)) {
         throw new Error("skills entry must be an object");
     }
-    if (raw.type === "truefoundry-skills-registry" || raw.type === "git") {
-        return raw as unknown as TruefoundryGatewayApi.SkillMount;
+
+    if (raw.type === "git") {
+        const url = nonEmptyString(raw.url);
+        const name = nonEmptyString(raw.name);
+        const ref = nonEmptyString(raw.ref);
+        if (url == null || name == null || ref == null) {
+            throw new Error("git skills entry needs url, name, and ref");
+        }
+        return {
+            type: "git",
+            url,
+            name,
+            ref,
+            ...(nonEmptyString(raw.path) != null ? { path: raw.path } : {}),
+            ...skillOptionalFields(raw),
+        } as unknown as TruefoundryGatewayApi.SkillMount;
     }
-    const fqn =
-        (typeof raw.fqn === "string" && raw.fqn !== "" ? raw.fqn : null) ??
-        (typeof raw.id === "string" && raw.id !== "" ? raw.id : null);
+
+    const fqn = nonEmptyString(raw.fqn) ?? nonEmptyString(raw.id);
     if (fqn == null) {
         throw new Error(
             "skills entry needs fqn or id to mount as registry skill",
@@ -62,8 +113,7 @@ export function normalizeSkillMount(
     return {
         type: "truefoundry-skills-registry",
         fqn,
-        ...(typeof raw.preload === "boolean" ? { preload: raw.preload } : {}),
-        ...(raw.config != null ? { config: raw.config } : {}),
+        ...skillOptionalFields(raw),
     } as unknown as TruefoundryGatewayApi.SkillMount;
 }
 

package/src/server/types.ts

@@ -523,6 +523,7 @@ export interface ConnectorConfigBase<
   TAuth extends ConnectorAuth = ConnectorAuth,
 > {
   name: string;
+  description: string;
   url: string;
   auth: TAuth;
 }

package/src/truefoundryExtras.test.ts

@@ -0,0 +1,161 @@
+import { describe, expect, it, vi } from "vitest";
+import type { AssistantClient } from "@assistant-ui/store";
+
+import {
+    getTrueFoundryExtras,
+    trueFoundryExtras,
+    tryGetTrueFoundryExtras,
+    type TrueFoundryRuntimeExtras,
+} from "./truefoundryExtras.js";
+
+function clientWithExtras(
+    extras: unknown,
+): AssistantClient {
+    return {
+        thread: () => ({
+            getState: () => ({ extras }),
+        }),
+    } as unknown as AssistantClient;
+}
+
+describe("tryGetTrueFoundryExtras", () => {
+    it("reads extras from the current client", () => {
+        const extras = trueFoundryExtras.provide({
+            pendingApprovals: [],
+            pendingToolResponses: [],
+            pendingMcpAuth: null,
+            resumeUnavailable: false,
+            sandboxId: undefined,
+            respondToToolApproval: vi.fn(),
+            respondToToolResponse: vi.fn(),
+            resumeMcpAuth: vi.fn(),
+            downloadSandboxFile: vi.fn(),
+            cancel: vi.fn(),
+            resetFromTurn: vi.fn(),
+            reload: vi.fn(),
+            hasOlderHistory: false,
+            isLoadingOlderHistory: false,
+            loadOlderHistory: vi.fn(),
+            draft: null,
+        } satisfies TrueFoundryRuntimeExtras);
+
+        expect(tryGetTrueFoundryExtras(clientWithExtras(extras))).toBe(extras);
+    });
+
+    it("walks nested readonly clients (Object.create parent) to find root extras", () => {
+        const respondToToolApproval = vi.fn();
+        const extras = trueFoundryExtras.provide({
+            pendingApprovals: [{ approvalId: "a1", threadId: "child-1", toolName: "bash", args: {}, argsText: "{}" }],
+            pendingToolResponses: [],
+            pendingMcpAuth: null,
+            resumeUnavailable: false,
+            sandboxId: undefined,
+            respondToToolApproval,
+            respondToToolResponse: vi.fn(),
+            resumeMcpAuth: vi.fn(),
+            downloadSandboxFile: vi.fn(),
+            cancel: vi.fn(),
+            resetFromTurn: vi.fn(),
+            reload: vi.fn(),
+            hasOlderHistory: false,
+            isLoadingOlderHistory: false,
+            loadOlderHistory: vi.fn(),
+            draft: null,
+        } satisfies TrueFoundryRuntimeExtras);
+
+        const root = clientWithExtras(extras);
+        // Mirrors ReadonlyThreadProvider: nested AUI is Object.create(parent) with
+        // thread overwritten to a readonly client that has no extras.
+        const nested = Object.assign(Object.create(root), {
+            thread: () => ({
+                getState: () => ({ extras: undefined }),
+            }),
+        }) as AssistantClient;
+
+        expect(tryGetTrueFoundryExtras(nested)).toBe(extras);
+        // Namespace .get must walk too (not only the named helper).
+        expect(trueFoundryExtras.get(nested)).toBe(extras);
+        getTrueFoundryExtras(nested).respondToToolApproval({
+            approvalId: "a1",
+            approved: true,
+        });
+        expect(respondToToolApproval).toHaveBeenCalledWith({
+            approvalId: "a1",
+            approved: true,
+        });
+    });
+
+    it("returns undefined when no ancestor has TrueFoundry extras", () => {
+        expect(tryGetTrueFoundryExtras(clientWithExtras(undefined))).toBeUndefined();
+    });
+
+    it("survives RootAssistantClient-style proxies that throw on missing accessors", () => {
+        const extras = trueFoundryExtras.provide({
+            pendingApprovals: [],
+            pendingToolResponses: [],
+            pendingMcpAuth: null,
+            resumeUnavailable: false,
+            sandboxId: undefined,
+            respondToToolApproval: vi.fn(),
+            respondToToolResponse: vi.fn(),
+            resumeMcpAuth: vi.fn(),
+            downloadSandboxFile: vi.fn(),
+            cancel: vi.fn(),
+            resetFromTurn: vi.fn(),
+            reload: vi.fn(),
+            hasOlderHistory: false,
+            isLoadingOlderHistory: false,
+            loadOlderHistory: vi.fn(),
+            draft: null,
+        } satisfies TrueFoundryRuntimeExtras);
+
+        // Mirrors @assistant-ui/store createRootAssistantClient: empty proxy that
+        // throws on any get (e.g. "subscribe" / "thread").
+        const rootProto = new Proxy(
+            {},
+            {
+                get(_, prop) {
+                    throw new Error(
+                        `The current scope does not have a "${String(prop)}" property.`,
+                    );
+                },
+            },
+        );
+        const root = Object.assign(Object.create(rootProto), {
+            subscribe: (cb: () => void) => {
+                cb();
+                return () => {};
+            },
+            thread: () => ({
+                getState: () => ({ extras }),
+            }),
+        }) as AssistantClient;
+
+        expect(tryGetTrueFoundryExtras(root)).toBe(extras);
+
+        // useTrueFoundryRuntimeExtras walks .subscribe up the same chain.
+        const nested = Object.assign(Object.create(root), {
+            thread: () => ({
+                getState: () => ({ extras: undefined }),
+            }),
+        }) as AssistantClient;
+        expect(tryGetTrueFoundryExtras(nested)).toBe(extras);
+        expect(() => {
+            let current: object | null = nested;
+            const seen = new Set<object>();
+            while (current != null && !seen.has(current)) {
+                seen.add(current);
+                try {
+                    const subscribe = (current as { subscribe?: (cb: () => void) => () => void })
+                        .subscribe;
+                    if (typeof subscribe === "function") {
+                        subscribe(() => {});
+                    }
+                } catch {
+                    break;
+                }
+                current = Object.getPrototypeOf(current);
+            }
+        }).not.toThrow();
+    });
+});