stitchkit 0.93.0 → 0.94.1

package/dist/index-3xwxfj4z.js

@@ -1,334 +0,0 @@
-import {
-  createTraceContext,
-  formatTraceparent
-} from "./index-zcgf3gqf.js";
-import {
-  isRecord,
-  transportResult
-} from "./index-77fekveh.js";
-
-// src/browser/http.ts
-import ky, {
-  isHTTPError,
-  isNetworkError,
-  isTimeoutError
-} from "ky";
-
-// src/browser/cancellation.ts
-class RequestCancellationError extends Error {
-  cause;
-  constructor(cause) {
-    super(cause === "caller" ? "Request was aborted" : "Request timed out");
-    this.cause = cause;
-    this.name = "RequestCancellationError";
-  }
-}
-function createRequestCancellation(caller, timeoutMs) {
-  if (!caller && timeoutMs === undefined) {
-    return { signal: undefined, run: (operation) => operation() };
-  }
-  const timeoutController = timeoutMs === undefined ? undefined : new AbortController;
-  const signal = caller && timeoutController ? AbortSignal.any([caller, timeoutController.signal]) : caller ?? timeoutController?.signal;
-  let cause;
-  let timer;
-  const abortFromCaller = () => {
-    if (cause)
-      return;
-    cause = "caller";
-  };
-  if (caller?.aborted)
-    abortFromCaller();
-  else
-    caller?.addEventListener("abort", abortFromCaller, { once: true });
-  if (timeoutMs !== undefined && timeoutController) {
-    timer = setTimeout(() => {
-      if (cause)
-        return;
-      cause = "timeout";
-      timeoutController.abort(new DOMException("Request timed out", "TimeoutError"));
-    }, timeoutMs);
-  }
-  return {
-    signal,
-    async run(operation) {
-      try {
-        if (cause === "caller")
-          throw cancellationError(cause);
-        return await operation(signal);
-      } catch (error) {
-        if (cause)
-          throw cancellationError(cause);
-        throw error;
-      } finally {
-        if (timer !== undefined)
-          clearTimeout(timer);
-        caller?.removeEventListener("abort", abortFromCaller);
-      }
-    }
-  };
-}
-function cancellationError(cause) {
-  return new RequestCancellationError(cause);
-}
-
-// src/browser/request-id.ts
-var REQUEST_ID_HEADER = "x-request-id";
-function responseTraceId(response) {
-  return response?.headers.get(REQUEST_ID_HEADER) ?? undefined;
-}
-
-// src/browser/http.ts
-var API_ERROR_BRAND = Symbol.for("stitchkit.ApiError");
-function messageForCode(code, message) {
-  return message !== undefined && message.length > 0 ? message : `${code} (no message supplied)`;
-}
-
-class ApiError extends Error {
-  code;
-  status;
-  details;
-  hint;
-  traceId;
-  constructor(code, status = 0, details, message, hint, traceId, options) {
-    super(messageForCode(code, message), options);
-    this.code = code;
-    this.status = status;
-    this.details = details;
-    this.hint = hint;
-    this.traceId = traceId;
-    this.name = "ApiError";
-    Object.defineProperty(this, API_ERROR_BRAND, { value: true });
-  }
-  static is(error) {
-    return typeof error === "object" && error !== null && API_ERROR_BRAND in error;
-  }
-}
-function refuseLocally(path, message) {
-  return new ApiError("VALIDATION_ERROR", 0, { issues: [{ path, code: "invalid_type", message }] }, message);
-}
-function isAbortLikeError(error) {
-  if (error instanceof RequestCancellationError)
-    return true;
-  return typeof error === "object" && error !== null && "name" in error && (error.name === "AbortError" || error.name === "TimeoutError");
-}
-function shouldRetryBunNetworkError(error) {
-  if (ApiError.is(error) || isHTTPError(error) || isNetworkError(error) || isTimeoutError(error) || isAbortLikeError(error)) {
-    return;
-  }
-  if (!(error instanceof Error))
-    return;
-  const code = Object.getOwnPropertyDescriptor(error, "code");
-  return code && "value" in code && code.value === "ConnectionRefused" ? true : undefined;
-}
-function parseApiErrorBody(body) {
-  if (!isRecord(body) || !isRecord(body.error))
-    return null;
-  const error = body.error;
-  if (typeof error.code !== "string")
-    return null;
-  return {
-    code: error.code,
-    message: typeof error.message === "string" ? error.message : undefined,
-    details: error.details,
-    hint: typeof error.hint === "string" ? error.hint : undefined
-  };
-}
-function createRetryAwareFetch(transportFetch, unix) {
-  const runtimeFetch = transportFetch;
-  let attempt = 0;
-  return (input, init) => {
-    attempt += 1;
-    if (unix === undefined && attempt === 1) {
-      return runtimeFetch(input, init);
-    }
-    if (!(input instanceof Request)) {
-      if (unix === undefined)
-        return runtimeFetch(input, init);
-      const unixInit = { ...init, unix };
-      return runtimeFetch(input, unixInit);
-    }
-    const streamedBody = input.body ? { body: input.body, duplex: "half" } : {};
-    const materialized = {
-      ...init,
-      ...unix !== undefined && { unix },
-      method: input.method,
-      headers: input.headers,
-      ...streamedBody,
-      cache: input.cache,
-      credentials: input.credentials,
-      integrity: input.integrity,
-      keepalive: input.keepalive,
-      mode: input.mode,
-      redirect: input.redirect,
-      referrer: input.referrer,
-      referrerPolicy: input.referrerPolicy,
-      signal: input.signal
-    };
-    return runtimeFetch(input.url, materialized);
-  };
-}
-function createHttpClient(config) {
-  if (config.fetch && config.unix) {
-    throw new TypeError("HttpClientConfig.fetch and unix are mutually exclusive");
-  }
-  if (config.unix !== undefined) {
-    if (!config.unix.startsWith("/") || config.unix.includes("\x00")) {
-      throw new TypeError("HttpClientConfig.unix must be an absolute Unix socket path");
-    }
-    if (typeof Reflect.get(globalThis, "Bun") !== "object") {
-      throw new TypeError("HttpClientConfig.unix requires Bun; on Bun or Node use createUnixClientTransport().fetch for an explicit portable transport");
-    }
-  }
-  let ssrCookies = null;
-  let isLoggedOut = false;
-  const listeners = new Set;
-  const suppressUnauthorizedFor = config.suppressUnauthorizedFor ?? [];
-  const parseError = config.parseError ?? parseApiErrorBody;
-  function emit(event) {
-    for (const fn of listeners) {
-      try {
-        fn(event);
-      } catch {}
-    }
-  }
-  const client = ky.create({
-    prefix: config.baseUrl,
-    credentials: config.credentials ?? "include",
-    timeout: false,
-    retry: {
-      limit: config.retry?.limit ?? 2,
-      methods: config.retry?.methods ?? ["get"],
-      statusCodes: config.retry?.statusCodes ?? [],
-      shouldRetry: ({ error }) => shouldRetryBunNetworkError(error)
-    },
-    hooks: {
-      beforeRequest: [
-        ({ request: request2 }) => {
-          if (ssrCookies) {
-            request2.headers.set("Cookie", ssrCookies);
-          }
-          const extra = typeof config.headers === "function" ? config.headers() : config.headers;
-          if (extra) {
-            for (const [key, value] of Object.entries(extra)) {
-              request2.headers.set(key, value);
-            }
-          }
-          if (config.trace && !request2.headers.has("traceparent")) {
-            request2.headers.set("traceparent", formatTraceparent(createTraceContext()));
-          }
-        }
-      ],
-      afterResponse: [
-        async ({ request: request2, response }) => {
-          if (config.release) {
-            try {
-              config.release.observe(response.headers.get("x-build-id"));
-            } catch {}
-          }
-          if (response.status === 401) {
-            const url = new URL(request2.url).pathname;
-            if (!isLoggedOut && !suppressUnauthorizedFor.some((matches) => matches(url))) {
-              isLoggedOut = true;
-              emit({ type: "unauthorized" });
-            }
-          }
-          if (!response.ok) {
-            const body = await response.clone().json().catch(() => null);
-            if (body) {
-              const parsed = parseError(body);
-              if (parsed) {
-                throw new ApiError(parsed.code, response.status, parsed.details, parsed.message, parsed.hint, responseTraceId(response));
-              }
-            }
-          }
-        }
-      ]
-    }
-  });
-  async function request(method, url, data, options = {}) {
-    const cancellation = createRequestCancellation(options.signal, options.timeout ?? config.timeout ?? 30000);
-    const kyOptions = {
-      fetch: createRetryAwareFetch(config.fetch ?? globalThis.fetch.bind(globalThis), config.unix),
-      timeout: false,
-      signal: cancellation.signal
-    };
-    if (options.params) {
-      const searchParams = new URLSearchParams;
-      for (const [key, value] of Object.entries(options.params)) {
-        if (value === undefined)
-          continue;
-        if (Array.isArray(value)) {
-          for (const item of value)
-            searchParams.append(key, String(item));
-        } else {
-          searchParams.set(key, String(value));
-        }
-      }
-      if (searchParams.size > 0) {
-        kyOptions.searchParams = searchParams;
-      }
-    }
-    if (data instanceof FormData) {
-      kyOptions.body = data;
-    } else if (data !== undefined) {
-      kyOptions.json = data;
-    }
-    try {
-      return await cancellation.run(async () => {
-        if (options.responseType === "blob") {
-          return transportResult(await client[method](url, kyOptions).blob());
-        }
-        if (options.responseType === "response") {
-          return transportResult(await client[method](url, kyOptions));
-        }
-        const response = await client[method](url, kyOptions);
-        if (options.responseType === "void") {
-          const text = await response.text();
-          if (text.length > 0) {
-            throw new Error("Server returned data for an endpoint with no output contract");
-          }
-        }
-        if (options.responseType === "void" || response.status === 204 || response.headers.get("content-length") === "0") {
-          return transportResult(undefined);
-        }
-        return await response.json();
-      });
-    } catch (error) {
-      if (error instanceof RequestCancellationError) {
-        throw new ApiError(error.cause === "caller" ? "REQUEST_ABORTED" : "REQUEST_TIMEOUT", 0, undefined, error.message);
-      }
-      if (ApiError.is(error))
-        throw error;
-      emit({ type: "network_error" });
-      const response = isHTTPError(error) ? error.response : undefined;
-      const status = response?.status ?? 0;
-      const msg = error instanceof Error ? error.message : undefined;
-      throw new ApiError("UNKNOWN_ERROR", status, msg ? { message: msg } : undefined, msg, undefined, responseTraceId(response), { cause: error });
-    }
-  }
-  return {
-    baseUrl: config.baseUrl,
-    get: (url, options) => request("get", url, undefined, options),
-    head: (url, options) => request("head", url, undefined, options),
-    post: (url, data, options) => request("post", url, data, options),
-    put: (url, data, options) => request("put", url, data, options),
-    patch: (url, data, options) => request("patch", url, data, options),
-    delete: (url, options) => request("delete", url, undefined, options),
-    setServerContext(cookies) {
-      ssrCookies = cookies;
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    logout() {
-      isLoggedOut = true;
-      emit({ type: "logout" });
-    },
-    resetLogoutState() {
-      isLoggedOut = false;
-    }
-  };
-}
-
-export { RequestCancellationError, createRequestCancellation, responseTraceId, ApiError, refuseLocally, isAbortLikeError, parseApiErrorBody, createHttpClient };

package/dist/index-4fpa9dy2.js

@@ -1,51 +0,0 @@
-// src/tools/async-operation-contract.ts
-import { z } from "zod";
-var AsyncOperationCancelResultSchema = z.discriminatedUnion("outcome", [
-  z.object({ outcome: z.literal("accepted") }),
-  z.object({ outcome: z.literal("already_terminal") }),
-  z.object({ outcome: z.literal("rejected"), reason: z.string().min(1) })
-]);
-function createAsyncOperationSnapshotSchema(config) {
-  const progress = config.progress ? { progress: config.progress.optional() } : {};
-  return z.discriminatedUnion("phase", [
-    z.object({ phase: z.literal("pending"), ...progress }),
-    z.object({ phase: z.literal("running"), ...progress }),
-    z.object({ phase: z.literal("succeeded"), ...progress }),
-    z.object({ phase: z.literal("failed"), failure: config.failure, ...progress }),
-    z.object({ phase: z.literal("cancelled"), ...progress })
-  ]);
-}
-// src/tools/view-file-contract.ts
-import { z as z2 } from "zod";
-var MAX_VIEW_FILES = 20;
-var McpAnnotationsSchema = z2.object({
-  audience: z2.array(z2.enum(["user", "assistant"])).optional(),
-  priority: z2.number().optional()
-});
-var McpMediaContentSchema = z2.discriminatedUnion("type", [
-  z2.object({ type: z2.literal("text"), text: z2.string() }),
-  z2.object({
-    type: z2.literal("image"),
-    data: z2.string(),
-    mimeType: z2.string(),
-    annotations: McpAnnotationsSchema.optional()
-  }),
-  z2.object({
-    type: z2.literal("audio"),
-    data: z2.string(),
-    mimeType: z2.string(),
-    annotations: McpAnnotationsSchema.optional()
-  })
-]);
-var ViewFileErrorSchema = z2.object({
-  path: z2.string(),
-  message: z2.string()
-});
-var ViewFileOutputSchema = z2.object({
-  content: z2.array(McpMediaContentSchema),
-  errors: z2.array(ViewFileErrorSchema)
-});
-var ViewFileInputSchema = z2.object({
-  paths: z2.union([z2.string(), z2.array(z2.string()).max(MAX_VIEW_FILES)]).describe("Media URL(s) or file path(s) to view")
-});
-export { AsyncOperationCancelResultSchema, createAsyncOperationSnapshotSchema, McpAnnotationsSchema, McpMediaContentSchema, ViewFileErrorSchema, ViewFileOutputSchema, ViewFileInputSchema };

package/dist/index-6kyksz9y.js

@@ -1,268 +0,0 @@
-import {
-  isUnsafeKey
-} from "./index-kzfs85xp.js";
-import {
-  isRecord
-} from "./index-77fekveh.js";
-
-// src/observability/sanitize.ts
-var SENSITIVE_WORDS = new Set([
-  "password",
-  "passwords",
-  "passwd",
-  "pwd",
-  "secret",
-  "secrets",
-  "token",
-  "tokens",
-  "apikey",
-  "auth",
-  "authorization",
-  "bearer",
-  "cookie",
-  "cookies",
-  "credential",
-  "credentials"
-]);
-var SENSITIVE_WORD_PAIRS = new Set([
-  "apikey",
-  "privatekey",
-  "initdata",
-  "sessionid",
-  "sessionkey"
-]);
-var SENSITIVE_EXACT = new Set(["session"]);
-function splitKeyWords(key) {
-  return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length > 0);
-}
-function isSensitiveKeyDefault(key) {
-  const words = splitKeyWords(key);
-  if (words.length === 1 && SENSITIVE_EXACT.has(words[0] ?? ""))
-    return true;
-  for (let index = 0;index < words.length; index += 1) {
-    const word = words[index] ?? "";
-    if (SENSITIVE_WORDS.has(word))
-      return true;
-    const next = words[index + 1];
-    if (next !== undefined && SENSITIVE_WORD_PAIRS.has(word + next))
-      return true;
-  }
-  return false;
-}
-var DEFAULT_MAX_BYTES = 16000;
-var DEFAULT_MAX_DEPTH = 20;
-var DEFAULT_MAX_NODES = 20000;
-var MASK = "[redacted]";
-function redact(value, options = {}) {
-  const custom = options.sensitiveKeys;
-  const isSensitive = custom === undefined ? isSensitiveKeyDefault : (key) => {
-    custom.lastIndex = 0;
-    return custom.test(key) || options.includeDefaultSensitiveKeys === true && isSensitiveKeyDefault(key);
-  };
-  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
-  const maxStringLength = options.maxStringLength ?? Number.POSITIVE_INFINITY;
-  const maxCollectionLength = options.maxCollectionLength ?? Number.POSITIVE_INFINITY;
-  const pathMatchers = (options.sensitivePaths ?? []).map((pattern) => pattern.split("."));
-  const matchesPath = (matcher, path, patternIndex = 0, pathIndex = 0) => {
-    if (patternIndex === matcher.length)
-      return pathIndex === path.length;
-    const segment = matcher[patternIndex];
-    if (segment === "**") {
-      if (patternIndex + 1 === matcher.length)
-        return true;
-      for (let next = pathIndex;next <= path.length; next += 1) {
-        if (matchesPath(matcher, path, patternIndex + 1, next))
-          return true;
-      }
-      return false;
-    }
-    if (pathIndex === path.length || segment !== "*" && segment !== path[pathIndex])
-      return false;
-    return matchesPath(matcher, path, patternIndex + 1, pathIndex + 1);
-  };
-  const isSensitivePath = (path) => pathMatchers.some((matcher) => matchesPath(matcher, path));
-  const stringBoundFor = (key) => {
-    const byKey = key === undefined ? undefined : options.maxStringLengthByKey?.[key];
-    return byKey ?? maxStringLength;
-  };
-  const safeString = (input, key) => {
-    const bound = stringBoundFor(key);
-    let output = input;
-    for (const pattern of options.sensitiveUrlPatterns ?? []) {
-      try {
-        const global = new RegExp(pattern.source, `${pattern.flags.replace(/[gy]/g, "")}g`);
-        output = output.replace(global, MASK);
-      } catch {}
-    }
-    if (output.length <= bound)
-      return output;
-    return `${output.slice(0, Math.max(0, bound))}…[truncated]`;
-  };
-  const ancestors = new Set;
-  const maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
-  let visited = 0;
-  const walk = (input, depth, path = []) => {
-    if (depth > maxDepth)
-      return "[max depth]";
-    visited += 1;
-    if (visited > maxNodes)
-      return "[node budget]";
-    if (input === null || input === undefined)
-      return null;
-    if (typeof input === "string")
-      return safeString(input, path[path.length - 1]);
-    if (typeof input === "number" || typeof input === "boolean") {
-      return input;
-    }
-    if (input instanceof Uint8Array || input instanceof ArrayBuffer) {
-      return { _type: "binary", size: input.byteLength };
-    }
-    if (input instanceof Blob) {
-      return { _type: "blob", size: input.size, mime: input.type };
-    }
-    if (typeof FormData !== "undefined" && input instanceof FormData) {
-      return { _type: "formdata", keys: [...input.keys()] };
-    }
-    if (input instanceof Map) {
-      if (ancestors.has(input))
-        return "[circular]";
-      ancestors.add(input);
-      const entries = [...input.entries()];
-      const result = entries.slice(0, maxCollectionLength).map(([key, value2]) => {
-        const segment = typeof key === "string" ? key : String(key);
-        const childPath = [...path, segment];
-        return [
-          walk(key, depth + 1, [...path, "[key]"]),
-          typeof key === "string" && isSensitive(key) || isSensitivePath(childPath) ? MASK : walk(value2, depth + 1, childPath)
-        ];
-      });
-      if (entries.length > maxCollectionLength)
-        result.push(["[truncated]", entries.length - maxCollectionLength]);
-      ancestors.delete(input);
-      return { _type: "map", entries: result };
-    }
-    if (input instanceof Set) {
-      if (ancestors.has(input))
-        return "[circular]";
-      ancestors.add(input);
-      const entries = [...input];
-      const values = entries.slice(0, maxCollectionLength).map((item, index) => walk(item, depth + 1, [...path, String(index)]));
-      if (entries.length > maxCollectionLength)
-        values.push(`[truncated ${entries.length - maxCollectionLength} items]`);
-      ancestors.delete(input);
-      return { _type: "set", values };
-    }
-    if (input instanceof Date) {
-      return Number.isNaN(input.getTime()) ? "[invalid date]" : input.toISOString();
-    }
-    if (input instanceof URL)
-      return safeString(input.href);
-    if (input instanceof Error) {
-      const property = (name) => {
-        try {
-          return Reflect.get(input, name);
-        } catch {
-          return "[unreadable]";
-        }
-      };
-      const stack = property("stack");
-      const cause = property("cause");
-      return {
-        _type: "error",
-        name: safeString(String(property("name")), "name"),
-        message: safeString(String(property("message")), "message"),
-        ...stack !== undefined && { stack: safeString(String(stack), "stack") },
-        ...cause !== undefined && { cause: walk(cause, depth + 1, [...path, "cause"]) }
-      };
-    }
-    if (Array.isArray(input)) {
-      if (ancestors.has(input))
-        return "[circular]";
-      ancestors.add(input);
-      const result = [];
-      const count = Math.min(input.length, maxCollectionLength);
-      for (let index = 0;index < count; index += 1) {
-        try {
-          result.push(walk(Reflect.get(input, index), depth + 1, [...path, String(index)]));
-        } catch {
-          result.push("[unreadable]");
-        }
-      }
-      if (input.length > maxCollectionLength)
-        result.push(`[truncated ${input.length - maxCollectionLength} items]`);
-      ancestors.delete(input);
-      return result;
-    }
-    if (isRecord(input)) {
-      if (ancestors.has(input))
-        return "[circular]";
-      ancestors.add(input);
-      const out = {};
-      const keys = Object.keys(input);
-      for (const key of keys.slice(0, maxCollectionLength)) {
-        if (isUnsafeKey(key))
-          continue;
-        const childPath = [...path, key];
-        if (isSensitive(key) || isSensitivePath(childPath)) {
-          out[key] = MASK;
-          continue;
-        }
-        try {
-          out[key] = walk(Reflect.get(input, key), depth + 1, childPath);
-        } catch {
-          out[key] = "[unreadable]";
-        }
-      }
-      if (keys.length > maxCollectionLength)
-        out["[truncated]"] = keys.length - maxCollectionLength;
-      ancestors.delete(input);
-      return out;
-    }
-    return String(input);
-  };
-  return walk(value, 0);
-}
-function truncatePreview(value, maxBytes = DEFAULT_MAX_BYTES) {
-  const json = JSON.stringify(value);
-  const bytes = new TextEncoder().encode(json);
-  if (bytes.byteLength <= maxBytes)
-    return value;
-  let end = Math.max(0, maxBytes);
-  while (end > 0 && ((bytes[end] ?? 0) & 192) === 128)
-    end -= 1;
-  const preview = new TextDecoder().decode(bytes.subarray(0, end));
-  return {
-    _truncated: true,
-    _originalBytes: bytes.byteLength,
-    preview: `${preview}…`
-  };
-}
-function sanitizePayload(value, options = {}) {
-  if (value === undefined || value === null)
-    return null;
-  try {
-    return truncatePreview(redact(value, options), options.maxBytes ?? DEFAULT_MAX_BYTES);
-  } catch {
-    return "[unserializable]";
-  }
-}
-function measureSize(value) {
-  if (value === undefined || value === null) {
-    return { resultSize: null, responseBytes: 0 };
-  }
-  let responseBytes = 0;
-  try {
-    responseBytes = new TextEncoder().encode(JSON.stringify(value)).byteLength;
-  } catch {
-    return { resultSize: null, responseBytes: 0, unserializable: true };
-  }
-  if (Array.isArray(value)) {
-    return { resultSize: value.length, responseBytes };
-  }
-  if (isRecord(value) && Array.isArray(value.items) && "nextCursor" in value) {
-    return { resultSize: value.items.length, responseBytes };
-  }
-  return { resultSize: null, responseBytes };
-}
-
-export { redact, truncatePreview, sanitizePayload, measureSize };

