veryfront 0.1.144 → 0.1.145

package/src/src/internal-agents/session-manager.ts

@@ -1,4 +1,18 @@
 import * as dntShim from "../../_dnt.shims.js";
+import {
+  RunAlreadyExistsError,
+  RunCancelledError,
+  RunNotActiveError,
+  RunResumeSessionManager,
+  type RunResumeSessionManagerOptions,
+  type RunSessionStatus,
+  type SubmitResumeValueOutcome,
+  WaitConflictError,
+  WaitNotPendingError,
+} from "../agent/runtime/resume-session.js";
+
+export { RunNotActiveError };
+
 function stableJsonStringify(value: unknown, depth = 0): string {
   if (depth > 64) {
     return JSON.stringify(value);
@@ -23,77 +37,48 @@ function createToolResultKey(result: unknown, isError: boolean): string {
   return `${isError ? "1" : "0"}:${stableJsonStringify(result)}`;
 }
 
-export class AgentRunCancelledError extends Error {
+export class AgentRunCancelledError extends RunCancelledError {
   constructor(message = "Run cancelled") {
     super(message);
     this.name = "AgentRunCancelledError";
   }
 }
 
-export class AgentRunAlreadyExistsError extends Error {
+export class AgentRunAlreadyExistsError extends RunAlreadyExistsError {
   constructor(runId: string) {
-    super(`Run "${runId}" is already active`);
+    super(runId);
     this.name = "AgentRunAlreadyExistsError";
   }
 }
 
-export class RunNotActiveError extends Error {
-  constructor(runId: string) {
-    super(`Run "${runId}" is not active`);
-    this.name = "RunNotActiveError";
-  }
-}
-
-export class ToolResultNotWaitingError extends Error {
+export class ToolResultNotWaitingError extends WaitNotPendingError {
   constructor(runId: string, toolCallId: string) {
-    super(`Run "${runId}" is not waiting for tool call "${toolCallId}"`);
+    super(runId, toolCallId);
     this.name = "ToolResultNotWaitingError";
   }
 }
 
-export class ToolResultConflictError extends Error {
+export class ToolResultConflictError extends WaitConflictError {
   constructor(runId: string, toolCallId: string) {
-    super(`Conflicting tool result for run "${runId}" and tool call "${toolCallId}"`);
+    super(runId, toolCallId);
     this.name = "ToolResultConflictError";
   }
 }
 
 const DEFAULT_WAITING_FOR_TOOL_TTL_MS = 5 * 60 * 1000;
 const DEFAULT_SESSION_TTL_MS = 15 * 60 * 1000;
-const DEFAULT_MAX_CONCURRENT_SESSIONS = 100;
 const AGENT_RUN_SESSION_MANAGER_GLOBAL_KEY = "__veryfrontAgentRunSessionManager" as const;
 
-type SessionStatus = "running" | "waiting" | "completed" | "cancelled" | "failed";
-
 interface SubmittedToolResult {
   result: unknown;
   isError: boolean;
   key: string;
 }
-
-interface WaitingToolState {
-  toolCallId: string;
-  resolve: (value: SubmittedToolResult) => void;
-  reject: (reason?: unknown) => void;
-}
-
-interface AgentRunSession {
-  runId: string;
-  status: SessionStatus;
-  abortController: AbortController;
-  waitingTool: WaitingToolState | null;
-  submittedResults: Map<string, SubmittedToolResult>;
-  waitingTimeoutId: number | null;
-  sessionTimeoutId: number | null;
-}
-
-export interface SubmitToolResultOutcome {
-  accepted: true;
-  duplicate?: true;
-}
+export type SessionStatus = RunSessionStatus;
+export type SubmitToolResultOutcome = SubmitResumeValueOutcome;
 
 export class AgentRunSessionManager {
-  private readonly sessions = new Map<string, AgentRunSession>();
+  private readonly sessions: RunResumeSessionManager<SubmittedToolResult>;
 
   constructor(
     private readonly options: {
@@ -103,250 +88,91 @@ export class AgentRunSessionManager {
       setTimeoutFn?: typeof dntShim.setTimeout;
       clearTimeoutFn?: typeof clearTimeout;
     } = {},
-  ) {}
-
-  private get waitingForToolTtlMs(): number {
-    return this.options.waitingForToolTtlMs ?? DEFAULT_WAITING_FOR_TOOL_TTL_MS;
-  }
-
-  private get sessionTtlMs(): number | null {
-    return this.options.sessionTtlMs ?? null;
-  }
-
-  private get setTimeoutFn(): typeof dntShim.setTimeout {
-    return this.options.setTimeoutFn ?? dntShim.dntGlobalThis.setTimeout.bind(dntShim.dntGlobalThis);
-  }
-
-  private get clearTimeoutFn(): typeof clearTimeout {
-    return this.options.clearTimeoutFn ?? globalThis.clearTimeout.bind(dntShim.dntGlobalThis);
-  }
-
-  private clearWaitingTimeout(session: AgentRunSession): void {
-    if (session.waitingTimeoutId === null) {
-      return;
-    }
-
-    this.clearTimeoutFn(session.waitingTimeoutId);
-    session.waitingTimeoutId = null;
-  }
-
-  private clearSessionTimeout(session: AgentRunSession): void {
-    if (session.sessionTimeoutId === null) {
-      return;
-    }
-
-    this.clearTimeoutFn(session.sessionTimeoutId);
-    session.sessionTimeoutId = null;
-  }
-
-  private scheduleSessionTimeout(session: AgentRunSession): void {
-    if (this.sessionTtlMs === null) {
-      return;
-    }
-
-    this.clearSessionTimeout(session);
-    session.sessionTimeoutId = this.setTimeoutFn(() => {
-      this.cancelRun(session.runId);
-    }, this.sessionTtlMs) as unknown as number;
-  }
-
-  private scheduleWaitingTimeout(session: AgentRunSession): void {
-    this.clearWaitingTimeout(session);
-    session.waitingTimeoutId = this.setTimeoutFn(() => {
-      this.cancelRun(session.runId);
-    }, this.waitingForToolTtlMs) as unknown as number;
-  }
-
-  private touchSession(session: AgentRunSession): void {
-    if (
-      session.status === "running" || session.status === "waiting"
-    ) {
-      this.scheduleSessionTimeout(session);
-    }
-  }
-
-  private finalizeSession(
-    session: AgentRunSession,
-    status: Exclude<SessionStatus, "running" | "waiting">,
-  ): void {
-    session.status = status;
-    this.clearWaitingTimeout(session);
-    this.clearSessionTimeout(session);
-    session.waitingTool = null;
-    this.sessions.delete(session.runId);
-  }
-
-  private get maxConcurrentSessions(): number {
-    return this.options.maxConcurrentSessions ?? DEFAULT_MAX_CONCURRENT_SESSIONS;
+  ) {
+    const managerOptions: RunResumeSessionManagerOptions<SubmittedToolResult> = {
+      waitingTtlMs: this.options.waitingForToolTtlMs ?? DEFAULT_WAITING_FOR_TOOL_TTL_MS,
+      sessionTtlMs: this.options.sessionTtlMs ?? null,
+      maxConcurrentSessions: this.options.maxConcurrentSessions,
+      setTimeoutFn: this.options.setTimeoutFn,
+      clearTimeoutFn: this.options.clearTimeoutFn,
+      getConflictKey: (value) => value.key,
+    };
+    this.sessions = new RunResumeSessionManager(managerOptions);
   }
 
   startRun(input: { runId: string; threadId: string }): AbortSignal {
-    const existing = this.sessions.get(input.runId);
-    if (existing && (existing.status === "running" || existing.status === "waiting")) {
-      throw new AgentRunAlreadyExistsError(input.runId);
-    }
-
-    if (this.sessions.size >= this.maxConcurrentSessions) {
-      throw new Error(
-        `Maximum concurrent sessions (${this.maxConcurrentSessions}) reached`,
-      );
+    try {
+      return this.sessions.startRun(input);
+    } catch (error) {
+      if (error instanceof RunAlreadyExistsError) {
+        throw new AgentRunAlreadyExistsError(input.runId);
+      }
+      throw error;
     }
-
-    const session: AgentRunSession = {
-      runId: input.runId,
-      status: "running",
-      abortController: new AbortController(),
-      waitingTool: null,
-      submittedResults: new Map(),
-      waitingTimeoutId: null,
-      sessionTimeoutId: null,
-    };
-
-    this.sessions.set(input.runId, session);
-    this.touchSession(session);
-    return session.abortController.signal;
   }
 
   async waitForToolResult(runId: string, toolCallId: string): Promise<{
     result: unknown;
     isError: boolean;
   }> {
-    const session = this.sessions.get(runId);
-    if (!session || session.status === "completed" || session.status === "failed") {
-      throw new RunNotActiveError(runId);
-    }
-
-    if (session.abortController.signal.aborted || session.status === "cancelled") {
-      throw new AgentRunCancelledError();
-    }
-
-    const existingResult = session.submittedResults.get(toolCallId);
-    if (existingResult) {
-      session.status = "running";
-      this.touchSession(session);
-      return { result: existingResult.result, isError: existingResult.isError };
-    }
-
-    if (session.waitingTool && session.waitingTool.toolCallId !== toolCallId) {
-      throw new ToolResultNotWaitingError(runId, toolCallId);
+    try {
+      const value = await this.sessions.waitForSignal(runId, toolCallId);
+      return { result: value.result, isError: value.isError };
+    } catch (error) {
+      if (error instanceof RunCancelledError) {
+        throw new AgentRunCancelledError();
+      }
+      if (error instanceof WaitNotPendingError) {
+        throw new ToolResultNotWaitingError(runId, toolCallId);
+      }
+      throw error;
     }
-
-    session.status = "waiting";
-    this.scheduleWaitingTimeout(session);
-    this.touchSession(session);
-
-    return await new Promise<{ result: unknown; isError: boolean }>((resolve, reject) => {
-      const abortHandler = () => {
-        this.clearWaitingTimeout(session);
-        session.waitingTool = null;
-        session.status = "cancelled";
-        reject(new AgentRunCancelledError());
-      };
-
-      session.abortController.signal.addEventListener("abort", abortHandler, { once: true });
-      session.waitingTool = {
-        toolCallId,
-        resolve: (value) => {
-          session.abortController.signal.removeEventListener("abort", abortHandler);
-          this.clearWaitingTimeout(session);
-          session.waitingTool = null;
-          session.status = "running";
-          this.touchSession(session);
-          resolve({ result: value.result, isError: value.isError });
-        },
-        reject: (reason) => {
-          session.abortController.signal.removeEventListener("abort", abortHandler);
-          this.clearWaitingTimeout(session);
-          session.waitingTool = null;
-          reject(reason);
-        },
-      };
-    });
   }
 
   submitToolResult(
     runId: string,
     input: { toolCallId: string; result: unknown; isError?: boolean },
   ): SubmitToolResultOutcome {
-    const session = this.sessions.get(runId);
-    if (!session) {
-      throw new RunNotActiveError(runId);
-    }
-
     const normalized: SubmittedToolResult = {
       result: input.result,
       isError: Boolean(input.isError),
       key: createToolResultKey(input.result, Boolean(input.isError)),
     };
 
-    const existingResult = session.submittedResults.get(input.toolCallId);
-    if (existingResult) {
-      if (existingResult.key === normalized.key) {
-        return { accepted: true, duplicate: true };
+    try {
+      return this.sessions.submitSignal(runId, {
+        waitKey: input.toolCallId,
+        value: normalized,
+      });
+    } catch (error) {
+      if (error instanceof WaitConflictError) {
+        throw new ToolResultConflictError(runId, input.toolCallId);
       }
-
-      throw new ToolResultConflictError(runId, input.toolCallId);
-    }
-
-    if (
-      session.status === "completed" || session.status === "failed" ||
-      session.status === "cancelled"
-    ) {
-      throw new RunNotActiveError(runId);
-    }
-
-    if (!session.waitingTool || session.waitingTool.toolCallId !== input.toolCallId) {
-      throw new ToolResultNotWaitingError(runId, input.toolCallId);
+      if (error instanceof WaitNotPendingError) {
+        throw new ToolResultNotWaitingError(runId, input.toolCallId);
+      }
+      throw error;
     }
-
-    session.submittedResults.set(input.toolCallId, normalized);
-    this.touchSession(session);
-    session.waitingTool.resolve(normalized);
-    return { accepted: true };
   }
 
   cancelRun(runId: string): boolean {
-    const session = this.sessions.get(runId);
-    if (!session) {
-      return false;
-    }
-
-    if (
-      session.status === "completed" || session.status === "failed" ||
-      session.status === "cancelled"
-    ) {
-      return false;
-    }
-
-    const waitingTool = session.waitingTool;
-    session.abortController.abort(new AgentRunCancelledError());
-    waitingTool?.reject(new AgentRunCancelledError());
-    this.finalizeSession(session, "cancelled");
-    return true;
+    return this.sessions.cancelRun(runId);
   }
 
   completeRun(runId: string): void {
-    const session = this.sessions.get(runId);
-    if (!session) return;
-    this.finalizeSession(session, "completed");
+    this.sessions.completeRun(runId);
   }
 
   failRun(runId: string): void {
-    const session = this.sessions.get(runId);
-    if (!session) return;
-    this.finalizeSession(session, "failed");
+    this.sessions.failRun(runId);
   }
 
   getRunStatus(runId: string): SessionStatus | null {
-    return this.sessions.get(runId)?.status ?? null;
+    return this.sessions.getRunStatus(runId);
   }
 
   reset(): void {
-    for (const session of this.sessions.values()) {
-      this.clearWaitingTimeout(session);
-      this.clearSessionTimeout(session);
-    }
-    this.sessions.clear();
+    this.sessions.reset();
   }
 }
 

package/src/src/mcp/index.ts

@@ -42,3 +42,6 @@ export {
 } from "./registry.js";
 
 export { createMCPServer, type IntegrationLoaderConfig, MCPServer } from "./server.js";
+
+export { formatSSEEvent, formatSSEPrimingEvent, formatSSERetry } from "./sse.js";
+export { SessionManager } from "./session.js";

package/src/src/mcp/server.ts

@@ -13,6 +13,7 @@ import { validateContentType } from "../security/input-validation/limits.js";
 import { VeryfrontError } from "../security/input-validation/errors.js";
 import type { IntegrationRuntimeConfig } from "../integrations/types.js";
 import { logger as baseLogger } from "../utils/index.js";
+import { SessionManager } from "./session.js";
 
 const logger = baseLogger.component("mcp-server");
 
@@ -112,6 +113,7 @@ export class MCPServer {
   private config: MCPServerConfig;
   private integrationLoader?: IntegrationLoaderConfig;
   private integrationsLoaded = false;
+  private sessionManager = new SessionManager();
 
   constructor(config: MCPServerConfig) {
     this.config = config;
@@ -448,21 +450,37 @@ export class MCPServer {
   createHTTPHandler(): (request: dntShim.Request) => Promise<dntShim.Response> {
     return async (request: dntShim.Request) => {
       const requestOrigin = request.headers.get("Origin");
+
+      // CORS preflight
       if (request.method === "OPTIONS") {
         return new dntShim.Response(null, { status: 204, headers: this.getCORSHeaders(requestOrigin) });
       }
 
+      // Origin validation (DNS rebinding protection)
       if (requestOrigin && this.config.cors?.enabled && this.config.cors.origins?.length) {
         if (!this.config.cors.origins.includes(requestOrigin)) {
           return createJSONRPCErrorResponse(403, -32600, "Forbidden: Origin not allowed");
         }
       }
 
+      // Auth check (applies to all methods including DELETE)
       if (this.config.auth?.type && this.config.auth.type !== "none") {
         const authorized = await this.validateAuth(request);
         if (!authorized) return new dntShim.Response("Unauthorized", { status: 401 });
       }
 
+      // DELETE = terminate session
+      if (request.method === "DELETE") {
+        const sessionId = request.headers.get("MCP-Session-Id");
+        if (sessionId) this.sessionManager.terminate(sessionId);
+        return new dntShim.Response(null, { status: 200, headers: this.getCORSHeaders(requestOrigin) });
+      }
+
+      // Only POST allowed for JSON-RPC messages
+      if (request.method !== "POST") {
+        return new dntShim.Response("Method Not Allowed", { status: 405 });
+      }
+
       // Enforce request body size limit (fast path via Content-Length header)
       const contentLength = request.headers.get("content-length");
       if (contentLength && Number(contentLength) > MAX_REQUEST_BODY_SIZE) {
@@ -488,15 +506,41 @@ export class MCPServer {
         return createJSONRPCErrorResponse(400, -32700, "Parse error");
       }
 
-      // Extract end-user identity from request headers for per-user token flows
+      // Session management: initialize creates session, everything else requires it
+      const responseHeaders: Record<string, string> = {
+        ...this.getCORSHeaders(requestOrigin),
+      };
+
+      if (rpcRequest.method === "initialize") {
+        const context = this.extractRequestContext(request);
+        const rpcResponse = await this.handleRequest(rpcRequest, context);
+        const sessionId = this.sessionManager.create();
+        responseHeaders["MCP-Session-Id"] = sessionId;
+        return createJSONResponse(rpcResponse, { headers: responseHeaders });
+      }
+
+      // Post-init: require session ID when sessions are active
+      if (this.sessionManager.size > 0) {
+        const sessionId = request.headers.get("MCP-Session-Id");
+        if (!sessionId) {
+          return createJSONRPCErrorResponse(400, -32600, "Missing MCP-Session-Id header");
+        }
+        if (!this.sessionManager.isValid(sessionId)) {
+          return createJSONRPCErrorResponse(404, -32600, "Session not found or expired");
+        }
+      }
+
+      // Notifications have no id member — return 202 Accepted
+      // Note: id:0 is a valid request ID per JSON-RPC 2.0, so check for undefined
+      if (rpcRequest.id === undefined) {
+        const context = this.extractRequestContext(request);
+        await this.handleRequest(rpcRequest, context);
+        return new dntShim.Response(null, { status: 202, headers: responseHeaders });
+      }
+
       const context = this.extractRequestContext(request);
       const rpcResponse = await this.handleRequest(rpcRequest, context);
-
-      return createJSONResponse(rpcResponse, {
-        headers: {
-          ...this.getCORSHeaders(requestOrigin),
-        },
-      });
+      return createJSONResponse(rpcResponse, { headers: responseHeaders });
     };
   }
 
@@ -553,8 +597,9 @@ export class MCPServer {
 
     return {
       "Access-Control-Allow-Origin": matchedOrigin,
-      "Access-Control-Allow-Methods": "POST, OPTIONS",
-      "Access-Control-Allow-Headers": "Content-Type, Authorization, X-End-User-Id, X-Project-Id",
+      "Access-Control-Allow-Methods": "POST, GET, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers":
+        "Content-Type, Authorization, MCP-Session-Id, X-End-User-Id, X-Project-Id",
       "Vary": "Origin",
     };
   }

package/src/src/mcp/session.ts

@@ -0,0 +1,31 @@
+/**
+ * Manages MCP sessions for the Streamable HTTP transport.
+ * Sessions are created during initialization and validated on subsequent requests.
+ */
+import * as dntShim from "../../_dnt.shims.js";
+
+export class SessionManager {
+  private sessions = new Set<string>();
+
+  create(): string {
+    const id = dntShim.crypto.randomUUID();
+    this.sessions.add(id);
+    return id;
+  }
+
+  isValid(id: string): boolean {
+    return this.sessions.has(id);
+  }
+
+  terminate(id: string): void {
+    this.sessions.delete(id);
+  }
+
+  get size(): number {
+    return this.sessions.size;
+  }
+
+  clear(): void {
+    this.sessions.clear();
+  }
+}

package/src/src/mcp/sse.ts

@@ -0,0 +1,19 @@
+/**
+ * Stateless SSE formatting utilities per the Server-Sent Events standard.
+ * Used by the Streamable HTTP transport for MCP.
+ */
+
+export function formatSSEEvent(data: unknown, id?: string): string {
+  let event = "";
+  if (id) event += `id: ${id}\n`;
+  event += `data: ${JSON.stringify(data)}\n\n`;
+  return event;
+}
+
+export function formatSSERetry(ms: number): string {
+  return `retry: ${ms}\n\n`;
+}
+
+export function formatSSEPrimingEvent(id: string): string {
+  return `id: ${id}\ndata: \n\n`;
+}

package/src/src/platform/cloud/resolver.ts

@@ -2,6 +2,7 @@ import { getRuntimeConfig, isRuntimeConfigInitialized } from "../../config/index
 import { getApiBaseUrlEnv } from "../../config/env.js";
 import { getCurrentRequestContext } from "../adapters/fs/veryfront/multi-project-adapter.js";
 import { getEnv } from "../compat/process.js";
+import { getCurrentVeryfrontCloudContext } from "../../provider/veryfront-cloud/context.js";
 
 export const DEFAULT_VERYFRONT_CLOUD_MODEL = "veryfront-cloud/anthropic/claude-sonnet-4-6";
 export const DEFAULT_VERYFRONT_CLOUD_EMBEDDING_MODEL =
@@ -39,19 +40,28 @@ function normalizeCloudModelString(value: string | undefined, fallback: string):
   return resolved.startsWith("veryfront-cloud/") ? resolved : `veryfront-cloud/${resolved}`;
 }
 
+function normalizeServiceLayer(value: string | undefined): string | undefined {
+  const normalized = value?.trim().toLowerCase();
+  return normalized?.length ? normalized : undefined;
+}
+
 function getResolvedVeryfrontCloudContext(): Omit<VeryfrontCloudBootstrap, "apiBaseUrl"> {
   const requestContext = getCurrentRequestContext();
+  const scopedContext = getCurrentVeryfrontCloudContext();
   const runtimeBootstrap = getRuntimeBootstrap();
 
   return {
     apiToken: requestContext?.token ??
+      scopedContext?.apiToken ??
       getEnv("VERYFRONT_API_TOKEN") ??
       runtimeBootstrap.apiToken,
     projectSlug: requestContext?.projectSlug ??
+      scopedContext?.projectSlug ??
       getEnv("VERYFRONT_PROJECT_SLUG") ??
       runtimeBootstrap.projectSlug,
-    serviceLayer: getEnv("VERYFRONT_SERVICE_LAYER")?.trim().toLowerCase(),
-    hasRequestContext: requestContext !== null,
+    serviceLayer: normalizeServiceLayer(scopedContext?.serviceLayer) ??
+      normalizeServiceLayer(getEnv("VERYFRONT_SERVICE_LAYER")),
+    hasRequestContext: requestContext !== null || scopedContext !== undefined,
     usesVeryfrontFs: runtimeBootstrap.usesVeryfrontFs,
   };
 }
@@ -65,8 +75,10 @@ export function getVeryfrontCloudProjectSlug(): string | undefined {
 }
 
 export function getVeryfrontCloudBootstrap(): VeryfrontCloudBootstrap {
+  const scopedContext = getCurrentVeryfrontCloudContext();
+
   return {
-    apiBaseUrl: getApiBaseUrlEnv(),
+    apiBaseUrl: scopedContext?.apiBaseUrl?.trim() || getApiBaseUrlEnv(),
     ...getResolvedVeryfrontCloudContext(),
   };
 }

package/src/src/provider/index.ts

@@ -28,3 +28,8 @@ export {
   resolveModel,
 } from "./model-registry.js";
 export type { ModelProviderFactory } from "./model-registry.js";
+export {
+  runWithVeryfrontCloudContext,
+  runWithVeryfrontCloudContextAsync,
+} from "./veryfront-cloud/context.js";
+export type { VeryfrontCloudContext } from "./veryfront-cloud/context.js";

package/src/src/provider/veryfront-cloud/context.ts

@@ -0,0 +1,28 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export interface VeryfrontCloudContext {
+  apiBaseUrl?: string;
+  apiToken?: string;
+  projectSlug?: string;
+  serviceLayer?: string;
+}
+
+const veryfrontCloudContextStorage = new AsyncLocalStorage<VeryfrontCloudContext>();
+
+export function runWithVeryfrontCloudContext<T>(
+  context: VeryfrontCloudContext,
+  fn: () => T,
+): T {
+  return veryfrontCloudContextStorage.run(context, fn);
+}
+
+export function runWithVeryfrontCloudContextAsync<T>(
+  context: VeryfrontCloudContext,
+  fn: () => Promise<T>,
+): Promise<T> {
+  return veryfrontCloudContextStorage.run(context, fn);
+}
+
+export function getCurrentVeryfrontCloudContext(): VeryfrontCloudContext | undefined {
+  return veryfrontCloudContextStorage.getStore();
+}

package/src/src/tool/index.ts

@@ -45,10 +45,18 @@
 import "../../_dnt.polyfills.js";
 
 
-export type { Tool, ToolConfig, ToolDefinition, ToolExecutionContext } from "./types.js";
+export type {
+  RemoteToolSource,
+  Tool,
+  ToolConfig,
+  ToolDefinition,
+  ToolExecutionContext,
+} from "./types.js";
 
 export { dynamicTool, tool } from "./factory.js";
 export type { DynamicToolConfig } from "./factory.js";
+export { createRemoteMCPToolSource } from "./remote-mcp.js";
+export type { RemoteMCPToolSourceConfig } from "./remote-mcp.js";
 
 export { toolRegistry } from "./registry.js";