@frontmcp/react 0.0.1

package/ai/index.js

@@ -0,0 +1,416 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/react/src/ai/index.ts
+var ai_exports = {};
+__export(ai_exports, {
+  createToolCallHandler: () => createToolCallHandler,
+  useAITools: () => useAITools,
+  useTools: () => useTools
+});
+module.exports = __toCommonJS(ai_exports);
+
+// libs/react/src/ai/useAITools.ts
+var import_react4 = require("react");
+var import_sdk = require("@frontmcp/sdk");
+
+// libs/react/src/hooks/useResolvedServer.ts
+var import_react3 = require("react");
+
+// libs/react/src/provider/FrontMcpContext.ts
+var import_react = require("react");
+
+// libs/react/src/components/ComponentRegistry.ts
+var ComponentRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  register(uri, component, meta) {
+    const name = extractName(uri);
+    this.entries.set(uri, { uri, name, component, description: meta?.description });
+  }
+  registerAll(map) {
+    for (const [uri, component] of Object.entries(map)) {
+      this.register(uri, component);
+    }
+  }
+  get(uri) {
+    return this.entries.get(uri)?.component;
+  }
+  /**
+   * Resolve a shorthand name like `'UserCard'` by trying
+   * `component://UserCard`, `element://UserCard`, `page://UserCard`.
+   */
+  resolve(type) {
+    const exact = this.entries.get(type);
+    if (exact) return exact.component;
+    for (const protocol of ["component://", "element://", "page://"]) {
+      const entry = this.entries.get(`${protocol}${type}`);
+      if (entry) return entry.component;
+    }
+    return void 0;
+  }
+  has(uri) {
+    return this.entries.has(uri);
+  }
+  list() {
+    return Array.from(this.entries.values()).map(({ uri, name, description }) => ({
+      uri,
+      name,
+      description
+    }));
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+function extractName(uri) {
+  const idx = uri.indexOf("://");
+  return idx >= 0 ? uri.slice(idx + 3) : uri;
+}
+
+// libs/react/src/registry/DynamicRegistry.ts
+var DynamicRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  resources = /* @__PURE__ */ new Map();
+  toolRefCounts = /* @__PURE__ */ new Map();
+  resourceRefCounts = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  version = 0;
+  /**
+   * Register a dynamic tool. Returns an unregister function
+   * suitable for useEffect cleanup.
+   *
+   * Multiple registrations of the same name are ref-counted:
+   * subsequent registrations update the definition but the tool
+   * is only removed when every registrant has unregistered.
+   */
+  registerTool(def) {
+    const existing = this.toolRefCounts.get(def.name) ?? 0;
+    this.toolRefCounts.set(def.name, existing + 1);
+    this.tools.set(def.name, def);
+    if (existing === 0) {
+      this.notify();
+    }
+    let called = false;
+    return () => {
+      if (called) return;
+      called = true;
+      this.unregisterTool(def.name);
+    };
+  }
+  unregisterTool(name) {
+    const count = this.toolRefCounts.get(name);
+    if (count == null) return;
+    if (count <= 1) {
+      this.toolRefCounts.delete(name);
+      this.tools.delete(name);
+      this.notify();
+    } else {
+      this.toolRefCounts.set(name, count - 1);
+    }
+  }
+  /**
+   * Register a dynamic resource. Returns an unregister function
+   * suitable for useEffect cleanup.
+   *
+   * Multiple registrations of the same URI are ref-counted.
+   */
+  registerResource(def) {
+    const existing = this.resourceRefCounts.get(def.uri) ?? 0;
+    this.resourceRefCounts.set(def.uri, existing + 1);
+    this.resources.set(def.uri, def);
+    if (existing === 0) {
+      this.notify();
+    }
+    let called = false;
+    return () => {
+      if (called) return;
+      called = true;
+      this.unregisterResource(def.uri);
+    };
+  }
+  unregisterResource(uri) {
+    const count = this.resourceRefCounts.get(uri);
+    if (count == null) return;
+    if (count <= 1) {
+      this.resourceRefCounts.delete(uri);
+      this.resources.delete(uri);
+      this.notify();
+    } else {
+      this.resourceRefCounts.set(uri, count - 1);
+    }
+  }
+  /** Update the execute function for an existing tool (for stale closure prevention). */
+  updateToolExecute(name, execute) {
+    const existing = this.tools.get(name);
+    if (existing) {
+      existing.execute = execute;
+    }
+  }
+  /** Update the read function for an existing resource and notify subscribers. */
+  updateResourceRead(uri, read) {
+    const existing = this.resources.get(uri);
+    if (existing) {
+      existing.read = read;
+      this.notify();
+    }
+  }
+  getTools() {
+    return [...this.tools.values()];
+  }
+  getResources() {
+    return [...this.resources.values()];
+  }
+  findTool(name) {
+    return this.tools.get(name);
+  }
+  findResource(uri) {
+    return this.resources.get(uri);
+  }
+  hasTool(name) {
+    return this.tools.has(name);
+  }
+  hasResource(uri) {
+    return this.resources.has(uri);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getVersion() {
+    return this.version;
+  }
+  clear() {
+    if (this.tools.size === 0 && this.resources.size === 0) return;
+    this.tools.clear();
+    this.resources.clear();
+    this.toolRefCounts.clear();
+    this.resourceRefCounts.clear();
+    this.notify();
+  }
+  notify() {
+    this.version++;
+    this.listeners.forEach((l) => {
+      l();
+    });
+  }
+};
+
+// libs/react/src/provider/FrontMcpContext.ts
+var defaultDynamicRegistry = new DynamicRegistry();
+var FrontMcpContext = (0, import_react.createContext)({
+  name: "default",
+  registry: new ComponentRegistry(),
+  dynamicRegistry: defaultDynamicRegistry,
+  getDynamicRegistry: () => defaultDynamicRegistry,
+  connect: async () => {
+  }
+});
+
+// libs/react/src/hooks/useServer.ts
+var import_react2 = require("react");
+
+// libs/react/src/registry/ServerRegistry.ts
+var ServerRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  version = 0;
+  register(name, server) {
+    this.entries.set(name, {
+      server,
+      client: null,
+      status: "idle",
+      error: null,
+      tools: [],
+      resources: [],
+      resourceTemplates: [],
+      prompts: []
+    });
+    this.notify();
+  }
+  unregister(name) {
+    this.entries.delete(name);
+    this.notify();
+  }
+  get(name) {
+    return this.entries.get(name);
+  }
+  has(name) {
+    return this.entries.has(name);
+  }
+  list() {
+    return [...this.entries.keys()];
+  }
+  async connect(name) {
+    const entry = this.entries.get(name);
+    if (!entry) throw new Error(`Server "${name}" not registered`);
+    if (entry.client) return entry.client;
+    this.entries.set(name, { ...entry, status: "connecting", error: null });
+    this.notify();
+    try {
+      const client = await entry.server.connect();
+      const [toolsResult, resourcesResult, templatesResult, promptsResult] = await Promise.all([
+        client.listTools(),
+        client.listResources(),
+        client.listResourceTemplates(),
+        client.listPrompts()
+      ]);
+      const connected = {
+        ...entry,
+        client,
+        tools: toolsResult,
+        resources: resourcesResult.resources ?? [],
+        resourceTemplates: templatesResult.resourceTemplates ?? [],
+        prompts: promptsResult.prompts ?? [],
+        status: "connected",
+        error: null
+      };
+      this.entries.set(name, connected);
+      this.notify();
+      return client;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.entries.set(name, { ...entry, error, status: "error" });
+      this.notify();
+      throw error;
+    }
+  }
+  async connectAll() {
+    await Promise.all(this.list().map((name) => this.connect(name)));
+  }
+  update(name, partial) {
+    const entry = this.entries.get(name);
+    if (entry) {
+      this.entries.set(name, { ...entry, ...partial });
+      this.notify();
+    }
+  }
+  clear() {
+    this.entries.clear();
+    this.notify();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getVersion() {
+    return this.version;
+  }
+  notify() {
+    this.version++;
+    this.listeners.forEach((l) => l());
+  }
+};
+var serverRegistry = new ServerRegistry();
+
+// libs/react/src/hooks/useServer.ts
+function useServer(name) {
+  const subscribe = (0, import_react2.useCallback)((cb) => serverRegistry.subscribe(cb), []);
+  const getSnapshot = (0, import_react2.useCallback)(() => {
+    return serverRegistry.get(name ?? "default");
+  }, [name]);
+  return (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+}
+
+// libs/react/src/hooks/useResolvedServer.ts
+function useResolvedServer(serverName) {
+  const ctx = (0, import_react3.useContext)(FrontMcpContext);
+  const resolvedName = serverName ?? ctx.name;
+  const entry = useServer(resolvedName);
+  return { entry, name: resolvedName, registry: ctx.registry, connect: ctx.connect };
+}
+
+// libs/react/src/ai/useAITools.ts
+function useAITools(platform, options) {
+  const { entry } = useResolvedServer(options?.server);
+  const server = entry?.server ?? null;
+  const toolInfos = entry?.tools ?? [];
+  const status = entry?.status ?? "idle";
+  const [formattedTools, setFormattedTools] = (0, import_react4.useState)(null);
+  const [loading, setLoading] = (0, import_react4.useState)(true);
+  const [error, setError] = (0, import_react4.useState)(null);
+  (0, import_react4.useEffect)(() => {
+    if (status !== "connected" || toolInfos.length === 0) {
+      setFormattedTools(null);
+      setLoading(status !== "connected" && status !== "error");
+      return;
+    }
+    try {
+      const mcpTools = toolInfos.filter((t) => t.inputSchema != null).map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }));
+      if (mcpTools.length === 0) {
+        setFormattedTools(null);
+        setLoading(false);
+        return;
+      }
+      const formatted = (0, import_sdk.formatToolsForPlatform)(
+        mcpTools,
+        platform
+      );
+      setFormattedTools(formatted);
+      setLoading(false);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setLoading(false);
+    }
+  }, [toolInfos, platform, status]);
+  const callTool = (0, import_react4.useCallback)(
+    async (name, args) => {
+      if (!server) {
+        throw new Error("FrontMCP server not available");
+      }
+      try {
+        const rawResult = await server.callTool(name, args);
+        return (0, import_sdk.formatResultForPlatform)(rawResult, platform);
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      }
+    },
+    [server, platform]
+  );
+  return { tools: formattedTools, callTool, loading, error };
+}
+
+// libs/react/src/ai/useTools.ts
+var import_react5 = require("react");
+var import_utils = require("@frontmcp/utils");
+function useTools(platform, options) {
+  const { tools, callTool, loading, error } = useAITools(platform, options);
+  const processToolCalls = (0, import_react5.useCallback)(
+    (calls) => (0, import_utils.processPlatformToolCalls)(platform, calls, callTool),
+    [platform, callTool]
+  );
+  return { tools, processToolCalls, loading, error };
+}
+
+// libs/react/src/ai/createToolHandler.ts
+var import_sdk2 = require("@frontmcp/sdk");
+function createToolCallHandler(server, platform) {
+  return {
+    callTool: async (name, args) => {
+      const rawResult = await server.callTool(name, args);
+      return (0, import_sdk2.formatResultForPlatform)(rawResult, platform);
+    }
+  };
+}

