veryfront 0.1.159 → 0.1.162

package/src/src/mcp/server.ts

@@ -9,18 +9,14 @@ import type { MCPServerConfig, ToolListEntry } from "./types.js";
 import { createError, toError } from "../errors/veryfront-error.js";
 import { withSpan } from "../observability/tracing/otlp-setup.js";
 import { VERSION } from "../utils/version.js";
-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 { createMCPHTTPHandler } from "./http-transport.js";
 import { SessionManager } from "./session.js";
 import { TaskStore } from "./task-store.js";
 
 const logger = baseLogger.component("mcp-server");
-
-const MAX_REQUEST_BODY_SIZE = 1_048_576; // 1 MB
 const MAX_CONTEXT_HEADER_LENGTH = 255;
-const JSON_CONTENT_TYPE = "application/json";
 const END_USER_ID_PATTERN = /^[a-zA-Z0-9._@-]+$/;
 const PROJECT_ID_PATTERN = /^[a-zA-Z0-9._-]+$/;
 
@@ -55,23 +51,6 @@ function toParamsRecord(params: JSONRPCParams | undefined): Record<string, unkno
   return params;
 }
 
-function createJSONResponse(body: unknown, init?: dntShim.ResponseInit): dntShim.Response {
-  const headers = new dntShim.Headers(init?.headers);
-  headers.set("Content-Type", JSON_CONTENT_TYPE);
-  return new dntShim.Response(JSON.stringify(body), { ...init, headers });
-}
-
-function createJSONRPCErrorResponse(status: number, code: number, message: string): dntShim.Response {
-  return createJSONResponse(
-    {
-      jsonrpc: "2.0",
-      id: null,
-      error: { code, message },
-    },
-    { status },
-  );
-}
-
 function readAllowedHeader(
   request: dntShim.Request,
   headerName: string,
@@ -628,107 +607,20 @@ 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);
-          this.sessionCapabilities.delete(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) {
-        return createJSONRPCErrorResponse(413, -32600, "Request body too large");
-      }
-
-      try {
-        validateContentType(request, JSON_CONTENT_TYPE);
-      } catch (error) {
-        const message = error instanceof VeryfrontError ? error.message : "Invalid Content-Type";
-        return createJSONRPCErrorResponse(400, -32700, message);
-      }
-
-      let rpcRequest: JSONRPCRequest;
-      try {
-        const bodyText = await request.text();
-        if (bodyText.length > MAX_REQUEST_BODY_SIZE) {
-          return createJSONRPCErrorResponse(413, -32600, "Request body too large");
-        }
-        rpcRequest = JSON.parse(bodyText) as JSONRPCRequest;
-      } catch (_) {
-        // expected: malformed JSON in request body
-        return createJSONRPCErrorResponse(400, -32700, "Parse error");
-      }
-
-      // 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 clientCaps =
-          toParamsRecord(rpcRequest.params).capabilities as Record<string, unknown> ??
-            {};
-        const sessionId = this.sessionManager.create();
-        this.sessionCapabilities.set(sessionId, clientCaps);
-        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: responseHeaders });
-    };
+    return createMCPHTTPHandler({
+      authEnabled: Boolean(this.config.auth?.type && this.config.auth.type !== "none"),
+      getCORSHeaders: (requestOrigin) => this.getCORSHeaders(requestOrigin),
+      validateAuth: (request) => this.validateAuth(request),
+      handleRequest: (request, context) => this.handleRequest(request, context),
+      extractRequestContext: (request) => this.extractRequestContext(request),
+      isOriginAllowed: (requestOrigin) =>
+        !requestOrigin ||
+        !this.config.cors?.enabled ||
+        !this.config.cors.origins?.length ||
+        this.config.cors.origins.includes(requestOrigin),
+      sessionCapabilities: this.sessionCapabilities,
+      sessionManager: this.sessionManager,
+    });
   }
 
   private extractRequestContext(request: dntShim.Request): ToolExecutionContext | undefined {

package/src/src/platform/adapters/fs/veryfront/base-operations.ts

@@ -1,7 +1,7 @@
 import type { VeryfrontApiClient } from "../../veryfront-api-client/index.js";
 import { FileCache } from "../cache/file-cache.js";
+import type { ContentContextProvider } from "./file-list-access.js";
 import { PathNormalizer } from "./path-normalizer.js";
-import type { ContentContextProvider } from "./read-operations.js";
 
 export class VeryfrontOperationsBase {
   constructor(

package/src/src/platform/adapters/fs/veryfront/directory-operations.ts

@@ -2,13 +2,9 @@ import { logger as baseLogger } from "../../../../utils/index.js";
 import type { DirectoryEntry } from "./types.js";
 import type { ProjectFile } from "../../veryfront-api-client/index.js";
 import { VeryfrontOperationsBase } from "./base-operations.js";
-import {
-  buildDirCacheKeyPrefix,
-  buildFileCacheKeyPrefix,
-  buildFileListCacheKey,
-} from "./cache-keys.js";
+import { buildDirCacheKeyPrefix } from "./cache-keys.js";
+import { loadAllProjectFiles } from "./file-list-access.js";
 import { withSpan } from "../../../../observability/tracing/otlp-setup.js";
-import { withRetryOnTransient } from "./retry.js";
 
 const logger = baseLogger.component("directory-operations");
 
@@ -154,74 +150,13 @@ export class DirectoryOperations extends VeryfrontOperationsBase {
   }
 
   private getAllFilesRaw(): Promise<ProjectFile[]> {
-    return withSpan("fs.veryfront.getAllFilesRaw", async () => {
-      const cacheStart = performance.now();
-      const ctx = this.contextProvider?.getContentContext();
-      const cacheKeyPrefix = buildFileCacheKeyPrefix(ctx);
-      const skipPersistentCache =
-        this.contextProvider?.isPersistentCacheInvalidated?.(cacheKeyPrefix) ?? false;
-
-      const adapterFiles = !skipPersistentCache
-        ? await this.contextProvider?.getFileList?.()
-        : undefined;
-
-      if (adapterFiles) {
-        const cacheMs = Math.round(performance.now() - cacheStart);
-        logger.debug("getAllFilesRaw - from adapter cache", {
-          cacheMs,
-          fileCount: adapterFiles.length,
-        });
-        return adapterFiles as ProjectFile[];
-      }
-
-      const cacheKey = buildFileListCacheKey(ctx);
-
-      if (skipPersistentCache) {
-        logger.debug("getAllFilesRaw - skipping persistent cache", {
-          cacheKey,
-          cacheKeyPrefix,
-        });
-      }
-
-      const cached = skipPersistentCache
-        ? undefined
-        : await this.cache.getAsync<ProjectFile[]>(cacheKey);
-
-      const cacheMs = Math.round(performance.now() - cacheStart);
-      if (cached) {
-        logger.debug("getAllFilesRaw - fallback cache HIT", {
-          cacheKey,
-          cacheMs,
-          fileCount: cached.length,
-        });
-        return cached;
-      }
-
-      logger.warn("getAllFilesRaw - cache MISS, fetching from API", {
-        cacheKey,
-        cacheMs,
-      });
-
-      const isPublished = ctx?.sourceType !== "branch";
-      logger.debug("Fetching files from API", {
-        sourceType: ctx?.sourceType,
-        cacheKey,
-      });
-
-      const files = await withRetryOnTransient(
-        () =>
-          isPublished
-            ? this.client.listPublishedFiles(
-              undefined,
-              ctx?.releaseId ?? undefined,
-              ctx?.environmentName ?? undefined,
-            )
-            : this.client.listAllFiles(),
-        "getAllFilesRaw (dir)",
-      );
-
-      this.cache.set(cacheKey, files);
-      return files;
-    });
+    return withSpan("fs.veryfront.getAllFilesRaw", () =>
+      loadAllProjectFiles({
+        client: this.client,
+        cache: this.cache,
+        contextProvider: this.contextProvider,
+        logger,
+        operationLabel: "dir",
+      }));
   }
 }

package/src/src/platform/adapters/fs/veryfront/file-list-access.ts

@@ -0,0 +1,109 @@
+import type { ProjectFile, VeryfrontApiClient } from "../../veryfront-api-client/index.js";
+import { FileCache } from "../cache/file-cache.js";
+import { buildFileCacheKeyPrefix, buildFileListCacheKey } from "./cache-keys.js";
+import { withRetryOnTransient } from "./retry.js";
+import type { ResolvedContentContext } from "./types.js";
+
+export interface ContentContextProvider {
+  isProductionMode: () => boolean;
+  getReleaseId: () => string | null;
+  getContentContext: () => ResolvedContentContext | null;
+  getFileList?: () => Promise<
+    Array<{
+      id?: string;
+      path: string;
+      content?: string;
+      type?: string;
+      size?: number;
+      updated_at?: string;
+    }> | undefined
+  >;
+  hasCachedFileList?: () => Promise<boolean>;
+  isPersistentCacheInvalidated?: (prefix: string) => boolean;
+  isReleaseBeingInvalidated?: (releaseId: string) => boolean;
+}
+
+interface FileListLogger {
+  debug(message: string, context?: Record<string, unknown>): void;
+  warn(message: string, context?: Record<string, unknown>): void;
+}
+
+interface LoadAllProjectFilesOptions {
+  client: VeryfrontApiClient;
+  cache: FileCache;
+  contextProvider?: ContentContextProvider;
+  logger: FileListLogger;
+  operationLabel: string;
+}
+
+export async function loadAllProjectFiles({
+  client,
+  cache,
+  contextProvider,
+  logger,
+  operationLabel,
+}: LoadAllProjectFilesOptions): Promise<ProjectFile[]> {
+  const cacheStart = performance.now();
+  const ctx = contextProvider?.getContentContext();
+  const cacheKeyPrefix = buildFileCacheKeyPrefix(ctx);
+  const skipPersistentCache = contextProvider?.isPersistentCacheInvalidated?.(cacheKeyPrefix) ??
+    false;
+
+  const adapterFiles = !skipPersistentCache ? await contextProvider?.getFileList?.() : undefined;
+
+  if (adapterFiles) {
+    const cacheMs = Math.round(performance.now() - cacheStart);
+    logger.debug("getAllFilesRaw - from adapter cache", {
+      cacheMs,
+      fileCount: adapterFiles.length,
+    });
+    return adapterFiles as ProjectFile[];
+  }
+
+  const cacheKey = buildFileListCacheKey(ctx);
+
+  if (skipPersistentCache) {
+    logger.debug("getAllFilesRaw - skipping persistent cache", {
+      cacheKey,
+      cacheKeyPrefix,
+    });
+  }
+
+  const cached = skipPersistentCache ? undefined : await cache.getAsync<ProjectFile[]>(cacheKey);
+  const cacheMs = Math.round(performance.now() - cacheStart);
+
+  if (cached) {
+    logger.debug("getAllFilesRaw - fallback cache HIT", {
+      cacheKey,
+      cacheMs,
+      fileCount: cached.length,
+    });
+    return cached;
+  }
+
+  logger.warn("getAllFilesRaw - cache MISS, fetching from API", {
+    cacheKey,
+    cacheMs,
+  });
+
+  const isPublished = ctx?.sourceType !== "branch";
+  logger.debug("Fetching files from API", {
+    sourceType: ctx?.sourceType,
+    cacheKey,
+  });
+
+  const files = await withRetryOnTransient(
+    () =>
+      isPublished
+        ? client.listPublishedFiles(
+          undefined,
+          ctx?.releaseId ?? undefined,
+          ctx?.environmentName ?? undefined,
+        )
+        : client.listAllFiles(),
+    `getAllFilesRaw (${operationLabel})`,
+  );
+
+  cache.set(cacheKey, files);
+  return files;
+}

package/src/src/platform/adapters/fs/veryfront/read-operations.ts

@@ -7,6 +7,7 @@ import { FileListIndex, type FileListMatchResult } from "./file-list-index.js";
 import { InFlightRequestDeduper } from "./in-flight-dedupe.js";
 import { getRequestScopedFile, setRequestScopedFile } from "./multi-project-adapter.js";
 import { PathNormalizer } from "./path-normalizer.js";
+import type { ContentContextProvider } from "./file-list-access.js";
 import {
   assertProjectSourcePath,
   buildExtensionCandidatePaths,
@@ -28,28 +29,6 @@ export {
 
 const logger = baseLogger.component("read-operations");
 
-export interface ContentContextProvider {
-  isProductionMode: () => boolean;
-  getReleaseId: () => string | null;
-  getContentContext: () => ResolvedContentContext | null;
-  /** Cached file list from adapter initialization (single source of truth) */
-  getFileList?: () => Promise<
-    Array<{
-      id?: string;
-      path: string;
-      content?: string;
-      type?: string;
-      size?: number;
-      updated_at?: string;
-    }> | undefined
-  >;
-  hasCachedFileList?: () => Promise<boolean>;
-  /** True if cache prefix is being deleted - skip persistent cache reads */
-  isPersistentCacheInvalidated?: (prefix: string) => boolean;
-  /** Back-compat: release-scoped invalidation */
-  isReleaseBeingInvalidated?: (releaseId: string) => boolean;
-}
-
 const IN_FLIGHT_REQUEST_TIMEOUT_MS = 15_000;
 const MAX_IN_FLIGHT_REQUESTS = 100;
 const IN_FLIGHT_CLEANUP_INTERVAL_MS = 1_000;

package/src/src/platform/adapters/fs/veryfront/stat-operations.ts

@@ -4,12 +4,7 @@ import type { FileInfo, ResolveFileOptions } from "../../base.js";
 import type { ProjectFile } from "../../veryfront-api-client/index.js";
 import { VeryfrontOperationsBase } from "./base-operations.js";
 import { createError, toError } from "../../../../errors/index.js";
-import {
-  buildFileCacheKeyPrefix,
-  buildFileListCacheKey,
-  buildStatCacheKeyPrefix,
-} from "./cache-keys.js";
-import { withRetryOnTransient } from "./retry.js";
+import { buildStatCacheKeyPrefix } from "./cache-keys.js";
 import { STAT_OPERATION_EXTENSION_PRIORITY as EXTENSION_PRIORITY } from "./extension-priority.js";
 import {
   collectParentDirectories,
@@ -21,6 +16,7 @@ import {
 } from "./stat-operations-helpers.js";
 import { ApiSearchCircuitBreaker } from "./api-search-circuit-breaker.js";
 import { withSpan } from "../../../../observability/tracing/otlp-setup.js";
+import { loadAllProjectFiles } from "./file-list-access.js";
 
 const logger = baseLogger.component("stat-operations");
 
@@ -258,77 +254,19 @@ export class StatOperations extends VeryfrontOperationsBase {
   }
 
   private async getAllFilesRaw(): Promise<ProjectFile[]> {
-    const cacheStart = performance.now();
-    const ctx = this.contextProvider?.getContentContext();
-    const cacheKeyPrefix = buildFileCacheKeyPrefix(ctx);
-    const skipPersistentCache =
-      this.contextProvider?.isPersistentCacheInvalidated?.(cacheKeyPrefix) ?? false;
-
-    if (!skipPersistentCache) {
-      const files = await this.contextProvider?.getFileList?.();
-      if (files) {
-        const cacheMs = Math.round(performance.now() - cacheStart);
-        logger.debug("getAllFilesRaw - from adapter cache", {
-          cacheMs,
-          fileCount: files.length,
-        });
-        return files as ProjectFile[];
-      }
-    }
-
-    const cacheKey = buildFileListCacheKey(ctx);
-
-    if (skipPersistentCache) {
-      logger.debug("getAllFilesRaw - skipping persistent cache (invalidation)", {
-        cacheKey,
-        cacheKeyPrefix,
-      });
-    }
-
-    const cached = skipPersistentCache
-      ? undefined
-      : await this.cache.getAsync<ProjectFile[]>(cacheKey);
-    const cacheMs = Math.round(performance.now() - cacheStart);
-
-    if (cached) {
-      logger.debug("getAllFilesRaw - fallback cache HIT", {
-        cacheKey,
-        cacheMs,
-        fileCount: cached.length,
-      });
-      return cached;
-    }
-
-    logger.warn("getAllFilesRaw - cache MISS, fetching from API", {
-      cacheKey,
-      cacheMs,
+    return await loadAllProjectFiles({
+      client: this.client,
+      cache: this.cache,
+      contextProvider: this.contextProvider,
+      logger,
+      operationLabel: "stat",
     });
-
-    const isPublished = ctx?.sourceType !== "branch";
-    logger.debug("Fetching files from API", {
-      sourceType: ctx?.sourceType,
-      cacheKey,
-    });
-
-    const files = await withRetryOnTransient(
-      () =>
-        isPublished
-          ? this.client.listPublishedFiles(
-            undefined,
-            ctx?.releaseId ?? undefined,
-            ctx?.environmentName ?? undefined,
-          )
-          : this.client.listAllFiles(),
-      "getAllFilesRaw (stat)",
-    );
-
-    this.cache.set(cacheKey, files);
-    return files;
   }
 
   private buildResolveSearchPatterns(
     normalizedPath: string,
     options?: ResolveFileOptions,
+    knownExtensionFallback: "exact" | "wildcard" = "exact",
   ): string[] {
     const patterns = new Set<string>();
     const pathWithoutExt = stripKnownExtension(normalizedPath, EXTENSION_PRIORITY);
@@ -338,7 +276,9 @@ export class StatOperations extends VeryfrontOperationsBase {
     };
 
     if (EXTENSION_PRIORITY.some((ext) => normalizedPath.endsWith(ext))) {
-      addPattern(normalizedPath);
+      addPattern(
+        knownExtensionFallback === "wildcard" ? `${pathWithoutExt}.*` : normalizedPath,
+      );
       return [...patterns];
     }
 
@@ -366,6 +306,7 @@ export class StatOperations extends VeryfrontOperationsBase {
   private async tryResolveViaApiSearch(
     normalizedPath: string,
     options?: ResolveFileOptions,
+    knownExtensionFallback: "exact" | "wildcard" = "exact",
   ): Promise<string | null | undefined> {
     if (isFrameworkSourcePath(normalizedPath)) {
       logger.debug("Skipping API search for framework path", { normalizedPath });
@@ -377,7 +318,11 @@ export class StatOperations extends VeryfrontOperationsBase {
       return undefined;
     }
 
-    const patterns = this.buildResolveSearchPatterns(normalizedPath, options);
+    const patterns = this.buildResolveSearchPatterns(
+      normalizedPath,
+      options,
+      knownExtensionFallback,
+    );
     let sawSuccessfulSearch = false;
 
     for (const pattern of patterns) {
@@ -573,55 +518,17 @@ export class StatOperations extends VeryfrontOperationsBase {
       return null;
     }
 
-    // NOTE: Removed optimization that skipped API search for paths with extensions.
-    // This was causing layout files and other project files to not be found when
-    // they were missing from the file index (due to cache issues, incomplete fetch, etc.).
-    // The API pattern search is the fallback to ensure files can still be found.
-
-    if (!this.apiSearchCircuitBreaker.canSearch()) {
-      logger.warn("API search circuit breaker open, skipping", { normalizedPath });
-      return null;
+    // NOTE: Keep the post-index API fallback aligned with the pre-index helper for extensionless
+    // paths, while preserving the older wildcard sibling-extension lookup for known-extension
+    // paths. Incomplete file-list snapshots otherwise hide valid files until the cache refreshes.
+    const apiResolved = await this.tryResolveViaApiSearch(normalizedPath, options, "wildcard");
+    if (typeof apiResolved === "string") {
+      this.cache.set(cacheKey, apiResolved);
+      return apiResolved;
     }
-
-    const searchPattern = `${pathWithoutExt}.*`;
-    logger.debug("Searching for file via API", {
-      pattern: searchPattern,
-      normalizedPath,
-    });
-
-    try {
-      const matches = await this.client.searchFiles(searchPattern);
-      this.apiSearchCircuitBreaker.recordSuccess();
-
-      logger.debug("API search result", {
-        pattern: searchPattern,
-        matchCount: matches.length,
-        matches: matches.map((m) => m.path).slice(0, 5),
-      });
-
-      const sortedMatches = sortPathsByExtensionPriority(matches, EXTENSION_PRIORITY);
-      const first = sortedMatches[0];
-      if (first) {
-        logger.debug("resolveFile found via API search", { path: first.path });
-        this.cache.set(cacheKey, first.path);
-        return first.path;
-      }
-    } catch (error) {
-      const result = this.apiSearchCircuitBreaker.recordFailure();
-      if (result.tripped) {
-        logger.warn("API search circuit breaker tripped", {
-          failures: result.failures,
-        });
-      }
-      logger.error("API pattern search failed", { pattern: searchPattern, error });
+    if (apiResolved === null) {
+      this.cache.set(cacheKey, NOT_FOUND_SENTINEL);
     }
-
-    logger.debug("resolveFile not found after API search", {
-      normalizedPath,
-      pathWithoutExt,
-    });
-
-    this.cache.set(cacheKey, NOT_FOUND_SENTINEL);
     return null;
   }
 }

package/src/src/tool/factory.ts

@@ -179,20 +179,18 @@ export interface DynamicToolConfig {
   id?: string;
   description: string;
   inputSchema: unknown;
+  inputSchemaJson?: JsonSchema;
   execute: (input: unknown, context?: ToolExecutionContext) => Promise<unknown> | unknown;
   toModelOutput?: (output: unknown) => unknown;
-  mcp?: {
-    enabled?: boolean;
-    requiresAuth?: boolean;
-    cachePolicy?: "no-cache" | "cache" | "cache-first";
-  };
+  mcp?: ToolConfig["mcp"];
 }
 
 export function dynamicTool(config: DynamicToolConfig): Tool<unknown, unknown> {
   const explicitId = typeof config.id === "string" && config.id.length > 0 ? config.id : undefined;
   const id = explicitId ?? generateToolId();
 
-  const inputSchemaJson = convertSchemaToJson(config.inputSchema, id, "DYNAMIC_TOOL", true);
+  const inputSchemaJson = config.inputSchemaJson ??
+    convertSchemaToJson(config.inputSchema, id, "DYNAMIC_TOOL", true);
 
   const createdTool: Tool<unknown, unknown> = {
     id,

package/src/src/tool/index.ts

@@ -57,6 +57,11 @@ 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 {
+  createToolsFromRemoteDefinitions,
+  loadRemoteToolsFromSource,
+} from "./remote-source-tools.js";
+export type { RemoteToolMaterializationOptions } from "./remote-source-tools.js";
 
 export { toolRegistry } from "./registry.js";