stitchkit 0.37.0 → 0.39.0

package/dist/tools.js

@@ -2,10 +2,10 @@ import {
   inputIsQuery,
   signJwt,
   verifyPkce
-} from "./index-xq45akyd.js";
+} from "./index-92gs1m5b.js";
 import {
   DEFAULT_CORS_ALLOW_HEADERS
-} from "./index-czmqks7r.js";
+} from "./index-6jypn22c.js";
 import {
   assertToolName,
   assertUniqueToolName,
@@ -24,7 +24,7 @@ import {
   readCapped,
   toolResultFromError,
   writeDownload
-} from "./index-s6yhmg1k.js";
+} from "./index-y5scd1cr.js";
 import {
   toJsonSchema
 } from "./index-frfyw9fa.js";
@@ -33,15 +33,63 @@ import {
 } from "./index-x3fcszf8.js";
 import {
   AppError,
-  formatZodError,
   getTraceId,
   isRecord,
   mergeMeta,
+  parseTrailingWildcard,
   typedEntries
-} from "./index-e497hxcy.js";
+} from "./index-fyfk537k.js";
 
 // src/tools/agent.ts
 import { jsonSchema, tool } from "ai";
+
+// src/tools/runtime-tool.ts
+function defineRuntimeTool(definition) {
+  if (definition.transports?.length === 0) {
+    throw new Error(`Runtime tool "${definition.name}" must expose at least one transport`);
+  }
+  return definition;
+}
+function runtimeToolSupports(definition, transport) {
+  if (definition.transports?.length === 0) {
+    throw new Error(`Runtime tool "${definition.name}" must expose at least one transport`);
+  }
+  return !definition.transports || definition.transports.includes(transport);
+}
+function runtimeToolIdentity(definition) {
+  return {
+    method: definition.identity.method,
+    desc: definition.description,
+    serviceName: definition.identity.serviceName,
+    key: definition.identity.action,
+    toolName: definition.name,
+    scope: definition.identity.scope,
+    meta: definition.identity.meta,
+    annotations: definition.annotations,
+    ui: definition.ui
+  };
+}
+function runtimeToolMountable(definition) {
+  assertToolName(definition.name, definition.identity.serviceName, definition.identity.action);
+  const method = {
+    ...runtimeToolIdentity(definition),
+    inputSchema: definition.input,
+    outputSchema: definition.output,
+    handler: definition.handler
+  };
+  return {
+    method,
+    name: definition.name,
+    argumentSchema: definition.input,
+    presentationSchema: buildToolPresentationSchema({
+      inputSchema: definition.input,
+      unrepresentable: "any"
+    }),
+    shouldExtend: false
+  };
+}
+
+// src/tools/agent.ts
 function mountAgent(services, config = {}) {
   const serviceList = Array.isArray(services) ? services : [services];
   const tools = {};
@@ -80,8 +128,88 @@ function mountAgent(services, config = {}) {
       });
     }
   }
+  for (const definition of config.runtimeTools ?? []) {
+    if (!runtimeToolSupports(definition, "AGENT"))
+      continue;
+    const mountable = runtimeToolMountable(definition);
+    assertUniqueToolName(definition.name, Object.hasOwn(tools, definition.name), "agent tool name");
+    const inputSchema = jsonSchema(mountable.presentationSchema, {
+      validate: async (value) => isRecord(value) ? { success: true, value } : { success: false, error: new Error("Tool arguments must be an object") }
+    });
+    const execute = async (rawArgs) => {
+      const args = isRecord(rawArgs) ? rawArgs : {};
+      try {
+        const result = await runTool(mountable, args);
+        if (result.ok)
+          return result.data;
+        return formatToolError(result, mountable.name, config.errorHint);
+      } catch (err) {
+        return formatToolError(toolResultFromError(err), mountable.name, config.errorHint);
+      }
+    };
+    if (definition.present?.agent) {
+      const presenter = definition.present.agent;
+      const output = definition.output;
+      tools[definition.name] = tool({
+        description: definition.description,
+        inputSchema,
+        outputSchema: output,
+        execute,
+        toModelOutput: async ({ output: rawOutput }) => {
+          const parsed = output.safeParse(rawOutput);
+          if (!parsed.success) {
+            return { type: "text", value: JSON.stringify(rawOutput) };
+          }
+          return presenter(parsed.data);
+        }
+      });
+    } else {
+      tools[definition.name] = tool({
+        description: definition.description,
+        inputSchema,
+        ...definition.output && { outputSchema: definition.output },
+        execute
+      });
+    }
+  }
   return tools;
 }