package/ai/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * AI SDK integration types.
+ *
+ * Platform-specific tool call types are re-exported from @frontmcp/utils.
+ * SDK-dependent types (tool shapes, hook return types) remain here.
+ */
+import type { OpenAITool, ClaudeTool, LangChainTool, VercelAITools, LLMPlatform, CallToolResult } from '@frontmcp/sdk';
+import type { OpenAIToolCallItem as _OpenAIToolCallItem, ClaudeToolUseBlock as _ClaudeToolUseBlock, VercelToolCallInfo as _VercelToolCallInfo } from '@frontmcp/utils';
+export type OpenAIToolCallItem = _OpenAIToolCallItem;
+export type ClaudeToolUseBlock = _ClaudeToolUseBlock;
+export type VercelToolCallInfo = _VercelToolCallInfo;
+/**
+ * Formatted tool result — local union matching SDK's FormattedToolResult.
+ * Synced with: libs/sdk/src/direct/llm-platform.ts FormattedToolResult
+ * @see libs/react/src/ai/__tests__/types-compat.spec.ts for drift guard
+ */
+export type FormattedToolResult = string | Record<string, unknown> | Array<{
+    type: string;
+    text: string;
+}> | CallToolResult['content'] | {
+    content?: Array<{
+        type: string;
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+} | {
+    text?: string[];
+    images?: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+};
+export interface McpToolInfo {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+export type PlatformToolsMap = {
+    openai: OpenAITool[];
+    claude: ClaudeTool[];
+    langchain: LangChainTool[];
+    'vercel-ai': VercelAITools;
+    raw: McpToolInfo[];
+};
+export interface UseAIToolsResult<P extends LLMPlatform> {
+    tools: PlatformToolsMap[P] | null;
+    callTool: (name: string, args?: Record<string, unknown>) => Promise<FormattedToolResult>;
+    loading: boolean;
+    error: Error | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/ai/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/ai/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACvH,OAAO,KAAK,EACV,kBAAkB,IAAI,mBAAmB,EACzC,kBAAkB,IAAI,mBAAmB,EACzC,kBAAkB,IAAI,mBAAmB,EAC1C,MAAM,iBAAiB,CAAC;AAGzB,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,CAAC;AACrD,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,CAAC;AACrD,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,CAAC;AAErD;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAC3B,MAAM,GACN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvB,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACrC,cAAc,CAAC,SAAS,CAAC,GACzB;IAAE,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,GACtF;IAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC;AAM5E,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAMD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,WAAW,EAAE,aAAa,CAAC;IAC3B,GAAG,EAAE,WAAW,EAAE,CAAC;CACpB,CAAC;AAMF,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,WAAW;IACrD,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAClC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACzF,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB"}

package/ai/useAITools.d.ts

@@ -0,0 +1,17 @@
+/**
+ * useAITools — generic hook that bridges FrontMCP tools to any AI SDK platform.
+ *
+ * Reads raw MCP tools from the ServerRegistry, formats them via
+ * `formatToolsForPlatform()`, and provides a `callTool` handler that
+ * executes via `server.callTool()` + `formatResultForPlatform()`.
+ *
+ * Supports multi-server via `options.server`.
+ */
+import type { LLMPlatform } from '@frontmcp/sdk';
+import type { UseAIToolsResult } from './types';
+interface AIToolsOptions {
+    server?: string;
+}
+export declare function useAITools<P extends LLMPlatform>(platform: P, options?: AIToolsOptions): UseAIToolsResult<P>;
+export {};
+//# sourceMappingURL=useAITools.d.ts.map

package/ai/useAITools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAITools.d.ts","sourceRoot":"","sources":["../../src/ai/useAITools.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjD,OAAO,KAAK,EAAE,gBAAgB,EAAsD,MAAM,SAAS,CAAC;AAEpG,UAAU,cAAc;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,UAAU,CAAC,CAAC,SAAS,WAAW,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,gBAAgB,CAAC,CAAC,CAAC,CA0D5G"}

package/ai/useTools.d.ts

@@ -0,0 +1,19 @@
+/**
+ * useTools — generic hook replacing per-platform hooks.
+ *
+ * Delegates tool call processing to `processPlatformToolCalls` from
+ * `@frontmcp/utils`, making the logic reusable in Node.js backends.
+ */
+import type { SupportedPlatform, PlatformToolCallsInput, PlatformToolCallsOutput } from '@frontmcp/utils';
+import type { PlatformToolsMap } from './types';
+export interface UseToolsResult<P extends SupportedPlatform> {
+    tools: PlatformToolsMap[P] | null;
+    processToolCalls: (calls: PlatformToolCallsInput[P]) => Promise<PlatformToolCallsOutput[P]>;
+    loading: boolean;
+    error: Error | null;
+}
+export interface ToolsOptions {
+    server?: string;
+}
+export declare function useTools<P extends SupportedPlatform>(platform: P, options?: ToolsOptions): UseToolsResult<P>;
+//# sourceMappingURL=useTools.d.ts.map

package/ai/useTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTools.d.ts","sourceRoot":"","sources":["../../src/ai/useTools.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,uBAAuB,EAAc,MAAM,iBAAiB,CAAC;AAEtH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,iBAAiB;IACzD,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAClC,gBAAgB,EAAE,CAAC,KAAK,EAAE,sBAAsB,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5F,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAcD,wBAAgB,QAAQ,CAAC,CAAC,SAAS,iBAAiB,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,cAAc,CAAC,CAAC,CAAC,CAS5G"}

package/api/api.types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Types for API client integration.
+ */
+export interface ApiOperation {
+    /** Unique operation identifier (becomes part of the tool name). */
+    operationId: string;
+    /** Human-readable description for agents. */
+    description: string;
+    /** HTTP method (GET, POST, PUT, DELETE, PATCH). */
+    method: string;
+    /** URL path (may contain {param} placeholders). */
+    path: string;
+    /** JSON Schema for the operation's input. */
+    inputSchema: Record<string, unknown>;
+}
+/** Configuration for a single HTTP request. */
+export interface HttpRequestConfig {
+    /** HTTP method (GET, POST, PUT, DELETE, PATCH, etc.). */
+    method: string;
+    /** Fully resolved URL. */
+    url: string;
+    /** Request headers. */
+    headers: Record<string, string>;
+    /** Request body (will be serialized by the client). */
+    body?: unknown;
+}
+/** Normalized HTTP response returned by an HttpClient. */
+export interface HttpResponse {
+    /** HTTP status code. */
+    status: number;
+    /** HTTP status text (optional). */
+    statusText?: string;
+    /** Parsed response data. */
+    data: unknown;
+}
+/**
+ * Generic HTTP client interface.
+ *
+ * Implement this to inject any HTTP library (axios, ky, got, custom wrappers
+ * with token refresh, auth headers, interceptors, etc.).
+ */
+export interface HttpClient {
+    request(config: HttpRequestConfig): Promise<HttpResponse>;
+}
+export interface ApiClientOptions {
+    /** Base URL for all API requests. */
+    baseUrl: string;
+    /** Operations to register as MCP tools. */
+    operations: ApiOperation[];
+    /** Static headers or header factory function. */
+    headers?: Record<string, string> | (() => Record<string, string>);
+    /** Tool name prefix (default: 'api'). */
+    prefix?: string;
+    /** Inject any HTTP client (axios, ky, custom). Takes precedence over `fetch`. */
+    client?: HttpClient;
+    /** @deprecated Use `client` instead. Raw fetch fallback. */
+    fetch?: typeof globalThis.fetch;
+    /** Target a specific named server. */
+    server?: string;
+}
+//# sourceMappingURL=api.types.d.ts.map

package/api/api.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.types.d.ts","sourceRoot":"","sources":["../../src/api/api.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,YAAY;IAC3B,mEAAmE;IACnE,WAAW,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,+CAA+C;AAC/C,MAAM,WAAW,iBAAiB;IAChC,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,uBAAuB;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,uDAAuD;IACvD,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,0DAA0D;AAC1D,MAAM,WAAW,YAAY;IAC3B,wBAAwB;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CAC3D;AAED,MAAM,WAAW,gBAAgB;IAC/B,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,UAAU,EAAE,YAAY,EAAE,CAAC;IAC3B,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClE,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,4DAA4D;IAC5D,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAChC,sCAAsC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/api/createFetchClient.d.ts

@@ -0,0 +1,9 @@
+/**
+ * createFetchClient — wraps a plain fetch function into the HttpClient interface.
+ *
+ * Useful for developers who want the generic HttpClient interface but still
+ * use fetch under the hood.
+ */
+import type { HttpClient } from './api.types';
+export declare function createFetchClient(fetchFn?: typeof globalThis.fetch): HttpClient;
+//# sourceMappingURL=createFetchClient.d.ts.map

package/api/createFetchClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFetchClient.d.ts","sourceRoot":"","sources":["../../src/api/createFetchClient.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAmC,MAAM,aAAa,CAAC;AAE/E,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,GAAG,UAAU,CAoC/E"}

package/api/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @frontmcp/react/api — API client integration for FrontMCP.
+ *
+ * Register OpenAPI operations as MCP tools so agents can call APIs directly.
+ *
+ * @packageDocumentation
+ */
+export { useApiClient } from './useApiClient';
+export { parseOpenApiSpec } from './parseOpenApiSpec';
+export { createFetchClient } from './createFetchClient';
+export type { ApiOperation, ApiClientOptions, HttpClient, HttpRequestConfig, HttpResponse } from './api.types';
+//# sourceMappingURL=index.d.ts.map

package/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}