@yourgpt/copilot-sdk 0.1.0

package/dist/chunk-W6KQT7YZ.cjs

@@ -0,0 +1,3152 @@
+'use strict';
+
+var chunk2ZCWVAAK_cjs = require('./chunk-2ZCWVAAK.cjs');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var z = require('zod');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespace(z);
+
+// src/chat/types/tool.ts
+var initialAgentLoopState = {
+  toolExecutions: [],
+  iteration: 0,
+  maxIterations: 20,
+  maxIterationsReached: false,
+  isProcessing: false
+};
+
+// src/chat/interfaces/ChatState.ts
+var SimpleChatState = class {
+  constructor() {
+    this._messages = [];
+    this._status = "ready";
+    this._error = void 0;
+    this.callbacks = /* @__PURE__ */ new Set();
+  }
+  get messages() {
+    return this._messages;
+  }
+  set messages(value) {
+    this._messages = value;
+    this.notify();
+  }
+  get status() {
+    return this._status;
+  }
+  set status(value) {
+    this._status = value;
+    this.notify();
+  }
+  get error() {
+    return this._error;
+  }
+  set error(value) {
+    this._error = value;
+    this.notify();
+  }
+  pushMessage(message) {
+    this._messages = [...this._messages, message];
+    this.notify();
+  }
+  popMessage() {
+    this._messages = this._messages.slice(0, -1);
+    this.notify();
+  }
+  replaceMessage(index, message) {
+    this._messages = [
+      ...this._messages.slice(0, index),
+      message,
+      ...this._messages.slice(index + 1)
+    ];
+    this.notify();
+  }
+  updateLastMessage(updater) {
+    if (this._messages.length === 0) return;
+    const lastIndex = this._messages.length - 1;
+    this.replaceMessage(lastIndex, updater(this._messages[lastIndex]));
+  }
+  setMessages(messages) {
+    this._messages = messages;
+    this.notify();
+  }
+  clearMessages() {
+    this._messages = [];
+    this.notify();
+  }
+  subscribe(callback) {
+    this.callbacks.add(callback);
+    return () => this.callbacks.delete(callback);
+  }
+  getMessagesSnapshot() {
+    return this._messages;
+  }
+  getStatusSnapshot() {
+    return this._status;
+  }
+  getErrorSnapshot() {
+    return this._error;
+  }
+  notify() {
+    this.callbacks.forEach((cb) => cb());
+  }
+};
+
+// src/chat/functions/stream/parseSSE.ts
+function parseSSELine(line) {
+  if (!line || line.trim() === "") {
+    return null;
+  }
+  if (line.startsWith(":")) {
+    return null;
+  }
+  if (line.startsWith("data: ")) {
+    const data = line.slice(6);
+    if (data === "[DONE]") {
+      return { type: "done" };
+    }
+    try {
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function isStreamDone(chunk) {
+  return chunk.type === "done" || chunk.type === "error";
+}
+function requiresToolExecution(chunk) {
+  if (chunk.type === "done" && chunk.requiresAction) {
+    return true;
+  }
+  if (chunk.type === "tool_calls") {
+    return true;
+  }
+  return false;
+}
+
+// src/chat/functions/stream/processChunk.ts
+function processStreamChunk(chunk, state) {
+  switch (chunk.type) {
+    case "message:start":
+      return {
+        ...state,
+        messageId: chunk.id
+      };
+    case "message:delta":
+      return {
+        ...state,
+        content: state.content + chunk.content
+      };
+    case "message:end":
+      return {
+        ...state,
+        finishReason: "stop"
+      };
+    case "thinking:delta":
+      return {
+        ...state,
+        thinking: state.thinking + chunk.content
+      };
+    case "tool_calls":
+      return {
+        ...state,
+        toolCalls: parseToolCalls(chunk.toolCalls),
+        requiresAction: true
+      };
+    case "done":
+      return {
+        ...state,
+        requiresAction: chunk.requiresAction ?? false,
+        finishReason: "stop"
+      };
+    case "error":
+      return {
+        ...state,
+        finishReason: "error"
+      };
+    default:
+      return state;
+  }
+}
+function parseToolCalls(rawToolCalls) {
+  return rawToolCalls.map((tc) => {
+    const toolCall = tc;
+    if (toolCall.function) {
+      return {
+        id: toolCall.id,
+        name: toolCall.function.name,
+        args: JSON.parse(toolCall.function.arguments)
+      };
+    }
+    return {
+      id: toolCall.id,
+      name: toolCall.name ?? "",
+      args: toolCall.args ?? {}
+    };
+  });
+}
+function createStreamState(messageId) {
+  return {
+    messageId,
+    content: "",
+    thinking: "",
+    toolCalls: [],
+    requiresAction: false,
+    finishReason: void 0
+  };
+}
+
+// src/chat/functions/message/createMessage.ts
+function generateMessageId() {
+  return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function createUserMessage(content, attachments) {
+  return {
+    id: generateMessageId(),
+    role: "user",
+    content,
+    attachments,
+    createdAt: /* @__PURE__ */ new Date()
+  };
+}
+function streamStateToMessage(state) {
+  const toolCalls = state.toolCalls.length > 0 ? state.toolCalls.map((tc) => ({
+    id: tc.id,
+    type: "function",
+    function: {
+      name: tc.name,
+      arguments: JSON.stringify(tc.args)
+    }
+  })) : void 0;
+  return {
+    id: state.messageId,
+    role: "assistant",
+    content: state.content,
+    thinking: state.thinking || void 0,
+    toolCalls,
+    createdAt: /* @__PURE__ */ new Date()
+  };
+}
+function createEmptyAssistantMessage(id) {
+  return {
+    id: generateMessageId(),
+    role: "assistant",
+    content: "",
+    createdAt: /* @__PURE__ */ new Date()
+  };
+}
+
+// src/chat/adapters/HttpTransport.ts
+var HttpTransport = class {
+  constructor(config) {
+    this.abortController = null;
+    this.streaming = false;
+    this.config = {
+      streaming: true,
+      timeout: 6e4,
+      ...config
+    };
+  }
+  /**
+   * Send a chat request
+   */
+  async send(request) {
+    this.abortController = new AbortController();
+    this.streaming = true;
+    try {
+      const response = await fetch(this.config.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.headers
+        },
+        body: JSON.stringify({
+          messages: request.messages,
+          threadId: request.threadId,
+          systemPrompt: request.systemPrompt,
+          llm: request.llm,
+          tools: request.tools,
+          actions: request.actions,
+          streaming: this.config.streaming,
+          ...request.body
+        }),
+        signal: this.abortController.signal
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`HTTP ${response.status}: ${error}`);
+      }
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        this.streaming = false;
+        const json = await response.json();
+        return json;
+      }
+      if (!response.body) {
+        throw new Error("No response body");
+      }
+      return this.createStreamIterable(response.body);
+    } catch (error) {
+      this.streaming = false;
+      if (error.name === "AbortError") {
+        return (async function* () {
+        })();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Abort the current request
+   */
+  abort() {
+    this.abortController?.abort();
+    this.abortController = null;
+    this.streaming = false;
+  }
+  /**
+   * Check if currently streaming
+   */
+  isStreaming() {
+    return this.streaming;
+  }
+  /**
+   * Create an async iterable from a ReadableStream
+   */
+  createStreamIterable(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const chunkQueue = [];
+    let streamDone = false;
+    const self = this;
+    return {
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            if (chunkQueue.length > 0) {
+              return { value: chunkQueue.shift(), done: false };
+            }
+            if (streamDone) {
+              return { value: void 0, done: true };
+            }
+            try {
+              const { done, value } = await reader.read();
+              if (done) {
+                self.streaming = false;
+                streamDone = true;
+                if (buffer.trim()) {
+                  const chunk = parseSSELine(buffer.trim());
+                  if (chunk) {
+                    buffer = "";
+                    return { value: chunk, done: false };
+                  }
+                }
+                return {
+                  value: void 0,
+                  done: true
+                };
+              }
+              buffer += decoder.decode(value, { stream: true });
+              const lines = buffer.split("\n");
+              buffer = lines.pop() || "";
+              for (const line of lines) {
+                const chunk = parseSSELine(line);
+                if (chunk) {
+                  chunkQueue.push(chunk);
+                }
+              }
+              if (chunkQueue.length > 0) {
+                return { value: chunkQueue.shift(), done: false };
+              }
+              return this.next();
+            } catch (error) {
+              self.streaming = false;
+              streamDone = true;
+              if (error.name === "AbortError") {
+                return {
+                  value: void 0,
+                  done: true
+                };
+              }
+              throw error;
+            }
+          }
+        };
+      }
+    };
+  }
+};
+
+// src/chat/classes/AbstractChat.ts
+function buildToolResultContentForAI(result, tool, args) {
+  if (typeof result === "string") return result;
+  const typedResult = result;
+  const responseMode = typedResult?._aiResponseMode ?? tool?.aiResponseMode ?? "full";
+  if (typedResult?._aiContent) {
+    return JSON.stringify(typedResult._aiContent);
+  }
+  let aiContext = typedResult?._aiContext;
+  if (!aiContext && tool?.aiContext) {
+    aiContext = typeof tool.aiContext === "function" ? tool.aiContext(typedResult, args ?? {}) : tool.aiContext;
+  }
+  switch (responseMode) {
+    case "none":
+      return aiContext ?? "[Result displayed to user]";
+    case "brief":
+      return aiContext ?? "[Tool executed successfully]";
+    case "full":
+    default:
+      if (aiContext) {
+        const { _aiResponseMode, _aiContext, _aiContent, ...dataOnly } = typedResult ?? {};
+        return `${aiContext}
+
+Full data: ${JSON.stringify(dataOnly)}`;
+      }
+      return JSON.stringify(result);
+  }
+}
+var AbstractChat = class {
+  constructor(init) {
+    // Event handlers
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    // Current streaming state
+    this.streamState = null;
+    /**
+     * Dynamic context from useAIContext hook
+     */
+    this.dynamicContext = "";
+    this.config = {
+      runtimeUrl: init.runtimeUrl,
+      llm: init.llm,
+      systemPrompt: init.systemPrompt,
+      streaming: init.streaming ?? true,
+      headers: init.headers,
+      threadId: init.threadId,
+      debug: init.debug
+    };
+    this.state = init.state ?? new SimpleChatState();
+    this.transport = init.transport ?? new HttpTransport({
+      url: init.runtimeUrl,
+      headers: init.headers,
+      streaming: init.streaming ?? true
+    });
+    this.callbacks = init.callbacks ?? {};
+    if (init.initialMessages?.length) {
+      this.state.setMessages(init.initialMessages);
+    }
+  }
+  // ============================================
+  // Public Getters
+  // ============================================
+  get messages() {
+    return this.state.messages;
+  }
+  get status() {
+    return this.state.status;
+  }
+  get error() {
+    return this.state.error;
+  }
+  get isStreaming() {
+    return this.transport.isStreaming();
+  }
+  // ============================================
+  // Public Actions
+  // ============================================
+  /**
+   * Send a message
+   */
+  async sendMessage(content, attachments) {
+    this.debug("sendMessage", { content, attachments });
+    try {
+      const userMessage = createUserMessage(content, attachments);
+      this.state.pushMessage(userMessage);
+      this.state.status = "submitted";
+      this.state.error = void 0;
+      this.callbacks.onMessagesChange?.(this.state.messages);
+      this.callbacks.onStatusChange?.("submitted");
+      await Promise.resolve();
+      await this.processRequest();
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Continue with tool results
+   *
+   * Automatically handles `addAsUserMessage` flag in results (e.g., screenshots).
+   * When a tool result has this flag, the attachment is extracted and sent as
+   * a user message so the AI can see it (e.g., for vision analysis).
+   */
+  async continueWithToolResults(toolResults) {
+    this.debug("continueWithToolResults", toolResults);
+    try {
+      const attachmentsToAdd = [];
+      for (const { toolCallId, result } of toolResults) {
+        const typedResult = result;
+        let messageContent;
+        if (typedResult?.addAsUserMessage && typedResult.data?.attachment) {
+          this.debug(
+            "Tool result has attachment to add as user message",
+            typedResult.data.attachment.type
+          );
+          attachmentsToAdd.push(typedResult.data.attachment);
+          messageContent = JSON.stringify({
+            success: true,
+            message: typedResult.message || "Content shared in conversation."
+          });
+        } else {
+          messageContent = typeof result === "string" ? result : JSON.stringify(result);
+        }
+        const toolMessage = {
+          id: generateMessageId(),
+          role: "tool",
+          content: messageContent,
+          toolCallId,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        this.state.pushMessage(toolMessage);
+      }
+      if (attachmentsToAdd.length > 0) {
+        this.debug(
+          "Adding user message with attachments",
+          attachmentsToAdd.length
+        );
+        const userMessage = {
+          id: generateMessageId(),
+          role: "user",
+          content: "Here's my screen:",
+          attachments: attachmentsToAdd,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        this.state.pushMessage(userMessage);
+      }
+      this.state.status = "submitted";
+      this.callbacks.onMessagesChange?.(this.state.messages);
+      this.callbacks.onStatusChange?.("submitted");
+      await Promise.resolve();
+      await this.processRequest();
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Stop generation
+   */
+  stop() {
+    this.transport.abort();
+    this.state.status = "ready";
+    this.callbacks.onStatusChange?.("ready");
+  }
+  /**
+   * Clear all messages
+   */
+  clearMessages() {
+    this.state.clearMessages();
+    this.callbacks.onMessagesChange?.([]);
+  }
+  /**
+   * Set messages directly
+   */
+  setMessages(messages) {
+    this.state.setMessages(messages);
+    this.callbacks.onMessagesChange?.(messages);
+  }
+  /**
+   * Regenerate last response
+   */
+  async regenerate(messageId) {
+    const messages = this.state.messages;
+    let targetIndex = messages.length - 1;
+    if (messageId) {
+      targetIndex = messages.findIndex((m) => m.id === messageId);
+    } else {
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "assistant") {
+          targetIndex = i;
+          break;
+        }
+      }
+    }
+    if (targetIndex > 0) {
+      this.state.setMessages(messages.slice(0, targetIndex));
+      this.callbacks.onMessagesChange?.(this.state.messages);
+      await this.processRequest();
+    }
+  }
+  // ============================================
+  // Event Handling
+  // ============================================
+  /**
+   * Subscribe to events
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+    return () => {
+      this.eventHandlers.get(event)?.delete(handler);
+    };
+  }
+  /**
+   * Emit an event
+   */
+  emit(type, data) {
+    const event = { type, ...data };
+    this.eventHandlers.get(type)?.forEach((handler) => handler(event));
+  }
+  // ============================================
+  // Protected Methods
+  // ============================================
+  /**
+   * Process a chat request
+   */
+  async processRequest() {
+    const request = this.buildRequest();
+    const response = await this.transport.send(request);
+    if (this.isAsyncIterable(response)) {
+      await this.handleStreamResponse(response);
+    } else {
+      this.handleJsonResponse(response);
+    }
+  }
+  /**
+   * Set tools available for the LLM
+   */
+  setTools(tools) {
+    this.config.tools = tools;
+  }
+  /**
+   * Set dynamic context (appended to system prompt)
+   */
+  setContext(context) {
+    this.dynamicContext = context;
+    this.debug("Context updated", { length: context.length });
+  }
+  /**
+   * Build the request payload
+   */
+  buildRequest() {
+    const tools = this.config.tools?.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }));
+    const toolCallMap = /* @__PURE__ */ new Map();
+    for (const msg of this.state.messages) {
+      if (msg.role === "assistant" && msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          try {
+            const args = tc.function?.arguments ? JSON.parse(tc.function.arguments) : {};
+            toolCallMap.set(tc.id, { toolName: tc.function.name, args });
+          } catch {
+            toolCallMap.set(tc.id, { toolName: tc.function.name, args: {} });
+          }
+        }
+      }
+    }
+    const toolDefMap = /* @__PURE__ */ new Map();
+    if (this.config.tools) {
+      for (const tool of this.config.tools) {
+        toolDefMap.set(tool.name, {
+          name: tool.name,
+          aiResponseMode: tool.aiResponseMode,
+          aiContext: tool.aiContext
+        });
+      }
+    }
+    return {
+      messages: this.state.messages.map((m) => {
+        if (m.role === "tool" && m.content && m.toolCallId) {
+          try {
+            const fullResult = JSON.parse(m.content);
+            const toolCallInfo = toolCallMap.get(m.toolCallId);
+            const toolDef = toolCallInfo ? toolDefMap.get(toolCallInfo.toolName) : void 0;
+            const toolArgs = toolCallInfo?.args;
+            const transformedContent = buildToolResultContentForAI(
+              fullResult,
+              toolDef,
+              toolArgs
+            );
+            return {
+              role: m.role,
+              content: transformedContent,
+              tool_call_id: m.toolCallId
+            };
+          } catch (e) {
+            this.debug("Failed to parse tool message JSON", {
+              content: m.content?.slice(0, 100),
+              error: e instanceof Error ? e.message : String(e)
+            });
+            return {
+              role: m.role,
+              content: m.content,
+              tool_call_id: m.toolCallId
+            };
+          }
+        }
+        return {
+          role: m.role,
+          content: m.content,
+          tool_calls: m.toolCalls,
+          tool_call_id: m.toolCallId,
+          attachments: m.attachments
+        };
+      }),
+      threadId: this.config.threadId,
+      systemPrompt: this.dynamicContext ? `${this.config.systemPrompt || ""}
+
+## Current App Context:
+${this.dynamicContext}`.trim() : this.config.systemPrompt,
+      llm: this.config.llm,
+      tools: tools?.length ? tools : void 0
+    };
+  }
+  /**
+   * Handle streaming response
+   */
+  async handleStreamResponse(stream) {
+    this.state.status = "streaming";
+    this.callbacks.onStatusChange?.("streaming");
+    const assistantMessage = createEmptyAssistantMessage();
+    this.state.pushMessage(assistantMessage);
+    this.streamState = createStreamState(assistantMessage.id);
+    this.callbacks.onMessageStart?.(assistantMessage.id);
+    this.debug("handleStreamResponse", "Starting to process stream");
+    let chunkCount = 0;
+    let toolCallsEmitted = false;
+    for await (const chunk of stream) {
+      chunkCount++;
+      this.debug("chunk", { count: chunkCount, type: chunk.type });
+      if (chunk.type === "error") {
+        const error = new Error(chunk.message || "Stream error");
+        this.handleError(error);
+        return;
+      }
+      this.streamState = processStreamChunk(chunk, this.streamState);
+      const updatedMessage = streamStateToMessage(this.streamState);
+      this.state.updateLastMessage(() => updatedMessage);
+      if (chunk.type === "message:delta") {
+        this.callbacks.onMessageDelta?.(assistantMessage.id, chunk.content);
+      }
+      if (requiresToolExecution(chunk) && !toolCallsEmitted) {
+        toolCallsEmitted = true;
+        this.debug("toolCalls", { toolCalls: updatedMessage.toolCalls });
+        this.emit("toolCalls", { toolCalls: updatedMessage.toolCalls });
+      }
+      if (isStreamDone(chunk)) {
+        this.debug("streamDone", { chunk });
+        break;
+      }
+    }
+    this.debug("handleStreamResponse", `Processed ${chunkCount} chunks`);
+    const finalMessage = streamStateToMessage(this.streamState);
+    this.state.updateLastMessage(() => finalMessage);
+    this.state.status = "ready";
+    if (!finalMessage.content && (!finalMessage.toolCalls || finalMessage.toolCalls.length === 0)) {
+      this.debug("warning", "Empty response - no content and no tool calls");
+    }
+    this.callbacks.onMessageFinish?.(finalMessage);
+    this.callbacks.onStatusChange?.("ready");
+    this.callbacks.onMessagesChange?.(this.state.messages);
+    this.callbacks.onFinish?.(this.state.messages);
+    this.emit("done", {});
+    this.streamState = null;
+  }
+  /**
+   * Handle JSON (non-streaming) response
+   */
+  handleJsonResponse(response) {
+    for (const msg of response.messages ?? []) {
+      const message = {
+        id: generateMessageId(),
+        role: msg.role,
+        content: msg.content ?? "",
+        toolCalls: msg.tool_calls,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      this.state.pushMessage(message);
+    }
+    this.state.status = "ready";
+    this.callbacks.onStatusChange?.("ready");
+    this.callbacks.onMessagesChange?.(this.state.messages);
+    this.callbacks.onFinish?.(this.state.messages);
+    if (response.requiresAction && this.state.messages.length > 0) {
+      const lastMessage = this.state.messages[this.state.messages.length - 1];
+      if (lastMessage?.toolCalls?.length) {
+        this.emit("toolCalls", { toolCalls: lastMessage.toolCalls });
+      }
+    }
+    this.emit("done", {});
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    this.debug("error", error);
+    this.state.error = error;
+    this.state.status = "error";
+    this.callbacks.onError?.(error);
+    this.callbacks.onStatusChange?.("error");
+    this.emit("error", { error });
+  }
+  /**
+   * Debug logging
+   */
+  debug(action, data) {
+    if (this.config.debug) {
+      console.log(`[AbstractChat] ${action}`, data);
+    }
+  }
+  /**
+   * Type guard for async iterable
+   */
+  isAsyncIterable(value) {
+    return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
+  }
+  /**
+   * Dispose and cleanup
+   */
+  dispose() {
+    this.stop();
+    this.eventHandlers.clear();
+  }
+};
+
+// src/chat/AbstractAgentLoop.ts
+var AbstractAgentLoop = class {
+  constructor(config = {}, callbacks = {}) {
+    // Internal state
+    this._toolExecutions = [];
+    this._iteration = 0;
+    this._maxIterationsReached = false;
+    this._isProcessing = false;
+    // Registered tools
+    this.registeredTools = /* @__PURE__ */ new Map();
+    // Pending approvals
+    this.pendingApprovals = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.callbacks = callbacks;
+    this._maxIterations = config.maxIterations ?? 20;
+    this._maxExecutionHistory = config.maxExecutionHistory ?? 100;
+    if (config.tools) {
+      for (const tool of config.tools) {
+        this.registerTool(tool);
+      }
+    }
+  }
+  // ============================================
+  // Getters
+  // ============================================
+  get toolExecutions() {
+    return this._toolExecutions;
+  }
+  get iteration() {
+    return this._iteration;
+  }
+  get maxIterations() {
+    return this._maxIterations;
+  }
+  get maxIterationsReached() {
+    return this._maxIterationsReached;
+  }
+  get isProcessing() {
+    return this._isProcessing;
+  }
+  get state() {
+    return {
+      toolExecutions: this._toolExecutions,
+      iteration: this._iteration,
+      maxIterations: this._maxIterations,
+      maxIterationsReached: this._maxIterationsReached,
+      isProcessing: this._isProcessing
+    };
+  }
+  get pendingApprovalExecutions() {
+    return this._toolExecutions.filter(
+      (exec) => exec.approvalStatus === "required"
+    );
+  }
+  get tools() {
+    return Array.from(this.registeredTools.values());
+  }
+  // ============================================
+  // Private setters with callbacks
+  // ============================================
+  setToolExecutions(executions) {
+    this._toolExecutions = executions;
+    this.callbacks.onExecutionsChange?.(executions);
+  }
+  setIteration(iteration) {
+    this._iteration = iteration;
+  }
+  setProcessing(processing) {
+    this._isProcessing = processing;
+  }
+  addToolExecution(execution) {
+    this._toolExecutions = [...this._toolExecutions, execution];
+    if (this._toolExecutions.length > this._maxExecutionHistory) {
+      this._toolExecutions = this._toolExecutions.slice(
+        -this._maxExecutionHistory
+      );
+    }
+    this.callbacks.onExecutionsChange?.(this._toolExecutions);
+  }
+  updateToolExecution(id, update) {
+    this._toolExecutions = this._toolExecutions.map(
+      (exec) => exec.id === id ? { ...exec, ...update } : exec
+    );
+    this.callbacks.onExecutionsChange?.(this._toolExecutions);
+  }
+  // ============================================
+  // Tool Registration
+  // ============================================
+  /**
+   * Register a tool
+   */
+  registerTool(tool) {
+    this.registeredTools.set(tool.name, tool);
+  }
+  /**
+   * Unregister a tool
+   */
+  unregisterTool(name) {
+    this.registeredTools.delete(name);
+  }
+  /**
+   * Get a registered tool
+   */
+  getTool(name) {
+    return this.registeredTools.get(name);
+  }
+  // ============================================
+  // Tool Execution
+  // ============================================
+  /**
+   * Execute tool calls from LLM response
+   * Returns tool results for sending back to LLM
+   */
+  async executeToolCalls(toolCalls) {
+    if (this._iteration >= this._maxIterations) {
+      this._maxIterationsReached = true;
+      this.callbacks.onMaxIterationsReached?.();
+      return [];
+    }
+    this.setIteration(this._iteration + 1);
+    const results = [];
+    for (const toolCall of toolCalls) {
+      const result = await this.executeSingleTool(toolCall);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Execute a single tool
+   */
+  async executeSingleTool(toolCall) {
+    const tool = this.registeredTools.get(toolCall.name);
+    const execution = {
+      id: toolCall.id,
+      toolCallId: toolCall.id,
+      name: toolCall.name,
+      args: toolCall.args,
+      status: "pending",
+      approvalStatus: "none",
+      startedAt: /* @__PURE__ */ new Date()
+    };
+    this.addToolExecution(execution);
+    this.callbacks.onToolStart?.(execution);
+    if (!tool) {
+      const errorResult = {
+        toolCallId: toolCall.id,
+        success: false,
+        error: `Tool "${toolCall.name}" not found`
+      };
+      this.updateToolExecution(toolCall.id, {
+        status: "failed",
+        error: errorResult.error,
+        completedAt: /* @__PURE__ */ new Date()
+      });
+      return errorResult;
+    }
+    if (tool.needsApproval && !this.config.autoApprove) {
+      typeof tool.approvalMessage === "function" ? tool.approvalMessage(toolCall.args) : tool.approvalMessage;
+      execution.approvalStatus = "required";
+      this.updateToolExecution(toolCall.id, {
+        approvalStatus: "required"
+      });
+      this.callbacks.onApprovalRequired?.(execution);
+      const approved = await this.waitForApproval(toolCall.id, execution);
+      if (!approved) {
+        const rejectedResult = {
+          toolCallId: toolCall.id,
+          success: false,
+          error: "Tool execution was rejected by user"
+        };
+        this.updateToolExecution(toolCall.id, {
+          status: "rejected",
+          approvalStatus: "rejected",
+          error: rejectedResult.error,
+          completedAt: /* @__PURE__ */ new Date()
+        });
+        return rejectedResult;
+      }
+      this.updateToolExecution(toolCall.id, {
+        approvalStatus: "approved"
+      });
+    }
+    this.updateToolExecution(toolCall.id, { status: "executing" });
+    try {
+      if (!tool.handler) {
+        throw new Error(`Tool "${toolCall.name}" has no handler`);
+      }
+      const result = await tool.handler(toolCall.args, {
+        data: { toolCallId: toolCall.id }
+      });
+      this.updateToolExecution(toolCall.id, {
+        status: "completed",
+        result,
+        completedAt: /* @__PURE__ */ new Date()
+      });
+      const updatedExecution = this._toolExecutions.find(
+        (e) => e.id === toolCall.id
+      );
+      if (updatedExecution) {
+        this.callbacks.onToolComplete?.(updatedExecution);
+      }
+      return {
+        toolCallId: toolCall.id,
+        success: true,
+        result
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.updateToolExecution(toolCall.id, {
+        status: "failed",
+        error: errorMessage,
+        completedAt: /* @__PURE__ */ new Date()
+      });
+      return {
+        toolCallId: toolCall.id,
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Wait for user approval
+   */
+  waitForApproval(executionId, execution) {
+    return new Promise((resolve) => {
+      this.pendingApprovals.set(executionId, { resolve, execution });
+    });
+  }
+  // ============================================
+  // Actions (implements AgentLoopActions)
+  // ============================================
+  /**
+   * Approve a tool execution
+   */
+  approveToolExecution(executionId, _permissionLevel) {
+    const pending = this.pendingApprovals.get(executionId);
+    if (pending) {
+      pending.resolve(true);
+      this.pendingApprovals.delete(executionId);
+    }
+  }
+  /**
+   * Reject a tool execution
+   */
+  rejectToolExecution(executionId, reason, _permissionLevel) {
+    const pending = this.pendingApprovals.get(executionId);
+    if (pending) {
+      if (reason) {
+        this.updateToolExecution(executionId, {
+          error: reason
+        });
+      }
+      pending.resolve(false);
+      this.pendingApprovals.delete(executionId);
+    }
+  }
+  /**
+   * Clear all tool executions
+   */
+  clearToolExecutions() {
+    this.setToolExecutions([]);
+    this.setIteration(0);
+    this._maxIterationsReached = false;
+  }
+  // ============================================
+  // State Management
+  // ============================================
+  /**
+   * Reset the agent loop for a new conversation
+   */
+  reset() {
+    this.clearToolExecutions();
+    this.pendingApprovals.clear();
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    if (config.maxIterations !== void 0) {
+      this._maxIterations = config.maxIterations;
+    }
+  }
+  /**
+   * Update callbacks
+   */
+  updateCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
+  // ============================================
+  // Cleanup
+  // ============================================
+  /**
+   * Dispose of resources
+   */
+  dispose() {
+    for (const [id, pending] of this.pendingApprovals) {
+      pending.resolve(false);
+    }
+    this.pendingApprovals.clear();
+    this.registeredTools.clear();
+    this._toolExecutions = [];
+  }
+};
+
+// src/chat/ChatWithTools.ts
+var ChatWithTools = class {
+  constructor(config, callbacks = {}) {
+    this.config = config;
+    this.callbacks = callbacks;
+    this.agentLoop = new AbstractAgentLoop(
+      {
+        maxIterations: config.maxIterations ?? 20,
+        tools: config.tools
+      },
+      {
+        onExecutionsChange: (executions) => {
+          callbacks.onToolExecutionsChange?.(executions);
+        },
+        onApprovalRequired: (execution) => {
+          callbacks.onApprovalRequired?.(execution);
+        }
+      }
+    );
+    this.chat = new AbstractChat({
+      runtimeUrl: config.runtimeUrl,
+      llm: config.llm,
+      systemPrompt: config.systemPrompt,
+      streaming: config.streaming,
+      headers: config.headers,
+      threadId: config.threadId,
+      debug: config.debug,
+      initialMessages: config.initialMessages,
+      state: config.state,
+      transport: config.transport,
+      callbacks: {
+        onMessagesChange: callbacks.onMessagesChange,
+        onStatusChange: callbacks.onStatusChange,
+        onError: callbacks.onError,
+        onMessageStart: callbacks.onMessageStart,
+        onMessageDelta: callbacks.onMessageDelta,
+        onMessageFinish: callbacks.onMessageFinish,
+        onToolCalls: callbacks.onToolCalls,
+        onFinish: callbacks.onFinish
+      }
+    });
+    this.wireEvents();
+  }
+  /**
+   * Wire up internal events between chat and agent loop
+   */
+  wireEvents() {
+    this.chat.on("toolCalls", async (event) => {
+      const toolCalls = event.toolCalls;
+      if (!toolCalls?.length) return;
+      this.debug("Tool calls received:", toolCalls);
+      const toolCallInfos = toolCalls.map((tc) => {
+        const tcAny = tc;
+        const name = tcAny.function?.name ?? tcAny.name ?? "";
+        let args = {};
+        if (tcAny.function?.arguments) {
+          try {
+            args = JSON.parse(tcAny.function.arguments);
+          } catch {
+            args = {};
+          }
+        } else if (tcAny.args) {
+          args = tcAny.args;
+        }
+        return { id: tc.id, name, args };
+      });
+      try {
+        const results = await this.agentLoop.executeToolCalls(toolCallInfos);
+        this.debug("Tool results:", results);
+        if (results.length > 0) {
+          const toolResults = results.map((r) => ({
+            toolCallId: r.toolCallId,
+            result: r.success ? r.result : { success: false, error: r.error }
+          }));
+          await this.chat.continueWithToolResults(toolResults);
+        }
+      } catch (error) {
+        this.debug("Error executing tools:", error);
+        console.error("[ChatWithTools] Tool execution error:", error);
+      }
+    });
+  }
+  // ============================================
+  // Chat Getters
+  // ============================================
+  get messages() {
+    return this.chat.messages;
+  }
+  get status() {
+    return this.chat.status;
+  }
+  get error() {
+    return this.chat.error;
+  }
+  get isStreaming() {
+    return this.chat.isStreaming;
+  }
+  // ============================================
+  // Tool Execution Getters
+  // ============================================
+  get toolExecutions() {
+    return this.agentLoop.toolExecutions;
+  }
+  get tools() {
+    return this.agentLoop.tools;
+  }
+  get iteration() {
+    return this.agentLoop.iteration;
+  }
+  get maxIterations() {
+    return this.agentLoop.maxIterations;
+  }
+  get isProcessing() {
+    return this.agentLoop.isProcessing;
+  }
+  // ============================================
+  // Chat Actions
+  // ============================================
+  /**
+   * Send a message
+   */
+  async sendMessage(content, attachments) {
+    await this.chat.sendMessage(content, attachments);
+  }
+  /**
+   * Stop generation
+   */
+  stop() {
+    this.chat.stop();
+  }
+  /**
+   * Clear all messages
+   */
+  clearMessages() {
+    this.chat.clearMessages();
+    this.agentLoop.clearToolExecutions();
+  }
+  /**
+   * Set messages directly
+   */
+  setMessages(messages) {
+    this.chat.setMessages(messages);
+  }
+  /**
+   * Regenerate last response
+   */
+  async regenerate(messageId) {
+    await this.chat.regenerate(messageId);
+  }
+  /**
+   * Set tools available for the LLM
+   */
+  setTools(tools) {
+    this.chat.setTools(tools);
+  }
+  /**
+   * Set dynamic context (from useAIContext hook)
+   */
+  setContext(context) {
+    this.chat.setContext(context);
+  }
+  // ============================================
+  // Tool Registration
+  // ============================================
+  /**
+   * Register a tool
+   */
+  registerTool(tool) {
+    this.agentLoop.registerTool(tool);
+    this.chat.setTools(this.agentLoop.tools);
+  }
+  /**
+   * Unregister a tool
+   */
+  unregisterTool(name) {
+    this.agentLoop.unregisterTool(name);
+    this.chat.setTools(this.agentLoop.tools);
+  }
+  // ============================================
+  // Tool Approval
+  // ============================================
+  /**
+   * Approve a tool execution
+   */
+  approveToolExecution(id, permissionLevel) {
+    this.agentLoop.approveToolExecution(id, permissionLevel);
+  }
+  /**
+   * Reject a tool execution
+   */
+  rejectToolExecution(id, reason, permissionLevel) {
+    this.agentLoop.rejectToolExecution(id, reason, permissionLevel);
+  }
+  /**
+   * Clear tool executions
+   */
+  clearToolExecutions() {
+    this.agentLoop.clearToolExecutions();
+  }
+  // ============================================
+  // Event Subscriptions (for framework adapters)
+  // ============================================
+  /**
+   * Subscribe to chat events
+   */
+  on(event, handler) {
+    return this.chat.on(event, handler);
+  }
+  // ============================================
+  // Cleanup
+  // ============================================
+  /**
+   * Dispose and cleanup
+   */
+  dispose() {
+    this.chat.dispose();
+    this.agentLoop.dispose();
+  }
+  // ============================================
+  // Private
+  // ============================================
+  debug(message, ...args) {
+    if (this.config.debug) {
+      console.log(`[ChatWithTools] ${message}`, ...args);
+    }
+  }
+};
+
+// src/react/internal/ReactChatState.ts
+var ReactChatState = class {
+  constructor(initialMessages) {
+    this._messages = [];
+    this._status = "ready";
+    this._error = void 0;
+    // Callbacks for React subscriptions (useSyncExternalStore)
+    this.subscribers = /* @__PURE__ */ new Set();
+    // ============================================
+    // Subscription (for useSyncExternalStore)
+    // ============================================
+    /**
+     * Subscribe to state changes.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```tsx
+     * const messages = useSyncExternalStore(
+     *   state.subscribe,
+     *   () => state.messages
+     * );
+     * ```
+     */
+    this.subscribe = (callback) => {
+      this.subscribers.add(callback);
+      return () => {
+        this.subscribers.delete(callback);
+      };
+    };
+    if (initialMessages) {
+      this._messages = initialMessages;
+    }
+  }
+  // ============================================
+  // Getters
+  // ============================================
+  get messages() {
+    return this._messages;
+  }
+  get status() {
+    return this._status;
+  }
+  get error() {
+    return this._error;
+  }
+  // ============================================
+  // Setters (trigger reactivity)
+  // ============================================
+  set messages(value) {
+    this._messages = value;
+    this.notify();
+  }
+  set status(value) {
+    this._status = value;
+    this.notify();
+  }
+  set error(value) {
+    this._error = value;
+    this.notify();
+  }
+  // ============================================
+  // Mutations
+  // ============================================
+  pushMessage(message) {
+    this._messages = [...this._messages, message];
+    this.notify();
+  }
+  popMessage() {
+    this._messages = this._messages.slice(0, -1);
+    this.notify();
+  }
+  replaceMessage(index, message) {
+    this._messages = this._messages.map((m, i) => i === index ? message : m);
+    this.notify();
+  }
+  updateLastMessage(updater) {
+    if (this._messages.length === 0) return;
+    const lastIndex = this._messages.length - 1;
+    const lastMessage = this._messages[lastIndex];
+    this._messages = [
+      ...this._messages.slice(0, lastIndex),
+      updater(lastMessage)
+    ];
+    this.notify();
+  }
+  setMessages(messages) {
+    this._messages = messages;
+    this.notify();
+  }
+  clearMessages() {
+    this._messages = [];
+    this.notify();
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  notify() {
+    this.subscribers.forEach((cb) => cb());
+  }
+  /**
+   * Cleanup subscriptions
+   */
+  dispose() {
+    this.subscribers.clear();
+  }
+};
+function createReactChatState(initialMessages) {
+  return new ReactChatState(initialMessages);
+}
+
+// src/react/internal/ReactChatWithTools.ts
+var ReactChatWithTools = class extends ChatWithTools {
+  constructor(config, callbacks = {}) {
+    const reactState = new ReactChatState(config.initialMessages);
+    super({ ...config, state: reactState }, callbacks);
+    /**
+     * Subscribe to state changes (for useSyncExternalStore)
+     */
+    this.subscribe = (callback) => {
+      return this.reactState.subscribe(callback);
+    };
+    this.reactState = reactState;
+  }
+  /**
+   * Dispose and cleanup
+   */
+  dispose() {
+    super.dispose();
+    this.reactState.dispose();
+  }
+};
+
+// src/react/utils/context-tree.ts
+function addNode(tree, node, parentId) {
+  const newNode = {
+    ...node,
+    children: node.children || []
+  };
+  if (!parentId) {
+    return [...tree, newNode];
+  }
+  return tree.map((n) => {
+    if (n.id === parentId) {
+      return { ...n, children: [...n.children, newNode] };
+    }
+    if (n.children.length > 0) {
+      return { ...n, children: addNode(n.children, node, parentId) };
+    }
+    return n;
+  });
+}
+function removeNode(tree, id) {
+  return tree.reduce((result, node) => {
+    if (node.id !== id) {
+      const newNode = { ...node, children: removeNode(node.children, id) };
+      result.push(newNode);
+    }
+    return result;
+  }, []);
+}
+function getIndentPrefix(index, level) {
+  if (level === 0) {
+    return `${index + 1}.`;
+  } else if (level === 1) {
+    return `${String.fromCharCode(65 + index)}.`;
+  } else if (level === 2) {
+    return `${String.fromCharCode(97 + index)}.`;
+  } else {
+    return "-";
+  }
+}
+function printNode(node, prefix = "", indentLevel = 0) {
+  const indent = "   ".repeat(indentLevel);
+  const prefixLength = prefix.length + indent.length;
+  const subsequentIndent = " ".repeat(prefixLength);
+  const lines = node.value.split("\n");
+  const firstLine = `${indent}${prefix}${lines[0]}`;
+  const subsequentLines = lines.slice(1).map((line) => `${subsequentIndent}${line}`).join("\n");
+  let output = `${firstLine}
+`;
+  if (subsequentLines) {
+    output += `${subsequentLines}
+`;
+  }
+  node.children.forEach((child, index) => {
+    const childPrefix = `${" ".repeat(prefix.length)}${getIndentPrefix(index, indentLevel + 1)} `;
+    output += printNode(child, childPrefix, indentLevel + 1);
+  });
+  return output;
+}
+function printTree(tree) {
+  if (tree.length === 0) {
+    return "";
+  }
+  let output = "";
+  tree.forEach((node, index) => {
+    if (index > 0) {
+      output += "\n";
+    }
+    output += printNode(node, `${getIndentPrefix(index, 0)} `);
+  });
+  return output.trim();
+}
+var CopilotContext = react.createContext(null);
+function useCopilot() {
+  const context = react.useContext(CopilotContext);
+  if (!context) {
+    throw new Error("useCopilot must be used within CopilotProvider");
+  }
+  return context;
+}
+function CopilotProvider({
+  children,
+  runtimeUrl,
+  config,
+  cloud,
+  systemPrompt,
+  tools: toolsConfig,
+  threadId,
+  initialMessages,
+  onMessagesChange,
+  onError,
+  streaming,
+  debug = false
+}) {
+  const debugLog = react.useCallback(
+    (...args) => {
+      if (debug) console.log("[Copilot SDK]", ...args);
+    },
+    [debug]
+  );
+  react.useEffect(() => {
+    if (toolsConfig && (toolsConfig.screenshot || toolsConfig.console || toolsConfig.network)) {
+      console.warn(
+        "[Copilot SDK] The `tools` prop is deprecated. Use the `useTools` hook instead."
+      );
+    }
+  }, [toolsConfig]);
+  const [toolExecutions, setToolExecutions] = react.useState([]);
+  const chatRef = react.useRef(null);
+  if (chatRef.current === null) {
+    const uiInitialMessages = initialMessages?.map(
+      (m) => ({
+        id: m.id,
+        role: m.role,
+        content: m.content ?? "",
+        createdAt: m.created_at ?? /* @__PURE__ */ new Date(),
+        attachments: m.metadata?.attachments,
+        toolCalls: m.tool_calls,
+        toolCallId: m.tool_call_id
+      })
+    );
+    chatRef.current = new ReactChatWithTools(
+      {
+        runtimeUrl,
+        llm: config,
+        systemPrompt,
+        threadId,
+        initialMessages: uiInitialMessages,
+        streaming,
+        debug
+      },
+      {
+        onToolExecutionsChange: (executions) => {
+          debugLog("Tool executions changed:", executions.length);
+          setToolExecutions(executions);
+        },
+        onApprovalRequired: (execution) => {
+          debugLog("Tool approval required:", execution.name);
+        },
+        onError: (error2) => {
+          if (error2) onError?.(error2);
+        }
+      }
+    );
+  }
+  const messages = react.useSyncExternalStore(
+    chatRef.current.subscribe,
+    () => chatRef.current.messages,
+    () => chatRef.current.messages
+  );
+  const status = react.useSyncExternalStore(
+    chatRef.current.subscribe,
+    () => chatRef.current.status,
+    () => "ready"
+  );
+  const errorFromChat = react.useSyncExternalStore(
+    chatRef.current.subscribe,
+    () => chatRef.current.error,
+    () => void 0
+  );
+  const error = errorFromChat ?? null;
+  const isLoading = status === "streaming" || status === "submitted";
+  const registerTool = react.useCallback((tool) => {
+    chatRef.current?.registerTool(tool);
+  }, []);
+  const unregisterTool = react.useCallback((name) => {
+    chatRef.current?.unregisterTool(name);
+  }, []);
+  const approveToolExecution = react.useCallback(
+    (id, permissionLevel) => {
+      chatRef.current?.approveToolExecution(id, permissionLevel);
+    },
+    []
+  );
+  const rejectToolExecution = react.useCallback(
+    (id, reason, permissionLevel) => {
+      chatRef.current?.rejectToolExecution(id, reason, permissionLevel);
+    },
+    []
+  );
+  const registeredTools = chatRef.current?.tools ?? [];
+  const pendingApprovals = toolExecutions.filter(
+    (e) => e.approvalStatus === "required"
+  );
+  const actionsRef = react.useRef(/* @__PURE__ */ new Map());
+  const [actionsVersion, setActionsVersion] = react.useState(0);
+  const registerAction = react.useCallback((action) => {
+    actionsRef.current.set(action.name, action);
+    setActionsVersion((v) => v + 1);
+  }, []);
+  const unregisterAction = react.useCallback((name) => {
+    actionsRef.current.delete(name);
+    setActionsVersion((v) => v + 1);
+  }, []);
+  const registeredActions = react.useMemo(
+    () => Array.from(actionsRef.current.values()),
+    [actionsVersion]
+  );
+  const contextTreeRef = react.useRef([]);
+  const contextIdCounter = react.useRef(0);
+  const addContext = react.useCallback(
+    (context, parentId) => {
+      const id = `ctx-${++contextIdCounter.current}`;
+      contextTreeRef.current = addNode(
+        contextTreeRef.current,
+        { id, value: context, parentId },
+        parentId
+      );
+      const contextString = printTree(contextTreeRef.current);
+      chatRef.current?.setContext(contextString);
+      debugLog("Context added:", id);
+      return id;
+    },
+    [debugLog]
+  );
+  const removeContext = react.useCallback(
+    (id) => {
+      contextTreeRef.current = removeNode(contextTreeRef.current, id);
+      const contextString = printTree(contextTreeRef.current);
+      chatRef.current?.setContext(contextString);
+      debugLog("Context removed:", id);
+    },
+    [debugLog]
+  );
+  const sendMessage = react.useCallback(
+    async (content, attachments) => {
+      debugLog("Sending message:", content);
+      await chatRef.current?.sendMessage(content, attachments);
+    },
+    [debugLog]
+  );
+  const stop = react.useCallback(() => {
+    chatRef.current?.stop();
+  }, []);
+  const clearMessages = react.useCallback(() => {
+    chatRef.current?.clearMessages();
+  }, []);
+  const regenerate = react.useCallback(async (messageId) => {
+    await chatRef.current?.regenerate(messageId);
+  }, []);
+  react.useEffect(() => {
+    if (onMessagesChange && messages.length > 0) {
+      const coreMessages = messages.map((m) => ({
+        id: m.id,
+        role: m.role,
+        content: m.content,
+        created_at: m.createdAt,
+        tool_calls: m.toolCalls,
+        tool_call_id: m.toolCallId,
+        metadata: {
+          attachments: m.attachments,
+          thinking: m.thinking
+        }
+      }));
+      onMessagesChange(coreMessages);
+    }
+  }, [messages, onMessagesChange]);
+  react.useEffect(() => {
+    if (error && onError) {
+      onError(error);
+    }
+  }, [error, onError]);
+  react.useEffect(() => {
+    return () => {
+      chatRef.current?.dispose();
+    };
+  }, []);
+  const contextValue = react.useMemo(
+    () => ({
+      // Chat state
+      messages,
+      status,
+      error,
+      isLoading,
+      // Chat actions
+      sendMessage,
+      stop,
+      clearMessages,
+      regenerate,
+      // Tool execution
+      registerTool,
+      unregisterTool,
+      registeredTools,
+      toolExecutions,
+      pendingApprovals,
+      approveToolExecution,
+      rejectToolExecution,
+      // Actions
+      registerAction,
+      unregisterAction,
+      registeredActions,
+      // AI Context
+      addContext,
+      removeContext,
+      // Config
+      threadId,
+      runtimeUrl,
+      toolsConfig
+    }),
+    [
+      messages,
+      status,
+      error,
+      isLoading,
+      sendMessage,
+      stop,
+      clearMessages,
+      regenerate,
+      registerTool,
+      unregisterTool,
+      registeredTools,
+      toolExecutions,
+      pendingApprovals,
+      approveToolExecution,
+      rejectToolExecution,
+      registerAction,
+      unregisterAction,
+      registeredActions,
+      addContext,
+      removeContext,
+      threadId,
+      runtimeUrl,
+      toolsConfig
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(CopilotContext.Provider, { value: contextValue, children });
+}
+function useAIActions(actions) {
+  const { registerAction, unregisterAction } = useCopilot();
+  react.useEffect(() => {
+    for (const action of actions) {
+      registerAction(action);
+    }
+    return () => {
+      for (const action of actions) {
+        unregisterAction(action.name);
+      }
+    };
+  }, [actions, registerAction, unregisterAction]);
+}
+function useAIAction(action) {
+  useAIActions([action]);
+}
+function useAIContext(item) {
+  const { addContext, removeContext } = useCopilot();
+  const contextIdRef = react.useRef(null);
+  const serializedData = typeof item.data === "string" ? item.data : JSON.stringify(item.data);
+  react.useEffect(() => {
+    const formattedValue = typeof item.data === "string" ? item.data : JSON.stringify(item.data, null, 2);
+    const contextString = item.description ? `${item.description}:
+${formattedValue}` : `${item.key}:
+${formattedValue}`;
+    contextIdRef.current = addContext(contextString, item.parentId);
+    return () => {
+      if (contextIdRef.current) {
+        removeContext(contextIdRef.current);
+        contextIdRef.current = null;
+      }
+    };
+  }, [
+    item.key,
+    serializedData,
+    item.description,
+    item.parentId,
+    addContext,
+    removeContext
+  ]);
+  return contextIdRef.current ?? void 0;
+}
+function useAIContexts(items) {
+  const { addContext, removeContext } = useCopilot();
+  const contextIdsRef = react.useRef([]);
+  const serializedItems = JSON.stringify(
+    items.map((item) => ({
+      key: item.key,
+      data: item.data,
+      description: item.description,
+      parentId: item.parentId
+    }))
+  );
+  react.useEffect(() => {
+    contextIdsRef.current.forEach((id) => removeContext(id));
+    contextIdsRef.current = [];
+    const parsedItems = JSON.parse(serializedItems);
+    for (const item of parsedItems) {
+      const formattedValue = typeof item.data === "string" ? item.data : JSON.stringify(item.data, null, 2);
+      const contextString = item.description ? `${item.description}:
+${formattedValue}` : `${item.key}:
+${formattedValue}`;
+      const id = addContext(contextString, item.parentId);
+      contextIdsRef.current.push(id);
+    }
+    return () => {
+      contextIdsRef.current.forEach((id) => removeContext(id));
+      contextIdsRef.current = [];
+    };
+  }, [serializedItems, addContext, removeContext]);
+}
+function useAITools(options = {}) {
+  const {
+    screenshot = false,
+    console: consoleCapture = false,
+    network = false,
+    requireConsent = true,
+    screenshotOptions,
+    consoleOptions,
+    networkOptions,
+    onConsentRequest,
+    autoStart = true
+  } = options;
+  const [isEnabled] = react.useState(screenshot || consoleCapture || network);
+  const [activeCaptures, setActiveCaptures] = react.useState({
+    console: false,
+    network: false
+  });
+  const [pendingConsent, setPendingConsent] = react.useState(null);
+  const consentResolverRef = react.useRef(null);
+  const rememberedConsentRef = react.useRef(/* @__PURE__ */ new Set());
+  react.useEffect(() => {
+    if (!autoStart || !isEnabled) return;
+    if (consoleCapture && !chunk2ZCWVAAK_cjs.isConsoleCaptureActive()) {
+      chunk2ZCWVAAK_cjs.startConsoleCapture(consoleOptions);
+      setActiveCaptures((prev) => ({ ...prev, console: true }));
+    }
+    if (network && !chunk2ZCWVAAK_cjs.isNetworkCaptureActive()) {
+      chunk2ZCWVAAK_cjs.startNetworkCapture(networkOptions);
+      setActiveCaptures((prev) => ({ ...prev, network: true }));
+    }
+    return () => {
+      chunk2ZCWVAAK_cjs.stopConsoleCapture();
+      chunk2ZCWVAAK_cjs.stopNetworkCapture();
+    };
+  }, [
+    autoStart,
+    isEnabled,
+    consoleCapture,
+    network,
+    consoleOptions,
+    networkOptions
+  ]);
+  const captureScreenshotFn = react.useCallback(
+    async (opts) => {
+      if (!screenshot) {
+        throw new Error("Screenshot capture is not enabled");
+      }
+      if (!chunk2ZCWVAAK_cjs.isScreenshotSupported()) {
+        throw new Error(
+          "Screenshot capture is not supported in this environment"
+        );
+      }
+      return chunk2ZCWVAAK_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
+    },
+    [screenshot, screenshotOptions]
+  );
+  const getConsoleLogsFn = react.useCallback(
+    (opts) => {
+      if (!consoleCapture) {
+        return { logs: [], totalCaptured: 0 };
+      }
+      return chunk2ZCWVAAK_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
+    },
+    [consoleCapture, consoleOptions]
+  );
+  const getNetworkRequestsFn = react.useCallback(
+    (opts) => {
+      if (!network) {
+        return { requests: [], totalCaptured: 0 };
+      }
+      return chunk2ZCWVAAK_cjs.getNetworkRequests({ ...networkOptions, ...opts });
+    },
+    [network, networkOptions]
+  );
+  const requestConsent = react.useCallback(
+    async (tools, reason = "") => {
+      const enabledTools = tools.filter((tool) => {
+        if (tool === "screenshot") return screenshot;
+        if (tool === "console") return consoleCapture;
+        if (tool === "network") return network;
+        return false;
+      });
+      if (enabledTools.length === 0) {
+        return { approved: [], denied: [] };
+      }
+      if (!requireConsent) {
+        return { approved: enabledTools, denied: [] };
+      }
+      const needsConsent = enabledTools.filter(
+        (tool) => !rememberedConsentRef.current.has(tool)
+      );
+      if (needsConsent.length === 0) {
+        return { approved: enabledTools, denied: [] };
+      }
+      const request = {
+        tools: needsConsent,
+        reason,
+        keywords: []
+      };
+      if (onConsentRequest) {
+        const response = await onConsentRequest(request);
+        if (response.remember) {
+          response.approved.forEach(
+            (tool) => rememberedConsentRef.current.add(tool)
+          );
+        }
+        return response;
+      }
+      return new Promise((resolve) => {
+        setPendingConsent(request);
+        consentResolverRef.current = (response) => {
+          if (response.remember) {
+            response.approved.forEach(
+              (tool) => rememberedConsentRef.current.add(tool)
+            );
+          }
+          resolve(response);
+        };
+      });
+    },
+    [screenshot, consoleCapture, network, requireConsent, onConsentRequest]
+  );
+  const respondToConsent = react.useCallback((response) => {
+    if (consentResolverRef.current) {
+      consentResolverRef.current(response);
+      consentResolverRef.current = null;
+    }
+    setPendingConsent(null);
+  }, []);
+  const captureContext = react.useCallback(
+    async (tools) => {
+      const toolsToCapture = tools || ["screenshot", "console", "network"];
+      const context = {
+        timestamp: Date.now()
+      };
+      const captures = [];
+      if (toolsToCapture.includes("screenshot") && screenshot) {
+        captures.push(
+          captureScreenshotFn().then((result) => {
+            context.screenshot = result;
+          }).catch(() => {
+          })
+        );
+      }
+      if (toolsToCapture.includes("console") && consoleCapture) {
+        context.consoleLogs = getConsoleLogsFn();
+      }
+      if (toolsToCapture.includes("network") && network) {
+        context.networkRequests = getNetworkRequestsFn();
+      }
+      await Promise.all(captures);
+      return context;
+    },
+    [
+      screenshot,
+      consoleCapture,
+      network,
+      captureScreenshotFn,
+      getConsoleLogsFn,
+      getNetworkRequestsFn
+    ]
+  );
+  const startCapturing = react.useCallback(() => {
+    if (consoleCapture && !chunk2ZCWVAAK_cjs.isConsoleCaptureActive()) {
+      chunk2ZCWVAAK_cjs.startConsoleCapture(consoleOptions);
+      setActiveCaptures((prev) => ({ ...prev, console: true }));
+    }
+    if (network && !chunk2ZCWVAAK_cjs.isNetworkCaptureActive()) {
+      chunk2ZCWVAAK_cjs.startNetworkCapture(networkOptions);
+      setActiveCaptures((prev) => ({ ...prev, network: true }));
+    }
+  }, [consoleCapture, network, consoleOptions, networkOptions]);
+  const stopCapturing = react.useCallback(() => {
+    chunk2ZCWVAAK_cjs.stopConsoleCapture();
+    chunk2ZCWVAAK_cjs.stopNetworkCapture();
+    setActiveCaptures({ console: false, network: false });
+  }, []);
+  const clearCaptured = react.useCallback(() => {
+    chunk2ZCWVAAK_cjs.clearConsoleLogs();
+    chunk2ZCWVAAK_cjs.clearNetworkRequests();
+  }, []);
+  const formatForAI = react.useCallback((context) => {
+    const parts = [];
+    if (context.screenshot) {
+      parts.push(
+        `Screenshot captured (${context.screenshot.width}x${context.screenshot.height}, ${context.screenshot.format})`
+      );
+    }
+    if (context.consoleLogs && context.consoleLogs.logs.length > 0) {
+      parts.push(chunk2ZCWVAAK_cjs.formatLogsForAI(context.consoleLogs.logs));
+    }
+    if (context.networkRequests && context.networkRequests.requests.length > 0) {
+      parts.push(chunk2ZCWVAAK_cjs.formatRequestsForAI(context.networkRequests.requests));
+    }
+    return parts.length > 0 ? parts.join("\n\n---\n\n") : "No context captured.";
+  }, []);
+  const detectIntentFn = react.useCallback(
+    (message) => {
+      const result = chunk2ZCWVAAK_cjs.detectIntent(message);
+      result.suggestedTools = result.suggestedTools.filter((tool) => {
+        if (tool === "screenshot") return screenshot;
+        if (tool === "console") return consoleCapture;
+        if (tool === "network") return network;
+        return false;
+      });
+      return result;
+    },
+    [screenshot, consoleCapture, network]
+  );
+  return react.useMemo(
+    () => ({
+      isEnabled,
+      activeCaptures,
+      captureScreenshot: captureScreenshotFn,
+      getConsoleLogs: getConsoleLogsFn,
+      getNetworkRequests: getNetworkRequestsFn,
+      captureContext,
+      detectIntent: detectIntentFn,
+      requestConsent,
+      startCapturing,
+      stopCapturing,
+      clearCaptured,
+      formatForAI,
+      pendingConsent,
+      respondToConsent
+    }),
+    [
+      isEnabled,
+      activeCaptures,
+      captureScreenshotFn,
+      getConsoleLogsFn,
+      getNetworkRequestsFn,
+      captureContext,
+      detectIntentFn,
+      requestConsent,
+      startCapturing,
+      stopCapturing,
+      clearCaptured,
+      formatForAI,
+      pendingConsent,
+      respondToConsent
+    ]
+  );
+}
+function useTool(config, dependencies = []) {
+  const { registerTool, unregisterTool } = useCopilot();
+  const configRef = react.useRef(config);
+  configRef.current = config;
+  react.useEffect(() => {
+    const tool = {
+      name: config.name,
+      description: config.description,
+      location: "client",
+      inputSchema: config.inputSchema,
+      handler: async (params, context) => {
+        return configRef.current.handler(params, context);
+      },
+      render: config.render,
+      available: config.available ?? true,
+      needsApproval: config.needsApproval,
+      approvalMessage: config.approvalMessage
+    };
+    registerTool(tool);
+    return () => {
+      unregisterTool(config.name);
+    };
+  }, [config.name, ...dependencies]);
+}
+function useTools(tools) {
+  const { registerTool, unregisterTool } = useCopilot();
+  const registeredToolsRef = react.useRef([]);
+  const toolsRef = react.useRef(tools);
+  toolsRef.current = tools;
+  const toolsKey = Object.keys(tools).sort().join(",");
+  react.useEffect(() => {
+    const currentTools = toolsRef.current;
+    const toolNames = [];
+    for (const [name, toolDef] of Object.entries(currentTools)) {
+      const fullTool = {
+        ...toolDef,
+        name
+        // Use the key as the name
+      };
+      registerTool(fullTool);
+      toolNames.push(name);
+    }
+    registeredToolsRef.current = toolNames;
+    return () => {
+      for (const name of registeredToolsRef.current) {
+        unregisterTool(name);
+      }
+      registeredToolsRef.current = [];
+    };
+  }, [toolsKey]);
+}
+var CopilotContext2 = react.createContext(null);
+function useCopilotContext() {
+  const context = react.useContext(CopilotContext2);
+  if (!context) {
+    throw new Error("useCopilotContext must be used within a CopilotProvider");
+  }
+  return context;
+}
+
+// src/react/hooks/useToolWithSchema.ts
+function convertZodSchema(schema, _toolName) {
+  try {
+    const zodWithJsonSchema = z__namespace;
+    if (typeof zodWithJsonSchema.toJSONSchema === "function") {
+      const jsonSchema = zodWithJsonSchema.toJSONSchema(
+        schema
+      );
+      if (jsonSchema.type === "object") {
+        return {
+          type: "object",
+          properties: jsonSchema.properties || {},
+          required: jsonSchema.required
+        };
+      }
+    }
+  } catch {
+  }
+  return chunk2ZCWVAAK_cjs.zodObjectToInputSchema(schema);
+}
+function useToolWithSchema(config, dependencies = []) {
+  const { registerTool, unregisterTool } = useCopilotContext();
+  const configRef = react.useRef(config);
+  configRef.current = config;
+  const inputSchema = react.useMemo(() => {
+    try {
+      return convertZodSchema(config.schema, config.name);
+    } catch (error) {
+      console.warn(
+        `[useToolWithSchema] Failed to convert Zod schema for tool "${config.name}"`,
+        error
+      );
+      return {
+        type: "object",
+        properties: {}
+      };
+    }
+  }, [config.schema, config.name]);
+  react.useEffect(() => {
+    const tool = {
+      name: config.name,
+      description: config.description,
+      location: "client",
+      inputSchema,
+      handler: async (params, context) => {
+        return configRef.current.handler(params, context);
+      },
+      render: config.render,
+      available: config.available ?? true
+    };
+    registerTool(tool);
+    return () => {
+      unregisterTool(config.name);
+    };
+  }, [config.name, inputSchema, ...dependencies]);
+}
+function useToolsWithSchema(tools, dependencies = []) {
+  const { registerTool, unregisterTool } = useCopilotContext();
+  const toolsRef = react.useRef(tools);
+  toolsRef.current = tools;
+  react.useEffect(() => {
+    const toolNames = [];
+    for (const config of tools) {
+      let inputSchema;
+      try {
+        inputSchema = convertZodSchema(config.schema, config.name);
+      } catch (error) {
+        console.warn(
+          `[useToolsWithSchema] Failed to convert Zod schema for tool "${config.name}"`,
+          error
+        );
+        inputSchema = { type: "object", properties: {} };
+      }
+      const tool = {
+        name: config.name,
+        description: config.description,
+        location: "client",
+        inputSchema,
+        handler: async (params, context) => {
+          const currentConfig = toolsRef.current.find(
+            (t) => t.name === config.name
+          );
+          if (currentConfig) {
+            return currentConfig.handler(params, context);
+          }
+          return { success: false, error: "Tool handler not found" };
+        },
+        available: config.available ?? true
+      };
+      registerTool(tool);
+      toolNames.push(config.name);
+    }
+    return () => {
+      for (const name of toolNames) {
+        unregisterTool(name);
+      }
+    };
+  }, [tools.map((t) => t.name).join(","), ...dependencies]);
+}
+function useToolExecutor() {
+  const {
+    registeredTools,
+    config,
+    chat,
+    addToolExecution,
+    updateToolExecution
+  } = useCopilotContext();
+  const toolsRef = react.useRef(registeredTools);
+  toolsRef.current = registeredTools;
+  const executeTool = react.useCallback(
+    async (toolCall) => {
+      const tool = toolsRef.current.find((t) => t.name === toolCall.name);
+      if (!tool) {
+        return {
+          success: false,
+          error: `Unknown tool: ${toolCall.name}`
+        };
+      }
+      if (!tool.handler) {
+        return {
+          success: false,
+          error: `Tool "${toolCall.name}" has no handler`
+        };
+      }
+      const execution = {
+        id: toolCall.id,
+        name: toolCall.name,
+        args: toolCall.input,
+        status: "executing",
+        timestamp: Date.now(),
+        approvalStatus: "none"
+      };
+      addToolExecution?.(execution);
+      try {
+        const startTime = Date.now();
+        const result = await tool.handler(toolCall.input);
+        const duration = Date.now() - startTime;
+        updateToolExecution?.(toolCall.id, {
+          status: result.success ? "completed" : "error",
+          result,
+          error: result.error,
+          duration
+        });
+        return result;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Tool execution failed";
+        updateToolExecution?.(toolCall.id, {
+          status: "error",
+          error: errorMessage
+        });
+        return {
+          success: false,
+          error: errorMessage
+        };
+      }
+    },
+    [addToolExecution, updateToolExecution]
+  );
+  const sendToolResult = react.useCallback(
+    async (toolCallId, result) => {
+      const runtimeUrl = config.runtimeUrl || config.cloud?.endpoint;
+      if (!runtimeUrl) {
+        console.warn(
+          "[useToolExecutor] No runtime URL configured, cannot send tool result"
+        );
+        return;
+      }
+      const baseUrl = runtimeUrl.replace(/\/chat\/?$/, "");
+      try {
+        const response = await fetch(`${baseUrl}/tool-result`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            threadId: chat.threadId || "default",
+            toolCallId,
+            result
+          })
+        });
+        if (!response.ok) {
+          console.error(
+            "[useToolExecutor] Failed to send tool result:",
+            await response.text()
+          );
+        }
+      } catch (error) {
+        console.error("[useToolExecutor] Error sending tool result:", error);
+      }
+    },
+    [config.runtimeUrl, config.cloud?.endpoint, chat.threadId]
+  );
+  const getTool = react.useCallback((name) => {
+    return toolsRef.current.find((t) => t.name === name);
+  }, []);
+  const hasTool = react.useCallback((name) => {
+    return toolsRef.current.some((t) => t.name === name);
+  }, []);
+  return {
+    executeTool,
+    sendToolResult,
+    getTool,
+    hasTool
+  };
+}
+function useSuggestions(options = {}) {
+  const {
+    count = 3,
+    context,
+    suggestions: staticSuggestions,
+    autoRefresh = true
+  } = options;
+  const { chat, actions, config } = useCopilotContext();
+  const [suggestions, setSuggestions] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const normalizedStatic = react.useMemo(
+    () => staticSuggestions?.map((s) => typeof s === "string" ? { text: s } : s),
+    [staticSuggestions]
+  );
+  const refresh = react.useCallback(async () => {
+    if (normalizedStatic) {
+      setSuggestions(normalizedStatic.slice(0, count));
+      return;
+    }
+    if (!config.cloud) {
+      return;
+    }
+    setIsLoading(true);
+    try {
+      const endpoint = config.cloud.endpoint || "https://api.yourgpt.ai/v1";
+      const response = await fetch(`${endpoint}/suggestions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${config.cloud.apiKey}`
+        },
+        body: JSON.stringify({
+          botId: config.cloud.botId,
+          count,
+          context,
+          messages: chat.messages.slice(-5)
+          // Last 5 messages for context
+        })
+      });
+      if (response.ok) {
+        const data = await response.json();
+        setSuggestions(
+          data.suggestions.map(
+            (s) => typeof s === "string" ? { text: s } : s
+          )
+        );
+      }
+    } catch (error) {
+      console.error("Failed to fetch suggestions:", error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [config.cloud, count, context, chat.messages, normalizedStatic]);
+  const select = react.useCallback(
+    (suggestion) => {
+      const text = typeof suggestion === "string" ? suggestion : suggestion.text;
+      actions.sendMessage(text);
+    },
+    [actions]
+  );
+  react.useEffect(() => {
+    if (autoRefresh && chat.messages.length === 0) {
+      refresh();
+    }
+  }, [autoRefresh, chat.messages.length, refresh]);
+  return {
+    suggestions: normalizedStatic?.slice(0, count) || suggestions,
+    isLoading,
+    refresh,
+    select
+  };
+}
+function useAgent(options) {
+  const { name, initialState = {}, onStateChange } = options;
+  const { config } = useCopilotContext();
+  const [state, setStateInternal] = react.useState(initialState);
+  const [isRunning, setIsRunning] = react.useState(false);
+  const [nodeName, setNodeName] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const abortControllerRef = react.useRef(null);
+  const getEndpoint = react.useCallback(() => {
+    if (config.cloud) {
+      return `${config.cloud.endpoint || "https://api.yourgpt.ai/v1"}/agents/${name}`;
+    }
+    return `${config.runtimeUrl || "/api"}/agents/${name}`;
+  }, [config, name]);
+  const start = react.useCallback(
+    async (input) => {
+      setIsRunning(true);
+      setError(null);
+      abortControllerRef.current = new AbortController();
+      try {
+        const endpoint = getEndpoint();
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (config.cloud?.apiKey) {
+          headers["Authorization"] = `Bearer ${config.cloud.apiKey}`;
+        }
+        const response = await fetch(`${endpoint}/start`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            input: typeof input === "string" ? { message: input } : input,
+            state
+          }),
+          signal: abortControllerRef.current.signal
+        });
+        if (!response.ok) {
+          throw new Error(`Agent error: ${response.status}`);
+        }
+        for await (const event of chunk2ZCWVAAK_cjs.streamSSE(response)) {
+          handleAgentEvent(event);
+        }
+      } catch (err) {
+        if (err.name !== "AbortError") {
+          setError(err instanceof Error ? err : new Error("Unknown error"));
+        }
+      } finally {
+        setIsRunning(false);
+        abortControllerRef.current = null;
+      }
+    },
+    [config, getEndpoint, state]
+  );
+  const handleAgentEvent = react.useCallback(
+    (event) => {
+      if (event.type === "error") {
+        setError(new Error(event.message));
+        return;
+      }
+      if ("state" in event && event.state) {
+        setStateInternal(event.state);
+        onStateChange?.(event.state);
+      }
+      if ("nodeName" in event && event.nodeName) {
+        setNodeName(event.nodeName);
+      }
+    },
+    [onStateChange]
+  );
+  const stop = react.useCallback(() => {
+    abortControllerRef.current?.abort();
+  }, []);
+  const setState = react.useCallback(
+    (partialState) => {
+      setStateInternal((prev) => {
+        const newState = { ...prev, ...partialState };
+        onStateChange?.(newState);
+        return newState;
+      });
+    },
+    [onStateChange]
+  );
+  react.useEffect(() => {
+    return () => {
+      abortControllerRef.current?.abort();
+    };
+  }, []);
+  return {
+    state,
+    isRunning,
+    nodeName,
+    start,
+    stop,
+    setState,
+    error
+  };
+}
+
+// src/react/utils/knowledge-base.ts
+var KNOWLEDGE_BASE_API = "https://api.yourgpt.ai/chatbot/v1/searchIndexDocument";
+async function searchKnowledgeBase(query, config) {
+  try {
+    const response = await fetch(KNOWLEDGE_BASE_API, {
+      method: "POST",
+      headers: {
+        accept: "*/*",
+        "content-type": "application/json",
+        authorization: `Bearer ${config.token}`
+      },
+      body: JSON.stringify({
+        project_uid: config.projectUid,
+        query,
+        page: 1,
+        limit: String(config.limit || 10),
+        app_id: config.appId || "1"
+      })
+    });
+    if (!response.ok) {
+      return {
+        success: false,
+        results: [],
+        error: `API error: ${response.status} ${response.statusText}`
+      };
+    }
+    const data = await response.json();
+    const results = (data.data || data.results || []).map((item) => ({
+      id: item.id || item._id || String(Math.random()),
+      title: item.title || item.name || void 0,
+      content: item.content || item.text || item.snippet || "",
+      score: item.score || item.relevance || void 0,
+      url: item.url || item.source_url || void 0,
+      metadata: item.metadata || {}
+    }));
+    return {
+      success: true,
+      results,
+      total: data.total || results.length,
+      page: data.page || 1
+    };
+  } catch (error) {
+    return {
+      success: false,
+      results: [],
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function formatKnowledgeResultsForAI(results) {
+  if (results.length === 0) {
+    return "No relevant documents found in the knowledge base.";
+  }
+  return results.map((result, index) => {
+    const parts = [`[${index + 1}]`];
+    if (result.title) parts.push(`**${result.title}**`);
+    parts.push(result.content);
+    if (result.url) parts.push(`Source: ${result.url}`);
+    return parts.join("\n");
+  }).join("\n\n---\n\n");
+}
+
+// src/react/hooks/useKnowledgeBase.ts
+function useKnowledgeBase(config) {
+  const { registerTool, unregisterTool } = useCopilotContext();
+  const configRef = react.useRef(config);
+  configRef.current = config;
+  const handleSearch = react.useCallback(
+    async (params) => {
+      const query = params.query;
+      if (!query) {
+        return {
+          success: false,
+          error: "Query is required"
+        };
+      }
+      const currentConfig = configRef.current;
+      const kbConfig = {
+        projectUid: currentConfig.projectUid,
+        token: currentConfig.token,
+        appId: currentConfig.appId,
+        limit: currentConfig.limit || 5
+      };
+      const response = await searchKnowledgeBase(
+        query,
+        kbConfig
+      );
+      if (!response.success) {
+        return {
+          success: false,
+          error: response.error || "Knowledge base search failed"
+        };
+      }
+      const formattedResults = formatKnowledgeResultsForAI(response.results);
+      return {
+        success: true,
+        message: formattedResults,
+        data: {
+          resultCount: response.results.length,
+          total: response.total
+        }
+      };
+    },
+    []
+  );
+  react.useEffect(() => {
+    if (config.enabled === false) {
+      return;
+    }
+    registerTool({
+      name: "search_knowledge",
+      description: "Search the knowledge base for relevant information about the product, documentation, or company. Use this to answer questions about features, pricing, policies, guides, or any factual information.",
+      location: "client",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query to find relevant information in the knowledge base"
+          }
+        },
+        required: ["query"]
+      },
+      handler: handleSearch
+    });
+    return () => {
+      unregisterTool("search_knowledge");
+    };
+  }, [
+    config.enabled,
+    config.projectUid,
+    config.token,
+    registerTool,
+    unregisterTool,
+    handleSearch
+  ]);
+}
+var DEFAULT_CAPABILITIES = {
+  supportsVision: false,
+  supportsTools: true,
+  supportsThinking: false,
+  supportsStreaming: true,
+  supportsPDF: false,
+  supportsAudio: false,
+  supportsVideo: false,
+  maxTokens: 8192,
+  supportedImageTypes: [],
+  supportsJsonMode: false,
+  supportsSystemMessages: true
+};
+function useCapabilities() {
+  const { config } = useCopilotContext();
+  const [capabilities, setCapabilities] = react.useState(DEFAULT_CAPABILITIES);
+  const [provider, setProvider] = react.useState("unknown");
+  const [model, setModel] = react.useState("unknown");
+  const [supportedModels, setSupportedModels] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const capabilitiesUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/chat\/?$/, "/capabilities") : null;
+  const fetchCapabilities = react.useCallback(async () => {
+    if (!capabilitiesUrl) {
+      setIsLoading(false);
+      return;
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      const response = await fetch(capabilitiesUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch capabilities: ${response.status}`);
+      }
+      const data = await response.json();
+      setCapabilities(data.capabilities);
+      setProvider(data.provider);
+      setModel(data.model);
+      setSupportedModels(data.supportedModels);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Unknown error"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [capabilitiesUrl]);
+  react.useEffect(() => {
+    fetchCapabilities();
+  }, [fetchCapabilities]);
+  return {
+    /** Current model capabilities */
+    capabilities,
+    /** Current provider name */
+    provider,
+    /** Current model ID */
+    model,
+    /** List of supported models for current provider */
+    supportedModels,
+    /** Whether capabilities are being loaded */
+    isLoading,
+    /** Error if fetch failed */
+    error,
+    /** Refetch capabilities */
+    refetch: fetchCapabilities
+  };
+}
+function useFeatureSupport(feature) {
+  const { capabilities } = useCapabilities();
+  return capabilities[feature] ?? false;
+}
+function useSupportedMediaTypes() {
+  const { capabilities } = useCapabilities();
+  return {
+    /** Supported image MIME types */
+    imageTypes: capabilities.supportedImageTypes || [],
+    /** Supported audio MIME types */
+    audioTypes: capabilities.supportedAudioTypes || [],
+    /** Supported video MIME types */
+    videoTypes: capabilities.supportedVideoTypes || [],
+    /** Whether any image types are supported */
+    hasImageSupport: (capabilities.supportedImageTypes?.length ?? 0) > 0,
+    /** Whether any audio types are supported */
+    hasAudioSupport: (capabilities.supportedAudioTypes?.length ?? 0) > 0,
+    /** Whether any video types are supported */
+    hasVideoSupport: (capabilities.supportedVideoTypes?.length ?? 0) > 0
+  };
+}
+function useDevLogger() {
+  const ctx = useCopilotContext();
+  return react.useMemo(() => {
+    const toolExecutions = (ctx.agentLoop?.toolExecutions || []).map(
+      (exec) => ({
+        id: exec.id,
+        name: exec.name,
+        status: exec.status,
+        approvalStatus: exec.approvalStatus || "not_required"
+      })
+    );
+    const pendingApprovalsCount = ctx.pendingApprovals?.length || 0;
+    const registeredTools = (ctx.registeredTools || []).map((tool) => ({
+      name: tool.name,
+      location: tool.location || "client"
+    }));
+    const registeredActions = (ctx.registeredActions || []).map((action) => ({
+      name: action.name
+    }));
+    const storedPermissions = (ctx.storedPermissions || []).map((p) => ({
+      toolName: p.toolName,
+      level: p.level
+    }));
+    return {
+      chat: {
+        isLoading: ctx.chat?.isLoading || false,
+        messageCount: ctx.chat?.messages?.length || 0,
+        threadId: ctx.chat?.threadId || "none",
+        error: ctx.chat?.error?.message || null
+      },
+      tools: {
+        isEnabled: !!ctx.toolsConfig,
+        isCapturing: ctx.tools?.isCapturing || false,
+        pendingConsent: !!ctx.tools?.pendingConsent
+      },
+      agentLoop: {
+        toolExecutions,
+        pendingApprovals: pendingApprovalsCount,
+        iteration: ctx.agentLoop?.iteration || 0,
+        maxIterations: ctx.agentLoop?.maxIterations || 10
+      },
+      registered: {
+        tools: registeredTools,
+        actions: registeredActions,
+        contextCount: ctx.contextTree?.length || 0
+      },
+      permissions: {
+        stored: storedPermissions,
+        loaded: ctx.permissionsLoaded || false
+      },
+      config: {
+        provider: ctx.config?.config?.provider || (ctx.config?.cloud ? "yourgpt-cloud" : "unknown"),
+        model: ctx.config?.config?.model || "default",
+        runtimeUrl: ctx.config?.runtimeUrl || ctx.config?.cloud?.endpoint || ""
+      }
+    };
+  }, [
+    ctx.chat,
+    ctx.tools,
+    ctx.toolsConfig,
+    ctx.agentLoop,
+    ctx.pendingApprovals,
+    ctx.registeredTools,
+    ctx.registeredActions,
+    ctx.contextTree,
+    ctx.storedPermissions,
+    ctx.permissionsLoaded,
+    ctx.config
+  ]);
+}
+
+// src/react/utils/permission-storage.ts
+var DEFAULT_KEY_PREFIX = "yourgpt-permissions";
+function createPermissionStorage(config) {
+  switch (config.type) {
+    case "localStorage":
+      return createBrowserStorageAdapter(
+        typeof window !== "undefined" ? localStorage : null,
+        config.keyPrefix
+      );
+    case "sessionStorage":
+      return createBrowserStorageAdapter(
+        typeof window !== "undefined" ? sessionStorage : null,
+        config.keyPrefix
+      );
+    case "memory":
+    default:
+      return createMemoryStorageAdapter();
+  }
+}
+function createBrowserStorageAdapter(storage, keyPrefix = DEFAULT_KEY_PREFIX) {
+  const getStorageKey = () => keyPrefix;
+  const loadPermissions = () => {
+    if (!storage) return /* @__PURE__ */ new Map();
+    try {
+      const data = storage.getItem(getStorageKey());
+      if (!data) return /* @__PURE__ */ new Map();
+      const parsed = JSON.parse(data);
+      return new Map(parsed.map((p) => [p.toolName, p]));
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  };
+  const savePermissions = (permissions) => {
+    if (!storage) return;
+    try {
+      storage.setItem(
+        getStorageKey(),
+        JSON.stringify(Array.from(permissions.values()))
+      );
+    } catch (e) {
+      console.warn("[PermissionStorage] Failed to save permissions:", e);
+    }
+  };
+  return {
+    async get(toolName) {
+      const permissions = loadPermissions();
+      return permissions.get(toolName) || null;
+    },
+    async set(permission) {
+      const permissions = loadPermissions();
+      permissions.set(permission.toolName, permission);
+      savePermissions(permissions);
+    },
+    async remove(toolName) {
+      const permissions = loadPermissions();
+      permissions.delete(toolName);
+      savePermissions(permissions);
+    },
+    async getAll() {
+      const permissions = loadPermissions();
+      return Array.from(permissions.values());
+    },
+    async clear() {
+      if (!storage) return;
+      storage.removeItem(getStorageKey());
+    }
+  };
+}
+function createMemoryStorageAdapter() {
+  const permissions = /* @__PURE__ */ new Map();
+  return {
+    async get(toolName) {
+      return permissions.get(toolName) || null;
+    },
+    async set(permission) {
+      permissions.set(permission.toolName, permission);
+    },
+    async remove(toolName) {
+      permissions.delete(toolName);
+    },
+    async getAll() {
+      return Array.from(permissions.values());
+    },
+    async clear() {
+      permissions.clear();
+    }
+  };
+}
+function createSessionPermissionCache() {
+  return /* @__PURE__ */ new Map();
+}
+
+// src/react/internal/ReactChat.ts
+var ReactChat = class extends AbstractChat {
+  constructor(config) {
+    const reactState = new ReactChatState(config.initialMessages);
+    const init = {
+      runtimeUrl: config.runtimeUrl,
+      systemPrompt: config.systemPrompt,
+      llm: config.llm,
+      threadId: config.threadId,
+      streaming: config.streaming ?? true,
+      headers: config.headers,
+      initialMessages: config.initialMessages,
+      state: reactState,
+      callbacks: config.callbacks,
+      debug: config.debug
+    };
+    super(init);
+    // ============================================
+    // Subscribe (for useSyncExternalStore)
+    // ============================================
+    /**
+     * Subscribe to state changes.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```tsx
+     * const messages = useSyncExternalStore(
+     *   chat.subscribe,
+     *   () => chat.messages
+     * );
+     * ```
+     */
+    this.subscribe = (callback) => {
+      return this.reactState.subscribe(callback);
+    };
+    this.reactState = reactState;
+  }
+  // ============================================
+  // Event handling shortcuts
+  // ============================================
+  /**
+   * Subscribe to tool calls events
+   */
+  onToolCalls(handler) {
+    return this.on("toolCalls", handler);
+  }
+  /**
+   * Subscribe to done events
+   */
+  onDone(handler) {
+    return this.on("done", handler);
+  }
+  /**
+   * Subscribe to error events
+   */
+  onError(handler) {
+    return this.on("error", handler);
+  }
+  // ============================================
+  // Override dispose to clean up state
+  // ============================================
+  dispose() {
+    super.dispose();
+    this.reactState.dispose();
+  }
+};
+function createReactChat(config) {
+  return new ReactChat(config);
+}
+function useChat(config) {
+  const chatRef = react.useRef(null);
+  const [input, setInput] = react.useState("");
+  if (chatRef.current === null) {
+    chatRef.current = createReactChat({
+      runtimeUrl: config.runtimeUrl,
+      systemPrompt: config.systemPrompt,
+      llm: config.llm,
+      threadId: config.threadId,
+      streaming: config.streaming,
+      headers: config.headers,
+      initialMessages: config.initialMessages,
+      debug: config.debug,
+      callbacks: {
+        onMessagesChange: config.onMessagesChange,
+        onError: config.onError,
+        onFinish: config.onFinish,
+        onToolCalls: config.onToolCalls
+      }
+    });
+  }
+  const messages = react.useSyncExternalStore(
+    chatRef.current.subscribe,
+    () => chatRef.current.messages,
+    () => chatRef.current.messages
+    // Server snapshot
+  );
+  const status = react.useSyncExternalStore(
+    chatRef.current.subscribe,
+    () => chatRef.current.status,
+    () => "ready"
+    // Server snapshot
+  );
+  const error = react.useSyncExternalStore(
+    chatRef.current.subscribe,
+    () => chatRef.current.error,
+    () => void 0
+    // Server snapshot
+  );
+  const isLoading = status === "streaming" || status === "submitted";
+  const sendMessage = react.useCallback(
+    async (content, attachments) => {
+      await chatRef.current?.sendMessage(content, attachments);
+      setInput("");
+    },
+    []
+  );
+  const stop = react.useCallback(() => {
+    chatRef.current?.stop();
+  }, []);
+  const clearMessages = react.useCallback(() => {
+    chatRef.current?.clearMessages();
+  }, []);
+  const setMessages = react.useCallback((messages2) => {
+    chatRef.current?.setMessages(messages2);
+  }, []);
+  const regenerate = react.useCallback(async (messageId) => {
+    await chatRef.current?.regenerate(messageId);
+  }, []);
+  const continueWithToolResults = react.useCallback(
+    async (toolResults) => {
+      await chatRef.current?.continueWithToolResults(toolResults);
+    },
+    []
+  );
+  react.useEffect(() => {
+    return () => {
+      chatRef.current?.dispose();
+    };
+  }, []);
+  return {
+    messages,
+    status,
+    error,
+    isLoading,
+    input,
+    setInput,
+    sendMessage,
+    stop,
+    clearMessages,
+    setMessages,
+    regenerate,
+    continueWithToolResults,
+    chatRef
+  };
+}
+
+exports.AbstractAgentLoop = AbstractAgentLoop;
+exports.AbstractChat = AbstractChat;
+exports.CopilotProvider = CopilotProvider;
+exports.ReactChat = ReactChat;
+exports.ReactChatState = ReactChatState;
+exports.createPermissionStorage = createPermissionStorage;
+exports.createReactChat = createReactChat;
+exports.createReactChatState = createReactChatState;
+exports.createSessionPermissionCache = createSessionPermissionCache;
+exports.formatKnowledgeResultsForAI = formatKnowledgeResultsForAI;
+exports.initialAgentLoopState = initialAgentLoopState;
+exports.searchKnowledgeBase = searchKnowledgeBase;
+exports.useAIAction = useAIAction;
+exports.useAIActions = useAIActions;
+exports.useAIContext = useAIContext;
+exports.useAIContexts = useAIContexts;
+exports.useAITools = useAITools;
+exports.useAgent = useAgent;
+exports.useCapabilities = useCapabilities;
+exports.useChat = useChat;
+exports.useCopilot = useCopilot;
+exports.useDevLogger = useDevLogger;
+exports.useFeatureSupport = useFeatureSupport;
+exports.useKnowledgeBase = useKnowledgeBase;
+exports.useSuggestions = useSuggestions;
+exports.useSupportedMediaTypes = useSupportedMediaTypes;
+exports.useTool = useTool;
+exports.useToolExecutor = useToolExecutor;
+exports.useToolWithSchema = useToolWithSchema;
+exports.useTools = useTools;
+exports.useToolsWithSchema = useToolsWithSchema;
+//# sourceMappingURL=chunk-W6KQT7YZ.cjs.map
+//# sourceMappingURL=chunk-W6KQT7YZ.cjs.map