@truefoundry/trueforge-ui 0.0.0 → 0.1.0-rc.1

package/dist/plugins/trueforge-agent-server-adapter/index.js

@@ -0,0 +1,851 @@
+import {
+  createTrueFoundryServer
+} from "../../chunk-CFLVPV5M.js";
+
+// src/plugins/trueforge-agent-server-adapter/catalogs/connectorCatalog.ts
+var DEFAULT_API_KEY_HEADER = "Authorization";
+function toUiAuthPublic(auth) {
+  if (auth === void 0) {
+    return { type: "none" };
+  }
+  if (auth.type === "dcr") {
+    return { type: "dcr" };
+  }
+  const headerName = Object.keys(auth.headers)[0];
+  return {
+    type: "header",
+    ...headerName === void 0 ? {} : { headerName }
+  };
+}
+function toHarnessAuth(auth) {
+  if (auth.type === "none") {
+    return void 0;
+  }
+  if (auth.type === "dcr") {
+    return { type: "dcr" };
+  }
+  const apiKey = auth.apiKey?.trim();
+  if (apiKey === void 0 || apiKey === "") {
+    throw new Error("API key is required for header-authenticated MCP servers");
+  }
+  const trimmedHeader = auth.headerName?.trim();
+  const headerName = trimmedHeader !== void 0 && trimmedHeader !== "" ? trimmedHeader : DEFAULT_API_KEY_HEADER;
+  return { type: "header", headers: { [headerName]: apiKey } };
+}
+function toUiCatalogEntry(server) {
+  return {
+    id: server.name,
+    name: server.name,
+    url: server.url,
+    description: server.description,
+    ...server.logo === void 0 ? {} : { logo: server.logo },
+    auth: toUiAuthPublic(server.auth)
+  };
+}
+function toUiTool(tool) {
+  const name = typeof tool.name === "string" && tool.name !== "" ? tool.name : "tool";
+  const description = typeof tool.description === "string" ? tool.description : "";
+  return { id: name, name, description };
+}
+function toUiConnector(server) {
+  const auth = toUiAuthPublic(server.manifest.auth);
+  return {
+    id: server.name,
+    name: server.name,
+    description: server.manifest.description,
+    url: server.manifest.url,
+    auth,
+    requiresAuth: server.authStatus.status === "auth_required",
+    authenticated: server.authStatus.status !== "auth_required"
+  };
+}
+function toUiConnectorFromReadEntry(server) {
+  const auth = server.auth?.type ? { type: server.auth.type } : { type: "none" };
+  return {
+    id: server.name,
+    name: server.name,
+    description: server.url,
+    url: server.url,
+    auth,
+    requiresAuth: server.authStatus.status === "auth_required",
+    authenticated: server.authStatus.status !== "auth_required"
+  };
+}
+function toHarnessManifest(req) {
+  const auth = toHarnessAuth(req.auth);
+  const trimmed = req.description?.trim();
+  return {
+    type: "remote",
+    name: req.name,
+    url: req.url,
+    description: trimmed !== void 0 && trimmed !== "" ? trimmed : `${req.name} MCP server`,
+    ...auth === void 0 ? {} : { auth }
+  };
+}
+function createConnectorCatalog(client) {
+  async function getConfigured(name) {
+    const listed = await client.settings.mcpServers.list();
+    const existing = listed.data.find((server) => server.name === name);
+    if (existing === void 0) {
+      throw new Error(`MCP server "${name}" not found`);
+    }
+    return existing;
+  }
+  async function resolveWriteAuth(req) {
+    if (req.auth.type !== "header") {
+      return req.auth;
+    }
+    const apiKey = req.auth.apiKey?.trim();
+    if (apiKey !== void 0 && apiKey !== "") {
+      return req.auth;
+    }
+    if (req.id === void 0) {
+      throw new Error("API key is required for header-authenticated MCP servers");
+    }
+    const existing = await getConfigured(req.id);
+    if (existing.manifest.auth?.type !== "header") {
+      throw new Error(`MCP server "${req.id}" has no stored header credentials to reuse`);
+    }
+    const preferredHeader = req.auth.headerName?.trim();
+    const storedHeaderName = Object.keys(existing.manifest.auth.headers)[0];
+    const headerName = preferredHeader !== void 0 && preferredHeader !== "" ? preferredHeader : storedHeaderName ?? DEFAULT_API_KEY_HEADER;
+    const stored = existing.manifest.auth.headers[headerName] ?? Object.values(existing.manifest.auth.headers)[0];
+    if (stored === void 0) {
+      throw new Error(`MCP server "${req.id}" has no stored header credentials to reuse`);
+    }
+    return { type: "header", apiKey: stored, headerName };
+  }
+  return {
+    getConnectorCatalog: async () => {
+      const body = await client.catalog.mcpServers.list();
+      return body.data.map(toUiCatalogEntry);
+    },
+    getConnector: async (req) => {
+      const body = await client.settings.mcpServers.get(req.id);
+      return toUiConnector(body.data);
+    },
+    listConnectors: async (req) => {
+      const body = await client.settings.mcpServers.list();
+      const connectors = body.data.map(toUiConnector);
+      const query = req?.query?.trim().toLowerCase();
+      if (query === void 0 || query === "") {
+        return connectors;
+      }
+      return connectors.filter(
+        (connector) => connector.name.toLowerCase().includes(query) || connector.description.toLowerCase().includes(query) || connector.url.toLowerCase().includes(query)
+      );
+    },
+    getToolsByConnectorId: async ({ id }) => {
+      const body = await client.settings.mcpServers.listTools(id);
+      return body.data.map(toUiTool);
+    },
+    createConnector: async (req) => {
+      const auth = await resolveWriteAuth({ auth: req.auth });
+      const catalog = await client.catalog.mcpServers.list();
+      const preset = catalog.data.find((server) => server.name === req.name);
+      const body = await client.settings.mcpServers.create({
+        manifest: toHarnessManifest({
+          name: req.name,
+          url: req.url,
+          auth,
+          description: preset?.description
+        })
+      });
+      return toUiConnector(body.data);
+    },
+    updateConnector: async (req) => {
+      const existing = await getConfigured(req.id);
+      const auth = await resolveWriteAuth({ id: req.id, auth: req.auth });
+      const body = await client.settings.mcpServers.upsert({
+        manifest: toHarnessManifest({
+          name: req.id,
+          url: req.url,
+          auth,
+          description: existing.manifest.description
+        })
+      });
+      return toUiConnector(body.data);
+    },
+    authenticateConnector: async (req) => {
+      const result = await client.mcpServers.authorize(
+        req.id,
+        req.redirectURL === void 0 ? {} : { redirectUrl: req.redirectURL }
+      );
+      return { status: result.status, authorization_endpoint: result.authorizationUrl };
+    },
+    disconnectConnector: async (req) => {
+      const existing = await getConfigured(req.id);
+      if (existing.manifest.auth?.type !== "dcr") {
+        throw new Error(`Disconnect is only supported for OAuth MCP servers`);
+      }
+      const body = await client.mcpServers.deleteAuthorize(req.id);
+      return toUiConnector(body.data);
+    }
+  };
+}
+
+// src/plugins/trueforge-agent-server-adapter/client.ts
+import { TrueForge } from "@truefoundry/trueforge-sdk";
+var DEFAULT_BASE_URL = "/";
+function createTrueForgeClient(options = {}) {
+  return new TrueForge({
+    baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+    ...options.token === void 0 ? {} : { token: options.token },
+    ...options.fetch === void 0 ? {} : { fetch: options.fetch }
+  });
+}
+
+// src/plugins/trueforge-agent-server-adapter/chatServer.ts
+function toUiMcpServer(server) {
+  return server;
+}
+function toUiSkill(skill) {
+  return { name: skill.name };
+}
+function toHarnessAgentSpec(spec) {
+  const { skills, mcpServers, ...rest } = spec;
+  return {
+    ...rest,
+    ...mcpServers === void 0 ? {} : {
+      mcpServers: mcpServers.map((server) => {
+        if ("id" in server) {
+          const { id, ...mount } = server;
+          void id;
+          return mount;
+        }
+        return server;
+      })
+    },
+    ...skills === void 0 ? {} : { skills: skills.map(({ name }) => ({ name })) }
+  };
+}
+function toUiAgentSpec(spec) {
+  const { mcpServers, skills, ...rest } = spec;
+  return {
+    ...rest,
+    ...mcpServers ? { mcpServers: mcpServers.map(toUiMcpServer) } : {},
+    ...skills ? { skills: skills.map(toUiSkill) } : {}
+  };
+}
+function toUiSession(session) {
+  return {
+    id: session.id,
+    isMutable: session.agent.type === "inline",
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt,
+    ...session.title === null ? {} : { title: session.title },
+    // `name` is a create-time snapshot, so references whose agent predates it stay
+    // unlabelled; `isMutable` alone keeps them out of the composer.
+    ...session.agent.type === "reference" && session.agent.name !== null ? { agentName: session.agent.name } : {},
+    ...session.agent.type === "inline" ? { agentSpec: toUiAgentSpec(session.agent.spec) } : {}
+  };
+}
+function toUiContent(content) {
+  return typeof content === "string" ? content : content.map((part) => ({ ...part }));
+}
+function toUiInput(input) {
+  return input.map((item) => item.type === "user.message" ? { ...item, content: toUiContent(item.content) } : item);
+}
+function toUiTurn(turn) {
+  const { previousTurnId, input, ...rest } = turn;
+  return {
+    ...rest,
+    ...previousTurnId === null ? {} : { previousTurnId },
+    ...input === void 0 ? {} : { input: toUiInput(input) }
+  };
+}
+function toUiEventItem(item) {
+  return { turnId: item.turnId, event: { ...item.event } };
+}
+function toListResult(page, map) {
+  const data = page.data.map(map);
+  const token = page.response.pagination.nextPageToken;
+  return {
+    data,
+    ...token === void 0 ? {} : { nextPageToken: token }
+  };
+}
+function sequenceNumber(id, fallback) {
+  if (id === void 0) return fallback;
+  const parsed = Number(id);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function toHarnessContent(content) {
+  if (typeof content === "string") return content;
+  return content.map((part) => {
+    if (part.type === "text") return part;
+    const { name, data } = part;
+    if (typeof name !== "string" || typeof data !== "string") {
+      throw new Error("File attachment must carry a string `name` and a data-URI `data`");
+    }
+    return { type: "file", name, data };
+  });
+}
+function toHarnessInput(input) {
+  return input.map(
+    (item) => item.type === "user.message" ? { ...item, content: toHarnessContent(item.content) } : item
+  );
+}
+function createHarnessChatServer(options = {}) {
+  const client = options.client ?? createTrueForgeClient(options);
+  return {
+    // The sandbox is resolved server-side from the turn, so `sandboxId` is accepted for parity
+    // with hosts that address sandboxes directly and deliberately not forwarded.
+    async downloadSandboxFile({ sessionId, turnId, path }) {
+      const response = await client.sessions.downloadSandboxFile(sessionId, turnId, { path });
+      return response.blob();
+    },
+    async createSession(request) {
+      if (request.agentName !== void 0 && request.agentName.length > 0) {
+        const created = await client.sessions.create({
+          agent: { name: request.agentName }
+        });
+        return toUiSession(created.data);
+      }
+      if (request.agentSpec !== void 0) {
+        const created = await client.sessions.create({
+          agent: { spec: toHarnessAgentSpec(request.agentSpec) }
+        });
+        return toUiSession(created.data);
+      }
+      throw new Error("createSession requires agentName or agentSpec");
+    },
+    async listSessions(request = {}) {
+      const page = await client.sessions.list({
+        ...request.limit === void 0 ? {} : { limit: request.limit },
+        ...request.order === void 0 ? {} : { order: request.order },
+        ...request.pageToken === void 0 ? {} : { pageToken: request.pageToken },
+        ...request.agentId === void 0 || request.agentId.length === 0 ? {} : { agentId: request.agentId }
+      });
+      return toListResult(page, toUiSession);
+    },
+    async getSession({ sessionId }) {
+      const response = await client.sessions.get(sessionId);
+      return toUiSession(response.data);
+    },
+    async updateSession({ sessionId, agentSpec }) {
+      const response = await client.sessions.update(sessionId, {
+        ...agentSpec === void 0 ? {} : { agent: { spec: toHarnessAgentSpec(agentSpec) } }
+      });
+      return toUiSession(response.data);
+    },
+    async *createTurn({
+      sessionId,
+      input,
+      previousTurnId
+    }) {
+      const stream = await client.sessions.createTurnStream(sessionId, {
+        ...input === void 0 ? {} : { input: toHarnessInput(input) },
+        ...previousTurnId === void 0 ? {} : { previousTurnId }
+      });
+      let fallbackSequence = 0;
+      for await (const item of stream.withMetadata()) {
+        yield {
+          sequenceNumber: sequenceNumber(item.id, fallbackSequence),
+          event: { ...item.data }
+        };
+        fallbackSequence += 1;
+      }
+    },
+    /** Resume a live turn; omitted/0 `afterSequenceNumber` replays from the start. */
+    async *subscribeToTurn({
+      sessionId,
+      turnId,
+      afterSequenceNumber
+    }) {
+      const stream = await client.sessions.subscribeToTurn(sessionId, turnId, {
+        ...afterSequenceNumber === void 0 ? {} : { afterSequenceNumber }
+      });
+      let fallbackSequence = 0;
+      for await (const item of stream.withMetadata()) {
+        yield {
+          sequenceNumber: sequenceNumber(item.id, fallbackSequence),
+          event: { ...item.data }
+        };
+        fallbackSequence += 1;
+      }
+    },
+    async cancelSession({ sessionId }) {
+      await client.sessions.cancel(sessionId);
+    },
+    async listTurns({ sessionId, limit, pageToken }) {
+      const page = await client.sessions.listTurns(sessionId, {
+        ...limit === void 0 ? {} : { limit },
+        ...pageToken === void 0 ? {} : { pageToken }
+      });
+      return toListResult(page, toUiTurn);
+    },
+    async getTurn({ sessionId, turnId }) {
+      const response = await client.sessions.getTurn(sessionId, turnId);
+      return toUiTurn(response.data);
+    },
+    async listEvents({ sessionId, pageToken, lastTurnId, limit }) {
+      const page = await client.sessions.listEvents(sessionId, {
+        ...pageToken === void 0 ? {} : { pageToken },
+        ...lastTurnId === void 0 ? {} : { lastTurnId },
+        ...limit === void 0 ? {} : { limit }
+      });
+      return toListResult(page, toUiEventItem);
+    }
+  };
+}
+
+// src/plugins/trueforge-agent-server-adapter/lists.ts
+async function listModels(client) {
+  const body = await client.models.list();
+  return body.data;
+}
+async function listConfiguredMcpServers(client) {
+  const body = await client.mcpServers.list();
+  return body.data;
+}
+async function listSkills(client) {
+  const body = await client.skills.list();
+  return body.data;
+}
+async function getCapabilities(client) {
+  const body = await client.server.getCapabilities();
+  return body.data;
+}
+
+// src/plugins/trueforge-agent-server-adapter/builderServer.ts
+function modelProviderLogosByName(catalog) {
+  const logos = /* @__PURE__ */ new Map();
+  for (const entry of catalog) {
+    if (entry.type === "custom" || entry.logo === void 0) {
+      continue;
+    }
+    logos.set(entry.type, entry.logo);
+  }
+  return logos;
+}
+function toModelSelection({ model, logo }) {
+  const efforts = model.properties.reasoningEfforts;
+  return {
+    id: model.modelId,
+    name: model.name,
+    provider: {
+      name: model.provider.name,
+      ...logo === void 0 ? {} : { logo }
+    },
+    properties: {
+      ...efforts !== void 0 && efforts.length > 0 ? { reasoningEfforts: [...efforts] } : {}
+    }
+  };
+}
+function toLibraryEntry(agent) {
+  return {
+    name: agent.name,
+    agentId: agent.id,
+    agentSpec: toUiAgentSpec(agent.manifest)
+  };
+}
+function createHarnessBuilderServer(options = {}) {
+  const client = options.client ?? createTrueForgeClient(options);
+  return {
+    getCapabilities: () => client.server.getCapabilities(),
+    getModels: async () => {
+      const [modelsBody, catalogEntries] = await Promise.all([
+        client.models.list(),
+        client.catalog.modelProviders.list().then(
+          (body) => body.data,
+          () => []
+        )
+      ]);
+      const logosByName = modelProviderLogosByName(catalogEntries);
+      return modelsBody.data.map((model) => {
+        const logo = logosByName.get(model.provider.name);
+        return toModelSelection(logo === void 0 ? { model } : { model, logo });
+      });
+    },
+    // Skills require a configured sandbox provider; keep the picker empty when skill capability is off.
+    getSkills: async () => {
+      const skills = await listSkills(client);
+      return skills.map((skill) => ({ id: skill.name, name: skill.name, description: skill.description }));
+    },
+    getMcp: async () => (await listConfiguredMcpServers(client)).map(toUiConnectorFromReadEntry),
+    async searchAgents(req) {
+      const { data } = await client.agents.list();
+      const query = req?.query?.trim().toLowerCase();
+      const filtered = query === void 0 || query === "" ? data : data.filter((agent) => agent.name.toLowerCase().includes(query));
+      const offset = req?.offset ?? 0;
+      const limit = req?.limit ?? 50;
+      return filtered.slice(offset, offset + limit).map(toLibraryEntry);
+    },
+    async saveAgent({ agentName, agentSpec, intent }) {
+      const manifest = toHarnessAgentSpec(agentSpec);
+      if (intent === "update") {
+        const { data } = await client.agents.list();
+        const existing = data.find((agent) => agent.name === agentName);
+        if (!existing) {
+          return {};
+        }
+        await client.agents.update(existing.id, { manifest });
+        return { agentId: existing.id };
+      }
+      const created = await client.agents.create({ name: agentName, manifest });
+      return { agentId: created.data.id };
+    }
+  };
+}
+
+// src/plugins/trueforge-agent-server-adapter/catalogs/modelProviderCatalog.ts
+import { TrueForgeApi } from "@truefoundry/trueforge-sdk";
+function toUiModelEntry(model) {
+  return {
+    id: model.modelId,
+    name: model.name,
+    properties: model.properties
+  };
+}
+function toHarnessModelEntry(model) {
+  return {
+    modelId: model.id,
+    name: model.name,
+    properties: model.properties ?? {}
+  };
+}
+function toUiModelProvider(provider) {
+  const { name, manifest } = provider;
+  return {
+    id: name,
+    type: manifest.type,
+    name,
+    ...manifest.baseUrl === void 0 ? {} : { baseUrl: manifest.baseUrl },
+    models: manifest.models.map(toUiModelEntry)
+  };
+}
+function toUiCatalogModelProviderEntry(provider) {
+  if (provider.type === "custom") {
+    return {
+      type: provider.type,
+      name: provider.type,
+      supportedReasoningEfforts: provider.supportedReasoningEfforts,
+      models: []
+    };
+  }
+  return {
+    type: provider.type,
+    name: provider.type,
+    ...provider.logo === void 0 ? {} : { logo: provider.logo },
+    models: provider.models.map(toUiModelEntry)
+  };
+}
+var PROVIDER_TYPES = [...Object.values(TrueForgeApi.CatalogWellKnownModelProviderType), "custom"];
+function isProviderType(type) {
+  return PROVIDER_TYPES.includes(type);
+}
+function toHarnessModelProvider(req) {
+  const models = req.models.map(toHarnessModelEntry);
+  if (!isProviderType(req.type)) {
+    throw new Error(`Unsupported model provider type: ${req.type}`);
+  }
+  const baseUrl = req.baseUrl?.trim() === "" ? void 0 : req.baseUrl;
+  if (req.type === "custom") {
+    if (baseUrl === void 0) {
+      throw new Error(`Model providers of type "${req.type}" require a base URL`);
+    }
+    return {
+      type: req.type,
+      name: req.name,
+      models,
+      baseUrl,
+      ...req.apiKey === "" ? {} : { auth: { apiKey: req.apiKey } }
+    };
+  }
+  const auth = { apiKey: req.apiKey };
+  if (baseUrl !== void 0) {
+    return { type: req.type, auth, models, baseUrl };
+  }
+  return { type: req.type, auth, models };
+}
+function createModelProviderCatalog(client) {
+  async function resolveApiKey(req) {
+    const trimmed = req.apiKey.trim();
+    if (trimmed !== "") {
+      return trimmed;
+    }
+    if (req.id === void 0) {
+      if (req.type === "custom") {
+        return "";
+      }
+      throw new Error("API key is required");
+    }
+    const listed = await client.settings.modelProviders.list();
+    const existing = listed.data.find((provider) => provider.name === req.id);
+    if (existing === void 0) {
+      throw new Error(`Model provider "${req.id}" not found`);
+    }
+    return existing.manifest.auth?.apiKey ?? "";
+  }
+  return {
+    getModelProviderCatalog: async () => {
+      const body = await client.catalog.modelProviders.list();
+      return body.data.map(toUiCatalogModelProviderEntry);
+    },
+    listModelProviders: async () => {
+      const body = await client.settings.modelProviders.list();
+      return body.data.map(toUiModelProvider);
+    },
+    createModelProvider: async (req) => {
+      const apiKey = await resolveApiKey({ type: req.type, apiKey: req.apiKey });
+      const body = await client.settings.modelProviders.create({
+        manifest: toHarnessModelProvider({
+          type: req.type,
+          name: req.name,
+          apiKey,
+          ...req.baseUrl === void 0 ? {} : { baseUrl: req.baseUrl },
+          models: req.models
+        })
+      });
+      return toUiModelProvider(body.data);
+    },
+    updateModelProvider: async (req) => {
+      const apiKey = await resolveApiKey({ id: req.id, type: req.type, apiKey: req.apiKey });
+      const body = await client.settings.modelProviders.upsert({
+        manifest: toHarnessModelProvider({
+          type: req.type,
+          name: req.id,
+          apiKey,
+          ...req.baseUrl === void 0 ? {} : { baseUrl: req.baseUrl },
+          models: req.models
+        })
+      });
+      return toUiModelProvider(body.data);
+    }
+  };
+}
+
+// src/plugins/trueforge-agent-server-adapter/catalogs/sandboxProviderCatalog.ts
+import { TrueForgeApi as TrueForgeApi2 } from "@truefoundry/trueforge-sdk";
+var DAYTONA_TYPE = "daytona";
+var DAYTONA_DISPLAY_NAME = "Daytona";
+function displayNameForType(type) {
+  if (type === DAYTONA_TYPE) {
+    return DAYTONA_DISPLAY_NAME;
+  }
+  return type;
+}
+function configFromHarness(provider) {
+  return {
+    // Snapshot/image is now release-owned; the field is gone from the backend. The external
+    // SandboxProviderConfig still requires it, so send an empty placeholder until that type drops it.
+    snapshotName: "",
+    execTimeoutMs: provider.execTimeoutMs,
+    autoStopIntervalInMinutes: provider.autoStopIntervalInMinutes,
+    autoArchiveIntervalInMinutes: provider.autoArchiveIntervalInMinutes,
+    autoDeleteIntervalInMinutes: provider.autoDeleteIntervalInMinutes
+  };
+}
+function toUiCatalogEntry2(provider) {
+  return {
+    id: provider.type,
+    name: displayNameForType(provider.type),
+    type: provider.type,
+    ...configFromHarness(provider)
+  };
+}
+function toUiSandboxProvider(provider) {
+  return {
+    id: provider.type,
+    name: displayNameForType(provider.type),
+    catalogId: provider.type,
+    isConnected: true,
+    ...configFromHarness(provider)
+  };
+}
+function toHarnessManifest2(req) {
+  if (req.type !== DAYTONA_TYPE) {
+    throw new Error(`Unsupported sandbox provider type: ${req.type}`);
+  }
+  return {
+    type: DAYTONA_TYPE,
+    execTimeoutMs: req.execTimeoutMs,
+    autoStopIntervalInMinutes: req.autoStopIntervalInMinutes,
+    autoArchiveIntervalInMinutes: req.autoArchiveIntervalInMinutes,
+    autoDeleteIntervalInMinutes: req.autoDeleteIntervalInMinutes,
+    auth: { apiKey: req.apiKey }
+  };
+}
+function createSandboxProviderCatalog(client) {
+  async function resolveApiKey(apiKey) {
+    const trimmed = apiKey?.trim();
+    if (trimmed !== void 0 && trimmed !== "") {
+      return trimmed;
+    }
+    const existing = await client.settings.sandboxProviders.get();
+    return existing.data.manifest.auth.apiKey;
+  }
+  return {
+    getSandboxProviderCatalog: async () => {
+      const body = await client.catalog.sandboxProviders.list();
+      return body.data.map(toUiCatalogEntry2);
+    },
+    listSandboxProviders: async (req) => {
+      let providers;
+      try {
+        const body = await client.settings.sandboxProviders.get();
+        providers = [toUiSandboxProvider(body.data.manifest)];
+      } catch (err) {
+        if (err instanceof TrueForgeApi2.NotFoundError) {
+          providers = [];
+        } else {
+          throw err;
+        }
+      }
+      const query = req?.query?.trim().toLowerCase();
+      if (query === void 0 || query === "") {
+        return providers;
+      }
+      return providers.filter(
+        (provider) => provider.name.toLowerCase().includes(query) || provider.id.toLowerCase().includes(query)
+      );
+    },
+    createSandboxProvider: async (req) => {
+      const body = await client.settings.sandboxProviders.upsert({
+        manifest: toHarnessManifest2({
+          type: req.type,
+          apiKey: req.apiKey,
+          execTimeoutMs: req.execTimeoutMs,
+          autoStopIntervalInMinutes: req.autoStopIntervalInMinutes,
+          autoArchiveIntervalInMinutes: req.autoArchiveIntervalInMinutes,
+          autoDeleteIntervalInMinutes: req.autoDeleteIntervalInMinutes
+        })
+      });
+      return toUiSandboxProvider(body.data.manifest);
+    },
+    updateSandboxProvider: async (req) => {
+      const apiKey = await resolveApiKey(req.apiKey);
+      const body = await client.settings.sandboxProviders.upsert({
+        manifest: toHarnessManifest2({
+          type: DAYTONA_TYPE,
+          apiKey,
+          execTimeoutMs: req.execTimeoutMs,
+          autoStopIntervalInMinutes: req.autoStopIntervalInMinutes,
+          autoArchiveIntervalInMinutes: req.autoArchiveIntervalInMinutes,
+          autoDeleteIntervalInMinutes: req.autoDeleteIntervalInMinutes
+        })
+      });
+      return toUiSandboxProvider(body.data.manifest);
+    }
+  };
+}
+
+// src/plugins/trueforge-agent-server-adapter/catalogs/skillCatalog.ts
+function toUiCatalogEntry3(skill) {
+  return {
+    id: skill.name,
+    name: skill.name,
+    description: skill.description,
+    repoURL: skill.url,
+    path: skill.path ?? "",
+    ref: skill.ref
+  };
+}
+function toHarnessManifest3(req) {
+  const path = req.path.trim();
+  return {
+    type: "git",
+    name: req.name,
+    url: req.repoURL,
+    ...path === "" ? {} : { path },
+    ref: req.ref,
+    description: req.description
+  };
+}
+function toUiSkill2(skill, catalogNames) {
+  const base = {
+    id: skill.name,
+    name: skill.name,
+    description: skill.manifest.description
+  };
+  if (catalogNames.has(skill.name)) {
+    return { ...base, catalogId: skill.name };
+  }
+  return base;
+}
+function createSkillCatalog(client) {
+  return {
+    getSkillCatalog: async () => {
+      const body = await client.catalog.skills.list();
+      return body.data.map(toUiCatalogEntry3);
+    },
+    listSkills: async (req) => {
+      const [listed, catalog] = await Promise.all([client.settings.skills.list(), client.catalog.skills.list()]);
+      const catalogNames = new Set(catalog.data.map((entry) => entry.name));
+      const skills = listed.data.map((skill) => toUiSkill2(skill, catalogNames));
+      const query = req?.query?.trim().toLowerCase();
+      if (query === void 0 || query === "") {
+        return skills;
+      }
+      return skills.filter(
+        (skill) => skill.name.toLowerCase().includes(query) || skill.description.toLowerCase().includes(query)
+      );
+    },
+    createSkill: async (req) => {
+      const body = await client.settings.skills.create({ manifest: toHarnessManifest3(req) });
+      const catalogId = "catalogId" in req ? req.catalogId : void 0;
+      if (catalogId !== void 0) {
+        return {
+          id: body.data.name,
+          name: body.data.name,
+          description: body.data.manifest.description,
+          catalogId
+        };
+      }
+      return {
+        id: body.data.name,
+        name: body.data.name,
+        description: body.data.manifest.description
+      };
+    }
+  };
+}
+
+// src/plugins/trueforge-agent-server-adapter/index.ts
+function createTrueForgeAgentUIServer(options = {}) {
+  const { catalog: catalogOverride, ...clientOptions } = options;
+  const client = createTrueForgeClient(clientOptions);
+  const catalog = catalogOverride ?? {
+    modelCatalog: createModelProviderCatalog(client),
+    connectorCatalog: createConnectorCatalog(client),
+    skillCatalog: createSkillCatalog(client),
+    sandboxCatalog: createSandboxProviderCatalog(client)
+  };
+  return createTrueFoundryServer({
+    chatServer: createHarnessChatServer({ client }),
+    ...createHarnessBuilderServer({ client }),
+    catalog
+  });
+}
+export {
+  configFromHarness,
+  createConnectorCatalog,
+  createHarnessBuilderServer,
+  createHarnessChatServer,
+  createModelProviderCatalog,
+  createSandboxProviderCatalog,
+  createSkillCatalog,
+  createTrueForgeAgentUIServer,
+  createTrueForgeClient,
+  getCapabilities,
+  listConfiguredMcpServers,
+  listModels,
+  listSkills,
+  modelProviderLogosByName,
+  toHarnessAgentSpec,
+  toHarnessAuth,
+  toHarnessManifest as toHarnessConnectorManifest,
+  toHarnessModelProvider,
+  toHarnessManifest2 as toHarnessSandboxManifest,
+  toHarnessManifest3 as toHarnessSkillManifest,
+  toModelSelection,
+  toUiAgentSpec,
+  toUiCatalogModelProviderEntry,
+  toUiConnector,
+  toUiConnectorFromReadEntry,
+  toUiModelProvider,
+  toUiSandboxProvider,
+  toUiSkill2 as toUiSkill
+};
+//# sourceMappingURL=index.js.map