package/dist/index-77fekveh.js

@@ -1,44 +0,0 @@
-// src/internal/typed.ts
-function typedEntries(value) {
-  return Object.entries(value);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function callRuntimeHandler(handler, context) {
-  if (typeof handler !== "function") {
-    throw new TypeError("Runtime handler must be a function");
-  }
-  return Reflect.apply(handler, undefined, [context]);
-}
-function executableAgentRuntimeTools(tools) {
-  for (const tool of tools) {
-    if (typeof tool.handler !== "function") {
-      throw new TypeError(`Runtime tool "${tool.name}" must provide a handler`);
-    }
-    if (tool.present?.agent !== undefined && typeof tool.present.agent !== "function") {
-      throw new TypeError(`Runtime tool "${tool.name}" Agent presenter must be a function`);
-    }
-    if (tool.present?.agent !== undefined && tool.output === undefined) {
-      throw new TypeError(`Runtime tool "${tool.name}" Agent presenter requires an output schema`);
-    }
-  }
-  return tools;
-}
-function transportResult(value) {
-  return value;
-}
-function mapObject(source, mapper) {
-  const result = {};
-  for (const [key, value] of typedEntries(source)) {
-    const mapped = mapper(key, value);
-    if (mapped !== undefined)
-      result[key] = mapped;
-  }
-  return result;
-}
-function mapObjectTypeBoundary(source, mapper) {
-  return mapObject(source, (key, value) => mapper(key, value));
-}
-
-export { typedEntries, isRecord, callRuntimeHandler, executableAgentRuntimeTools, transportResult, mapObject, mapObjectTypeBoundary };