@dbx-tools/appkit 0.9.129 → 0.9.131

package/lib/src/telemetry.js

@@ -0,0 +1,126 @@
+/** AppKit telemetry compatibility helpers. */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+/** Return the request pathname without its query string. */
+function requestPath(request) {
+    return request.url?.split("?", 1)[0] ?? "";
+}
+/** Whether one request matches the default or configured HTTP telemetry exclusions. */
+export function excludeHttpTelemetryRequest(request, options = {}) {
+    if (request.method === "HEAD")
+        return true;
+    const pathname = requestPath(request);
+    for (const pattern of options.exclude ?? []) {
+        if (pattern.endsWith("*")) {
+            if (pathname.startsWith(pattern.slice(0, -1)))
+                return true;
+        }
+        else if (pathname === pattern) {
+            return true;
+        }
+    }
+    return options.filter?.(request) ?? false;
+}
+function appKitInternalModuleUrl(relativePath) {
+    const require = createRequire(import.meta.url);
+    const packageRoot = path.dirname(require.resolve("@databricks/appkit/package.json"));
+    return pathToFileURL(path.join(packageRoot, "dist", ...relativePath.split("/"))).href;
+}
+function isNativeHttpInstrumentation(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return typeof candidate.getConfig === "function" && typeof candidate.setConfig === "function";
+}
+async function nativeInstrumentations() {
+    const loaded = (await import(__rewriteRelativeImportExtension(appKitInternalModuleUrl("telemetry/instrumentations.js"))));
+    if (!loaded.instrumentations) {
+        throw new Error("@databricks/appkit no longer exposes its native instrumentations");
+    }
+    return loaded.instrumentations;
+}
+async function nativeHttpInstrumentation() {
+    const instrumentation = (await nativeInstrumentations()).http;
+    if (!isNativeHttpInstrumentation(instrumentation)) {
+        throw new Error("@databricks/appkit no longer exposes the expected native HTTP telemetry instrumentation");
+    }
+    return instrumentation;
+}
+async function nativeTelemetryManagerClass() {
+    const loaded = (await import(__rewriteRelativeImportExtension(appKitInternalModuleUrl("telemetry/telemetry-manager.js"))));
+    if (!loaded.TelemetryManager) {
+        throw new Error("@databricks/appkit no longer exposes its native telemetry manager");
+    }
+    return loaded.TelemetryManager;
+}
+async function nativeTelemetryManager() {
+    return (await nativeTelemetryManagerClass()).getInstance();
+}
+function requireNativeTracerProvider(manager) {
+    if (!manager.tracerProvider) {
+        throw new Error("AppKit's native tracer provider has not started");
+    }
+    return manager.tracerProvider;
+}
+/**
+ * Extend AppKit's native HTTP request filter without registering a second HTTP
+ * instrumentation. AppKit 0.81 owns the instrumentation but does not expose a
+ * public filter option, so this compatibility hook mutates its existing
+ * singleton before `createApp()` registers it.
+ */
+export async function configureNativeHttpTelemetry(options = {}) {
+    const instrumentation = await nativeHttpInstrumentation();
+    const config = instrumentation.getConfig();
+    const appKitFilter = config.ignoreIncomingRequestHook;
+    instrumentation.setConfig({
+        ...config,
+        ignoreIncomingRequestHook: (request) => Boolean(appKitFilter?.(request)) || excludeHttpTelemetryRequest(request, options),
+    });
+}
+/**
+ * Bind AppKit's native instrumentations to the provider AppKit started. This is
+ * called after AppKit's deferred `TelemetryManager.start()` phase so a runtime
+ * that already occupied the global OTel slot cannot leave native spans no-op.
+ */
+export async function bindNativeTelemetryProvider() {
+    const manager = await nativeTelemetryManager();
+    if (!manager.tracerProvider)
+        return false;
+    for (const instrumentation of Object.values(await nativeInstrumentations())) {
+        instrumentation.setTracerProvider?.(manager.tracerProvider);
+    }
+    return true;
+}
+/** Contribute a processor before AppKit builds its native tracer provider. */
+export async function registerNativeSpanProcessor(processor) {
+    (await nativeTelemetryManagerClass()).registerSpanProcessor(processor);
+}
+/**
+ * Return a tracer provider that resolves AppKit's provider when a tracer method
+ * is invoked. AppKit starts its provider after plugin setup, while consumers
+ * such as Mastra construct their OTel bridge during setup.
+ */
+export async function deferredNativeTracerProvider() {
+    const manager = await nativeTelemetryManager();
+    return {
+        getTracer(name, version, options) {
+            return new Proxy({}, {
+                get(_target, property) {
+                    const tracer = requireNativeTracerProvider(manager).getTracer(name, version, options);
+                    const value = Reflect.get(tracer, property, tracer);
+                    return typeof value === "function" ? value.bind(tracer) : value;
+                },
+            });
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"telemetry.js","sourceRoot":"","sources":["../../src/telemetry.ts"],"names":[],"mappings":"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","sourcesContent":["/** AppKit telemetry compatibility helpers. */\n\nimport type { IncomingMessage } from \"node:http\";\nimport { createRequire } from \"node:module\";\nimport path from \"node:path\";\nimport { pathToFileURL } from \"node:url\";\n\nimport type { Tracer, TracerOptions, TracerProvider } from \"@opentelemetry/api\";\nimport type { SpanProcessor } from \"@opentelemetry/sdk-trace-base\";\n\ntype IncomingRequestFilter = (request: IncomingMessage) => boolean;\n\ninterface NativeHttpInstrumentationConfig {\n  readonly enabled?: boolean;\n  readonly ignoreIncomingRequestHook?: IncomingRequestFilter;\n  readonly [key: string]: unknown;\n}\n\ninterface NativeInstrumentation {\n  setTracerProvider?(provider: TracerProvider): void;\n}\n\ninterface NativeHttpInstrumentation extends NativeInstrumentation {\n  getConfig(): NativeHttpInstrumentationConfig;\n  setConfig(config: NativeHttpInstrumentationConfig): void;\n}\n\ninterface NativeTelemetryManager {\n  tracerProvider?: TracerProvider;\n}\n\ninterface NativeTelemetryManagerClass {\n  getInstance(): NativeTelemetryManager;\n  registerSpanProcessor(processor: SpanProcessor): void;\n}\n\n/** Options for AppKit's native HTTP request tracing. */\nexport interface NativeHttpTelemetryOptions {\n  /**\n   * Request paths to exclude. A trailing `*` matches every path with that\n   * prefix; other values are exact path matches. Query strings are ignored.\n   */\n  readonly exclude?: readonly string[];\n  /** Additional caller-owned request filter. Returning `true` excludes the request. */\n  readonly filter?: IncomingRequestFilter;\n}\n\n/** Return the request pathname without its query string. */\nfunction requestPath(request: IncomingMessage): string {\n  return request.url?.split(\"?\", 1)[0] ?? \"\";\n}\n\n/** Whether one request matches the default or configured HTTP telemetry exclusions. */\nexport function excludeHttpTelemetryRequest(\n  request: IncomingMessage,\n  options: NativeHttpTelemetryOptions = {},\n): boolean {\n  if (request.method === \"HEAD\") return true;\n  const pathname = requestPath(request);\n  for (const pattern of options.exclude ?? []) {\n    if (pattern.endsWith(\"*\")) {\n      if (pathname.startsWith(pattern.slice(0, -1))) return true;\n    } else if (pathname === pattern) {\n      return true;\n    }\n  }\n  return options.filter?.(request) ?? false;\n}\n\nfunction appKitInternalModuleUrl(relativePath: string): string {\n  const require = createRequire(import.meta.url);\n  const packageRoot = path.dirname(require.resolve(\"@databricks/appkit/package.json\"));\n  return pathToFileURL(path.join(packageRoot, \"dist\", ...relativePath.split(\"/\"))).href;\n}\n\nfunction isNativeHttpInstrumentation(value: unknown): value is NativeHttpInstrumentation {\n  if (!value || typeof value !== \"object\") return false;\n  const candidate = value as Partial<NativeHttpInstrumentation>;\n  return typeof candidate.getConfig === \"function\" && typeof candidate.setConfig === \"function\";\n}\n\nasync function nativeInstrumentations(): Promise<Record<string, NativeInstrumentation>> {\n  const loaded = (await import(appKitInternalModuleUrl(\"telemetry/instrumentations.js\"))) as {\n    instrumentations?: Record<string, NativeInstrumentation>;\n  };\n  if (!loaded.instrumentations) {\n    throw new Error(\"@databricks/appkit no longer exposes its native instrumentations\");\n  }\n  return loaded.instrumentations;\n}\n\nasync function nativeHttpInstrumentation(): Promise<NativeHttpInstrumentation> {\n  const instrumentation = (await nativeInstrumentations()).http;\n  if (!isNativeHttpInstrumentation(instrumentation)) {\n    throw new Error(\n      \"@databricks/appkit no longer exposes the expected native HTTP telemetry instrumentation\",\n    );\n  }\n  return instrumentation;\n}\n\nasync function nativeTelemetryManagerClass(): Promise<NativeTelemetryManagerClass> {\n  const loaded = (await import(appKitInternalModuleUrl(\"telemetry/telemetry-manager.js\"))) as {\n    TelemetryManager?: NativeTelemetryManagerClass;\n  };\n  if (!loaded.TelemetryManager) {\n    throw new Error(\"@databricks/appkit no longer exposes its native telemetry manager\");\n  }\n  return loaded.TelemetryManager;\n}\n\nasync function nativeTelemetryManager(): Promise<NativeTelemetryManager> {\n  return (await nativeTelemetryManagerClass()).getInstance();\n}\n\nfunction requireNativeTracerProvider(manager: NativeTelemetryManager): TracerProvider {\n  if (!manager.tracerProvider) {\n    throw new Error(\"AppKit's native tracer provider has not started\");\n  }\n  return manager.tracerProvider;\n}\n\n/**\n * Extend AppKit's native HTTP request filter without registering a second HTTP\n * instrumentation. AppKit 0.81 owns the instrumentation but does not expose a\n * public filter option, so this compatibility hook mutates its existing\n * singleton before `createApp()` registers it.\n */\nexport async function configureNativeHttpTelemetry(\n  options: NativeHttpTelemetryOptions = {},\n): Promise<void> {\n  const instrumentation = await nativeHttpInstrumentation();\n  const config = instrumentation.getConfig();\n  const appKitFilter = config.ignoreIncomingRequestHook;\n  instrumentation.setConfig({\n    ...config,\n    ignoreIncomingRequestHook: (request) =>\n      Boolean(appKitFilter?.(request)) || excludeHttpTelemetryRequest(request, options),\n  });\n}\n\n/**\n * Bind AppKit's native instrumentations to the provider AppKit started. This is\n * called after AppKit's deferred `TelemetryManager.start()` phase so a runtime\n * that already occupied the global OTel slot cannot leave native spans no-op.\n */\nexport async function bindNativeTelemetryProvider(): Promise<boolean> {\n  const manager = await nativeTelemetryManager();\n  if (!manager.tracerProvider) return false;\n  for (const instrumentation of Object.values(await nativeInstrumentations())) {\n    instrumentation.setTracerProvider?.(manager.tracerProvider);\n  }\n  return true;\n}\n\n/** Contribute a processor before AppKit builds its native tracer provider. */\nexport async function registerNativeSpanProcessor(processor: SpanProcessor): Promise<void> {\n  (await nativeTelemetryManagerClass()).registerSpanProcessor(processor);\n}\n\n/**\n * Return a tracer provider that resolves AppKit's provider when a tracer method\n * is invoked. AppKit starts its provider after plugin setup, while consumers\n * such as Mastra construct their OTel bridge during setup.\n */\nexport async function deferredNativeTracerProvider(): Promise<TracerProvider> {\n  const manager = await nativeTelemetryManager();\n  return {\n    getTracer(name: string, version?: string, options?: TracerOptions): Tracer {\n      return new Proxy({} as Tracer, {\n        get(_target, property) {\n          const tracer = requireNativeTracerProvider(manager).getTracer(name, version, options);\n          const value = Reflect.get(tracer, property, tracer) as unknown;\n          return typeof value === \"function\" ? value.bind(tracer) : value;\n        },\n      });\n    },\n  };\n}\n"]}

package/lib/src/tool-provider.d.ts

@@ -12,6 +12,8 @@ export interface AgentToolExecutionContext {
     readonly resourceId?: string;
     /** Model endpoint selected for the current agent turn. */
     readonly model?: string;
+    /** Browser application origin associated with the current agent turn. */
+    readonly origin?: string;
     /** Best-effort progress sink validated by the hosting integration. */
     readonly writeProgress?: (event: unknown, options?: AgentToolProgressOptions) => Promise<void>;
 }

package/lib/src/tool-provider.js

@@ -17,4 +17,4 @@ export class ToolRegistryPlugin extends Plugin {
         return executeFromRegistry(this.toolRegistry, name, args, signal);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/_auto-configure.ts","../src/appkit.ts","../src/brand-context.ts","../src/bundle.ts","../src/cache-storage.ts","../src/databricks.ts","../src/files-cache.ts","../src/identity.ts","../src/interceptor.ts","../src/lakebase-resolver.ts","../src/migration.ts","../src/pgaddress.ts","../src/plugin-execution.ts","../src/plugin-registry.ts","../src/provision.ts","../src/request-tags.ts","../src/tool-operations.ts","../src/tool-provider.ts","../src/toolkit-entries.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/_auto-configure.ts","../src/appkit.ts","../src/brand-context.ts","../src/bundle.ts","../src/cache-storage.ts","../src/databricks.ts","../src/files-cache.ts","../src/identity.ts","../src/interceptor.ts","../src/lakebase-resolver.ts","../src/migration.ts","../src/openapi-tool.ts","../src/pgaddress.ts","../src/plugin-execution.ts","../src/plugin-registry.ts","../src/provision.ts","../src/request-tags.ts","../src/telemetry.ts","../src/tool-operations.ts","../src/tool-provider.ts","../src/toolkit-entries.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -20,7 +20,8 @@
   },
   "devDependencies": {
     "@databricks/appkit": "0.81.0",
-    "@dbx-tools/projen": "^0.9.129",
+    "@dbx-tools/projen": "^0.9.131",
+    "@types/json-schema": "^7",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3",
     "vitest": "3.2.4"
@@ -30,13 +31,15 @@
   },
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17.0",
-    "@dbx-tools/auth": "^0.9.129",
-    "@dbx-tools/cache": "^0.9.129",
-    "@dbx-tools/core": "^0.9.129",
-    "@dbx-tools/lakebase": "^0.9.129",
-    "@dbx-tools/postgres": "^0.9.129",
-    "@dbx-tools/shared-core": "^0.9.129",
-    "@dbx-tools/shared-fs": "^0.9.129",
+    "@dbx-tools/auth": "^0.9.131",
+    "@dbx-tools/cache": "^0.9.131",
+    "@dbx-tools/core": "^0.9.131",
+    "@dbx-tools/lakebase": "^0.9.131",
+    "@dbx-tools/postgres": "^0.9.131",
+    "@dbx-tools/shared-core": "^0.9.131",
+    "@dbx-tools/shared-fs": "^0.9.131",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/sdk-trace-base": "2.8.0",
     "zod": "4.3.6"
   },
   "main": "./lib/index.js",
@@ -90,6 +93,10 @@
         "types": "./lib/src/migration.d.ts",
         "default": "./lib/src/migration.js"
       },
