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

package/dist/plugins/trueforge-agent-server-adapter/index.d.ts

@@ -0,0 +1,479 @@
+import { T as TrueFoundryServer } from '../../createTrueFoundryServer-B72bU-J7.js';
+import * as _truefoundry_assistant_ui_runtime from '@truefoundry/assistant-ui-runtime';
+import { AgentSpec, AgentBuilderServer, ModelSelection as ModelSelection$1, ConnectorCatalogServer as ConnectorCatalogServer$1, ToolBase as ToolBase$1, ConnectorAuth as ConnectorAuth$1, ConnectorAuthPublic as ConnectorAuthPublic$1, ConnectorBase as ConnectorBase$1, ConnectorCatalogEntry as ConnectorCatalogEntry$1, CreateConnectorRequest as CreateConnectorRequest$1, UpdateConnectorRequest as UpdateConnectorRequest$1, ModelCatalogServer as ModelCatalogServer$1, ModelEntry as ModelEntry$1, ModelProviderBase as ModelProviderBase$1, ModelProviderCatalogEntry as ModelProviderCatalogEntry$1, CreateModelProviderRequest as CreateModelProviderRequest$1, UpdateModelProviderRequest as UpdateModelProviderRequest$1, SandboxProviderConfig, SandboxCatalogServer as SandboxCatalogServer$1, SandboxProviderBase, SkillCatalogServer as SkillCatalogServer$1, DefinedSkill, SkillConfigBase as SkillConfigBase$1, AgentChatServer, CatalogServer } from '@truefoundry/assistant-ui-runtime/server';
+import { TrueForge, TrueForgeApi } from '@truefoundry/trueforge-sdk';
+
+/**
+ * FE-owned AgentUIServer contract.
+ *
+ * Rule: only methods/fields the runtime or UI invokes.
+ * Hosts extend via `T extends Base` for system-specific extras.
+ * No dependency on truefoundry-gateway-sdk.
+ */
+
+interface ProviderEntry {
+    name: string;
+    logo?: string;
+}
+interface ModelProperties {
+    reasoningEfforts?: string[];
+}
+/** Model selector row. Host extends for apiModel, modelId, pricing, etc. */
+interface ModelSelectorEntry<TProvider extends ProviderEntry = ProviderEntry, TProperties extends ModelProperties = ModelProperties> {
+    name: string;
+    id: string;
+    provider: TProvider;
+    properties: TProperties;
+}
+interface SaveAgentResult {
+    /** Immutable id allocated by the host registry. */
+    agentId?: string;
+    /** Timestamp returned when the active mutable session was updated. */
+    sessionUpdatedAt?: string;
+}
+/**
+ * Builder feature flags — atoms gate sandbox / skill / settings surfaces on these.
+ */
+interface AgentBuilderCapabilitiesResponse {
+    data: {
+        sandbox: {
+            enabled: boolean;
+        };
+        skill: {
+            enabled: boolean;
+            reason?: string;
+        };
+        settings?: {
+            enabled: boolean;
+        };
+    };
+}
+/**
+* Provider type id. Reserved literal: `"custom"` for user-defined providers;
+* any other string is a builtin (e.g. `"openai"`, `"anthropic"`).
+*
+* Note: `string | "custom"` is useless in TypeScript (`"custom"` ⊆ `string`),
+* so this stays `string` and `"custom"` is a documented convention.
+*/
+type ProviderType = string;
+/**
+* Model row — form "Model ID" + "Display name".
+* Host extends for properties, etc.
+*/
+interface ModelEntry {
+    id: string;
+    name: string;
+}
+/**
+* Write config for create/update (custom form + catalog "Save key").
+* Host extends. `baseUrl` present iff `type === "custom"`.
+*/
+interface ModelProviderConfigBase<TModel extends ModelEntry = ModelEntry> {
+    type: ProviderType;
+    name: string;
+    /** Present iff `type === "custom"`. */
+    baseUrl?: string;
+    apiKey: string;
+    models: TModel[];
+}
+/**
+* Configured provider card (list/read). No raw `apiKey`.
+* Host extends for apiKeySet, timestamps, etc.
+*/
+interface ModelProviderBase<TModel extends ModelEntry = ModelEntry> {
+    id: string;
+    type: ProviderType;
+    name: string;
+    /** Present iff `type === "custom"`. */
+    baseUrl?: string;
+    models: TModel[];
+}
+/**
+* Discovery-only catalog provider (AVAILABLE list).
+* `type` must not be `"custom"` — custom providers use the custom form.
+* Host extends for richer model rows.
+*/
+interface ModelProviderCatalogEntry<TModel extends ModelEntry = ModelEntry> {
+    type: ProviderType;
+    name: string;
+    models: TModel[];
+    supportedReasoningEfforts?: string[];
+    logo?: string;
+}
+/** Create — no `id`; server assigns it. Catalog path = entry + apiKey. */
+type CreateModelProviderRequest<TModel extends ModelEntry = ModelEntry> = ModelProviderConfigBase<TModel>;
+/** Update — `id` required. */
+type UpdateModelProviderRequest<TModel extends ModelEntry = ModelEntry> = ModelProviderConfigBase<TModel> & {
+    id: string;
+};
+interface ModelCatalogServer<TModel extends ModelEntry = ModelEntry, TProvider extends ModelProviderBase<TModel> = ModelProviderBase<TModel>, TCatalogProvider extends ModelProviderCatalogEntry<TModel> = ModelProviderCatalogEntry<TModel>, TCreate extends CreateModelProviderRequest<TModel> = CreateModelProviderRequest<TModel>, TUpdate extends UpdateModelProviderRequest<TModel> = UpdateModelProviderRequest<TModel>> {
+    getModelProviderCatalog(): Promise<TCatalogProvider[]>;
+    listModelProviders(): Promise<TProvider[]>;
+    createModelProvider(req: TCreate): Promise<TProvider>;
+    /** Full replace update keyed by provider `id`. */
+    updateModelProvider(req: TUpdate): Promise<TProvider>;
+    deleteModelProvider?(req: {
+        id: string;
+    }): Promise<void>;
+}
+/** Tool row on a connector detail. Host extends for schemas, etc. */
+interface ToolBase {
+    id: string;
+    name: string;
+    description: string;
+}
+type ConnectorAuthOAuth = {
+    type: "dcr";
+    authUrl?: string;
+};
+type ConnectorAuthApiKey = {
+    type: "header";
+    apiKey?: string;
+    headerName?: string;
+};
+type ConnectorAuthNone = {
+    type: "none";
+};
+type ConnectorAuth = ConnectorAuthOAuth | ConnectorAuthApiKey | ConnectorAuthNone;
+type ConnectorAuthPublicOAuth = {
+    type: "dcr";
+    authUrl?: string;
+};
+type ConnectorAuthPublicApiKey = {
+    type: "header";
+    headerName?: string;
+};
+type ConnectorAuthPublicNone = {
+    type: "none";
+};
+type ConnectorAuthPublic = ConnectorAuthPublicOAuth | ConnectorAuthPublicApiKey | ConnectorAuthPublicNone;
+/**
+* MCP / connector create-edit config. Host extends for extra fields, etc.
+*/
+interface ConnectorConfigBase<TAuth extends ConnectorAuth = ConnectorAuth> {
+    name: string;
+    url: string;
+    auth: TAuth;
+}
+/**
+ * Connected connector row (settings/connectors). No raw `apiKey` or tools.
+ * Tools are fetched separately with `getToolsByConnectorId`.
+ * Host extends.
+ */
+interface ConnectorBase<TAuth extends ConnectorAuthPublic = ConnectorAuthPublic> {
+    id: string;
+    name: string;
+    description: string;
+    url: string;
+    auth: TAuth;
+    /** When true, UI should not show Disconnect. */
+    requiresAuth: boolean;
+    authenticated: boolean;
+}
+/** Discovery catalog entry for "+ Add MCP server". Host extends. */
+interface ConnectorCatalogEntry<TAuth extends ConnectorAuthPublic = ConnectorAuthPublic> {
+    id: string;
+    name: string;
+    description?: string;
+    url: string;
+    auth: TAuth;
+    logo?: string;
+}
+/** Create connector — no `id`; server assigns it. Host extends. */
+type CreateConnectorRequest<TAuth extends ConnectorAuth = ConnectorAuth> = ConnectorConfigBase<TAuth>;
+/** Update connector — `id` required. Host extends. */
+type UpdateConnectorRequest<TAuth extends ConnectorAuth = ConnectorAuth> = ConnectorConfigBase<TAuth> & {
+    id: string;
+};
+interface AuthenticateConnectorRequest {
+    id: string;
+    /** OAuth callback page owned by the host application. */
+    redirectURL?: string;
+}
+interface ConnectorAuthenticationResult<TConnector extends ConnectorBase = ConnectorBase> {
+    connector?: TConnector;
+    status?: string;
+    authorization_endpoint?: string | undefined;
+}
+interface ConnectorCatalogServer<TTool extends ToolBase = ToolBase, TAuthWrite extends ConnectorAuth = ConnectorAuth, TAuthPublic extends ConnectorAuthPublic = ConnectorAuthPublic, TConnector extends ConnectorBase<TAuthPublic> = ConnectorBase<TAuthPublic>, TCatalogEntry extends ConnectorCatalogEntry<TAuthPublic> = ConnectorCatalogEntry<TAuthPublic>, TCreate extends CreateConnectorRequest<TAuthWrite> = CreateConnectorRequest<TAuthWrite>, TUpdate extends UpdateConnectorRequest<TAuthWrite> = UpdateConnectorRequest<TAuthWrite>> {
+    getConnectorCatalog(): Promise<TCatalogEntry[]>;
+    getConnector(req: {
+        id: string;
+    }): Promise<TConnector>;
+    listConnectors(req?: {
+        query?: string;
+    }): Promise<TConnector[]>;
+    getToolsByConnectorId(req: {
+        id: string;
+    }): Promise<TTool[]>;
+    createConnector(req: TCreate): Promise<TConnector>;
+    /** Full replace update keyed by connector `id`. */
+    updateConnector(req: TUpdate): Promise<TConnector>;
+    /**
+     * Start connector auth (e.g. OAuth).
+     * May return a connector (already authenticated / with `auth.authUrl`) or a
+     * result carrying `authorization_endpoint` for the popup flow.
+     */
+    authenticateConnector(req: AuthenticateConnectorRequest): Promise<TConnector | ConnectorAuthenticationResult<TConnector>>;
+    /** Clear connector auth. */
+    disconnectConnector(req: {
+        id: string;
+    }): Promise<TConnector>;
+    deleteConnector?(req: {
+        id: string;
+    }): Promise<void>;
+}
+/** Skill row shown in settings/skills (list + delete). Host extends for fqn, etc. */
+interface SkillBase {
+    id: string;
+    name: string;
+    description: string;
+}
+/** Git source fields shared by catalog entries and create requests. */
+interface SkillConfigBase {
+    name: string;
+    description: string;
+    repoURL: string;
+    path: string;
+    ref: string;
+}
+interface SkillCatalogEntry extends SkillConfigBase {
+    id: string;
+}
+/** Create-skill base. Hosts may intersect extra fields and re-union. */
+interface CreateSkillRequestBase extends SkillConfigBase {
+}
+interface SelectRegistrySkillRequest extends CreateSkillRequestBase {
+    /** `SkillCatalogEntry.id`, persisted so the created skill links back to it. */
+    catalogId: string;
+}
+interface ImportGithubSkillRequest extends CreateSkillRequestBase {
+}
+type CreateSkillRequest = SelectRegistrySkillRequest | ImportGithubSkillRequest;
+interface SkillCatalogServer<TSkill extends SkillBase = SkillBase, TCatalogEntry extends SkillCatalogEntry = SkillCatalogEntry, TCreate extends CreateSkillRequest = CreateSkillRequest> {
+    getSkillCatalog(): Promise<TCatalogEntry[]>;
+    listSkills(req?: {
+        query?: string;
+    }): Promise<TSkill[]>;
+    createSkill(req: TCreate): Promise<TSkill>;
+    deleteSkill?(req: {
+        id: string;
+    }): Promise<void>;
+}
+/** Mutable sandbox provider settings shared by catalog rows, create, and update. */
+interface SandboxConfig {
+    snapshotName: string;
+    execTimeoutMs: number;
+    autoStopIntervalInMinutes: number;
+    autoArchiveIntervalInMinutes: number;
+    autoDeleteIntervalInMinutes: number;
+}
+interface SandboxCatalogEntry extends SandboxConfig {
+    id: string;
+    name: string;
+    type: string;
+}
+/**
+ * Connected sandbox provider row (settings/sandboxes). No raw `apiKey`.
+ * Includes last-saved config so update forms can show previous values.
+ */
+interface SandboxBase extends SandboxConfig {
+    id: string;
+    name: string;
+    catalogId: string;
+    isConnected: boolean;
+}
+interface CreateSandboxRequest extends SandboxConfig {
+    /** `SandboxCatalogEntry.id` used to create this sandbox provider. */
+    catalogId: string;
+    name: string;
+    type: string;
+    apiKey: string;
+}
+interface UpdateSandboxRequest extends SandboxConfig {
+    id: string;
+    /** Omit to keep the existing key; send a value to rotate. */
+    apiKey?: string;
+}
+interface SandboxCatalogServer<TProvider extends SandboxBase = SandboxBase, TCatalogEntry extends SandboxCatalogEntry = SandboxCatalogEntry, TCreate extends CreateSandboxRequest = CreateSandboxRequest, TUpdate extends UpdateSandboxRequest = UpdateSandboxRequest> {
+    getSandboxProviderCatalog(): Promise<TCatalogEntry[]>;
+    listSandboxProviders(req?: {
+        query?: string;
+    }): Promise<TProvider[]>;
+    createSandboxProvider(req: TCreate): Promise<TProvider>;
+    updateSandboxProvider(req: TUpdate): Promise<TProvider>;
+    deleteSandboxProvider?(req: {
+        id: string;
+    }): Promise<void>;
+}
+/** Host-facing selector / compose aliases (trueforge-ui public names). */
+type ModelSelection = ModelSelectorEntry;
+
+/**
+ * TrueForge HTTP client for the Harness adapter.
+ * Auth is host-owned: pass `token` (Bearer) and/or a custom `fetch` (e.g. cookie + OIDC).
+ */
+
+interface CreateTrueForgeClientOptions {
+    baseUrl?: string;
+    /** SDK Bearer token (`Authorization: Bearer …`). */
+    token?: string;
+    fetch?: typeof fetch;
+}
+declare function createTrueForgeClient(options?: CreateTrueForgeClientOptions): TrueForge;
+
+type HarnessSkillMount = TrueForgeApi.SkillNameRef;
+type HarnessMcpServerMount = TrueForgeApi.McpServer;
+interface HarnessAgentSpec extends AgentSpec<TrueForgeApi.AgentSpecModel, HarnessSkillMount, HarnessMcpServerMount> {
+    config?: TrueForgeApi.RuntimeConfig;
+    instructions?: string;
+    messages?: TrueForgeApi.AgentSpecUserMessage[];
+    responseFormat?: TrueForgeApi.ResponseFormat;
+}
+
+/**
+ * AgentBuilderServer callbacks for createTrueFoundryServer.
+ * Composer pickers + agent library backed by the Harness agents registry.
+ */
+
+type CreateHarnessBuilderServerOptions = CreateTrueForgeClientOptions & {
+    client?: TrueForge;
+};
+/** Well-known catalog entries key logos by `type` (same as configured provider resource name). */
+declare function modelProviderLogosByName(catalog: readonly TrueForgeApi.CatalogModelProvider[]): ReadonlyMap<string, string>;
+/** Map harness model rows onto the UI picker shape (nested provider + properties + optional logo). */
+declare function toModelSelection({ model, logo }: {
+    model: TrueForgeApi.Model;
+    logo?: string;
+}): ModelSelection$1;
+declare function createHarnessBuilderServer(options?: CreateHarnessBuilderServerOptions): AgentBuilderServer<HarnessAgentSpec>;
+
+/**
+ * Maps trueforge-ui connector-settings calls onto Harness
+ *
+ * UI: `dcr` / `header` / `none`, connector `id`.
+ * Harness: `dcr` / `header` / omitted auth, resource `name`.
+ */
+
+type UiConnectorAuth = ConnectorAuth$1;
+type UiConnectorAuthPublic = ConnectorAuthPublic$1;
+type UiConnector = ConnectorBase$1;
+type UiConnectorCatalogEntry = ConnectorCatalogEntry$1;
+declare function toHarnessAuth(auth: ConnectorAuth$1): TrueForgeApi.ConfiguredMcpServerAuth | undefined;
+declare function toUiConnector(server: TrueForgeApi.ConfiguredMcpServer): UiConnector;
+declare function toUiConnectorFromReadEntry(server: TrueForgeApi.McpServerReadEntry): UiConnector;
+interface HarnessMcpUpsert {
+    name: string;
+    url: string;
+    auth?: TrueForgeApi.ConfiguredMcpServerAuth;
+}
+declare function toHarnessManifest$2(req: {
+    name: string;
+    url: string;
+    auth: ConnectorAuth$1;
+}): HarnessMcpUpsert;
+/** Settings connector port for `createTrueFoundryServer`. Delete omitted; disconnect unsupported. */
+declare function createConnectorCatalog(client: TrueForge): ConnectorCatalogServer$1<ToolBase$1, UiConnectorAuth, UiConnectorAuthPublic, UiConnector, UiConnectorCatalogEntry, CreateConnectorRequest$1, UpdateConnectorRequest$1>;
+
+/**
+ * Maps trueforge-ui model-settings calls onto Harness
+ *
+ * UI: flat `apiKey` / model `id`. Harness: `auth.apiKey` / `modelId`.
+ * Provider `id` in the UI is the Harness resource `name`.
+ */
+
+/** Custom-form rows omit properties; catalog rows round-trip them. */
+type UiModelEntry = ModelEntry$1 & {
+    properties?: TrueForgeApi.ModelProperties;
+};
+type UiModelProvider = ModelProviderBase$1<UiModelEntry>;
+type UiModelProviderCatalogEntry = ModelProviderCatalogEntry$1<UiModelEntry>;
+declare function toUiModelProvider(provider: TrueForgeApi.ModelProvider): UiModelProvider;
+declare function toUiCatalogModelProviderEntry(provider: TrueForgeApi.CatalogModelProvider): UiModelProviderCatalogEntry;
+declare function toHarnessModelProvider(req: {
+    type: string;
+    name: string;
+    apiKey: string;
+    baseUrl?: string;
+    models: UiModelEntry[];
+}): TrueForgeApi.ModelProvider;
+/** Settings model-catalog port for `createTrueFoundryServer`. Delete is omitted (no BE route). */
+declare function createModelProviderCatalog(client: TrueForge): ModelCatalogServer$1<UiModelEntry, UiModelProvider, UiModelProviderCatalogEntry, CreateModelProviderRequest$1<UiModelEntry>, UpdateModelProviderRequest$1<UiModelEntry>>;
+
+/**
+ * Maps trueforge-ui sandbox-settings calls onto Harness
+ * `/api/v1/settings/sandbox-providers` (singleton upsert, no delete).
+ *
+ * UI: multi-row providers with `id` / `catalogId` / `name` / flat `apiKey`.
+ * Harness: one Daytona provider per tenant; catalog YAML has no name — synthetic
+ * identity uses `type` (`daytona`) as id/catalogId and display name `Daytona`.
+ */
+
+type UiSandboxProvider = SandboxProviderBase;
+declare function configFromHarness(provider: TrueForgeApi.CatalogDaytonaSandboxProvider | TrueForgeApi.SandboxProviderManifest): SandboxProviderConfig;
+declare function toUiSandboxProvider(provider: TrueForgeApi.SandboxProviderManifest): UiSandboxProvider;
+declare function toHarnessManifest$1(req: {
+    type: string;
+    apiKey: string;
+} & Omit<SandboxProviderConfig, 'snapshotName'>): TrueForgeApi.SandboxProviderManifest;
+/** Settings sandbox-catalog port for `createTrueFoundryServer`. Delete omitted (no BE route). */
+declare function createSandboxProviderCatalog(client: TrueForge): SandboxCatalogServer$1;
+
+/**
+ * Maps trueforge-ui skill-settings calls onto Harness
+ *
+ * UI: `repoURL` / skill `id` / optional `catalogId`.
+ * Harness: `url` / resource `name` (no separate id or catalogId on wire).
+ * For now UI `id = name`; registry link uses `catalogId = name` when the
+ * configured skill name matches a catalog preset.
+ */
+
+type UiSkill = DefinedSkill;
+declare function toHarnessManifest(req: SkillConfigBase$1): TrueForgeApi.SkillManifest;
+declare function toUiSkill(skill: TrueForgeApi.SkillManifest, catalogNames: ReadonlySet<string>): UiSkill;
+/** Settings skill-catalog port for `createTrueFoundryServer`. Delete omitted (no BE route). */
+declare function createSkillCatalog(client: TrueForge): SkillCatalogServer$1<UiSkill>;
+
+/**
+ * Harness `AgentChatServer` adapter for @truefoundry/trueforge-ui.
+ *
+ * Runtime contract: opaque mounts (`object`), flat `ListResult` (`data` +
+ * `nextPageToken`), and `null` normalized to absent. Harness keys MCP mounts by
+ * name and returns `null` for optional fields — the maps below bridge both.
+ *
+ * Skills are name refs on the wire (`SkillNameRef`).
+ *
+ * Session create takes `{ name }` or `{ spec }`; reads carry the
+ * `reference`/`inline` discriminator, with reference rows already naming their
+ * agent. The UI filters with registry `agentId`.
+ */
+
+type CreateHarnessChatServerOptions = CreateTrueForgeClientOptions & {
+    /** Injected client — skips creating one from options. */
+    client?: TrueForge;
+};
+/** Drop UI draft `id` before admission; Harness MCP mounts are name-keyed. */
+declare function toHarnessAgentSpec(spec: HarnessAgentSpec): TrueForgeApi.AgentSpec;
+declare function toUiAgentSpec(spec: TrueForgeApi.AgentSpec): HarnessAgentSpec;
+declare function createHarnessChatServer(options?: CreateHarnessChatServerOptions): AgentChatServer<HarnessAgentSpec>;
+
+/**
+ * Configured-resource list helpers for composer pickers and host boot.
+ * Not the settings catalog ports (`catalogs/*`).
+ */
+
+declare function listModels(client: TrueForge): Promise<TrueForgeApi.Model[]>;
+declare function listConfiguredMcpServers(client: TrueForge): Promise<TrueForgeApi.McpServerReadEntry[]>;
+declare function listSkills(client: TrueForge): Promise<TrueForgeApi.SkillReadEntry[]>;
+declare function getCapabilities(client: TrueForge): Promise<TrueForgeApi.GetCapabilitiesResponseData>;
+
+type CreateTrueForgeAgentUIServerOptions = CreateTrueForgeClientOptions & {
+    /** Override the default Harness settings catalogs. */
+    catalog?: CatalogServer;
+};
+/**
+ * Compose chat + builder + default settings catalogs into an `AgentUIServer`.
+ */
+declare function createTrueForgeAgentUIServer(options?: CreateTrueForgeAgentUIServerOptions): TrueFoundryServer<HarnessAgentSpec, ModelSelection, _truefoundry_assistant_ui_runtime.SkillSelectorEntry, _truefoundry_assistant_ui_runtime.ConnectorSelectorEntry, _truefoundry_assistant_ui_runtime.AgentSelectorEntry, SaveAgentResult, CatalogServer<ModelCatalogServer<ModelEntry, ModelProviderBase<ModelEntry>, ModelProviderCatalogEntry<ModelEntry>, CreateModelProviderRequest<ModelEntry>, UpdateModelProviderRequest<ModelEntry>>, ConnectorCatalogServer<ToolBase, ConnectorAuth, ConnectorAuthPublic, ConnectorBase<ConnectorAuthPublic>, ConnectorCatalogEntry<ConnectorAuthPublic>, CreateConnectorRequest<ConnectorAuth>, UpdateConnectorRequest<ConnectorAuth>>, SkillCatalogServer<SkillBase, SkillCatalogEntry, CreateSkillRequest>, SandboxCatalogServer<_truefoundry_assistant_ui_runtime.SandboxBase, _truefoundry_assistant_ui_runtime.SandboxCatalogEntry, _truefoundry_assistant_ui_runtime.CreateSandboxRequest, _truefoundry_assistant_ui_runtime.UpdateSandboxRequest>>, AgentBuilderCapabilitiesResponse>;
+
+export { type CreateHarnessBuilderServerOptions, type CreateHarnessChatServerOptions, type CreateTrueForgeAgentUIServerOptions, type CreateTrueForgeClientOptions, type HarnessAgentSpec, type HarnessMcpServerMount, type HarnessSkillMount, configFromHarness, createConnectorCatalog, createHarnessBuilderServer, createHarnessChatServer, createModelProviderCatalog, createSandboxProviderCatalog, createSkillCatalog, createTrueForgeAgentUIServer, createTrueForgeClient, getCapabilities, listConfiguredMcpServers, listModels, listSkills, modelProviderLogosByName, toHarnessAgentSpec, toHarnessAuth, toHarnessManifest$2 as toHarnessConnectorManifest, toHarnessModelProvider, toHarnessManifest$1 as toHarnessSandboxManifest, toHarnessManifest as toHarnessSkillManifest, toModelSelection, toUiAgentSpec, toUiCatalogModelProviderEntry, toUiConnector, toUiConnectorFromReadEntry, toUiModelProvider, toUiSandboxProvider, toUiSkill };