@truefoundry/assistant-ui-runtime 0.1.6-rc.0 → 0.1.7

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

@@ -4,18 +4,61 @@ import { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/privat
 import type { AgentDraftSession } from "truefoundry-gateway-sdk/agents/private";
 import type {
     AgentChatServer,
-    AgentSpec,
     ListResult,
-    Session,
-    Turn,
     TurnInputItem,
     PreviousTurnIdInput,
+    UpdateSessionRequest,
 } from "../../server/types.js";
 import type {
+    SessionEventItem,
     TurnEvent,
     TurnStreamData,
-    SessionEventItem,
 } from "../../server/events.js";
+import type {
+    TfyAgentSpec,
+    TfyCreateSessionRequest,
+    TfyListSessionsParams,
+    TfySession,
+    TfyTurn,
+    TfyTurnState,
+} from "./types.js";
+
+export {
+    type TfyAgentSpec,
+    type TfySkillMount,
+    type TfyMcpServerMount,
+    type TfyModelParams,
+    type TfyRuntimeConfig,
+    type TfyResponseFormat,
+    type TfySubject,
+    type ToolsSelectorItem,
+    type ToolsSelectorTag,
+    type RequireApprovalToolSelectorItem,
+    type RequireApprovalToolsSelectorTag,
+    type TfyTurn,
+    type TfyTurnState,
+    type TfyTurnCancelledReason,
+    type TfyTurnStateDoneOutput,
+    type TfySession,
+    type TfyCreateSessionRequest,
+    type TfyListSessionsParams,
+    type TfyToolInfo,
+    type TfySystemToolInfo,
+    type TfyMcpToolInfo,
+    type TfyModelMessageUsage,
+    type TfyFinishReason,
+    type TfyThreadState,
+    type TfyMcpServerInitInfo,
+} from "./types.js";
+
+export {
+    isTfyToolInfo,
+    isTfySystemToolInfo,
+    isTfyMcpToolInfo,
+    getTfyUsage,
+    getTfyThreadState,
+    getTfyMcpInitServers,
+} from "./guards.js";
 
 type GwSession = AgentSession | AgentDraftSession;
 
@@ -28,26 +71,51 @@ export type CreateTrueFoundryChatServerOptions = {
     deleteSession?: (req: { sessionId: string }) => Promise<void>;
 };
 
-export type TrueFoundryChatServer = AgentChatServer & {
-    /** Escape hatch for hosts that still need raw gateway clients. */
-    getGatewayClients(): {
-        client: AgentSessionClient;
-        privateClient: PrivateAgentSessionClient;
+/**
+ * Only the spec is generic. Session/Turn/list-params are the concrete Tfy*
+ * types because the adapter builds them as fixed object literals — a generic
+ * there would type fields that nothing ever populates. The spec is safe: the
+ * gateway SDK serializes with `unrecognizedObjectKeys: "passthrough"`, so
+ * host-added spec fields survive the round trip.
+ */
+export type TrueFoundryChatServer<TSpec extends TfyAgentSpec = TfyAgentSpec> =
+    AgentChatServer<
+        TSpec,
+        TfySession<TSpec>,
+        TfyCreateSessionRequest<TSpec>,
+        TfyListSessionsParams,
+        UpdateSessionRequest<TSpec>,
+        TfyTurn
+    > & {
+        /** Escape hatch for hosts that still need raw gateway clients. */
+        getGatewayClients(): {
+            client: AgentSessionClient;
+            privateClient: PrivateAgentSessionClient;
+        };
     };
-};
+
+/** Gateway SDK errors carry the HTTP status as `statusCode`. */
+function isNotFound(error: unknown): boolean {
+    return (
+        typeof error === "object" &&
+        error !== null &&
+        (error as { statusCode?: unknown }).statusCode === 404
+    );
+}
 
 function isDraft(session: GwSession): session is AgentDraftSession {
     return (session as AgentDraftSession).type === "session/draft";
 }
 
-function toSession(raw: GwSession): Session {
+function toSession<TSpec extends TfyAgentSpec>(raw: GwSession): TfySession<TSpec> {
     const mutable = isDraft(raw);
     return {
         id: raw.id,
         title: raw.title,
         agentName: raw.agentName,
-        ...(mutable ? { agentSpec: raw.agentSpec as AgentSpec } : {}),
+        ...(mutable ? { agentSpec: raw.agentSpec as TSpec } : {}),
         isMutable: mutable,
+        createdBySubject: raw.createdBySubject,
         createdAt: raw.createdAt,
         updatedAt: raw.updatedAt,
     };
@@ -58,15 +126,17 @@ function toTurn(raw: {
     sessionId: string;
     previousTurnId?: string | null;
     input?: TurnInputItem[];
-    state: Turn["state"];
+    state: unknown;
+    createdBySubject: TfyTurn["createdBySubject"];
     createdAt: string;
-}): Turn {
+}): TfyTurn {
     return {
         id: raw.id,
         sessionId: raw.sessionId,
         previousTurnId: raw.previousTurnId,
-        input: raw.input as TurnInputItem[] | undefined,
-        state: raw.state as Turn["state"],
+        input: raw.input,
+        state: raw.state as TfyTurnState,
+        createdBySubject: raw.createdBySubject,
         createdAt: raw.createdAt,
     };
 }
@@ -92,52 +162,94 @@ async function toListResult<TIn, TOut>(
  * Wraps TrueFoundry gateway clients into a flat `AgentChatServer`.
  * Named vs draft routing is fully internal — an in-memory session-type cache
  * (populated by createSession/listSessions) determines which gateway client
- * to call. No try/catch fallback, no double network calls.
+ * to call, falling back to a one-time probe for ids seen only in a URL.
  */
-export function createTrueFoundryChatServer(
+export function createTrueFoundryChatServer<
+    TSpec extends TfyAgentSpec = TfyAgentSpec,
+>(
     opts: CreateTrueFoundryChatServerOptions,
-): TrueFoundryChatServer {
+): TrueFoundryChatServer<TSpec> {
     const gatewayOpts = { apiKey: opts.apiKey, baseUrl: opts.baseUrl };
     const client = opts.client ?? new AgentSessionClient(gatewayOpts);
     const privateClient =
         opts.privateClient ?? new PrivateAgentSessionClient(gatewayOpts);
 
     const sessionTypeCache = new Map<string, boolean>();
+    const sessionTypeProbes = new Map<string, Promise<boolean>>();
 
-    function cacheSessionType(session: Session): void {
+    function cacheSessionType(session: {
+        id: string;
+        isMutable: boolean;
+    }): void {
         sessionTypeCache.set(session.id, session.isMutable);
     }
 
-    function getSessionObj(sessionId: string): Promise<GwSession> {
-        const isMutable = sessionTypeCache.get(sessionId);
-        if (isMutable === true) {
-            return privateClient.getDraftSession({ draftSessionId: sessionId });
+    /**
+     * Resolving a session id straight from a URL (page reload / shared link)
+     * reaches the gateway before createSession or listSessions has cached the
+     * type, so discover it by probing the draft endpoint and falling back to
+     * the conversation endpoint. Concurrent callers share one probe.
+     */
+    async function probeSessionType(sessionId: string): Promise<boolean> {
+        const inflight = sessionTypeProbes.get(sessionId);
+        if (inflight != null) {
+            return inflight;
         }
-        if (isMutable === false) {
-            return client.getSession({ sessionId });
+        const probe = (async () => {
+            try {
+                await privateClient.getDraftSession({ draftSessionId: sessionId });
+                return true;
+            } catch (error) {
+                // Only a miss proves the id isn't a draft. Auth or transient
+                // failures would otherwise be retried as a conversation session
+                // and mislabel a real draft as named.
+                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);
         }
-        throw new Error(
-            `Cannot resolve session "${sessionId}": session type not cached. ` +
-                `Ensure createSession or listSessions was called first.`,
-        );
     }
 
-    const server: TrueFoundryChatServer = {
+    async function getSessionObj(sessionId: string): Promise<GwSession> {
+        const isMutable =
+            sessionTypeCache.get(sessionId) ?? (await probeSessionType(sessionId));
+        return isMutable
+            ? privateClient.getDraftSession({ draftSessionId: sessionId })
+            : client.getSession({ sessionId });
+    }
+
+    const server: TrueFoundryChatServer<TSpec> = {
         async createSession(req) {
             if (req.agentSpec != null) {
                 const draft = await privateClient.createDraftSession({
-                    agentSpec: req.agentSpec as never,
+                    agentSpec: req.agentSpec,
                     ...(req.agentName != null ? { agentName: req.agentName } : {}),
+                    ...(req.tfyMetadata != null
+                        ? { tfyMetadata: req.tfyMetadata }
+                        : {}),
                 });
-                const session = toSession(draft);
+                const session = toSession<TSpec>(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);
+                const session = toSession<TSpec>(named);
                 cacheSessionType(session);
                 return session;
             }
@@ -150,9 +262,10 @@ export function createTrueFoundryChatServer(
                 order: req?.order,
                 pageToken: req?.pageToken,
                 startTimestamp: req?.startTimestamp,
+                endTimestamp: req?.endTimestamp,
                 ...(req?.agentName != null ? { agentName: req.agentName } : {}),
             });
-            const result = await toListResult(page, toSession);
+            const result = await toListResult(page, (s) => toSession<TSpec>(s));
             for (const session of result.data) {
                 cacheSessionType(session);
             }
@@ -161,7 +274,7 @@ export function createTrueFoundryChatServer(
 
         async getSession({ sessionId }) {
             const raw = await getSessionObj(sessionId);
-            const session = toSession(raw);
+            const session = toSession<TSpec>(raw);
             cacheSessionType(session);
             return session;
         },
@@ -174,9 +287,9 @@ export function createTrueFoundryChatServer(
                 );
             }
             if (req.agentSpec != null) {
-                await raw.update({ agentSpec: req.agentSpec as never });
+                await raw.update({ agentSpec: req.agentSpec });
             }
-            return toSession(raw);
+            return toSession<TSpec>(raw);
         },
 
         prepareAndExecuteTurn(req: {
@@ -217,12 +330,13 @@ export function createTrueFoundryChatServer(
             await opts.deleteSession({ sessionId });
         },
 
-        async listTurns({ sessionId, limit, pageToken, order }) {
+        // 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 } : {}),
-                ...(order != null ? { order } : {}),
             });
             return toListResult(page, (turn) => toTurn(turn));
         },

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

@@ -0,0 +1,137 @@
+/**
+ * TrueFoundry-specific type extensions over the runtime's generic bases.
+ *
+ * The runtime defines minimal bases (SkillMount = {id,name}, McpServerMount =
+ * {id,name}, AgentSpec.config = unknown, etc.) that hosts extend via generics.
+ *
+ * This file builds the concrete TrueFoundry types by:
+ *  - Importing the runtime's AgentSpec as the base to extend.
+ *  - Importing concrete sub-types from the gateway SDK namespace rather than
+ *    re-defining them — they're purely gateway concepts.
+ *  - Composing a TfyAgentSpec that satisfies both the runtime's
+ *    `TSpec extends AgentSpec` constraint and the gateway SDK's AgentSpec shape.
+ */
+
+import type {
+    AgentSpec,
+    CreateSessionRequest,
+    ListSessionsParams,
+    Session,
+    Turn,
+    TurnState,
+} from "../../server/types.js";
+import type { TruefoundryGatewayApi } from "truefoundry-gateway-sdk";
+
+// ---------------------------------------------------------------------------
+// Re-exports — gateway sub-types surfaced for host convenience
+// ---------------------------------------------------------------------------
+
+export type TfyRuntimeConfig = TruefoundryGatewayApi.RuntimeConfig;
+export type TfyResponseFormat = TruefoundryGatewayApi.ResponseFormat;
+export type TfyModelParams = TruefoundryGatewayApi.ModelParams;
+export type TfySubject = TruefoundryGatewayApi.Subject;
+
+// ---------------------------------------------------------------------------
+// Tool selector helpers (mirrors gateway SDK enum values)
+// ---------------------------------------------------------------------------
+
+export type ToolsSelectorTag = "@all" | "@read-only";
+export type RequireApprovalToolsSelectorTag = "@all" | "@write" | "@destructive";
+export type ToolsSelectorItem = ToolsSelectorTag | string;
+export type RequireApprovalToolSelectorItem = RequireApprovalToolsSelectorTag | string;
+
+// ---------------------------------------------------------------------------
+// Runtime mount bases — derived from AgentSpec, which the runtime does export
+// (SkillMount / McpServerMount themselves are not part of its public API).
+// ---------------------------------------------------------------------------
+
+type RuntimeSkillMount = NonNullable<NonNullable<AgentSpec["skills"]>[number]>;
+type RuntimeMcpServerMount = NonNullable<NonNullable<AgentSpec["mcpServers"]>[number]>;
+
+// ---------------------------------------------------------------------------
+// Mounts — runtime base + gateway fields (fqn, type, url, tool selectors)
+// ---------------------------------------------------------------------------
+
+// Both gateway types are unions (git vs registry source, inline vs registry
+// server), so these must be intersections — an interface cannot `extends` a
+// union, and doing so silently degrades to the runtime base under skipLibCheck.
+export type TfySkillMount = RuntimeSkillMount & TruefoundryGatewayApi.SkillMount;
+
+export type TfyMcpServerMount = RuntimeMcpServerMount & TruefoundryGatewayApi.McpServer;
+
+// ---------------------------------------------------------------------------
+// AgentSpec — the concrete TrueFoundry agent definition
+// ---------------------------------------------------------------------------
+
+export interface TfyAgentSpec
+    extends AgentSpec<
+        TruefoundryGatewayApi.Model,
+        TfySkillMount,
+        TfyMcpServerMount
+    > {
+    config?: TruefoundryGatewayApi.RuntimeConfig;
+    responseFormat?: TruefoundryGatewayApi.ResponseFormat;
+    messages?: TruefoundryGatewayApi.AgentSpecUserMessage[];
+}
+
+// ---------------------------------------------------------------------------
+// Turn — runtime base narrowed to the gateway's concrete state shapes
+// ---------------------------------------------------------------------------
+
+export type TfyTurnCancelledReason = TruefoundryGatewayApi.TurnStateCancelledReason;
+export type TfyTurnStateDoneOutput = TruefoundryGatewayApi.TurnStateDoneOutput;
+
+type RuntimeTurnStateDone = Extract<TurnState, { status: "done" }>;
+type RuntimeTurnStateCancelled = Extract<TurnState, { status: "cancelled" }>;
+
+/**
+ * The runtime types `output` as `unknown` and `reason` as bare `string`. The
+ * gateway sends a model message and one of four reasons — `cancelled-for-next-turn`
+ * in particular is routine and should not render like a failure.
+ */
+export type TfyTurnState =
+    | Exclude<TurnState, { status: "done" | "cancelled" }>
+    | (Omit<RuntimeTurnStateDone, "output"> & { output?: TfyTurnStateDoneOutput })
+    | (Omit<RuntimeTurnStateCancelled, "reason"> & { reason: TfyTurnCancelledReason });
+
+export interface TfyTurn extends Turn {
+    state: TfyTurnState;
+    createdBySubject: TfySubject;
+}
+
+// ---------------------------------------------------------------------------
+// Session and request params — runtime bases + gateway-only fields
+// ---------------------------------------------------------------------------
+
+export interface TfySession<TSpec extends TfyAgentSpec = TfyAgentSpec>
+    extends Session<TSpec> {
+    createdBySubject: TfySubject;
+}
+
+export interface TfyCreateSessionRequest<TSpec extends TfyAgentSpec = TfyAgentSpec>
+    extends CreateSessionRequest<TSpec> {
+    /** Sent as `x-tfy-metadata`, persisted server-side as `request_metadata`. */
+    tfyMetadata?: string;
+}
+
+export interface TfyListSessionsParams extends ListSessionsParams {
+    /** Inclusive upper bound on `createdAt` (ISO-8601). */
+    endTimestamp?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Event-side types.
+//
+// These do NOT flow through AgentChatServer — its listEvents / listTurnEvents /
+// subscribeToTurn / prepareAndExecuteTurn signatures hardcode the runtime's
+// event types with no generic to override. Hosts narrow at the point of use
+// with the guards in `guards.ts`.
+// ---------------------------------------------------------------------------
+
+export type TfyToolInfo = TruefoundryGatewayApi.ToolInfo;
+export type TfySystemToolInfo = TruefoundryGatewayApi.TrueFoundrySystemToolInfo;
+export type TfyMcpToolInfo = TruefoundryGatewayApi.McpToolInfo;
+export type TfyModelMessageUsage = TruefoundryGatewayApi.ModelMessageUsage;
+export type TfyFinishReason = TruefoundryGatewayApi.FinishReason;
+export type TfyThreadState = TruefoundryGatewayApi.ThreadState;
+export type TfyMcpServerInitInfo = TruefoundryGatewayApi.McpServerInitInfo;

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

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

package/src/server/index.ts

@@ -31,6 +31,29 @@ export type {
     Turn,
     AgentChatServer,
     AgentBuilderServer,
+    ProviderType,
+    ModelEntry,
+    ModelProviderConfigBase,
+    ModelProviderBase,
+    ModelProviderCatalogEntry,
+    CreateModelProviderRequest,
+    UpdateModelProviderRequest,
+    ModelCatalogServer,
+    ToolBase,
+    ConnectorAuthType,
+    ConnectorAuth,
+    ConnectorAuthPublic,
+    ConnectorConfigBase,
+    ConnectorBase,
+    ConnectorCatalogEntry,
+    CreateConnectorRequest,
+    UpdateConnectorRequest,
+    ConnectorCatalogServer,
+    SkillBase,
+    CreateSkillRequest,
+    SkillCatalogServer,
+    CatalogServer,
+    AgentUIServerPort,
 } from "./types.js";
 
 export type {