+      "./openapi-tool": {
+        "types": "./lib/src/openapi-tool.d.ts",
+        "default": "./lib/src/openapi-tool.js"
+      },
       "./pgaddress": {
         "types": "./lib/src/pgaddress.d.ts",
         "default": "./lib/src/pgaddress.js"
@@ -110,6 +117,10 @@
         "types": "./lib/src/request-tags.d.ts",
         "default": "./lib/src/request-tags.js"
       },
+      "./telemetry": {
+        "types": "./lib/src/telemetry.d.ts",
+        "default": "./lib/src/telemetry.js"
+      },
       "./tool-operations": {
         "types": "./lib/src/tool-operations.d.ts",
         "default": "./lib/src/tool-operations.js"
@@ -129,7 +140,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.129",
+  "version": "0.9.131",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [
@@ -182,6 +193,10 @@
       "types": "./lib/src/migration.d.ts",
       "default": "./lib/src/migration.js"
     },
+    "./openapi-tool": {
+      "types": "./lib/src/openapi-tool.d.ts",
+      "default": "./lib/src/openapi-tool.js"
+    },
     "./pgaddress": {
       "types": "./lib/src/pgaddress.d.ts",
       "default": "./lib/src/pgaddress.js"
@@ -202,6 +217,10 @@
       "types": "./lib/src/request-tags.d.ts",
       "default": "./lib/src/request-tags.js"
     },
+    "./telemetry": {
+      "types": "./lib/src/telemetry.d.ts",
+      "default": "./lib/src/telemetry.js"
+    },
     "./tool-operations": {
       "types": "./lib/src/tool-operations.d.ts",
       "default": "./lib/src/tool-operations.js"

package/src/appkit.ts

@@ -51,6 +51,7 @@ import {
 } from "./interceptor.ts";
 import { applyLakebaseEnv, type LakebaseConnection } from "./lakebase-resolver.ts";
 import { provisionCacheSchema } from "./provision.ts";
+import { bindNativeTelemetryProvider } from "./telemetry.ts";
 
 const logger = log.logger("appkit");
 
@@ -309,6 +310,12 @@ export async function createApp<T extends AppKitPlugins>(
   const appConfig = { ...config };
   delete appConfig.autoConfigure;
   delete appConfig.interceptor;
+  const onPluginsReady = appConfig.onPluginsReady;
+  appConfig.onPluginsReady = async (app) => {
+    const bound = await bindNativeTelemetryProvider();
+    logger.debug("createApp: native telemetry provider binding", { bound });
+    await onPluginsReady?.(app);
+  };
 
   if (shouldInjectCacheStorage(config)) {
     logger.debug("createApp: inject memory-first cache storage");

package/src/openapi-tool.ts

@@ -0,0 +1,246 @@
+/**
+ * OpenAPI operation loading and JSON Schema extraction.
+ *
+ * @module
+ */
+
+import { readFile } from "node:fs/promises";
+import { object } from "@dbx-tools/shared-core";
+import { urlBuilder, type UrlBuilder } from "@dbx-tools/shared-core/net";
+import type { JSONSchema7 } from "json-schema";
+import { z } from "zod";
+
+const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD", "TRACE"] as const;
+
+const JsonObjectSchema = z
+  .record(z.string(), z.unknown())
+  .describe("A JSON object embedded in an OpenAPI document.");
+
+const OpenApiMediaTypeSchema = z
+  .object({
+    schema: JsonObjectSchema.describe("The JSON Schema for this media type."),
+  })
+  .describe("One OpenAPI media type.");
+
+const OpenApiRequestBodySchema = z
+  .object({
+    content: z
+      .record(z.string(), OpenApiMediaTypeSchema)
+      .describe("Request media types keyed by content type."),
+  })
+  .describe("An OpenAPI request body.");
+
+const OpenApiResponseSchema = z
+  .object({
+    content: z
+      .record(z.string(), OpenApiMediaTypeSchema)
+      .optional()
+      .describe("Response media types keyed by content type."),
+  })
+  .describe("One OpenAPI response.");
+
+const OpenApiOperationSchema = z
+  .object({
+    operationId: z.string().describe("The stable operation identifier."),
+    summary: z.string().optional().describe("The short operation summary."),
+    description: z.string().optional().describe("The full operation description."),
+    requestBody: OpenApiRequestBodySchema.optional().describe(
+      "The optional operation request body.",
+    ),
+    responses: z
+      .record(z.string(), OpenApiResponseSchema)
+      .describe("Operation responses keyed by HTTP status."),
+  })
+  .describe("The OpenAPI fields required to define a tool.");
+
+const OpenApiPathSchema = z
+  .object({
+    get: OpenApiOperationSchema.optional(),
+    post: OpenApiOperationSchema.optional(),
+    put: OpenApiOperationSchema.optional(),
+    patch: OpenApiOperationSchema.optional(),
+    delete: OpenApiOperationSchema.optional(),
+    options: OpenApiOperationSchema.optional(),
+    head: OpenApiOperationSchema.optional(),
+    trace: OpenApiOperationSchema.optional(),
+  })
+  .describe("Operations available at one OpenAPI path.");
+
+const OpenApiDocumentSchema = z
+  .object({
+    paths: z
+      .record(z.string(), OpenApiPathSchema)
+      .refine((paths) => Object.keys(paths).length > 0, "OpenAPI paths must not be empty")
+      .describe("OpenAPI path items keyed by URL path."),
+    components: JsonObjectSchema.optional().describe("Reusable OpenAPI components."),
+    servers: z
+      .array(
+        z.object({
+          url: z.string().describe("Server base URL."),
+        }),
+      )
+      .optional()
+      .describe("OpenAPI server definitions."),
+  })
+  .describe("An OpenAPI document used to define HTTP tools.");
+
+type OpenApiDocument = z.infer<typeof OpenApiDocumentSchema>;
+type OpenApiOperation = z.infer<typeof OpenApiOperationSchema>;
+
+/** HTTP method supported by an {@link OpenApiTool}. */
+export type OpenApiHttpMethod = (typeof HTTP_METHODS)[number];
+
+/** One executable HTTP operation derived from an OpenAPI document. */
+export interface OpenApiTool {
+  /** Stable operation identifier. */
+  id: string;
+  /** Model-facing operation description. */
+  description: string;
+  /** Resolved operation URL, or the OpenAPI path for a local document without a server URL. */
+  url: string;
+  /** HTTP method used by the operation. */
+  method: OpenApiHttpMethod;
+  /** JSON Schema describing operation input. */
+  inputSchema: JSONSchema7;
+  /** JSON Schema describing a successful operation result. */
+  outputSchema: JSONSchema7;
+}
+
+/** Request options used while loading an OpenAPI document. */
+export interface OpenApiToolsOptions {
+  /** Cancels an HTTP request or file read. */
+  signal?: AbortSignal;
+  /** Headers sent when `source` is an HTTP(S) URL. */
+  headers?: RequestInit["headers"];
+}
+
+/** Load an HTTP(S) URL or local file and return its OpenAPI operations as tool schemas. */
+export async function openApiTools(
+  source: string,
+  options: OpenApiToolsOptions = {},
+): Promise<OpenApiTool[]> {
+  const sourceUrl = httpUrl(source);
+  const document = OpenApiDocumentSchema.parse(
+    sourceUrl
+      ? await fetchDocument(sourceUrl, options)
+      : await readDocument(source, options.signal),
+  );
+  return Object.entries(document.paths).flatMap(([path, item]) =>
+    HTTP_METHODS.flatMap((method) => {
+      const operation = item[method.toLowerCase() as Lowercase<OpenApiHttpMethod>];
+      return operation ? [operationTool(document, sourceUrl, path, method, operation)] : [];
+    }),
+  );
+}
+
+function httpUrl(source: string): UrlBuilder | undefined {
+  const value = source.trim();
+  if (!value.startsWith("http://") && !value.startsWith("https://")) return undefined;
+  const url = urlBuilder(value);
+  return url?.scheme === "http" || url?.scheme === "https" ? url : undefined;
+}
+
+async function fetchDocument(url: URL, options: OpenApiToolsOptions): Promise<unknown> {
+  const response = await fetch(url, {
+    signal: options.signal,
+    headers: options.headers,
+  });
+  if (!response.ok) {
+    throw new Error(`OpenAPI request failed with HTTP ${response.status}: ${url}`);
+  }
+  return response.json();
+}
+
+async function readDocument(path: string, signal?: AbortSignal): Promise<unknown> {
+  return JSON.parse(await readFile(path, { encoding: "utf8", signal }));
+}
+
+function operationTool(
+  document: OpenApiDocument,
+  sourceUrl: URL | undefined,
+  path: string,
+  method: OpenApiHttpMethod,
+  operation: OpenApiOperation,
+): OpenApiTool {
+  const requestSchema = jsonSchema(operation.requestBody?.content) ?? { type: "object" };
+  const responseSchema = successfulResponseSchema(operation);
+  return {
+    id: operation.operationId,
+    description:
+      operation.description?.trim() || operation.summary?.trim() || operation.operationId,
+    url: operationUrl(document, sourceUrl, path),
+    method,
+    inputSchema: resolveReferences(document, requestSchema) as JSONSchema7,
+    outputSchema: resolveReferences(document, responseSchema) as JSONSchema7,
+  };
+}
+
+function successfulResponseSchema(operation: OpenApiOperation): Record<string, unknown> {
+  for (const [status, response] of Object.entries(operation.responses)) {
+    const schema = jsonSchema(response.content);
+    if (/^2(?:\d{2}|XX)$/i.test(status) && schema) return schema;
+  }
+  return {};
+}
+
+function jsonSchema(
+  content: Record<string, z.infer<typeof OpenApiMediaTypeSchema>> | undefined,
+): Record<string, unknown> | undefined {
+  const mediaType = Object.entries(content ?? {}).find(([type]) =>
+    /^application\/(?:[^+;]+\+)?json(?:;|$)/i.test(type),
+  );
+  return mediaType?.[1].schema;
+}
+
+function operationUrl(document: OpenApiDocument, sourceUrl: URL | undefined, path: string): string {
+  const server = document.servers?.[0]?.url;
+  if (server) {
+    const base = sourceUrl ? urlBuilder(new URL(server, sourceUrl)) : httpUrl(server);
+    return base
+      ? base.withPathAppend(path).toString()
+      : `${server.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+  }
+  return sourceUrl ? (urlBuilder(sourceUrl)?.withPathReplace(path).toString() ?? path) : path;
+}
+
+function resolveReferences(
+  document: OpenApiDocument,
+  value: unknown,
+  active: ReadonlySet<string> = new Set(),
+): unknown {
+  if (Array.isArray(value)) return value.map((item) => resolveReferences(document, item, active));
+  if (!object.isRecord(value)) return value;
+  const reference = typeof value.$ref === "string" ? value.$ref : undefined;
+  if (reference) {
+    if (active.has(reference)) throw new Error(`Cyclic OpenAPI reference: ${reference}`);
+    const target = referenceTarget(document, reference);
+    const next = new Set(active).add(reference);
+    const { $ref: _ignored, ...siblings } = value;
+    return {
+      ...(resolveReferences(document, target, next) as Record<string, unknown>),
+      ...(resolveReferences(document, siblings, next) as Record<string, unknown>),
+    };
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, child]) => [key, resolveReferences(document, child, active)]),
+  );
+}
+
+function referenceTarget(document: OpenApiDocument, reference: string): unknown {
+  if (!reference.startsWith("#/")) throw new Error(`Unsupported OpenAPI reference: ${reference}`);
+  let current: unknown = document;
+  for (const rawSegment of reference.slice(2).split("/")) {
+    const segment = rawSegment.replaceAll("~1", "/").replaceAll("~0", "~");
+    if (!object.isRecord(current) || !(segment in current)) {
+      throw new Error(`Unresolved OpenAPI reference: ${reference}`);
+    }
+    current = current[segment];
+  }
+  return current;
+}
+
+if (import.meta.main) {
+  const source = process.argv[2];
+  if (!source) throw new Error("Usage: bun openapi-tool.ts <openapi-url-or-file>");
+  console.log(JSON.stringify(await openApiTools(source), null, 2));
+}