+// src/tools/invoker.ts
+function createToolInvoker(services, config) {
+  const serviceList = Array.isArray(services) ? services : [services];
+  const tools = new Map;
+  for (const service of serviceList) {
+    for (const tool2 of collectTools(service, config.transport, {
+      extend: config.extend,
+      flattenUnionInput: config.flattenUnionInput
+    })) {
+      assertUniqueToolName(tool2.name, tools.has(tool2.name), "in-process tool name");
+      tools.set(tool2.name, tool2);
+    }
+  }
+  const names = Object.freeze([...tools.keys()].sort());
+  const runTool = createToolRunner({
+    source: config.source ?? "internal",
+    context: config.context,
+    hooks: config.hooks,
+    lifecycle: config.lifecycle,
+    extend: config.extend,
+    coerceJsonArgs: config.coerceJsonArgs,
+    onOutputStrip: config.onOutputStrip
+  });
+  return Object.freeze({
+    names,
+    invoke(name, args) {
+      const tool2 = tools.get(name);
+      if (!tool2) {
+        throw new AppError("NOT_FOUND", `Unknown tool: ${name}`, 404, {
+          available: names
+        });
+      }
+      return runTool(tool2, args);
+    }
+  });
+}
 // src/tools/list-names.ts
 var TOOL_TRANSPORTS = ["MCP", "AGENT", "CLI"];
 function listToolNames(services) {
@@ -142,72 +270,21 @@ function inlineMcpAppBundle(html) {
 // src/tools/native-mcp.ts
 import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
-function operationIdentity(definition) {
-  return {
-    method: definition.identity.method,
-    desc: definition.description,
-    serviceName: definition.identity.serviceName,
-    key: definition.identity.action,
-    toolName: definition.name,
-    scope: definition.identity.scope,
-    meta: definition.identity.meta,
-    annotations: definition.annotations,
-    ui: definition.ui
-  };
-}
 function isCallToolResult(value) {
   return CallToolResultSchema.safeParse(value).success;
 }
-function nativeResultSchema(output) {
-  const envelope = z.custom(isCallToolResult, {
-    error: "Native MCP handler must return a valid CallToolResult"
-  });
-  if (!output)
-    return envelope;
-  return envelope.transform((result, context) => {
-    const parsed = output.safeParse(result.structuredContent);
-    if (!parsed.success) {
-      context.addIssue({
-        code: "custom",
-        message: `Invalid structuredContent: ${formatZodError(parsed.error)}`
-      });
-      return z.NEVER;
-    }
-    return { ...result, structuredContent: parsed.data };
-  });
-}
 function createNativeMcpRegistrar(server, config) {
   return {
     rawServer: server,
     registerTool: (definition) => {
-      const identity = operationIdentity(definition);
-      const advertisedOperation = {
-        ...identity,
-        inputSchema: definition.input,
-        outputSchema: definition.output,
-        handler: () => {
-          return;
-        }
-      };
-      const mountable = {
-        method: advertisedOperation,
-        name: definition.name,
-        argumentSchema: definition.input,
-        presentationSchema: buildToolPresentationSchema({
-          inputSchema: definition.input,
-          unrepresentable: "any"
-        }),
-        shouldExtend: false
-      };
+      if (!runtimeToolSupports(definition, "MCP"))
+        return;
+      assertUniqueToolName(definition.name, config.takenNames.has(definition.name), "MCP tool name");
+      config.takenNames.add(definition.name);
+      const mountable = runtimeToolMountable(definition);
       const [prepared] = config.prepare(mountable);
       if (!prepared)
         return;
-      const executionOperation = {
-        ...identity,
-        inputSchema: definition.input,
-        outputSchema: nativeResultSchema(definition.output),
-        handler: definition.handler
-      };
       const toolConfig = {
         description: definition.description,
         inputSchema: z.looseObject({}).meta(presentationMetadata(prepared.inputSchema))
@@ -224,16 +301,32 @@ function createNativeMcpRegistrar(server, config) {
       }
       server.registerTool(definition.name, toolConfig, async (rawArgs) => {
         const args = isRecord(rawArgs) ? rawArgs : {};
-        const result = await executeToolMethod(executionOperation, definition.name, args, { ...config.context, source: "mcp" }, config.hooks, config.lifecycle, config.coerceJsonArgs ?? true, config.onOutputStrip ? (paths) => config.onOutputStrip?.(definition.name, paths) : undefined);
-        if (!result.ok)
-          return config.formatError(result, definition.name);
-        if (isCallToolResult(result.data))
-          return result.data;
-        return config.formatError({
+        const result = await executeToolMethod(mountable.method, definition.name, args, { ...config.context, source: "mcp" }, config.hooks, config.lifecycle, config.coerceJsonArgs ?? true, config.onOutputStrip ? (paths) => config.onOutputStrip?.(definition.name, paths) : undefined);
+        if (!result.ok || !definition.present?.mcp) {
+          return config.formatResult(result, prepared.outputMode, definition.name);
+        }
+        const presented = await definition.present.mcp(result.data);
+        if ("structuredContent" in presented || "isError" in presented) {
+          return config.formatResult({
+            ok: false,
+            code: "INTERNAL_SERVER_ERROR",
+            details: {
+              message: "Runtime MCP presenter cannot set framework-owned structuredContent or isError"
+            }
+          }, "none", definition.name);
+        }
+        const structured = config.formatResult(result, prepared.outputMode, definition.name).structuredContent;
+        const response = {
+          ...presented,
+          ...structured && { structuredContent: structured }
+        };
+        if (isCallToolResult(response))
+          return response;
+        return config.formatResult({
           ok: false,
           code: "INTERNAL_SERVER_ERROR",
-          details: { message: "Native MCP handler returned an invalid result" }
-        }, definition.name);
+          details: { message: "Runtime MCP presenter returned an invalid CallToolResult" }
+        }, "none", definition.name);
       });
     }
   };
@@ -606,17 +699,19 @@ function buildMcpServerFromPrepared(config, auth, prepared) {
     onOutputStrip: config.onOutputStrip
   });
   if (config.nativeTools) {
+    const takenNames = new Set(prepared.map((tool2) => tool2.mountable.name));
     const registrar = createNativeMcpRegistrar(server, {
       context,
       hooks: config.hooks,
       lifecycle: config.lifecycle,
       coerceJsonArgs: config.coerceJsonArgs,
       onOutputStrip: config.onOutputStrip,
+      takenNames,
       prepare: (tool2) => prepareMcpTools([tool2], {
         schemaValidation: config.schemaValidation,
         logger: config.logger
       }),
-      formatError: (result, toolName) => formatMcpResult(result, "none", toolName, config.errorHint)
+      formatResult: (result, mode, toolName) => formatMcpResult(result, mode, toolName, config.errorHint)
     });
     config.nativeTools(registrar, auth);
   }
@@ -1235,6 +1330,119 @@ function appendFormFields(formData, values, skipKeys) {
   }
 }
 
+// src/browser/client-url.ts
+function isParamArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string" || typeof item === "number");
+}
+function collectQueryParams(args, endpoint) {
+  const params = {};
+  let hasParams = false;
+  for (const [key, value] of Object.entries(args)) {
+    if (value === undefined || value === null)
+      continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || isParamArray(value)) {
+      params[key] = value;
+      hasParams = true;
+      continue;
+    }
+    const what = Array.isArray(value) ? "an array with non-primitive items" : typeof value === "object" ? "a nested object" : `a ${typeof value}`;
+    throw new Error(`${endpoint.method} ${endpoint.path}: input field "${key}" is ${what} — it cannot ` + "travel as a query parameter. GET / DELETE input must be flat (string / number / " + "boolean, or an array of string / number); flatten the field or move the " + "operation to a body verb (POST).");
+  }
+  return hasParams ? params : undefined;
+}
+function hasStringKeys(args, keys) {
+  for (const key of keys) {
+    if (typeof args[key] !== "string")
+      return false;
+  }
+  return true;
+}
+function resolvePathPrefix(config, args) {
+  if (!config?.pathPrefix)
+    return "";
+  if (typeof config.pathPrefix === "string")
+    return config.pathPrefix;
+  const keys = config.stripPrefixKeys ?? [];
+  if (!hasStringKeys(args, keys)) {
+    const missing = keys.find((key) => typeof args[key] !== "string");
+    throw new Error(`Missing path prefix key: ${missing}`);
+  }
+  return config.pathPrefix(args);
+}
+function extractParamNames(path) {
+  const matches = path.match(/:(\w+)/g);
+  const names = matches ? matches.map((match) => match.slice(1)) : [];
+  const wildcard = parseTrailingWildcard(path);
+  if (wildcard)
+    names.push(wildcard.name);
+  return names;
+}
+function fillPathParams(path, args) {
+  const wildcard = parseTrailingWildcard(path);
+  let filled = path.replace(/:(\w+)/g, (_, key) => {
+    const value = args[key];
+    if (value === undefined || value === null) {
+      throw new Error(`Missing path param: ${key}`);
+    }
+    return encodeURIComponent(String(value));
+  });
+  if (!wildcard)
+    return filled;
+  const wildcardValue = args[wildcard.name];
+  if (wildcardValue === undefined || wildcardValue === null) {
+    throw new Error(`Missing path param: ${wildcard.name}`);
+  }
+  const remainder = String(wildcardValue).split("/").map((segment) => encodeURIComponent(segment)).join("/");
+  filled = `${filled.slice(0, -(wildcard.name.length + 1))}${remainder}`;
+  return filled;
+}
+function stripConsumedArgs(args, path, scopeKeys) {
+  const consumed = new Set(scopeKeys);
+  for (const name of extractParamNames(path))
+    consumed.add(name);
+  const remaining = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (!consumed.has(key) && value !== undefined)
+      remaining[key] = value;
+  }
+  return remaining;
+}
+function appendQuery(relativeUrl, params) {
+  if (!params)
+    return relativeUrl;
+  const search = new URLSearchParams;
+  for (const [key, value] of Object.entries(params)) {
+    if (Array.isArray(value)) {
+      for (const item of value)
+        search.append(key, String(item));
+    } else {
+      search.set(key, String(value));
+    }
+  }
+  return search.size > 0 ? `${relativeUrl}?${search}` : relativeUrl;
+}
+function planClientRequest(endpoint, contractPrefix, args, config) {
+  let pathPrefix = resolvePathPrefix(config, args);
+  if (pathPrefix && !pathPrefix.endsWith("/"))
+    pathPrefix += "/";
+  if (pathPrefix.startsWith("/"))
+    pathPrefix = pathPrefix.slice(1);
+  const endpointPath = endpoint.path === "/" ? "" : endpoint.path;
+  let relativeUrl = fillPathParams(`${pathPrefix}${contractPrefix}${endpointPath}`, args);
+  if (relativeUrl.endsWith("/"))
+    relativeUrl = relativeUrl.slice(0, -1);
+  const remainingArgs = stripConsumedArgs(args, endpoint.path, config?.stripPrefixKeys ?? []);
+  if (inputIsQuery(endpoint.method)) {
+    relativeUrl = appendQuery(relativeUrl, collectQueryParams(remainingArgs, endpoint));
+  }
+  return { relativeUrl, remainingArgs };
+}
+function joinClientBaseUrl(baseUrl, relativeUrl) {
+  const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const path = relativeUrl.startsWith("/") ? relativeUrl : `/${relativeUrl}`;
+  return `${base}${path}`;
+}
+
 // src/browser/http.ts
 import ky, { isHTTPError } from "ky";
 class ApiError extends Error {
@@ -1285,25 +1493,6 @@ function withOutput(endpoint, result) {
     return result;
   return result.then((value) => value === undefined ? undefined : schema.parse(value));
 }
-function isParamArray(value) {
-  return Array.isArray(value) && value.every((v) => typeof v === "string" || typeof v === "number");
-}
-function collectQueryParams(args, skipKeys, endpoint) {
-  const params = {};
-  let hasParams = false;
-  for (const [key, value] of Object.entries(args)) {
-    if (skipKeys.has(key) || value === undefined || value === null)
-      continue;
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || isParamArray(value)) {
-      params[key] = value;
-      hasParams = true;
-      continue;
-    }
-    const what = Array.isArray(value) ? "an array with non-primitive items" : typeof value === "object" ? "a nested object" : `a ${typeof value}`;
-    throw new Error(`${endpoint.method} ${endpoint.path}: input field "${key}" is ${what} — it cannot ` + "travel as a query parameter. GET / DELETE input must be flat (string / number / " + "boolean, or an array of string / number); flatten the field or move the " + "operation to a body verb (POST).");
-  }
-  return hasParams ? params : undefined;
-}
 function createClient(contract, configOrClient, contractConfig) {
   const client = {};
   const makeMethod = isHttpAdapter(configOrClient) ? (endpoint) => createHttpMethod(endpoint, contract.meta.prefix, configOrClient, contractConfig) : (endpoint) => createFetchMethod(endpoint, contract.meta.prefix, configOrClient, contractConfig);
@@ -1322,90 +1511,41 @@ function setClientMethod(target, key, method) {
 }
 function createHttpMethod(endpoint, prefix, client, config) {
   const httpMethod = endpoint.method.toLowerCase();
-  const isGet = httpMethod === "get";
-  const paramNames = extractParamNames(endpoint.path);
-  const prefixKeys = new Set([...config?.stripPrefixKeys ?? [], ...paramNames]);
   return (...args) => {
     const firstArg = args[0] ?? {};
-    let pathPrefixStr = "";
-    if (config?.pathPrefix) {
-      pathPrefixStr = typeof config.pathPrefix === "function" ? config.pathPrefix(firstArg) : config.pathPrefix;
-      if (pathPrefixStr && !pathPrefixStr.endsWith("/"))
-        pathPrefixStr += "/";
-    }
-    let url = `${pathPrefixStr}${prefix}${endpoint.path}`;
-    for (const name of paramNames) {
-      const value = firstArg[name];
-      if (value === undefined || value === null) {
-        throw new Error(`Missing path param: ${name}`);
-      }
-      url = url.replace(`:${name}`, encodeURIComponent(String(value)));
-    }
-    if (url.endsWith("/"))
-      url = url.slice(0, -1);
+    const plan = planClientRequest(endpoint, prefix, firstArg, config);
     if (endpoint.multipart) {
       const file = firstArg[endpoint.multipart];
       if (!isMultipartFile(file)) {
         throw new Error(`Missing multipart file field: ${endpoint.multipart}`);
       }
-      if (httpMethod === "get" || httpMethod === "delete") {
+      if (httpMethod === "get" || httpMethod === "head" || httpMethod === "delete") {
         throw new Error(`Multipart endpoint ${endpoint.method} ${endpoint.path} must be POST / PUT / PATCH`);
       }
       const formData = new FormData;
       appendMultipartFile(formData, endpoint.multipart, file);
-      appendFormFields(formData, firstArg, new Set([...prefixKeys, endpoint.multipart]));
-      return withOutput(endpoint, client[httpMethod](url, formData, withTimeout(undefined, endpoint)));
+      appendFormFields(formData, plan.remainingArgs, new Set([endpoint.multipart]));
+      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, formData, withTimeout(undefined, endpoint)));
     }
-    if (isGet) {
-      const params = collectQueryParams(firstArg, prefixKeys, endpoint);
-      return withOutput(endpoint, client.get(url, withTimeout(params ? { params } : undefined, endpoint)));
+    if (httpMethod === "get" || httpMethod === "head") {
+      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, withTimeout(undefined, endpoint)));
     }
     if (httpMethod === "delete") {
-      const params = collectQueryParams(firstArg, prefixKeys, endpoint);
-      return withOutput(endpoint, client.delete(url, withTimeout(params ? { params } : undefined, endpoint)));
-    }
-    const payload = {};
-    for (const [key, value] of Object.entries(firstArg)) {
-      if (!prefixKeys.has(key) && value !== undefined) {
-        payload[key] = value;
-      }
+      return withOutput(endpoint, client.delete(plan.relativeUrl, withTimeout(undefined, endpoint)));
     }
-    return withOutput(endpoint, client[httpMethod](url, Object.keys(payload).length > 0 ? payload : undefined, withTimeout(undefined, endpoint)));
+    return withOutput(endpoint, client[httpMethod](plan.relativeUrl, Object.keys(plan.remainingArgs).length > 0 ? plan.remainingArgs : undefined, withTimeout(undefined, endpoint)));
   };
 }
 function createFetchMethod(endpoint, prefix, config, contractConfig) {
-  const prefixKeys = new Set(contractConfig?.stripPrefixKeys ?? []);
   return async (args) => {
-    let pathPrefixStr = "";
-    if (contractConfig?.pathPrefix) {
-      pathPrefixStr = typeof contractConfig.pathPrefix === "function" ? contractConfig.pathPrefix(args ?? {}) : contractConfig.pathPrefix;
-      if (pathPrefixStr && !pathPrefixStr.endsWith("/"))
-        pathPrefixStr += "/";
-    }
-    let url = buildFetchUrl(config.baseUrl, prefix, endpoint.path, args, pathPrefixStr);
+    const plan = planClientRequest(endpoint, prefix, args ?? {}, contractConfig);
+    const url = joinClientBaseUrl(config.baseUrl, plan.relativeUrl);
     const headers = {
       Accept: "application/json",
       ...typeof config.headers === "function" ? config.headers() : config.headers
     };
     const signal = endpoint.timeout !== undefined ? AbortSignal.timeout(endpoint.timeout) : undefined;
-    const isQuery = inputIsQuery(endpoint.method);
-    const hasBody = !isQuery && !endpoint.multipart && endpoint.input && args;
-    if (isQuery && args) {
-      const remaining = stripParams(args, endpoint.path, prefixKeys);
-      const params = collectQueryParams(remaining, new Set, endpoint);
-      if (params) {
-        const searchParams = new URLSearchParams;
-        for (const [k, v] of Object.entries(params)) {
-          if (Array.isArray(v)) {
-            for (const item of v)
-              searchParams.append(k, String(item));
-          } else {
-            searchParams.set(k, String(v));
-          }
-        }
-        url += `?${searchParams}`;
-      }
-    }
+    const hasBody = endpoint.method !== "GET" && endpoint.method !== "HEAD" && endpoint.method !== "DELETE" && !endpoint.multipart && endpoint.input && args;
     if (hasBody)
       headers["Content-Type"] = "application/json";
     if (endpoint.multipart && args) {
@@ -1415,7 +1555,7 @@ function createFetchMethod(endpoint, prefix, config, contractConfig) {
       }
       const formData = new FormData;
       appendMultipartFile(formData, endpoint.multipart, file);
-      appendFormFields(formData, stripParams(args, endpoint.path, prefixKeys), new Set([endpoint.multipart]));
+      appendFormFields(formData, plan.remainingArgs, new Set([endpoint.multipart]));
       const res2 = await fetch(url, {
         method: endpoint.method,
         headers,
@@ -1439,7 +1579,7 @@ function createFetchMethod(endpoint, prefix, config, contractConfig) {
       credentials: config.credentials,
       signal,
       ...hasBody && {
-        body: JSON.stringify(stripParams(hasBody, endpoint.path, prefixKeys))
+        body: JSON.stringify(plan.remainingArgs)
       }
     });
     if (!res.ok) {
@@ -1462,36 +1602,6 @@ async function throwForErrorResponse(res, config, fallbackBody) {
   }
   throw new ApiError("HTTP_ERROR", res.status, { body });
 }
-function extractParamNames(path) {
-  const matches = path.match(/:(\w+)/g);
-  return matches ? matches.map((m) => m.slice(1)) : [];
-}
-function buildFetchUrl(baseUrl, prefix, path, args, pathPrefix = "") {
-  let fullPath = `/${pathPrefix}${prefix}${path === "/" ? "" : path}`;
-  if (args) {
-    fullPath = fullPath.replace(/:(\w+)/g, (_, key) => {
-      const val = args[key];
-      if (val === undefined || val === null) {
-        throw new Error(`Missing path param: ${key}`);
-      }
-      return encodeURIComponent(String(val));
-    });
-  }
-  return `${baseUrl}${fullPath}`;
-}
-function stripParams(args, path, extra) {
-  const skip = new Set(extra);
-  for (const match of path.matchAll(/:(\w+)/g)) {
-    if (match[1])
-      skip.add(match[1]);
-  }
-  const result = {};
-  for (const [k, v] of Object.entries(args)) {
-    if (!skip.has(k))
-      result[k] = v;
-  }
-  return result;
-}
 
 // src/tools/remote.ts
 var HTTP_ONLY = Object.freeze(["HTTP"]);
@@ -1514,7 +1624,7 @@ function implementRemote(contract, http, options) {
       serviceName: contract.meta.prefix,
       key,
       toolName: "toolName" in endpoint ? endpoint.toolName : undefined,
-      expose: endpoint.rawResponse || endpoint.rawBody ? HTTP_ONLY : endpoint.expose,
+      expose: endpoint.rawResponse || endpoint.rawBody || endpoint.responseMeta ? HTTP_ONLY : endpoint.expose,
       ui: "ui" in endpoint ? endpoint.ui : undefined,
       annotations: "annotations" in endpoint ? endpoint.annotations : undefined,
       meta: mergeMeta(contract.meta.meta, endpoint.meta),
@@ -1527,6 +1637,7 @@ function implementRemote(contract, http, options) {
       idempotent: endpoint.idempotent,
       rawResponse: endpoint.rawResponse,
       rawBody: endpoint.rawBody,
+      responseMeta: endpoint.responseMeta,
       contentType: "contentType" in endpoint ? endpoint.contentType : undefined,
       handler: async (ctx) => {
         const call = client[key];
@@ -1751,8 +1862,10 @@ export {
   flattenToolJsonSchema,
   findUntypedProperties,
   findNonPortableFormats,
+  defineRuntimeTool,
   createToolkit,
   createToolLogger,
+  createToolInvoker,
   createStdioMcpServer,
   createMcpHandler,
   createCli,