@truefoundry/assistant-ui-runtime 0.1.7 → 0.1.8

package/dist/chunk-CXBZ6WLZ.js

@@ -0,0 +1,636 @@
+// src/plugins/truefoundry-agent-server-adapter/chatServer.ts
+import { AgentSessionClient } from "truefoundry-gateway-sdk/agents";
+import { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
+
+// src/plugins/truefoundry-agent-server-adapter/normalizeAgentSpec.ts
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeMcpMount(raw) {
+  if (!isRecord(raw)) {
+    throw new Error("mcpServers entry must be an object");
+  }
+  if (raw.type === "truefoundry-mcp-registry" || raw.type === "inline") {
+    return raw;
+  }
+  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);
+  if (name == null) {
+    throw new Error(
+      "mcpServers entry needs name, mcpName, or id to mount as registry MCP"
+    );
+  }
+  return { type: "truefoundry-mcp-registry", name };
+}
+function normalizeSkillMount(raw) {
+  if (!isRecord(raw)) {
+    throw new Error("skills entry must be an object");
+  }
+  if (raw.type === "truefoundry-skills-registry" || raw.type === "git") {
+    return raw;
+  }
+  const fqn = (typeof raw.fqn === "string" && raw.fqn !== "" ? raw.fqn : null) ?? (typeof raw.id === "string" && raw.id !== "" ? raw.id : null);
+  if (fqn == null) {
+    throw new Error(
+      "skills entry needs fqn or id to mount as registry skill"
+    );
+  }
+  return {
+    type: "truefoundry-skills-registry",
+    fqn,
+    ...raw.preload === true ? { preload: true } : {}
+  };
+}
+function normalizeAgentSpecForGateway(spec) {
+  return {
+    ...spec,
+    ...spec.mcpServers != null ? {
+      mcpServers: spec.mcpServers.map(
+        normalizeMcpMount
+      )
+    } : {},
+    ...spec.skills != null ? {
+      skills: spec.skills.map(
+        normalizeSkillMount
+      )
+    } : {}
+  };
+}
+
+// src/plugins/truefoundry-agent-server-adapter/chatServer.ts
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && error.statusCode === 404;
+}
+function isDraft(session) {
+  return session.type === "session/draft";
+}
+function toSession(raw) {
+  const mutable = isDraft(raw);
+  return {
+    id: raw.id,
+    title: raw.title,
+    agentName: raw.agentName,
+    ...mutable ? { agentSpec: raw.agentSpec } : {},
+    isMutable: mutable,
+    createdBySubject: raw.createdBySubject,
+    createdAt: raw.createdAt,
+    updatedAt: raw.updatedAt
+  };
+}
+function toTurn(raw) {
+  return {
+    id: raw.id,
+    sessionId: raw.sessionId,
+    previousTurnId: raw.previousTurnId,
+    input: raw.input,
+    state: raw.state,
+    createdBySubject: raw.createdBySubject,
+    createdAt: raw.createdAt
+  };
+}
+async function toListResult(page, map) {
+  const nextPageToken = page.response?.pagination?.nextPageToken;
+  return {
+    data: page.data.map(map),
+    ...nextPageToken != null && nextPageToken !== "" ? { nextPageToken } : {}
+  };
+}
+function createTrueFoundryChatServer(opts) {
+  const gatewayOpts = { apiKey: opts.apiKey, baseUrl: opts.baseUrl };
+  const client = opts.client ?? new AgentSessionClient(gatewayOpts);
+  const privateClient = opts.privateClient ?? new PrivateAgentSessionClient(gatewayOpts);
+  const sessionTypeCache = /* @__PURE__ */ new Map();
+  const sessionTypeProbes = /* @__PURE__ */ new Map();
+  function cacheSessionType(session) {
+    sessionTypeCache.set(session.id, session.isMutable);
+  }
+  async function probeSessionType(sessionId) {
+    const inflight2 = sessionTypeProbes.get(sessionId);
+    if (inflight2 != null) {
+      return inflight2;
+    }
+    const probe = (async () => {
+      try {
+        await privateClient.getDraftSession({ draftSessionId: sessionId });
+        return true;
+      } catch (error) {
+        if (!isNotFound(error)) {
+          throw error;
+        }
+        await client.getSession({ sessionId });
+        return false;
+      }
+    })();
+    sessionTypeProbes.set(sessionId, probe);
+    try {
+      const isMutable = await probe;
+      sessionTypeCache.set(sessionId, isMutable);
+      return isMutable;
+    } finally {
+      sessionTypeProbes.delete(sessionId);
+    }
+  }
+  async function getSessionObj(sessionId) {
+    const isMutable = sessionTypeCache.get(sessionId) ?? await probeSessionType(sessionId);
+    return isMutable ? privateClient.getDraftSession({ draftSessionId: sessionId }) : client.getSession({ sessionId });
+  }
+  const server = {
+    async createSession(req) {
+      if (req.agentSpec != null) {
+        const draft = await privateClient.createDraftSession({
+          agentSpec: normalizeAgentSpecForGateway(req.agentSpec),
+          ...req.agentName != null ? { agentName: req.agentName } : {},
+          ...req.tfyMetadata != null ? { tfyMetadata: req.tfyMetadata } : {}
+        });
+        const session = toSession(draft);
+        cacheSessionType(session);
+        return session;
+      }
+      if (req.agentName != null) {
+        const named = await client.createSession({
+          agentName: req.agentName,
+          ...req.tfyMetadata != null ? { tfyMetadata: req.tfyMetadata } : {}
+        });
+        const session = toSession(named);
+        cacheSessionType(session);
+        return session;
+      }
+      throw new Error("createSession requires agentName and/or agentSpec");
+    },
+    async listSessions(req) {
+      const page = await privateClient.listOwnedSessions({
+        limit: req?.limit,
+        order: req?.order,
+        pageToken: req?.pageToken,
+        startTimestamp: req?.startTimestamp,
+        endTimestamp: req?.endTimestamp,
+        ...req?.agentName != null ? { agentName: req.agentName } : {}
+      });
+      const result = await toListResult(page, (s) => toSession(s));
+      for (const session of result.data) {
+        cacheSessionType(session);
+      }
+      return result;
+    },
+    async getSession({ sessionId }) {
+      const raw = await getSessionObj(sessionId);
+      const session = toSession(raw);
+      cacheSessionType(session);
+      return session;
+    },
+    async updateSession(req) {
+      const raw = await getSessionObj(req.sessionId);
+      if (!isDraft(raw)) {
+        throw new Error(
+          "updateSession: session is not mutable (isMutable=false)"
+        );
+      }
+      if (req.agentSpec != null) {
+        await raw.update({
+          agentSpec: normalizeAgentSpecForGateway(req.agentSpec)
+        });
+      }
+      return toSession(raw);
+    },
+    createTurn(req) {
+      return (async function* () {
+        const session = await getSessionObj(req.sessionId);
+        const prepared = session.prepareTurn({
+          input: req.input,
+          previousTurnId: req.previousTurnId ?? "auto"
+        });
+        yield* prepared.execute(
+          { stream: true },
+          {
+            ...req.abortSignal != null ? { abortSignal: req.abortSignal } : {},
+            ...req.headers != null ? { headers: req.headers } : {}
+          }
+        );
+      })();
+    },
+    async cancelSession({ sessionId }) {
+      await (await getSessionObj(sessionId)).cancel();
+    },
+    async deleteSession({ sessionId }) {
+      if (opts.deleteSession == null) {
+        throw new Error(
+          "deleteSession is not on the gateway SDK. Pass deleteSession to createTrueFoundryChatServer."
+        );
+      }
+      await opts.deleteSession({ sessionId });
+    },
+    // The runtime's signature offers `order`, but the gateway's listTurns
+    // takes no such param — forwarding it silently did nothing.
+    async listTurns({ sessionId, limit, pageToken }) {
+      const raw = await getSessionObj(sessionId);
+      const page = await raw.listTurns({
+        ...limit != null ? { limit } : {},
+        ...pageToken != null ? { pageToken } : {}
+      });
+      return toListResult(page, (turn) => toTurn(turn));
+    },
+    async getTurn({ sessionId, turnId }) {
+      const raw = await getSessionObj(sessionId);
+      return toTurn(await raw.getTurn({ turnId }));
+    },
+    async listEvents({ sessionId, pageToken, lastTurnId, limit }) {
+      const raw = await getSessionObj(sessionId);
+      const page = await raw.listEvents({
+        ...limit != null ? { limit } : {},
+        ...pageToken != null ? { pageToken } : {},
+        ...lastTurnId != null ? { lastTurnId } : {}
+      });
+      return toListResult(
+        page,
+        (item) => item
+      );
+    },
+    async listTurnEvents({ sessionId, turnId, limit, pageToken, order }) {
+      const raw = await getSessionObj(sessionId);
+      const turn = await raw.getTurn({ turnId });
+      const page = await turn.listEvents({
+        ...limit != null ? { limit } : {},
+        ...pageToken != null ? { pageToken } : {},
+        ...order != null ? { order } : {}
+      });
+      return toListResult(page, (event) => event);
+    },
+    async *subscribeToTurn({
+      sessionId,
+      turnId,
+      afterSequenceNumber,
+      abortSignal
+    }) {
+      const raw = await getSessionObj(sessionId);
+      const turn = await raw.getTurn({ turnId });
+      yield* turn.stream(
+        afterSequenceNumber != null ? { afterSequenceNumber } : {},
+        abortSignal != null ? { abortSignal } : {}
+      );
+    },
+    async downloadSandboxFile(sandboxId, req) {
+      const response = await privateClient.downloadSandboxFile(
+        sandboxId,
+        req
+      );
+      return await response.blob();
+    },
+    getGatewayClients: () => ({ client, privateClient })
+  };
+  return server;
+}
+
+// src/plugins/truefoundry-agent-server-adapter/cp.ts
+function trimSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+async function cpFetch(opts, path, init) {
+  const url = `${trimSlash(opts.cpURL)}${path.startsWith("/") ? path : `/${path}`}`;
+  const res = await fetch(url, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${opts.apiKey}`,
+      Accept: "application/json",
+      ...init?.headers ?? {}
+    }
+  });
+  if (!res.ok) {
+    throw new Error(`CP ${res.status} ${res.statusText}: ${path}`);
+  }
+  return await res.json();
+}
+function joinCpPath(cpURL, path) {
+  const base = trimSlash(cpURL);
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${p}`;
+}
+async function resolveGatewayURL(opts) {
+  if (opts.gatewayURL != null && opts.gatewayURL !== "") {
+    return opts.gatewayURL;
+  }
+  const session = await cpFetch(opts, "/api/svc/v1/session");
+  const tenantName = session.user?.tenantName ?? session.env?.TENANT_NAME ?? session.data?.user?.tenantName;
+  if (tenantName == null || tenantName === "") {
+    throw new Error(
+      "resolveGatewayURL: /api/svc/v1/session did not return user.tenantName"
+    );
+  }
+  const llmPrefix = trimSlash(session.env?.LLM_GATEWAY_URL ?? "/api/llm");
+  return joinCpPath(opts.cpURL, `${llmPrefix}/${tenantName}`);
+}
+function isChatModel(row) {
+  const types = row.types;
+  if (types == null || types.length === 0) return true;
+  return types.includes("chat");
+}
+function toModelEntry(row) {
+  if (!isChatModel(row)) return null;
+  const apiModel = row.model_fqn ?? row.id;
+  const name = row.name;
+  if (apiModel == null || apiModel === "" || name == null || name === "") {
+    return null;
+  }
+  const provider = row.provider ?? "unknown";
+  const modelId = row.model_id ?? name;
+  return {
+    name,
+    provider,
+    apiModel,
+    modelId,
+    ...row.provider_account_name != null ? { providerAccount: row.provider_account_name } : {},
+    id: apiModel
+  };
+}
+function normalizeEnabledModels(raw) {
+  if (raw == null || typeof raw !== "object" || Array.isArray(raw)) {
+    return [];
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  function pushRow(row) {
+    const entry = toModelEntry(row);
+    if (entry == null || seen.has(entry.apiModel)) return;
+    seen.add(entry.apiModel);
+    out.push(entry);
+  }
+  for (const level1 of Object.values(raw)) {
+    if (Array.isArray(level1)) {
+      for (const row of level1) {
+        if (row != null && typeof row === "object") {
+          pushRow(row);
+        }
+      }
+      continue;
+    }
+    if (level1 == null || typeof level1 !== "object") continue;
+    for (const level2 of Object.values(level1)) {
+      if (!Array.isArray(level2)) continue;
+      for (const row of level2) {
+        if (row != null && typeof row === "object") {
+          pushRow(row);
+        }
+      }
+    }
+  }
+  return out;
+}
+async function listEnabledModels(opts) {
+  const raw = await cpFetch(
+    opts,
+    "/api/svc/v1/llm-gateway/model/enabled"
+  );
+  return normalizeEnabledModels(raw);
+}
+function normalizeAgentSkills(raw) {
+  const data = raw != null && typeof raw === "object" && Array.isArray(raw.data) ? raw.data : [];
+  const out = [];
+  for (const row of data) {
+    const fqn = row.latest_version?.fqn;
+    const name = row.name;
+    if (fqn == null || fqn === "" || name == null || name === "") continue;
+    const description = row.latest_version?.manifest?.source?.description;
+    out.push({
+      id: fqn,
+      name,
+      fqn,
+      ...description != null ? { description } : {}
+    });
+  }
+  return out;
+}
+async function listAgentSkills(opts) {
+  const raw = await cpFetch(
+    opts,
+    "/api/ml/v1/agent-skills?include_empty_agent_skills=false"
+  );
+  return normalizeAgentSkills(raw);
+}
+function normalizeMcpServers(raw) {
+  const data = raw != null && typeof raw === "object" && Array.isArray(raw.data) ? raw.data : [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of data) {
+    const mcpName = row.name;
+    if (mcpName == null || mcpName === "" || seen.has(mcpName)) continue;
+    seen.add(mcpName);
+    const description = row.manifest?.description;
+    const authenticated = row.authStatus?.status === "authenticated";
+    out.push({
+      id: mcpName,
+      name: mcpName,
+      mcpName,
+      ...description != null ? { description } : {},
+      ...row.id != null ? { serverId: row.id } : { serverId: null },
+      authenticated
+    });
+  }
+  return out;
+}
+async function listMcpServers(opts) {
+  const raw = await cpFetch(opts, "/api/svc/v1/mcp-servers");
+  return normalizeMcpServers(raw);
+}
+function normalizeAgents(raw) {
+  const data = raw != null && typeof raw === "object" && Array.isArray(raw.data) ? raw.data : [];
+  const out = [];
+  for (const row of data) {
+    if (row.name == null || row.name === "") continue;
+    out.push({ name: row.name });
+  }
+  return out;
+}
+async function listAgents(opts, req) {
+  const limit = req?.limit ?? 50;
+  const offset = req?.offset ?? 0;
+  const namePrefix = req?.query ?? "";
+  const qs = new URLSearchParams({
+    type: "truefoundry-agent",
+    limit: String(limit),
+    offset: String(offset),
+    namePrefix
+  });
+  const raw = await cpFetch(
+    opts,
+    `/api/svc/v1/agents?${qs.toString()}`
+  );
+  return normalizeAgents(raw);
+}
+var SAVE_AGENT_METADATA_TAGS = {
+  agent: "tfy-ai-gateway-agent",
+  TFY_ALPHA_ENABLE_OPENUI: "true",
+  TFY_ALPHA_ENABLE_ASK_USER: "true",
+  TFY_ALPHA_ENABLE_ASK_SECRET: "true",
+  TFY_ALPHA_CONTEXT_MANAGEMENT: '{"large_tool_response":{"individual_tool_response_token_threshold":8000}}',
+  TFY_ALPHA_ENABLE_FILE_DOWNLOAD: "true"
+};
+var SAVE_AGENT_COLLABORATORS = [
+  { subject: "team:everyone", role_id: "agent-access" }
+];
+function camelToSnakeKey(key) {
+  return key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function toSnakeCaseDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(toSnakeCaseDeep);
+  }
+  if (value != null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[camelToSnakeKey(k)] = toSnakeCaseDeep(v);
+    }
+    return out;
+  }
+  return value;
+}
+function mcpMountForCp(mount) {
+  const snake = toSnakeCaseDeep(mount);
+  if (snake.type === "truefoundry-mcp-registry") {
+    return {
+      ...snake,
+      enable_tools: snake.enable_tools ?? ["@all"],
+      preload: snake.preload ?? false
+    };
+  }
+  return snake;
+}
+function skillMountForCp(mount) {
+  const snake = toSnakeCaseDeep(mount);
+  if (snake.type === "truefoundry-skills-registry") {
+    return {
+      ...snake,
+      preload: snake.preload ?? false
+    };
+  }
+  return snake;
+}
+function buildSaveAgentManifest(agentName, agentSpec) {
+  const spec = normalizeAgentSpecForGateway(agentSpec);
+  const mcpServers = (spec.mcpServers ?? []).map(mcpMountForCp);
+  const skills = (spec.skills ?? []).map(skillMountForCp);
+  const rawDescription = agentSpec.description;
+  const description = typeof rawDescription === "string" ? rawDescription : "";
+  return {
+    type: "truefoundry-agent",
+    name: agentName,
+    description,
+    model: toSnakeCaseDeep(spec.model),
+    metadata_tags: { ...SAVE_AGENT_METADATA_TAGS },
+    collaborators: [...SAVE_AGENT_COLLABORATORS],
+    ...spec.instructions != null ? { instructions: spec.instructions } : {},
+    ...spec.config != null ? { config: toSnakeCaseDeep(spec.config) } : {},
+    ...mcpServers.length > 0 ? { mcp_servers: mcpServers } : {},
+    ...skills.length > 0 ? { skills } : {}
+  };
+}
+async function saveAgent(opts, req) {
+  const manifest = buildSaveAgentManifest(req.agentName, req.agentSpec);
+  return cpFetch(opts, "/api/svc/v1/agents", {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ manifest })
+  });
+}
+
+// src/plugins/truefoundry-agent-server-adapter/createTrueFoundryAgentUIServer.ts
+function credentialsKey(opts) {
+  return `${opts.apiKey}\0${opts.cpURL}\0${opts.gatewayURL ?? ""}`;
+}
+var inflight = /* @__PURE__ */ new Map();
+async function createTrueFoundryAgentUIServer(opts) {
+  const key = credentialsKey(opts);
+  const existing = inflight.get(key);
+  if (existing != null) {
+    return existing;
+  }
+  const promise = (async () => {
+    const baseUrl = await resolveGatewayURL(opts);
+    const chat = createTrueFoundryChatServer({
+      apiKey: opts.apiKey,
+      baseUrl
+    });
+    const cp = { apiKey: opts.apiKey, cpURL: opts.cpURL };
+    const server = {
+      ...chat,
+      getModels: () => listEnabledModels(cp),
+      getSkills: () => listAgentSkills(cp),
+      getMcp: () => listMcpServers(cp),
+      searchAgents: (req) => listAgents(cp, req),
+      saveAgent: (req) => saveAgent(cp, req)
+    };
+    return server;
+  })();
+  inflight.set(key, promise);
+  try {
+    return await promise;
+  } finally {
+    inflight.delete(key);
+  }
+}
+
+// src/plugins/truefoundry-agent-server-adapter/guards.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasNumbers(value, keys) {
+  return isRecord2(value) && keys.every((key) => typeof value[key] === "number");
+}
+function isTfySystemToolInfo(toolInfo) {
+  return isRecord2(toolInfo) && toolInfo.type === "truefoundry-system" && typeof toolInfo.name === "string";
+}
+function isTfyMcpToolInfo(toolInfo) {
+  return isRecord2(toolInfo) && toolInfo.type === "mcp" && typeof toolInfo.name === "string" && typeof toolInfo.serverId === "string" && typeof toolInfo.serverName === "string";
+}
+function isTfyToolInfo(toolInfo) {
+  return isTfySystemToolInfo(toolInfo) || isTfyMcpToolInfo(toolInfo);
+}
+var USAGE_BREAKDOWN_KEYS = [
+  "harness",
+  "skills",
+  "instructions",
+  "toolDefinitions",
+  "messages"
+];
+function getTfyUsage(source) {
+  const usage = source?.usage;
+  if (!hasNumbers(usage, ["inputTokens", "outputTokens"])) {
+    return void 0;
+  }
+  if (!hasNumbers(usage.inputTokensBreakdown, USAGE_BREAKDOWN_KEYS)) {
+    return void 0;
+  }
+  return usage;
+}
+function getTfyThreadState(event) {
+  const state = event?.state;
+  if (!isRecord2(state)) {
+    return void 0;
+  }
+  if (state.status === "done" && isRecord2(state.output)) {
+    return state;
+  }
+  if (state.status === "error" && typeof state.error === "string") {
+    return state;
+  }
+  return void 0;
+}
+function getTfyMcpInitServers(event) {
+  const servers = event?.mcpServers;
+  if (!Array.isArray(servers)) {
+    return void 0;
+  }
+  const valid = servers.every(
+    (server) => isRecord2(server) && typeof server.id === "string" && typeof server.name === "string"
+  );
+  return valid ? servers : void 0;
+}
+
+export {
+  createTrueFoundryChatServer,
+  createTrueFoundryAgentUIServer,
+  isTfySystemToolInfo,
+  isTfyMcpToolInfo,
+  isTfyToolInfo,
+  getTfyUsage,
+  getTfyThreadState,
+  getTfyMcpInitServers
+};
+//# sourceMappingURL=chunk-CXBZ6WLZ.js.map