react-observer-agent 0.2.0

package/dist/index.js

@@ -0,0 +1,955 @@
+// src/tools/registerTool.ts
+function registerTool(name, handler, options) {
+  return {
+    name,
+    handler,
+    description: options?.description,
+    parameters: options?.parameters,
+    confirm: options?.confirm ?? false
+  };
+}
+
+// src/tools/validateToolNames.ts
+var RESERVED_PREFIX = "__";
+function validateToolNames(tools) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    if (tool.name.startsWith(RESERVED_PREFIX)) {
+      throw new Error(
+        `Tool name "${tool.name}" uses the reserved "${RESERVED_PREFIX}" prefix. Names beginning with "${RESERVED_PREFIX}" are reserved for internal tools.`
+      );
+    }
+    if (seen.has(tool.name)) {
+      throw new Error(
+        `Duplicate tool name "${tool.name}". All tools passed to a single provider must have unique names.`
+      );
+    }
+    seen.add(tool.name);
+  }
+}
+
+// src/provider/AIAgentProvider.tsx
+import { createContext, useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+// src/state/resolveState.ts
+function resolveState(state) {
+  const resolved = typeof state === "function" ? state() : state;
+  return resolved;
+}
+
+// src/state/createStateSnapshot.ts
+function stripNonSerializable(obj, debug = false) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    try {
+      JSON.stringify(value);
+      result[key] = value;
+    } catch {
+      if (debug) {
+        console.warn(
+          `[react-observer-agent] Non-serializable value stripped from state key "${key}"`
+        );
+      }
+    }
+  }
+  return result;
+}
+function isSerializableValue(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "function" || typeof value === "symbol") return false;
+  if (typeof value === "bigint") return false;
+  return true;
+}
+function createStateSnapshot(state, canAccess, debug = false) {
+  const resolved = resolveState(state);
+  const filtered = {};
+  for (const key of canAccess) {
+    if (key in resolved) {
+      const value = resolved[key];
+      if (!isSerializableValue(value)) {
+        if (debug) {
+          console.warn(
+            `[react-observer-agent] Non-serializable value stripped from state key "${key}"`
+          );
+        }
+        continue;
+      }
+      filtered[key] = value;
+    }
+  }
+  return stripNonSerializable(filtered, debug);
+}
+
+// src/permissions/filterTools.ts
+function filterTools(tools, canExecute) {
+  const allowed = new Set(canExecute);
+  return tools.filter((tool) => allowed.has(tool.name));
+}
+
+// src/permissions/validateToolCall.ts
+function validateToolCall(name, canExecute) {
+  return canExecute.includes(name);
+}
+
+// src/tools/validateArgs.ts
+function validateArgs(args, schema) {
+  const errors = [];
+  validateValue(args, schema, "", errors);
+  return { valid: errors.length === 0, errors };
+}
+function describeType(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? "integer" : "number";
+  }
+  return typeof value;
+}
+function matchesType(value, expected) {
+  const actual = describeType(value);
+  if (expected === "number") return actual === "number" || actual === "integer";
+  return actual === expected;
+}
+function sameValue(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function label(path) {
+  return path === "" ? "value" : path;
+}
+function validateValue(value, schema, path, errors) {
+  if (!schema || typeof schema !== "object") return;
+  const expectedType = schema.type;
+  if (typeof expectedType === "string" && !matchesType(value, expectedType)) {
+    errors.push(
+      `${label(path)} should be ${expectedType}, got ${describeType(value)}`
+    );
+    return;
+  }
+  if (Array.isArray(schema.enum) && !schema.enum.some((option) => sameValue(option, value))) {
+    errors.push(
+      `${label(path)} should be one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
+    );
+  }
+  if (isPlainObject(value)) {
+    validateObject(value, schema, path, errors);
+  }
+  if (Array.isArray(value) && isPlainObject(schema.items)) {
+    const itemSchema = schema.items;
+    value.forEach((item, index) => {
+      validateValue(item, itemSchema, `${label(path)}[${index}]`, errors);
+    });
+  }
+}
+function validateObject(value, schema, path, errors) {
+  if (Array.isArray(schema.required)) {
+    for (const key of schema.required) {
+      if (typeof key === "string" && value[key] === void 0) {
+        errors.push(`${path === "" ? "" : `${path}.`}${key} is required`);
+      }
+    }
+  }
+  if (isPlainObject(schema.properties)) {
+    const properties = schema.properties;
+    for (const [key, propertySchema] of Object.entries(properties)) {
+      if (value[key] !== void 0 && isPlainObject(propertySchema)) {
+        validateValue(
+          value[key],
+          propertySchema,
+          path === "" ? key : `${path}.${key}`,
+          errors
+        );
+      }
+    }
+  }
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/provider/executeAgentLoop.ts
+var DEFAULT_MAX_TURNS = 5;
+var READ_STATE_TOOL_NAME = "__readState";
+var EMPTY_OBJECT_SCHEMA = { type: "object", properties: {} };
+var UsageTotal = class {
+  constructor() {
+    this.promptTokens = 0;
+    this.completionTokens = 0;
+    this.reported = false;
+  }
+  add(usage) {
+    if (!usage) return;
+    this.reported = true;
+    this.promptTokens += usage.promptTokens ?? 0;
+    this.completionTokens += usage.completionTokens ?? 0;
+  }
+  /** Undefined when no adapter response carried usage, rather than a false zero. */
+  total() {
+    if (!this.reported) return void 0;
+    return {
+      promptTokens: this.promptTokens,
+      completionTokens: this.completionTokens
+    };
+  }
+};
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function buildStateManifest(canAccess, descriptions) {
+  return canAccess.map((key) => ({
+    key,
+    description: descriptions?.[key] ?? key
+  }));
+}
+function buildStateManifestPrompt(manifest) {
+  if (manifest.length === 0) return "";
+  const lines = manifest.map((m) => `- ${m.key}: ${m.description}`);
+  return [
+    "Available application state (use the __readState tool to access specific keys when needed):",
+    ...lines,
+    "",
+    "Only request state keys relevant to the user's question. Do not read all keys at once unless necessary."
+  ].join("\n");
+}
+function buildReadStateToolDef() {
+  return {
+    name: READ_STATE_TOOL_NAME,
+    description: "Read specific keys from the application state. Only request keys you need.",
+    parameters: {
+      type: "object",
+      properties: {
+        keys: {
+          type: "array",
+          items: { type: "string" },
+          description: "State keys to read"
+        }
+      },
+      required: ["keys"]
+    }
+  };
+}
+async function executeAgentLoop(message, ctx) {
+  const { model, state, tools, permissions, options, signal } = ctx;
+  const debug = options?.debug ?? false;
+  const maxTurns = options?.maxTurns ?? DEFAULT_MAX_TURNS;
+  const stateManifest = buildStateManifest(
+    permissions.canAccess,
+    permissions.stateDescriptions
+  );
+  if (debug) {
+    console.log("[react-observer-agent] State manifest:", stateManifest.map((m) => m.key));
+  }
+  const allowedTools = filterTools(tools, permissions.canExecute);
+  const llmTools = [];
+  for (const tool of allowedTools) {
+    if (!tool.description) {
+      if (debug) {
+        console.warn(
+          `[react-observer-agent] Tool "${tool.name}" has no description and is hidden from the LLM.`
+        );
+      }
+      continue;
+    }
+    llmTools.push({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters ?? EMPTY_OBJECT_SCHEMA
+    });
+  }
+  if (stateManifest.length > 0) {
+    llmTools.push(buildReadStateToolDef());
+  }
+  if (debug) {
+    console.log("[react-observer-agent] Available tools:", llmTools.map((t) => t.name));
+  }
+  const toolMap = new Map(allowedTools.map((t) => [t.name, t]));
+  const messages = [
+    ...ctx.conversationHistory,
+    { role: "user", content: message }
+  ];
+  const manifestPrompt = buildStateManifestPrompt(stateManifest);
+  const systemPrompt = [options?.systemPrompt, manifestPrompt].filter(Boolean).join("\n\n") || void 0;
+  const allToolCalls = [];
+  const usage = new UsageTotal();
+  let turns = 0;
+  let finalMessage = "";
+  let completed = false;
+  const abortedResult = () => ({
+    response: {
+      message: "",
+      toolCalls: allToolCalls,
+      error: { message: "Interaction aborted", code: "ABORTED" },
+      usage: usage.total()
+    },
+    messages
+  });
+  while (turns < maxTurns) {
+    if (signal?.aborted) return abortedResult();
+    turns++;
+    if (debug) {
+      console.log(`[react-observer-agent] Turn ${turns}/${maxTurns}`);
+    }
+    const modelRequest = {
+      // A snapshot, since the loop keeps appending to `messages` after this
+      // call and an adapter that reads it asynchronously would see the churn.
+      messages: [...messages],
+      tools: llmTools,
+      state: {},
+      systemPrompt,
+      stateManifest,
+      signal
+    };
+    if (debug) {
+      console.log("[react-observer-agent] LLM request:", {
+        messageCount: modelRequest.messages.length,
+        toolCount: modelRequest.tools.length,
+        hasSystemPrompt: !!modelRequest.systemPrompt
+      });
+    }
+    let modelResponse;
+    try {
+      modelResponse = await model.sendMessage(modelRequest);
+    } catch (error) {
+      if (isAbortError(error) || signal?.aborted) {
+        return abortedResult();
+      }
+      throw error;
+    }
+    usage.add(modelResponse.usage);
+    if (signal?.aborted) return abortedResult();
+    if (debug) {
+      console.log("[react-observer-agent] LLM response:", {
+        content: modelResponse.content?.slice(0, 200),
+        toolCalls: modelResponse.toolCalls?.map((tc) => tc.name)
+      });
+    }
+    if (!modelResponse.toolCalls || modelResponse.toolCalls.length === 0) {
+      finalMessage = modelResponse.content ?? "";
+      completed = true;
+      break;
+    }
+    messages.push({
+      role: "assistant",
+      content: modelResponse.content ?? "",
+      toolCalls: modelResponse.toolCalls
+    });
+    for (const llmCall of modelResponse.toolCalls) {
+      if (signal?.aborted) return abortedResult();
+      if (llmCall.name === READ_STATE_TOOL_NAME) {
+        const args = llmCall.arguments;
+        const requestedKeys = args?.keys ?? [];
+        const allowedKeys = requestedKeys.filter((k) => permissions.canAccess.includes(k));
+        const snapshot = createStateSnapshot(state, allowedKeys, debug);
+        if (debug) {
+          console.log("[react-observer-agent] readState requested:", requestedKeys);
+          console.log("[react-observer-agent] readState allowed:", allowedKeys);
+          console.log("[react-observer-agent] readState result:", snapshot);
+        }
+        messages.push({
+          role: "tool",
+          content: JSON.stringify(snapshot),
+          toolCallId: llmCall.id
+        });
+        continue;
+      }
+      if (!validateToolCall(llmCall.name, permissions.canExecute)) {
+        const deniedResult = {
+          toolName: llmCall.name,
+          args: llmCall.arguments,
+          result: `Tool "${llmCall.name}" is not permitted`,
+          status: "denied"
+        };
+        allToolCalls.push(deniedResult);
+        options?.onToolCall?.({
+          toolName: llmCall.name,
+          args: llmCall.arguments,
+          result: deniedResult.result,
+          status: "denied"
+        });
+        messages.push({
+          role: "tool",
+          content: JSON.stringify({ error: deniedResult.result }),
+          toolCallId: llmCall.id
+        });
+        continue;
+      }
+      const toolDef = toolMap.get(llmCall.name);
+      if (!toolDef) {
+        const deniedResult = {
+          toolName: llmCall.name,
+          args: llmCall.arguments,
+          result: `Tool "${llmCall.name}" not found`,
+          status: "denied"
+        };
+        allToolCalls.push(deniedResult);
+        messages.push({
+          role: "tool",
+          content: JSON.stringify({ error: deniedResult.result }),
+          toolCallId: llmCall.id
+        });
+        continue;
+      }
+      if (toolDef.parameters) {
+        const validation = validateArgs(llmCall.arguments, toolDef.parameters);
+        if (!validation.valid) {
+          const errorMessage = `Invalid arguments for tool "${llmCall.name}": ${validation.errors.join("; ")}`;
+          if (debug) {
+            console.warn(`[react-observer-agent] ${errorMessage}`);
+          }
+          const invalidResult = {
+            toolName: llmCall.name,
+            args: llmCall.arguments,
+            result: errorMessage,
+            status: "error"
+          };
+          allToolCalls.push(invalidResult);
+          options?.onToolCall?.({
+            toolName: llmCall.name,
+            args: llmCall.arguments,
+            result: errorMessage,
+            status: "error"
+          });
+          messages.push({
+            role: "tool",
+            content: JSON.stringify({ error: errorMessage }),
+            toolCallId: llmCall.id
+          });
+          continue;
+        }
+      }
+      if (toolDef.confirm) {
+        if (!options?.onConfirm) {
+          if (debug) {
+            console.warn(
+              `[react-observer-agent] Tool "${llmCall.name}" requires confirmation but no onConfirm handler provided. Skipping.`
+            );
+          }
+          const cancelledResult = {
+            toolName: llmCall.name,
+            args: llmCall.arguments,
+            result: "Tool execution cancelled: no confirmation handler provided",
+            status: "cancelled"
+          };
+          allToolCalls.push(cancelledResult);
+          options?.onToolCall?.({
+            toolName: llmCall.name,
+            args: llmCall.arguments,
+            result: cancelledResult.result,
+            status: "cancelled"
+          });
+          messages.push({
+            role: "tool",
+            content: JSON.stringify({ status: "cancelled", reason: "No confirmation handler" }),
+            toolCallId: llmCall.id
+          });
+          continue;
+        }
+        const confirmed = await options.onConfirm({
+          toolName: llmCall.name,
+          args: llmCall.arguments,
+          description: toolDef.description
+        });
+        if (!confirmed) {
+          const cancelledResult = {
+            toolName: llmCall.name,
+            args: llmCall.arguments,
+            result: "Tool execution cancelled by user",
+            status: "cancelled"
+          };
+          allToolCalls.push(cancelledResult);
+          options?.onToolCall?.({
+            toolName: llmCall.name,
+            args: llmCall.arguments,
+            result: cancelledResult.result,
+            status: "cancelled"
+          });
+          messages.push({
+            role: "tool",
+            content: JSON.stringify({ status: "cancelled", reason: "User denied" }),
+            toolCallId: llmCall.id
+          });
+          continue;
+        }
+      }
+      try {
+        const result = await toolDef.handler(llmCall.arguments);
+        const status = toolDef.confirm ? "confirmed" : "success";
+        if (debug) {
+          console.log(`[react-observer-agent] Tool "${llmCall.name}" executed:`, { status, result });
+        }
+        const toolResult = {
+          toolName: llmCall.name,
+          args: llmCall.arguments,
+          result,
+          status
+        };
+        allToolCalls.push(toolResult);
+        options?.onToolCall?.({
+          toolName: llmCall.name,
+          args: llmCall.arguments,
+          result,
+          status
+        });
+        messages.push({
+          role: "tool",
+          content: JSON.stringify({ result }),
+          toolCallId: llmCall.id
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        const errorResult = {
+          toolName: llmCall.name,
+          args: llmCall.arguments,
+          result: errorMessage,
+          status: "error"
+        };
+        allToolCalls.push(errorResult);
+        options?.onToolCall?.({
+          toolName: llmCall.name,
+          args: llmCall.arguments,
+          result: errorMessage,
+          status: "error"
+        });
+        messages.push({
+          role: "tool",
+          content: JSON.stringify({ error: errorMessage }),
+          toolCallId: llmCall.id
+        });
+      }
+    }
+  }
+  if (!completed) {
+    if (debug) {
+      console.warn(`[react-observer-agent] Max turns (${maxTurns}) reached`);
+    }
+    return {
+      response: {
+        message: "",
+        toolCalls: allToolCalls,
+        error: {
+          message: `Agent did not produce a final response within ${maxTurns} turns`,
+          code: "MAX_TURNS"
+        },
+        usage: usage.total()
+      },
+      messages
+    };
+  }
+  messages.push({ role: "assistant", content: finalMessage });
+  return {
+    response: {
+      message: finalMessage,
+      toolCalls: allToolCalls,
+      usage: usage.total()
+    },
+    messages
+  };
+}
+
+// src/provider/AIAgentProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var AgentContextValue = createContext(null);
+function AIAgentProvider({
+  model,
+  state,
+  tools,
+  permissions,
+  options,
+  children
+}) {
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [history, setHistory] = useState([]);
+  const [lastResponse, setLastResponse] = useState(null);
+  const modelRef = useRef(model);
+  const stateRef = useRef(state);
+  const toolsRef = useRef(tools);
+  const permissionsRef = useRef(permissions);
+  const optionsRef = useRef(options);
+  modelRef.current = model;
+  stateRef.current = state;
+  toolsRef.current = tools;
+  permissionsRef.current = permissions;
+  optionsRef.current = options;
+  useEffect(() => {
+    validateToolNames(tools);
+  }, [tools]);
+  const transcriptRef = useRef([]);
+  const clearHistory = useCallback(() => {
+    setHistory([]);
+    setLastResponse(null);
+    transcriptRef.current = [];
+  }, []);
+  const send = useCallback(async (message, sendOptions) => {
+    setIsProcessing(true);
+    const userEntry = {
+      role: "user",
+      content: message,
+      timestamp: Date.now()
+    };
+    setHistory((prev) => [...prev, userEntry]);
+    try {
+      const { response, messages } = await executeAgentLoop(message, {
+        model: modelRef.current,
+        state: stateRef.current,
+        tools: toolsRef.current,
+        permissions: permissionsRef.current,
+        options: optionsRef.current,
+        conversationHistory: transcriptRef.current,
+        signal: sendOptions?.signal
+      });
+      if (response.error?.code !== "ABORTED") {
+        transcriptRef.current = messages;
+      }
+      const assistantEntry = {
+        role: "assistant",
+        content: response.message,
+        toolCalls: response.toolCalls,
+        timestamp: Date.now()
+      };
+      setHistory((prev) => [...prev, assistantEntry]);
+      setLastResponse(response);
+      if (response.error && response.error.code !== "ABORTED") {
+        optionsRef.current?.onError?.(response.error);
+      }
+      return response;
+    } catch (error) {
+      const agentError = {
+        message: error instanceof Error ? error.message : "Unknown error",
+        cause: error
+      };
+      const errorResponse = {
+        message: "",
+        toolCalls: [],
+        error: agentError
+      };
+      setLastResponse(errorResponse);
+      optionsRef.current?.onError?.(agentError);
+      return errorResponse;
+    } finally {
+      setIsProcessing(false);
+    }
+  }, []);
+  const contextValue = useMemo(
+    () => ({
+      send,
+      isProcessing,
+      history,
+      clearHistory,
+      lastResponse
+    }),
+    [send, isProcessing, history, clearHistory, lastResponse]
+  );
+  return /* @__PURE__ */ jsx(AgentContextValue.Provider, { value: contextValue, children });
+}
+
+// src/provider/useAgent.ts
+import { useContext } from "react";
+function useAgent() {
+  const context = useContext(AgentContextValue);
+  if (!context) {
+    throw new Error(
+      "useAgent() must be used within an <AIAgentProvider>. Wrap your component tree with <AIAgentProvider> to use this hook."
+    );
+  }
+  return context;
+}
+
+// src/permissions/filterState.ts
+function filterState(state, canAccess) {
+  const filtered = {};
+  for (const key of canAccess) {
+    if (key in state) {
+      filtered[key] = state[key];
+    }
+  }
+  return filtered;
+}
+
+// src/adapters/openai.ts
+var DEFAULT_MODEL = "gpt-4o";
+var DEFAULT_TEMPERATURE = 0.2;
+var OPENAI_BASE_URL = "https://api.openai.com/v1";
+function openAIAdapter(config) {
+  if (!config.apiKey && !config.baseURL) {
+    throw new Error(
+      'openAIAdapter requires either "apiKey" or "baseURL". Provide an API key for direct access, or a baseURL to route through your backend proxy.'
+    );
+  }
+  const baseURL = config.baseURL ? config.baseURL.replace(/\/+$/, "") : OPENAI_BASE_URL;
+  const model = config.model ?? DEFAULT_MODEL;
+  const temperature = config.temperature ?? DEFAULT_TEMPERATURE;
+  return {
+    async sendMessage(request) {
+      const headers = {
+        "Content-Type": "application/json",
+        ...config.headers
+      };
+      if (config.apiKey) {
+        headers["Authorization"] = `Bearer ${config.apiKey}`;
+      }
+      const messages = request.systemPrompt ? [
+        { role: "system", content: request.systemPrompt },
+        ...request.messages.map(formatMessage)
+      ] : request.messages.map(formatMessage);
+      const tools = request.tools.length > 0 ? request.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters
+        }
+      })) : void 0;
+      const body = {
+        model,
+        messages,
+        temperature
+      };
+      if (tools) {
+        body.tools = tools;
+      }
+      const url = baseURL.includes("/chat/completions") ? baseURL : `${baseURL}/chat/completions`;
+      let res;
+      try {
+        res = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+          signal: request.signal
+        });
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") throw error;
+        throw new Error(
+          `Network error calling OpenAI API: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(
+          `OpenAI API error (${res.status}): ${text || res.statusText}`
+        );
+      }
+      let data;
+      try {
+        data = await res.json();
+      } catch {
+        throw new Error("Failed to parse OpenAI API response as JSON");
+      }
+      return parseResponse(data);
+    }
+  };
+}
+function formatMessage(msg) {
+  const formatted = {
+    role: msg.role,
+    content: msg.content
+  };
+  if (msg.toolCallId) {
+    formatted.tool_call_id = msg.toolCallId;
+  }
+  if (msg.toolCalls && msg.toolCalls.length > 0) {
+    formatted.tool_calls = msg.toolCalls.map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: {
+        name: tc.name,
+        arguments: typeof tc.arguments === "string" ? tc.arguments : JSON.stringify(tc.arguments ?? {})
+      }
+    }));
+    if (msg.content === "") {
+      formatted.content = null;
+    }
+  }
+  return formatted;
+}
+function parseResponse(data) {
+  const obj = data;
+  const choices = obj.choices;
+  if (!choices || choices.length === 0) {
+    throw new Error("Malformed OpenAI response: no choices returned");
+  }
+  const message = choices[0].message;
+  if (!message) {
+    throw new Error("Malformed OpenAI response: no message in first choice");
+  }
+  const content = message.content ?? null;
+  const toolCalls = message.tool_calls;
+  const usage = obj.usage;
+  return {
+    content,
+    toolCalls: toolCalls?.map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      arguments: safeParseJSON(tc.function.arguments)
+    })),
+    usage: usage ? {
+      promptTokens: usage.prompt_tokens,
+      completionTokens: usage.completion_tokens
+    } : void 0
+  };
+}
+function safeParseJSON(str) {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return str;
+  }
+}
+
+// src/adapters/claude.ts
+var DEFAULT_MODEL2 = "claude-opus-5";
+var DEFAULT_MAX_TOKENS = 16e3;
+var ANTHROPIC_BASE_URL = "https://api.anthropic.com";
+var ANTHROPIC_VERSION = "2023-06-01";
+function claudeAdapter(config) {
+  if (!config.apiKey && !config.baseURL) {
+    throw new Error(
+      'claudeAdapter requires either "apiKey" or "baseURL". Provide an API key for direct access, or a baseURL to route through your backend proxy.'
+    );
+  }
+  const baseURL = config.baseURL ? config.baseURL.replace(/\/+$/, "") : ANTHROPIC_BASE_URL;
+  const model = config.model ?? DEFAULT_MODEL2;
+  const maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
+  return {
+    async sendMessage(request) {
+      const headers = {
+        "Content-Type": "application/json",
+        "anthropic-version": ANTHROPIC_VERSION
+      };
+      if (config.apiKey) {
+        headers["x-api-key"] = config.apiKey;
+      }
+      Object.assign(headers, config.headers);
+      const body = {
+        model,
+        max_tokens: maxTokens,
+        messages: toAnthropicMessages(request.messages)
+      };
+      if (request.systemPrompt) {
+        body.system = request.systemPrompt;
+      }
+      if (request.tools.length > 0) {
+        body.tools = request.tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          input_schema: t.parameters
+        }));
+      }
+      const url = baseURL.includes("/v1/messages") ? baseURL : `${baseURL}/v1/messages`;
+      let res;
+      try {
+        res = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+          signal: request.signal
+        });
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") throw error;
+        throw new Error(
+          `Network error calling Anthropic API: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(
+          `Anthropic API error (${res.status}): ${text || res.statusText}`
+        );
+      }
+      let data;
+      try {
+        data = await res.json();
+      } catch {
+        throw new Error("Failed to parse Anthropic API response as JSON");
+      }
+      return parseResponse2(data);
+    }
+  };
+}
+function toAnthropicMessages(messages) {
+  const result = [];
+  let pendingToolResults = [];
+  const flushToolResults = () => {
+    if (pendingToolResults.length > 0) {
+      result.push({ role: "user", content: pendingToolResults });
+      pendingToolResults = [];
+    }
+  };
+  for (const message of messages) {
+    if (message.role === "tool") {
+      pendingToolResults.push({
+        type: "tool_result",
+        tool_use_id: message.toolCallId ?? "",
+        content: message.content
+      });
+      continue;
+    }
+    flushToolResults();
+    if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
+      const blocks = [];
+      if (message.content) {
+        blocks.push({ type: "text", text: message.content });
+      }
+      for (const call of message.toolCalls) {
+        blocks.push({
+          type: "tool_use",
+          id: call.id,
+          name: call.name,
+          input: isPlainObject2(call.arguments) ? call.arguments : {}
+        });
+      }
+      result.push({ role: "assistant", content: blocks });
+      continue;
+    }
+    result.push({ role: message.role, content: message.content });
+  }
+  flushToolResults();
+  return result;
+}
+function parseResponse2(data) {
+  const obj = data;
+  const blocks = obj.content;
+  if (!Array.isArray(blocks)) {
+    throw new Error("Malformed Anthropic response: no content blocks returned");
+  }
+  const textParts = [];
+  const toolCalls = [];
+  for (const block of blocks) {
+    if (block?.type === "text") {
+      textParts.push(block.text);
+    } else if (block?.type === "tool_use") {
+      toolCalls.push({
+        id: block.id,
+        name: block.name,
+        arguments: block.input
+      });
+    }
+  }
+  const usage = obj.usage;
+  return {
+    content: textParts.length > 0 ? textParts.join("") : null,
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    usage: usage ? {
+      promptTokens: usage.input_tokens,
+      completionTokens: usage.output_tokens
+    } : void 0
+  };
+}
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  AIAgentProvider,
+  claudeAdapter,
+  filterState,
+  filterTools,
+  openAIAdapter,
+  registerTool,
+  useAgent,
+  validateToolCall,
+  validateToolNames
+};
+//# sourceMappingURL=index.js.map