@automattic/agenttic-client 0.1.11 → 0.1.13

package/dist/index.js

@@ -1,462 +1,364 @@
-import {
-  BarChart,
-  ChartBlock,
-  LineChart,
-  createChartBlock
-} from "./chunk-LAB4XYXR.js";
-
-// src/react/useClientContext.ts
-import { useMemo } from "@wordpress/element";
-
-// src/client/utils/logger.ts
-var logger = (message, ...args) => {
-  if (isDebugEnabled()) {
-    console.log(`[agenttic-client] ${message}`, ...args);
-  }
+var Nt = Object.defineProperty;
+var $t = (t, e, s) => e in t ? Nt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s;
+var at = (t, e, s) => $t(t, typeof e != "symbol" ? e + "" : e, s);
+import gt, { useMemo as it, useCallback as j, Component as Dt, useState as X, useRef as xt, useEffect as Y } from "react";
+import { j as $, C as tt, g as _t, a as jt, B as Ft, b as Ht } from "./BarChart-Cid6YH81.js";
+import qt from "streamdown";
+import Ut from "remark-gfm";
+import { __ as H, sprintf as ft } from "@wordpress/i18n";
+import { LineChart as Bt } from "@automattic/charts";
+import mt from "@wordpress/api-fetch";
+const N = (t, ...e) => {
+  Jt() && console.log(`[agenttic-client] ${t}`, ...e);
 };
-function isDebugEnabled() {
-  return typeof globalThis !== "undefined" && "window" in globalThis && globalThis.window?.DEBUG === "agenttic-client";
+function Jt() {
+  var t;
+  return typeof globalThis < "u" && "window" in globalThis && ((t = globalThis.window) == null ? void 0 : t.DEBUG) === "agenttic-client";
 }
-function formatObject(obj) {
-  return JSON.stringify(obj, null, 2);
+function Mt(t) {
+  return JSON.stringify(t, null, 2);
 }
-function log(message, ...args) {
-  console.log(`[agenttic-client] ${message}`, ...args);
+function ht(t, ...e) {
+  console.log(`[agenttic-client] ${t}`, ...e);
 }
-
-// src/react/useClientContext.ts
-function useClientContext(getClientContextCallback) {
-  const contextProvider = useMemo(() => {
-    if (!getClientContextCallback) {
-      return void 0;
-    }
-    const provider = {
-      getClientContext: () => {
-        try {
-          const context = getClientContextCallback();
-          return context || {};
-        } catch (error) {
-          logger("Error getting client context: %O", error);
-          return {};
-        }
+function Ve(t) {
+  return it(() => t ? {
+    getClientContext: () => {
+      try {
+        return t() || {};
+      } catch (n) {
+        return N("Error getting client context: %O", n), {};
       }
-    };
-    return provider;
-  }, [getClientContextCallback]);
-  return contextProvider;
-}
-
-// src/react/useClientTools.ts
-import { useCallback, useMemo as useMemo2 } from "@wordpress/element";
-function useClientTools(getClientTools, executeTool) {
-  const stableGetAvailableTools = useCallback(async () => {
-    if (!getClientTools) {
-      return [];
     }
-    try {
-      return await getClientTools();
-    } catch (error) {
-      logger("Error getting available tools: %O", error);
+  } : void 0, [t]);
+}
+function ze(t, e) {
+  const s = j(async () => {
+    if (!t)
       return [];
+    try {
+      return await t();
+    } catch (r) {
+      return N("Error getting available tools: %O", r), [];
     }
-  }, [getClientTools]);
-  const stableExecuteTool = useCallback(
-    async (toolId, args) => {
-      if (!executeTool) {
+  }, [t]), n = j(
+    async (r, o) => {
+      if (!e)
         throw new Error("No executeTool callback provided");
-      }
       try {
-        return await executeTool(toolId, args);
-      } catch (error) {
-        logger("Error executing tool %s: %O", toolId, error);
-        throw error;
+        return await e(r, o);
+      } catch (i) {
+        throw N("Error executing tool %s: %O", r, i), i;
       }
     },
-    [executeTool]
+    [e]
   );
-  const toolProvider = useMemo2(() => {
-    if (!getClientTools) {
-      return void 0;
-    }
-    return {
-      getAvailableTools: stableGetAvailableTools,
-      executeTool: stableExecuteTool
-    };
-  }, [stableGetAvailableTools, stableExecuteTool, getClientTools]);
-  return toolProvider;
-}
-
-// src/react/useAgentChat.ts
-import { useCallback as useCallback3, useEffect, useMemo as useMemo3, useRef, useState as useState2 } from "react";
-
-// src/client/utils/core.ts
-function generateRandomId() {
-  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "";
-  for (let i = 0; i < 8; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return result;
+  return it(() => {
+    if (t)
+      return {
+        getAvailableTools: s,
+        executeTool: n
+      };
+  }, [s, n, t]);
+}
+function lt() {
+  const t = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let e = "";
+  for (let s = 0; s < 8; s++)
+    e += t.charAt(Math.floor(Math.random() * t.length));
+  return e;
 }
-function generateMessageId() {
-  return generateRandomId();
+function D() {
+  return lt();
 }
-function createRequestId() {
-  return `req-${generateRandomId()}`;
+function Lt() {
+  return `req-${lt()}`;
 }
-function createTaskId() {
-  return `task-${generateRandomId()}`;
+function Wt() {
+  return `task-${lt()}`;
 }
-function createTextPart(text) {
+function Tt(t) {
   return {
     type: "text",
-    text
+    text: t
   };
 }
-function createSendMessageRequest(params, method = "message/send", tokenStreaming = false) {
-  const request = {
+function Kt(t, e = "message/send", s = !1) {
+  const n = {
     jsonrpc: "2.0",
-    id: createRequestId(),
-    method,
+    id: Lt(),
+    method: e,
     params: {
-      id: params.id || createTaskId(),
-      ...params
+      id: t.id || Wt(),
+      ...t
     }
   };
-  if (tokenStreaming && method === "message/stream") {
-    request.tokenStreaming = true;
-  }
-  return request;
+  return s && e === "message/stream" && (n.tokenStreaming = !0), n;
 }
-function extractTextFromMessage(message) {
-  if (!message || !message.parts || !Array.isArray(message.parts)) {
-    return "";
-  }
-  return message.parts.filter((part) => part.type === "text").map((part) => part.text).join(" ");
+function U(t) {
+  return !t || !t.parts || !Array.isArray(t.parts) ? "" : t.parts.filter((e) => e.type === "text").map((e) => e.text).join(" ");
 }
-function createToolDataPart(tool) {
+function Vt(t) {
   return {
     type: "data",
     data: {
-      toolId: tool.id,
-      toolName: tool.name,
-      description: tool.description,
-      inputSchema: tool.input_schema
+      toolId: t.id,
+      toolName: t.name,
+      description: t.description,
+      inputSchema: t.input_schema
     },
     metadata: {}
   };
 }
-function extractToolCallsFromMessage(message) {
-  if (!message || !message.parts || !Array.isArray(message.parts)) {
-    return [];
-  }
-  return message.parts.filter(
-    (part) => part.type === "data" && "toolCallId" in part.data && "toolId" in part.data && "arguments" in part.data
+function J(t) {
+  return !t || !t.parts || !Array.isArray(t.parts) ? [] : t.parts.filter(
+    (e) => e.type === "data" && "toolCallId" in e.data && "toolId" in e.data && "arguments" in e.data
   );
 }
-function createToolResultDataPart(toolCallId, toolId, result, error) {
+function W(t, e, s, n) {
   return {
     type: "data",
     data: {
-      toolCallId,
-      toolId,
-      result
+      toolCallId: t,
+      toolId: e,
+      result: s
     },
-    metadata: error ? { error } : void 0
+    metadata: n ? { error: n } : void 0
   };
 }
-function createContextDataPart(clientContext) {
+function zt(t) {
   return {
     type: "data",
     data: {
-      clientContext
+      clientContext: t
     },
     metadata: {}
   };
 }
-function createTextMessage(text) {
+function rt(t) {
   return {
     role: "user",
-    parts: [createTextPart(text)],
+    parts: [Tt(t)],
     kind: "message",
-    messageId: generateMessageId(),
+    messageId: D(),
     metadata: {
       timestamp: Date.now()
     }
   };
 }
-function createAgentTextMessage(text) {
+function Z(t) {
   return {
     role: "agent",
-    parts: [createTextPart(text)],
+    parts: [Tt(t)],
     kind: "message",
-    messageId: generateMessageId(),
+    messageId: D(),
     metadata: {
       timestamp: Date.now()
     }
   };
 }
-function processToolExecutionResult(executionResult) {
-  if (executionResult && typeof executionResult === "object" && "result" in executionResult) {
-    return {
-      result: executionResult.result,
-      returnToAgent: executionResult.returnToAgent !== false,
-      // Default to true
-      agentMessage: executionResult.agentMessage
-      // Pass through agentMessage if present
-    };
-  }
-  return {
-    result: executionResult,
-    returnToAgent: true
+function ct(t) {
+  return t && typeof t == "object" && "result" in t ? {
+    result: t.result,
+    returnToAgent: t.returnToAgent !== !1,
+    // Default to true
+    agentMessage: t.agentMessage
+    // Pass through agentMessage if present
+  } : {
+    result: t,
+    returnToAgent: !0
   };
 }
-function createToolResultMessage(toolResults, historyDataParts = []) {
+function et(t, e = []) {
   return {
     role: "user",
     kind: "message",
-    parts: [...historyDataParts, ...toolResults],
-    messageId: generateMessageId(),
+    parts: [...e, ...t],
+    messageId: D(),
     metadata: {
       timestamp: Date.now()
     }
   };
 }
-function createAbortController() {
+function Ge() {
   return new AbortController();
 }
-
-// src/client/utils/internal/messages.ts
-async function enhanceMessageWithTools(message, toolProvider) {
-  if (!toolProvider) {
-    return message;
-  }
+async function Gt(t, e) {
+  if (!e)
+    return t;
   try {
-    const tools = await toolProvider.getAvailableTools();
-    if (tools.length === 0) {
-      return message;
-    }
-    const toolParts = tools.map(createToolDataPart);
+    const s = await e.getAvailableTools();
+    if (s.length === 0)
+      return t;
+    const n = s.map(Vt);
     return {
-      ...message,
-      parts: [...message.parts, ...toolParts]
+      ...t,
+      parts: [...t.parts, ...n]
     };
-  } catch (error) {
-    logger("Warning: Failed to get tools: %s", error);
-    return message;
+  } catch (s) {
+    return N("Warning: Failed to get tools: %s", s), t;
   }
 }
-function enhanceMessageWithContext(message, contextProvider) {
-  if (!contextProvider) {
-    return message;
-  }
+function Qt(t, e) {
+  if (!e)
+    return t;
   try {
-    const clientContext = contextProvider.getClientContext();
-    if (!clientContext || Object.keys(clientContext).length === 0) {
-      return message;
-    }
-    const contextPart = createContextDataPart(clientContext);
+    const s = e.getClientContext();
+    if (!s || Object.keys(s).length === 0)
+      return t;
+    const n = zt(s);
     return {
-      ...message,
-      parts: [...message.parts, contextPart]
+      ...t,
+      parts: [...t.parts, n]
     };
-  } catch (error) {
-    logger("Warning: Failed to get context: %s", error);
-    return message;
+  } catch (s) {
+    return N("Warning: Failed to get context: %s", s), t;
   }
 }
-async function enhanceMessage(message, toolProvider, contextProvider) {
-  let enhancedMessage = await enhanceMessageWithTools(
-    message,
-    toolProvider
+async function Xt(t, e, s) {
+  let n = await Gt(
+    t,
+    e
   );
-  enhancedMessage = enhanceMessageWithContext(
-    enhancedMessage,
-    contextProvider
+  n = Qt(
+    n,
+    s
   );
-  const { metadata, ...messageForAgent } = enhancedMessage;
-  return messageForAgent;
-}
-
-// src/client/utils/internal/streaming.ts
-function parseStreamChunk(chunk, buffer = "") {
-  const events = [];
-  const currentStreamData = buffer + chunk;
-  let eventPayload = "";
-  let lastCompleteEventEnd = 0;
-  let searchStartIndex = 0;
-  while (searchStartIndex < currentStreamData.length) {
-    const newlineIndex = currentStreamData.indexOf(
-      "\n",
-      searchStartIndex
-    );
-    const line = newlineIndex === -1 ? currentStreamData.substring(searchStartIndex) : currentStreamData.substring(searchStartIndex, newlineIndex);
-    if (line.startsWith("data:")) {
-      if (eventPayload !== "") {
-        eventPayload += "\n";
-      }
-      eventPayload += line.substring(
-        line.startsWith("data: ") ? 6 : 5
+  const { metadata: a, ...r } = n;
+  return r;
+}
+function Yt(t, e = "") {
+  const s = [], n = e + t;
+  let a = "", r = 0, o = 0;
+  for (; o < n.length; ) {
+    const l = n.indexOf(
+      `
+`,
+      o
+    ), c = l === -1 ? n.substring(o) : n.substring(o, l);
+    if (c.startsWith("data:"))
+      a !== "" && (a += `
+`), a += c.substring(
+        c.startsWith("data: ") ? 6 : 5
       );
-    } else if (line.trim() === "") {
-      if (eventPayload) {
-        try {
-          events.push(JSON.parse(eventPayload));
-          lastCompleteEventEnd = newlineIndex === -1 ? currentStreamData.length : newlineIndex + 1;
-        } catch (e) {
-          logger("Failed to parse SSE event: %o", e);
-          logger("Problematic payload: %s", eventPayload);
-        }
-        eventPayload = "";
+    else if (c.trim() === "" && a) {
+      try {
+        s.push(JSON.parse(a)), r = l === -1 ? n.length : l + 1;
+      } catch (g) {
+        N("Failed to parse SSE event: %o", g), N("Problematic payload: %s", a);
       }
+      a = "";
     }
-    if (newlineIndex === -1) {
-      searchStartIndex = currentStreamData.length;
-    } else {
-      searchStartIndex = newlineIndex + 1;
-    }
+    l === -1 ? o = n.length : o = l + 1;
   }
-  const nextBuffer = currentStreamData.substring(lastCompleteEventEnd);
-  return { events, nextBuffer };
-}
-async function* parseSSEStream(stream, options = {}) {
-  const { supportDeltas = false } = options;
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const accumulator = new DeltaAccumulator();
-  let currentTaskId = null;
-  let lastStatus = null;
+  const i = n.substring(r);
+  return { events: s, nextBuffer: i };
+}
+async function* Zt(t, e = {}) {
+  var c, g, y;
+  const { supportDeltas: s = !1 } = e, n = t.getReader(), a = new TextDecoder();
+  let r = "";
+  const o = new te();
+  let i = null, l = null;
   try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
+    for (; ; ) {
+      const { done: b, value: A } = await n.read();
+      if (b)
         break;
-      }
-      const chunk = decoder.decode(value, { stream: true });
-      const { events, nextBuffer } = parseStreamChunk(chunk, buffer);
-      if (events && Array.isArray(events)) {
-        for (let i = 0; i < events.length; i++) {
-          const event = events[i];
-          if (i > 0 && event.method === "message/delta" && typeof requestAnimationFrame !== "undefined") {
-            await new Promise((resolve) => {
-              requestAnimationFrame(() => resolve(void 0));
-            });
-          }
-          if (event.error) {
+      const S = a.decode(A, { stream: !0 }), { events: M, nextBuffer: x } = Yt(S, r);
+      if (M && Array.isArray(M))
+        for (let p = 0; p < M.length; p++) {
+          const u = M[p];
+          if (p > 0 && u.method === "message/delta" && typeof requestAnimationFrame < "u" && await new Promise((h) => {
+            requestAnimationFrame(() => h(void 0));
+          }), u.error)
             throw new Error(
-              `Streaming error: ${event.error.message}`
+              `Streaming error: ${u.error.message}`
             );
-          }
-          if (supportDeltas && event.method === "message/delta" && event.params?.delta) {
-            const delta = event.params.delta;
+          if (s && u.method === "message/delta" && ((c = u.params) != null && c.delta)) {
+            const h = u.params.delta;
             try {
-              if (delta.deltaType === "content") {
-                accumulator.processContentDelta(
-                  delta.content
-                );
-                if (!currentTaskId && event.params.id) {
-                  currentTaskId = event.params.id;
-                }
-                if (currentTaskId) {
-                  const currentMessage = accumulator.getCurrentMessage();
-                  yield {
-                    id: currentTaskId,
-                    status: {
-                      state: "working",
-                      message: currentMessage
-                    },
-                    final: false,
-                    text: accumulator.getTextContent()
-                  };
-                }
+              if (h.deltaType === "content" && (o.processContentDelta(
+                h.content
+              ), !i && u.params.id && (i = u.params.id), i)) {
+                const d = o.getCurrentMessage();
+                yield {
+                  id: i,
+                  status: {
+                    state: "working",
+                    message: d
+                  },
+                  final: !1,
+                  text: o.getTextContent()
+                };
               }
-            } catch (error) {
-              logger("Failed to process delta: %o", error);
-            }
-          } else if (event.result && event.result.status) {
-            currentTaskId = event.result.id;
-            lastStatus = event.result.status;
-            if (accumulator.getTextContent() || accumulator.getCurrentMessage().parts.length > 0) {
-              accumulator.reset();
-            }
-            const update = {
-              id: event.result.id,
-              status: event.result.status,
-              final: event.result.status.state === "completed" || event.result.status.state === "failed" || event.result.status.state === "canceled",
-              text: extractTextFromMessage(
-                event.result.status?.message || {
-                  role: "agent",
-                  parts: []
-                }
-              )
-            };
-            yield update;
-          } else if (event.id && event.result) {
-            currentTaskId = event.result.id;
-            if (event.result.status) {
-              const update = {
-                id: event.result.id,
-                status: event.result.status,
-                final: event.result.status.state === "completed" || event.result.status.state === "failed" || event.result.status.state === "canceled",
-                text: extractTextFromMessage(
-                  event.result.status?.message || {
-                    role: "agent",
-                    parts: []
-                  }
-                )
-              };
-              yield update;
+            } catch (d) {
+              N("Failed to process delta: %o", d);
             }
-          }
+          } else u.result && u.result.status ? (i = u.result.id, l = u.result.status, (o.getTextContent() || o.getCurrentMessage().parts.length > 0) && o.reset(), yield {
+            id: u.result.id,
+            status: u.result.status,
+            final: u.result.status.state === "completed" || u.result.status.state === "failed" || u.result.status.state === "canceled",
+            text: U(
+              ((g = u.result.status) == null ? void 0 : g.message) || {
+                role: "agent",
+                parts: []
+              }
+            )
+          }) : u.id && u.result && (i = u.result.id, u.result.status && (yield {
+            id: u.result.id,
+            status: u.result.status,
+            final: u.result.status.state === "completed" || u.result.status.state === "failed" || u.result.status.state === "canceled",
+            text: U(
+              ((y = u.result.status) == null ? void 0 : y.message) || {
+                role: "agent",
+                parts: []
+              }
+            )
+          }));
         }
-      }
-      buffer = nextBuffer;
+      r = x;
     }
   } finally {
-    reader.releaseLock();
+    n.releaseLock();
   }
 }
-var DeltaAccumulator = class {
-  textContent = "";
-  toolCalls = /* @__PURE__ */ new Map();
+class te {
+  constructor() {
+    at(this, "textContent", "");
+    at(this, "toolCalls", /* @__PURE__ */ new Map());
+  }
   /**
    * Process a simple content delta (server's actual format)
    * @param content - The text content to append
    */
-  processContentDelta(content) {
-    this.textContent += content;
+  processContentDelta(e) {
+    this.textContent += e;
   }
   /**
    * Process a delta message and accumulate the content (original format)
    * @param delta - The delta message to process
    */
-  processDelta(delta) {
-    switch (delta.type) {
+  processDelta(e) {
+    switch (e.type) {
       case "content":
-        this.textContent += delta.content;
+        this.textContent += e.content;
         break;
       case "tool_name":
-        if (!this.toolCalls.has(delta.toolCallIndex)) {
-          this.toolCalls.set(delta.toolCallIndex, {
-            toolCallId: delta.toolCallId,
-            toolName: "",
-            argumentFragments: []
-          });
-        }
-        const toolCall = this.toolCalls.get(delta.toolCallIndex);
-        toolCall.toolName += delta.content;
+        this.toolCalls.has(e.toolCallIndex) || this.toolCalls.set(e.toolCallIndex, {
+          toolCallId: e.toolCallId,
+          toolName: "",
+          argumentFragments: []
+        });
+        const s = this.toolCalls.get(e.toolCallIndex);
+        s.toolName += e.content;
         break;
       case "tool_argument":
-        if (!this.toolCalls.has(delta.toolCallIndex)) {
-          this.toolCalls.set(delta.toolCallIndex, {
-            toolCallId: delta.toolCallId,
-            toolName: "",
-            argumentFragments: []
-          });
-        }
-        const call = this.toolCalls.get(delta.toolCallIndex);
-        call.argumentFragments.push(delta.content);
+        this.toolCalls.has(e.toolCallIndex) || this.toolCalls.set(e.toolCallIndex, {
+          toolCallId: e.toolCallId,
+          toolName: "",
+          argumentFragments: []
+        }), this.toolCalls.get(e.toolCallIndex).argumentFragments.push(e.content);
         break;
     }
   }
@@ -470,715 +372,566 @@ var DeltaAccumulator = class {
    * Get the current accumulated message
    * @param role - The role for the message (default: 'agent')
    */
-  getCurrentMessage(role = "agent") {
-    const parts = [];
-    if (this.textContent) {
-      parts.push({
-        type: "text",
-        text: this.textContent
-      });
-    }
-    for (const [index, toolCall] of this.toolCalls) {
-      if (toolCall.toolName) {
-        const argumentsStr = toolCall.argumentFragments.join("");
-        let args = {};
-        if (argumentsStr) {
+  getCurrentMessage(e = "agent") {
+    const s = [];
+    this.textContent && s.push({
+      type: "text",
+      text: this.textContent
+    });
+    for (const [n, a] of this.toolCalls)
+      if (a.toolName) {
+        const r = a.argumentFragments.join("");
+        let o = {};
+        if (r)
           try {
-            args = JSON.parse(argumentsStr);
+            o = JSON.parse(r);
           } catch {
-            args = { _raw: argumentsStr };
+            o = { _raw: r };
           }
-        }
-        parts.push({
+        s.push({
           type: "data",
           data: {
-            toolCallId: toolCall.toolCallId,
-            toolId: toolCall.toolName,
-            arguments: args
+            toolCallId: a.toolCallId,
+            toolId: a.toolName,
+            arguments: o
           }
         });
       }
-    }
     return {
-      role,
-      parts,
+      role: e,
+      parts: s,
       kind: "message",
-      messageId: generateMessageId()
+      messageId: D()
     };
   }
   /**
    * Reset the accumulator
    */
   reset() {
-    this.textContent = "";
-    this.toolCalls.clear();
-  }
-};
-
-// src/client/utils/internal/errors.ts
-function handleRequestError(error, timeoutId, operation = "request") {
-  clearTimeout(timeoutId);
-  logger("%s failed with error: %O", operation, error);
-  if (error instanceof Error) {
-    logger("Error message: %s", error.message);
-    logger("Error stack: %s", error.stack);
+    this.textContent = "", this.toolCalls.clear();
   }
-  throw error;
 }
-function validateHttpResponse(response, operation = "request") {
-  if (!response.ok) {
-    throw new Error(`HTTP error! status: ${response.status}`);
-  }
+function bt(t, e, s = "request") {
+  throw clearTimeout(e), N("%s failed with error: %O", s, t), t instanceof Error && (N("Error message: %s", t.message), N("Error stack: %s", t.stack)), t;
 }
-function validateJsonRpcResponse(data, operation = "request") {
-  if (data.error) {
-    throw new Error(`A2A ${operation} error: ${data.error.message}`);
-  }
-  if (!data.result) {
-    throw new Error(`No result in ${operation} response`);
-  }
-  return data.result;
+function St(t, e = "request") {
+  if (!t.ok)
+    throw new Error(`HTTP error! status: ${t.status}`);
 }
-function validateStreamingResponse(response, operation = "streaming request") {
-  validateHttpResponse(response, operation);
-  if (!response.body) {
-    throw new Error(`No response body for ${operation}`);
-  }
+function ee(t, e = "request") {
+  if (t.error)
+    throw new Error(`A2A ${e} error: ${t.error.message}`);
+  if (!t.result)
+    throw new Error(`No result in ${e} response`);
+  return t.result;
 }
-function createTimeoutHandler(timeout, operation = "request") {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(
-    () => controller.abort(),
-    timeout
-  );
-  return { timeoutId, controller };
-}
-
-// src/client/utils/internal/requests.ts
-function constructAgentUrl(agentUrl, agentId) {
-  return `${agentUrl}/${agentId}`;
-}
-function logRequest(method, url, headers, body) {
-  logger("Request: %s %s", method, url);
-  logger("Headers: %o", headers);
-  if (body) {
-    logger("Body: %s", formatObject(body));
-  }
+function se(t, e = "streaming request") {
+  if (St(t, e), !t.body)
+    throw new Error(`No response body for ${e}`);
+}
+function kt(t, e = "request") {
+  const s = new AbortController();
+  return { timeoutId: setTimeout(
+    () => s.abort(),
+    t
+  ), controller: s };
+}
+function ne(t, e) {
+  return `${t}/${e}`;
 }
-async function getHeaders(authProvider, isStreaming = false) {
-  const baseHeaders = {
+function ae(t, e, s, n) {
+  N("Request: %s %s", t, e), N("Headers: %o", s), n && N("Body: %s", Mt(n));
+}
+async function oe(t, e = !1) {
+  const s = {
     "Content-Type": "application/json"
   };
-  if (isStreaming) {
-    baseHeaders.Accept = "text/event-stream";
-  }
-  if (authProvider) {
-    const authHeaders = await authProvider();
-    return { ...baseHeaders, ...authHeaders };
+  if (e && (s.Accept = "text/event-stream"), t) {
+    const n = await t();
+    return { ...s, ...n };
   }
-  return baseHeaders;
+  return s;
 }
-function combineSignals(signal1, signal2) {
-  if (!signal2) {
-    return signal1;
-  }
-  const controller = new AbortController();
-  const handleAbort = (signal) => {
-    if (!controller.signal.aborted) {
-      controller.abort(signal.reason);
-    }
+function At(t, e) {
+  if (!e)
+    return t;
+  const s = new AbortController(), n = (a) => {
+    s.signal.aborted || s.abort(a.reason);
   };
-  if (signal1.aborted) {
-    controller.abort(signal1.reason);
-  } else {
-    signal1.addEventListener("abort", () => handleAbort(signal1), {
-      once: true
-    });
-  }
-  if (signal2.aborted) {
-    controller.abort(signal2.reason);
-  } else {
-    signal2.addEventListener("abort", () => handleAbort(signal2), {
-      once: true
-    });
-  }
-  return controller.signal;
+  return t.aborted ? s.abort(t.reason) : t.addEventListener("abort", () => n(t), {
+    once: !0
+  }), e.aborted ? s.abort(e.reason) : e.addEventListener("abort", () => n(e), {
+    once: !0
+  }), s.signal;
 }
-function createFetchOptions(headers, body, signal) {
+function vt(t, e, s) {
   return {
     method: "POST",
-    headers,
-    body,
-    signal
+    headers: t,
+    body: e,
+    signal: s
   };
 }
-async function prepareRequest(params, config, options, toolProvider, contextProvider, defaultSessionId) {
-  const { message, sessionId, taskId, metadata } = params;
-  const { agentId, agentUrl, authProvider, proxy } = config;
-  const { isStreaming = false, enableTokenStreaming = false } = options;
-  const effectiveSessionId = sessionId || defaultSessionId;
-  const fullAgentUrl = constructAgentUrl(agentUrl, agentId);
-  const enhancedMessage = await enhanceMessage(
-    message,
-    toolProvider,
-    contextProvider
-  );
-  const request = createSendMessageRequest(
+async function st(t, e, s, n, a, r) {
+  const { message: o, sessionId: i, taskId: l, metadata: c } = t, { agentId: g, agentUrl: y, authProvider: b, proxy: A } = e, { isStreaming: S = !1, enableTokenStreaming: M = !1 } = s, x = i || r, p = ne(y, g), u = await Xt(
+    o,
+    n,
+    a
+  ), h = Kt(
     {
-      id: taskId,
-      sessionId: effectiveSessionId,
-      message: enhancedMessage,
-      metadata
+      id: l,
+      sessionId: x,
+      message: u,
+      metadata: c
     },
-    isStreaming ? "message/stream" : "message/send",
-    enableTokenStreaming && isStreaming
+    S ? "message/stream" : "message/send",
+    M && S
     // Only enable token streaming if using SSE
-  );
-  const headers = await getHeaders(authProvider, isStreaming);
-  logRequest("POST", fullAgentUrl, headers, request);
-  return {
-    request,
-    headers,
-    enhancedMessage,
-    effectiveSessionId,
-    fullAgentUrl
+  ), d = await oe(b, S);
+  return ae("POST", p, d, h), {
+    request: h,
+    headers: d,
+    enhancedMessage: u,
+    effectiveSessionId: x,
+    fullAgentUrl: p
   };
 }
-async function executeRequest(preparedRequest, config, options = {}) {
-  const { request, headers, fullAgentUrl } = preparedRequest;
-  const { timeout } = config;
-  const { abortSignal: externalSignal } = options;
-  const { timeoutId, controller: timeoutController } = createTimeoutHandler(
-    timeout,
+async function Rt(t, e, s = {}) {
+  const { request: n, headers: a, fullAgentUrl: r } = t, { timeout: o } = e, { abortSignal: i } = s, { timeoutId: l, controller: c } = kt(
+    o,
     "request"
-  );
-  const signal = externalSignal ? combineSignals(timeoutController.signal, externalSignal) : timeoutController.signal;
+  ), g = i ? At(c.signal, i) : c.signal;
   try {
-    const fetchOptions = createFetchOptions(
-      headers,
-      JSON.stringify(request),
-      signal
+    const y = vt(
+      a,
+      JSON.stringify(n),
+      g
     );
-    logger("Making request to %s with options: %O", fullAgentUrl, {
-      method: fetchOptions.method,
-      headers: fetchOptions.headers
+    N("Making request to %s with options: %O", r, {
+      method: y.method,
+      headers: y.headers
     });
-    const response = await fetch(fullAgentUrl, fetchOptions);
-    clearTimeout(timeoutId);
-    validateHttpResponse(response, "request");
-    const data = await response.json();
-    logger(
+    const b = await fetch(r, y);
+    clearTimeout(l), St(b, "request");
+    const A = await b.json();
+    return N(
       "Response from %s: %d %O",
-      fullAgentUrl,
-      response.status,
-      formatObject(data)
-    );
-    return validateJsonRpcResponse(data, "request");
-  } catch (error) {
-    handleRequestError(error, timeoutId, "request");
+      r,
+      b.status,
+      Mt(A)
+    ), ee(A, "request");
+  } catch (y) {
+    bt(y, l, "request");
   }
 }
-async function* executeStreamingRequest(preparedRequest, config, options) {
-  const { request, headers, fullAgentUrl } = preparedRequest;
-  const {} = config;
-  const {
-    streamingTimeout = 6e4,
-    abortSignal: externalSignal,
-    enableTokenStreaming = false
-  } = options;
-  const { timeoutId, controller } = createTimeoutHandler(
-    streamingTimeout,
+async function* Et(t, e, s) {
+  const { request: n, headers: a, fullAgentUrl: r } = t, {
+    streamingTimeout: o = 6e4,
+    abortSignal: i,
+    enableTokenStreaming: l = !1
+  } = s, { timeoutId: c, controller: g } = kt(
+    o,
     "streaming request"
-  );
-  const signal = externalSignal ? combineSignals(controller.signal, externalSignal) : controller.signal;
+  ), y = i ? At(g.signal, i) : g.signal;
   try {
-    const requestBody = JSON.stringify(request);
-    const fetchOptions = createFetchOptions(headers, requestBody, signal);
-    const response = await fetch(fullAgentUrl, fetchOptions);
-    clearTimeout(timeoutId);
-    validateStreamingResponse(response, "streaming request");
-    if (!response.body) {
+    const b = JSON.stringify(n), A = vt(a, b, y), S = await fetch(r, A);
+    if (clearTimeout(c), se(S, "streaming request"), !S.body)
       throw new Error(
         "Response body is null - server may not support streaming"
       );
-    }
-    const supportDeltas = enableTokenStreaming && request.tokenStreaming === true;
-    yield* parseSSEStream(response.body, {
-      supportDeltas
+    const M = l && n.tokenStreaming === !0;
+    yield* Zt(S.body, {
+      supportDeltas: M
     });
-  } catch (error) {
-    handleRequestError(error, timeoutId, "streaming request");
+  } catch (b) {
+    bt(b, c, "streaming request");
   }
 }
-
-// src/client/index.ts
-var DEFAULT_TIMEOUT = 12e4;
-var toolResultPromises = /* @__PURE__ */ new Map();
-async function hasMatchingToolCallbacks(toolProvider, message) {
-  if (!toolProvider || !message || !toolProvider.getAvailableTools) {
-    return false;
-  }
-  const toolCalls = extractToolCallsFromMessage(message);
-  if (toolCalls.length === 0) {
-    return false;
-  }
+const re = 12e4, ut = /* @__PURE__ */ new Map();
+async function ie(t, e) {
+  if (!t || !e || !t.getAvailableTools)
+    return !1;
+  const s = J(e);
+  if (s.length === 0)
+    return !1;
   try {
-    const availableTools = await toolProvider.getAvailableTools();
-    for (const toolCall of toolCalls) {
-      const hasCallback = availableTools.some(
-        (tool) => tool.id === toolCall.data.toolId
-      );
-      if (hasCallback) {
-        return true;
-      }
-    }
-  } catch (error) {
-    return false;
+    const n = await t.getAvailableTools();
+    for (const a of s)
+      if (n.some(
+        (o) => o.id === a.data.toolId
+      ))
+        return !0;
+  } catch {
+    return !1;
   }
-  return false;
-}
-function clearToolResultPromises() {
-  toolResultPromises.clear();
-}
-function updateToolResultsWithResolvedPromises(toolResults) {
-  return toolResults.map((toolResult) => {
-    const toolCallId = toolResult.data.toolCallId;
-    const promiseEntry = toolResultPromises.get(toolCallId);
-    if (promiseEntry && promiseEntry.resolvedValue !== null) {
-      const resolvedValue = promiseEntry.resolvedValue;
-      if (resolvedValue.error) {
-        return createToolResultDataPart(
-          toolCallId,
-          toolResult.data.toolId,
-          void 0,
-          resolvedValue.error
-        );
-      }
-      return createToolResultDataPart(
-        toolCallId,
-        toolResult.data.toolId,
-        resolvedValue
+  return !1;
+}
+function le() {
+  ut.clear();
+}
+function ce(t) {
+  return t.map((e) => {
+    const s = e.data.toolCallId, n = ut.get(s);
+    if (n && n.resolvedValue !== null) {
+      const a = n.resolvedValue;
+      return a.error ? W(
+        s,
+        e.data.toolId,
+        void 0,
+        a.error
+      ) : W(
+        s,
+        e.data.toolId,
+        a
       );
     }
-    return toolResult;
+    return e;
   });
 }
-async function executeToolCallBatch(toolCalls, toolProvider, messageId) {
-  const results = [];
-  const agentMessages = [];
-  let shouldReturnToAgent = false;
-  for (const toolCall of toolCalls) {
-    const { toolCallId, toolId, arguments: args } = toolCall.data;
+async function Pt(t, e, s) {
+  const n = [], a = [];
+  let r = !1;
+  for (const o of t) {
+    const { toolCallId: i, toolId: l, arguments: c } = o.data;
     try {
-      const executionResult = await toolProvider.executeTool(
-        toolId,
-        args,
-        messageId,
-        toolCallId
-      );
-      const { result, returnToAgent, agentMessage } = processToolExecutionResult(executionResult);
-      if (returnToAgent) {
-        shouldReturnToAgent = true;
-      }
-      if (agentMessage) {
-        agentMessages.push(createAgentTextMessage(agentMessage));
-      }
-      results.push(
-        createToolResultDataPart(
-          toolCallId,
-          toolId,
-          result
+      const g = await e.executeTool(
+        l,
+        c,
+        s,
+        i
+      ), { result: y, returnToAgent: b, agentMessage: A } = ct(g);
+      b && (r = !0), A && a.push(Z(A)), n.push(
+        W(
+          i,
+          l,
+          y
         )
       );
-    } catch (error) {
-      shouldReturnToAgent = true;
-      results.push(
-        createToolResultDataPart(
-          toolCallId,
-          toolId,
+    } catch (g) {
+      r = !0, n.push(
+        W(
+          i,
+          l,
           void 0,
-          error instanceof Error ? error.message : String(error)
+          g instanceof Error ? g.message : String(g)
         )
       );
     }
   }
-  return { results, shouldReturnToAgent, agentMessages };
-}
-function conversationHistoryToDataParts(conversationHistory) {
-  const historyParts = [];
-  for (const message of conversationHistory) {
-    for (const part of message.parts) {
-      if (part.type === "text") {
-        historyParts.push({
-          type: "data",
-          data: {
-            role: message.role,
-            text: part.text
-          }
-        });
-      } else if (part.type === "data") {
-        historyParts.push(part);
-      }
-    }
-  }
-  return historyParts;
+  return { results: n, shouldReturnToAgent: r, agentMessages: a };
 }
-async function continueTask(taskId, message, requestConfig, toolProvider, contextProvider, sessionId, abortSignal) {
-  const continueParams = {
-    message,
-    taskId,
-    sessionId: void 0
-    // Use task's session
-  };
-  const preparedRequest = await prepareRequest(
-    continueParams,
-    requestConfig,
-    { isStreaming: false, abortSignal },
-    toolProvider,
-    contextProvider,
-    sessionId
+function pt(t) {
+  const e = [];
+  for (const s of t)
+    for (const n of s.parts)
+      n.type === "text" ? e.push({
+        type: "data",
+        data: {
+          role: s.role,
+          text: n.text
+        }
+      }) : n.type === "data" && e.push(n);
+  return e;
+}
+async function ot(t, e, s, n, a, r, o) {
+  const l = await st(
+    {
+      message: e,
+      taskId: t,
+      sessionId: void 0
+      // Use task's session
+    },
+    s,
+    { isStreaming: !1 },
+    n,
+    a,
+    r
   );
-  return await executeRequest(preparedRequest, requestConfig, {
-    abortSignal
+  return await Rt(l, s, {
+    abortSignal: o
   });
 }
-async function continueTaskStreamed(taskId, message, requestConfig, toolProvider, contextProvider, sessionId, abortSignal, requestOptions) {
-  const continueParams = {
-    message,
-    taskId,
+async function yt(t, e, s, n, a, r, o, i) {
+  const l = {
+    message: e,
+    taskId: t,
     sessionId: void 0
     // Use task's session
-  };
-  const options = requestOptions || { isStreaming: true };
-  const preparedRequest = await prepareRequest(
-    continueParams,
-    requestConfig,
+  }, c = i || { isStreaming: !0 }, g = await st(
+    l,
+    s,
     {
-      ...options,
-      abortSignal
+      ...c
     },
-    toolProvider,
-    contextProvider,
-    sessionId
-  );
-  const stream = executeStreamingRequest(preparedRequest, requestConfig, {
-    ...options,
-    abortSignal
+    n,
+    a,
+    r
+  ), y = Et(g, s, {
+    ...c,
+    abortSignal: o
   });
-  return processAgentResponseStream(
-    stream,
-    toolProvider,
-    contextProvider,
-    requestConfig,
-    sessionId,
-    true,
+  return Ot(
+    y,
+    n,
+    a,
+    s,
+    r,
+    !0,
     // withHistory
     [],
     // newConversationParts - empty for continueTask
-    abortSignal,
-    options
+    o,
+    c
     // Pass through the same request options
   );
 }
-async function* processAgentResponseStream(stream, toolProvider, contextProvider, requestConfig, sessionId, withHistory = true, newConversationParts = [], abortSignal, requestOptions) {
-  for await (const update of stream) {
-    yield update;
-    if (update.status.state === "running" && update.status.message && toolProvider && await hasMatchingToolCallbacks(
-      toolProvider,
-      update.status.message
+async function* Ot(t, e, s, n, a, r = !0, o = [], i, l) {
+  var c, g, y, b, A, S, M, x, p, u, h, d;
+  for await (const f of t) {
+    if (yield f, f.status.state === "running" && f.status.message && e && await ie(
+      e,
+      f.status.message
     )) {
-      const toolCalls = extractToolCallsFromMessage(
-        update.status.message
+      const T = J(
+        f.status.message
       );
-      for (const toolCall of toolCalls) {
-        const { toolCallId, toolId, arguments: args } = toolCall.data;
-        toolProvider.executeTool(
-          toolId,
-          args,
-          update.status?.message?.messageId,
-          toolCallId
-        ).catch((error) => {
+      for (const I of T) {
+        const { toolCallId: P, toolId: w, arguments: m } = I.data;
+        e.executeTool(
+          w,
+          m,
+          (g = (c = f.status) == null ? void 0 : c.message) == null ? void 0 : g.messageId,
+          P
+        ).catch((k) => {
           console.error(
-            `Tool execution failed for ${toolId}:`,
-            error
+            `Tool execution failed for ${w}:`,
+            k
           );
         });
       }
       yield {
-        id: update.id,
+        id: f.id,
         status: {
           state: "running",
           message: {
             role: "agent",
             kind: "message",
-            parts: toolCalls,
-            messageId: generateMessageId()
+            parts: T,
+            messageId: D()
           }
         },
-        final: false,
+        final: !1,
         text: ""
       };
     }
-    if (update.status.state === "input-required" && update.status.message && toolProvider) {
-      const toolCalls = extractToolCallsFromMessage(
-        update.status.message
+    if (f.status.state === "input-required" && f.status.message && e) {
+      const T = J(
+        f.status.message
       );
-      if (toolCalls.length > 0) {
-        const toolResults = [];
-        let shouldReturnToAgent = false;
-        const toolParts = [];
-        const agentMessages = [];
-        for (const toolCall of toolCalls) {
+      if (T.length > 0) {
+        const I = [];
+        let P = !1;
+        const w = [], m = [];
+        for (const k of T) {
           const {
-            toolCallId,
-            toolId,
-            arguments: args
-          } = toolCall.data;
+            toolCallId: C,
+            toolId: E,
+            arguments: R
+          } = k.data;
           try {
-            const executionResult = await toolProvider.executeTool(
-              toolId,
-              args,
-              update.status?.message?.messageId,
-              toolCallId
-            );
-            const { result, returnToAgent, agentMessage } = processToolExecutionResult(executionResult);
-            if (returnToAgent) {
-              shouldReturnToAgent = true;
-            }
-            if (agentMessage) {
-              agentMessages.push(
-                createAgentTextMessage(agentMessage)
-              );
-            }
-            if (result.result instanceof Promise) {
-              const promise = result.result;
-              const promiseEntry = {
-                promise,
+            const O = await e.executeTool(
+              E,
+              R,
+              (b = (y = f.status) == null ? void 0 : y.message) == null ? void 0 : b.messageId,
+              C
+            ), { result: v, returnToAgent: F, agentMessage: B } = ct(O);
+            if (F && (P = !0), B && m.push(
+              Z(B)
+            ), v.result instanceof Promise) {
+              const K = v.result, z = {
+                promise: K,
                 resolvedValue: null
               };
-              toolResultPromises.set(
-                toolCallId,
-                promiseEntry
-              );
-              promise.then((resolvedValue) => {
-                promiseEntry.resolvedValue = resolvedValue;
-              }).catch((error) => {
+              ut.set(
+                C,
+                z
+              ), K.then((q) => {
+                z.resolvedValue = q;
+              }).catch((q) => {
                 console.error(
-                  `Promise rejected for tool call ${toolCallId}:`,
-                  error
-                );
-                promiseEntry.resolvedValue = {
-                  error: error instanceof Error ? error.message : String(error)
+                  `Promise rejected for tool call ${C}:`,
+                  q
+                ), z.resolvedValue = {
+                  error: q instanceof Error ? q.message : String(q)
                 };
               });
             }
-            const toolResult = createToolResultDataPart(
-              toolCallId,
-              toolId,
-              result
+            const _ = W(
+              C,
+              E,
+              v
             );
-            toolResults.push(toolResult);
-            toolParts.push(toolResult);
-          } catch (error) {
-            const toolResult = createToolResultDataPart(
-              toolCallId,
-              toolId,
+            I.push(_), w.push(_);
+          } catch (O) {
+            const v = W(
+              C,
+              E,
               void 0,
-              error instanceof Error ? error.message : String(error)
+              O instanceof Error ? O.message : String(O)
             );
-            toolResults.push(toolResult);
-            toolParts.push(toolResult);
+            I.push(v), w.push(v);
           }
         }
-        newConversationParts.push(update.status.message);
-        if (shouldReturnToAgent) {
-          const historyDataParts = conversationHistoryToDataParts(newConversationParts);
-          const toolResultMessage = createToolResultMessage(
-            toolResults,
-            historyDataParts
+        if (o.push(f.status.message), P) {
+          const k = pt(o), C = et(
+            I,
+            k
           );
           yield {
-            id: update.id,
+            id: f.id,
             status: {
               state: "working",
-              message: toolResultMessage
+              message: C
             },
-            final: false,
+            final: !1,
             text: ""
           };
-          const continuedTaskStream = await continueTaskStreamed(
-            update.id,
-            toolResultMessage,
-            requestConfig,
-            toolProvider,
-            contextProvider,
-            sessionId,
-            abortSignal,
-            requestOptions
+          const E = await yt(
+            f.id,
+            C,
+            n,
+            e,
+            s,
+            a,
+            i,
+            l
           );
-          let continuedTaskUpdate = null;
-          for await (const streamUpdate of continuedTaskStream) {
-            if (!streamUpdate.final) {
-              yield streamUpdate;
-            } else {
-              continuedTaskUpdate = streamUpdate;
-            }
-          }
-          if (!continuedTaskUpdate) {
+          let R = null;
+          for await (const F of E)
+            F.final ? R = F : yield F;
+          if (!R)
             throw new Error(
               "Continue task stream ended without final result"
             );
-          }
-          let continuedToolCalls = continuedTaskUpdate.status?.message ? extractToolCallsFromMessage(
-            continuedTaskUpdate.status.message
+          let O = (A = R.status) != null && A.message ? J(
+            R.status.message
           ) : [];
-          if (toolResults.length > 0) {
-            newConversationParts.push({
-              role: "agent",
-              kind: "message",
-              parts: toolResults,
-              messageId: generateMessageId()
-            });
-          }
-          let finalTask = continuedTaskUpdate;
-          if (continuedToolCalls.length > 0) {
-            yield {
-              ...continuedTaskUpdate,
-              final: false,
-              text: extractTextFromMessage(
-                continuedTaskUpdate.status?.message || {
-                  role: "agent",
-                  kind: "message",
+          I.length > 0 && o.push({
+            role: "agent",
+            kind: "message",
+            parts: I,
+            messageId: D()
+          });
+          let v = R;
+          if (O.length > 0)
+            for (yield {
+              ...R,
+              final: !1,
+              text: U(
+                ((S = R.status) == null ? void 0 : S.message) || {
                   parts: [],
-                  messageId: generateMessageId()
+                  messageId: D()
                 }
               )
-            };
-            while (continuedToolCalls.length > 0) {
-              if (finalTask.status?.message) {
-                newConversationParts.push(
-                  finalTask.status.message
-                );
-              }
+            }; O.length > 0; ) {
+              (M = v.status) != null && M.message && o.push(
+                v.status.message
+              );
               const {
-                results: moreResults,
-                shouldReturnToAgent: moreShouldReturn
-              } = await executeToolCallBatch(
-                continuedToolCalls,
-                toolProvider,
-                finalTask.status?.message?.messageId
+                results: F,
+                shouldReturnToAgent: B
+              } = await Pt(
+                O,
+                e,
+                (p = (x = v.status) == null ? void 0 : x.message) == null ? void 0 : p.messageId
               );
-              if (moreResults.length > 0) {
-                yield {
-                  id: finalTask.id,
-                  status: {
-                    state: "working",
-                    message: {
-                      role: "agent",
-                      kind: "message",
-                      parts: moreResults,
-                      messageId: generateMessageId()
-                    }
-                    // Simple message with just the results
-                  },
-                  final: false,
-                  text: ""
-                };
-              }
-              if (moreShouldReturn) {
-                const moreHistoryDataParts = withHistory ? conversationHistoryToDataParts(
-                  newConversationParts
-                ) : [];
-                const moreResultMessage = createToolResultMessage(
-                  moreResults,
-                  moreHistoryDataParts
-                );
-                const moreTaskStream = await continueTaskStreamed(
-                  finalTask.id,
-                  moreResultMessage,
-                  requestConfig,
-                  toolProvider,
-                  contextProvider,
-                  sessionId,
-                  abortSignal,
-                  requestOptions
-                );
-                let moreFinalTask = null;
-                for await (const streamUpdate of moreTaskStream) {
-                  if (!streamUpdate.final) {
-                    yield streamUpdate;
-                  } else {
-                    moreFinalTask = streamUpdate;
+              if (F.length > 0 && (yield {
+                id: v.id,
+                status: {
+                  state: "working",
+                  message: {
+                    role: "agent",
+                    kind: "message",
+                    parts: F,
+                    messageId: D()
                   }
-                }
-                if (!moreFinalTask) {
+                  // Simple message with just the results
+                },
+                final: !1,
+                text: ""
+              }), B) {
+                const _ = r ? pt(
+                  o
+                ) : [], K = et(
+                  F,
+                  _
+                ), z = await yt(
+                  v.id,
+                  K,
+                  n,
+                  e,
+                  s,
+                  a,
+                  i,
+                  l
+                );
+                let q = null;
+                for await (const nt of z)
+                  nt.final ? q = nt : yield nt;
+                if (!q)
                   throw new Error(
                     "Continue task stream ended without final result"
                   );
-                }
-                finalTask = moreFinalTask;
-                continuedToolCalls = finalTask.status?.message ? extractToolCallsFromMessage(
-                  finalTask.status.message
-                ) : [];
-                if (continuedToolCalls.length > 0) {
-                  yield {
-                    id: finalTask.id,
-                    status: finalTask.status,
-                    final: false,
-                    text: extractTextFromMessage(
-                      finalTask.status?.message || {
-                        role: "agent",
-                        kind: "message",
-                        parts: [],
-                        messageId: generateMessageId()
-                      }
-                    )
-                  };
-                }
-              } else {
+                v = q, O = (u = v.status) != null && u.message ? J(
+                  v.status.message
+                ) : [], O.length > 0 && (yield {
+                  id: v.id,
+                  status: v.status,
+                  final: !1,
+                  text: U(
+                    ((h = v.status) == null ? void 0 : h.message) || {
+                      parts: [],
+                      messageId: D()
+                    }
+                  )
+                });
+              } else
                 break;
-              }
             }
-          }
           yield {
-            ...finalTask,
-            final: true,
-            text: extractTextFromMessage(
-              finalTask.status?.message || {
-                role: "agent",
-                kind: "message",
+            ...v,
+            final: !0,
+            text: U(
+              ((d = v.status) == null ? void 0 : d.message) || {
                 parts: [],
-                messageId: generateMessageId()
+                messageId: D()
               }
             )
           };
         } else {
-          const enhancedMessage = {
-            ...update.status.message,
-            parts: toolParts
-          };
-          const enhancedUpdate = {
-            ...update,
+          const k = {
+            ...f.status.message,
+            parts: w
+          }, C = {
+            ...f,
             status: {
-              ...update.status,
-              message: enhancedMessage
+              ...f.status,
+              message: k
             },
-            final: agentMessages.length === 0,
+            final: m.length === 0,
             // Only final if no agent messages to follow
-            text: extractTextFromMessage(enhancedMessage)
+            text: U(k)
           };
-          yield enhancedUpdate;
-          if (agentMessages.length > 0) {
-            const combinedAgentText = agentMessages.map((msg) => extractTextFromMessage(msg)).join(" ");
-            const finalAgentMessage = createAgentTextMessage(combinedAgentText);
+          if (yield C, m.length > 0) {
+            const E = m.map((O) => U(O)).join(" "), R = Z(E);
             yield {
-              id: enhancedUpdate.id,
+              id: C.id,
               status: {
                 state: "completed",
-                message: finalAgentMessage
+                message: R
               },
-              final: true,
-              text: combinedAgentText
+              final: !0,
+              text: E
             };
           }
         }
@@ -1186,1540 +939,1596 @@ async function* processAgentResponseStream(stream, toolProvider, contextProvider
     }
   }
 }
-function createClient(config) {
+function ue(t) {
   const {
-    agentId,
-    agentUrl,
-    authProvider,
-    defaultSessionId,
-    timeout = DEFAULT_TIMEOUT,
-    toolProvider,
-    contextProvider,
-    enableStreaming = false
-  } = config;
-  const requestConfig = {
-    agentId,
-    agentUrl,
-    authProvider,
-    timeout
+    agentId: e,
+    agentUrl: s,
+    authProvider: n,
+    defaultSessionId: a,
+    timeout: r = re,
+    toolProvider: o,
+    contextProvider: i,
+    enableStreaming: l = !1
+  } = t, c = {
+    agentId: e,
+    agentUrl: s,
+    authProvider: n,
+    timeout: r
   };
   return {
-    async sendMessage(params) {
-      const { withHistory = true, abortSignal } = params;
-      const sessionId = params.sessionId || defaultSessionId || void 0;
-      const newConversationParts = [];
-      newConversationParts.push(params.message);
-      const preparedRequest = await prepareRequest(
-        params,
-        requestConfig,
-        { isStreaming: false, abortSignal },
-        toolProvider,
-        contextProvider,
-        sessionId
+    async sendMessage(g) {
+      var h, d;
+      const { withHistory: y = !0, abortSignal: b } = g, A = g.sessionId || a || void 0, S = [];
+      S.push(g.message);
+      const M = await st(
+        g,
+        c,
+        { isStreaming: !1 },
+        o,
+        i,
+        A
       );
-      let currentTask = await executeRequest(
-        preparedRequest,
-        requestConfig,
-        { abortSignal }
+      let x = await Rt(
+        M,
+        c,
+        { abortSignal: b }
       );
-      const allToolParts = [];
-      const agentMessages = [];
-      while (currentTask.status.message && toolProvider) {
-        const toolCalls = extractToolCallsFromMessage(
-          currentTask.status.message
+      const p = [], u = [];
+      for (; x.status.message && o; ) {
+        const f = J(
+          x.status.message
         );
-        if (toolCalls.length === 0) {
+        if (f.length === 0)
           break;
-        }
-        allToolParts.push(...toolCalls);
-        const toolResults = [];
-        let shouldReturnToAgent = false;
-        for (const toolCall of toolCalls) {
+        p.push(...f);
+        const T = [];
+        let I = !1;
+        for (const P of f) {
           const {
-            toolCallId,
-            toolId,
-            arguments: args
-          } = toolCall.data;
+            toolCallId: w,
+            toolId: m,
+            arguments: k
+          } = P.data;
           try {
-            const executionResult = await toolProvider.executeTool(
-              toolId,
-              args
+            const C = await o.executeTool(
+              m,
+              k
+            ), { result: E, returnToAgent: R, agentMessage: O } = ct(C);
+            R && (I = !0), O && u.push(
+              Z(O)
             );
-            const { result, returnToAgent, agentMessage } = processToolExecutionResult(executionResult);
-            if (returnToAgent) {
-              shouldReturnToAgent = true;
-            }
-            if (agentMessage) {
-              agentMessages.push(
-                createAgentTextMessage(agentMessage)
-              );
-            }
-            const toolResult = createToolResultDataPart(
-              toolCallId,
-              toolId,
-              result
+            const v = W(
+              w,
+              m,
+              E
             );
-            toolResults.push(toolResult);
-            allToolParts.push(toolResult);
-          } catch (error) {
-            const toolResult = createToolResultDataPart(
-              toolCallId,
-              toolId,
+            T.push(v), p.push(v);
+          } catch (C) {
+            const E = W(
+              w,
+              m,
               void 0,
-              error instanceof Error ? error.message : String(error)
+              C instanceof Error ? C.message : String(C)
             );
-            toolResults.push(toolResult);
-            allToolParts.push(toolResult);
+            T.push(E), p.push(E);
           }
         }
-        newConversationParts.push(currentTask.status.message);
-        if (shouldReturnToAgent) {
-          const toolResultMessage = createToolResultMessage(toolResults);
-          currentTask = await continueTask(
-            currentTask.id,
-            toolResultMessage,
-            requestConfig,
-            toolProvider,
-            contextProvider,
-            sessionId,
-            abortSignal
+        if (S.push(x.status.message), I) {
+          const P = et(T);
+          x = await ot(
+            x.id,
+            P,
+            c,
+            o,
+            i,
+            A,
+            b
           );
-        } else {
+        } else
           break;
-        }
       }
-      if (allToolParts.length > 0) {
-        if (currentTask.status?.message) {
-          const enhancedMessage = {
-            ...currentTask.status.message,
-            parts: allToolParts
-          };
-          currentTask = {
-            ...currentTask,
-            status: {
-              ...currentTask.status,
-              message: enhancedMessage
-            }
-          };
-        }
+      if (p.length > 0 && (h = x.status) != null && h.message) {
+        const f = {
+          ...x.status.message,
+          parts: p
+        };
+        x = {
+          ...x,
+          status: {
+            ...x.status,
+            message: f
+          }
+        };
       }
-      if (agentMessages.length > 0) {
-        const combinedAgentText = agentMessages.map((msg) => extractTextFromMessage(msg)).join(" ");
-        const finalAgentMessage = createAgentTextMessage(combinedAgentText);
+      if (u.length > 0) {
+        const f = u.map((I) => U(I)).join(" "), T = Z(f);
         return {
-          ...currentTask,
+          ...x,
           // Keep the enhanced message with tool results
           // The agent message will be handled separately by the caller
-          text: combinedAgentText,
-          agentMessage: finalAgentMessage
+          text: f,
+          agentMessage: T
           // Add this for the caller to handle
         };
       }
       return {
-        ...currentTask,
-        text: extractTextFromMessage(
-          currentTask.status?.message || {
-            role: "agent",
-            kind: "message",
+        ...x,
+        text: U(
+          ((d = x.status) == null ? void 0 : d.message) || {
             parts: [],
-            messageId: generateMessageId()
+            messageId: D()
           }
         )
       };
     },
-    async *sendMessageStream(params) {
+    async *sendMessageStream(g) {
       const {
-        withHistory = true,
-        abortSignal,
-        enableStreaming: requestStreaming
-      } = params;
-      const sessionId = params.sessionId || defaultSessionId || void 0;
-      const useTokenStreaming = requestStreaming ?? enableStreaming;
-      const newConversationParts = [];
-      newConversationParts.push(params.message);
-      const preparedRequest = await prepareRequest(
-        params,
-        requestConfig,
+        withHistory: y = !0,
+        abortSignal: b,
+        enableStreaming: A
+      } = g, S = g.sessionId || a || void 0, M = A ?? l, x = [];
+      x.push(g.message);
+      const p = await st(
+        g,
+        c,
         {
-          isStreaming: true,
+          isStreaming: !0,
           // Always use message/stream endpoint for SSE
-          enableTokenStreaming: useTokenStreaming,
-          // Optional token-by-token streaming
-          streamingTimeout: timeout,
-          abortSignal
+          enableTokenStreaming: M
         },
-        toolProvider,
-        contextProvider,
-        sessionId
-      );
-      const stream = executeStreamingRequest(
-        preparedRequest,
-        requestConfig,
+        o,
+        i,
+        S
+      ), u = Et(
+        p,
+        c,
         {
-          isStreaming: true,
-          enableTokenStreaming: useTokenStreaming,
+          enableTokenStreaming: M,
           // Token streaming is optional
-          streamingTimeout: timeout,
-          abortSignal
+          streamingTimeout: r,
+          abortSignal: b
         }
       );
-      yield* processAgentResponseStream(
-        stream,
-        toolProvider,
-        contextProvider,
-        requestConfig,
-        sessionId,
-        withHistory,
-        newConversationParts,
-        abortSignal,
+      yield* Ot(
+        u,
+        o,
+        i,
+        c,
+        S,
+        y,
+        x,
+        b,
         {
-          isStreaming: true,
-          enableTokenStreaming: useTokenStreaming,
-          streamingTimeout: timeout
+          isStreaming: !0,
+          enableTokenStreaming: M,
+          streamingTimeout: r
         }
       );
     },
-    async continueTask(taskId, userInput, sessionId) {
-      const userMessage = createTextMessage(userInput);
-      const continuedTask = await continueTask(
-        taskId,
-        userMessage,
-        requestConfig,
-        toolProvider,
-        contextProvider,
-        sessionId
+    async continueTask(g, y, b) {
+      var x;
+      const A = rt(y);
+      let M = await ot(
+        g,
+        A,
+        c,
+        o,
+        i,
+        b
       );
-      let currentTask = continuedTask;
-      while (currentTask.status.state === "input-required" && currentTask.status.message && toolProvider) {
-        const toolCalls = extractToolCallsFromMessage(
-          currentTask.status.message
+      for (; M.status.state === "input-required" && M.status.message && o; ) {
+        const p = J(
+          M.status.message
         );
-        if (toolCalls.length === 0) {
+        if (p.length === 0)
           break;
-        }
-        const { results: toolResults, shouldReturnToAgent } = await executeToolCallBatch(toolCalls, toolProvider);
-        if (shouldReturnToAgent) {
-          const toolResultMessage = createToolResultMessage(toolResults);
-          currentTask = await continueTask(
-            currentTask.id,
-            toolResultMessage,
-            requestConfig,
-            toolProvider,
-            contextProvider,
-            sessionId
+        const { results: u, shouldReturnToAgent: h } = await Pt(p, o);
+        if (h) {
+          const d = et(u);
+          M = await ot(
+            M.id,
+            d,
+            c,
+            o,
+            i,
+            b
           );
-        } else {
+        } else
           break;
-        }
       }
       return {
-        ...currentTask,
-        text: extractTextFromMessage(
-          currentTask.status?.message || {
-            role: "agent",
-            kind: "message",
+        ...M,
+        text: U(
+          ((x = M.status) == null ? void 0 : x.message) || {
             parts: [],
-            messageId: generateMessageId()
+            messageId: D()
           }
         )
       };
     },
-    async getTask(taskId) {
+    async getTask(g) {
       throw new Error("getTask not implemented yet");
     },
-    async cancelTask(taskId) {
+    async cancelTask(g) {
       throw new Error("cancelTask not implemented yet");
     }
   };
 }
-
-// src/react/conversationStorage.ts
-var STORAGE_KEY = "a8c_agenttic_conversation_history";
-function extractStorableContent(message) {
-  const textParts = message.parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-  const toolCalls = message.parts.filter(
-    (part) => part.type === "data" && "toolCallId" in part.data && "arguments" in part.data
-  ).map((part) => ({
-    toolCallId: part.data.toolCallId,
-    toolId: part.data.toolId,
-    arguments: part.data.arguments
-  }));
-  const toolResults = message.parts.filter(
-    (part) => part.type === "data" && "toolCallId" in part.data && "result" in part.data
-  ).map((part) => ({
-    toolCallId: part.data.toolCallId,
-    result: part.data.result,
-    error: part.data.error
-  }));
-  const hasToolInteractions = toolCalls.length > 0 || toolResults.length > 0;
-  const storageRole = hasToolInteractions ? "agent" : message.role;
-  const timestamp = message.metadata?.timestamp ?? Date.now();
+const dt = "a8c_agenttic_conversation_history";
+function de(t) {
+  var i;
+  const e = t.parts.filter((l) => l.type === "text").map((l) => l.text).join(`
+`), s = t.parts.filter(
+    (l) => l.type === "data" && "toolCallId" in l.data && "arguments" in l.data
+  ).map((l) => ({
+    toolCallId: l.data.toolCallId,
+    toolId: l.data.toolId,
+    arguments: l.data.arguments
+  })), n = t.parts.filter(
+    (l) => l.type === "data" && "toolCallId" in l.data && "result" in l.data
+  ).map((l) => ({
+    toolCallId: l.data.toolCallId,
+    result: l.data.result,
+    error: l.data.error
+  })), r = s.length > 0 || n.length > 0 ? "agent" : t.role, o = ((i = t.metadata) == null ? void 0 : i.timestamp) ?? Date.now();
   return {
-    role: storageRole,
-    content: textParts || "(No text content)",
-    timestamp,
-    ...toolCalls.length > 0 && { toolCalls },
-    ...toolResults.length > 0 && { toolResults }
+    role: r,
+    content: e || "(No text content)",
+    timestamp: o,
+    ...s.length > 0 && { toolCalls: s },
+    ...n.length > 0 && { toolResults: n }
   };
 }
-function restoreMessage(stored) {
-  const parts = [];
-  if (stored.content && stored.content !== "(No text content)") {
-    parts.push({
-      type: "text",
-      text: stored.content
-    });
-  }
-  if (stored.toolCalls) {
-    for (const toolCall of stored.toolCalls) {
-      parts.push({
+function ge(t) {
+  const e = [];
+  if (t.content && t.content !== "(No text content)" && e.push({
+    type: "text",
+    text: t.content
+  }), t.toolCalls)
+    for (const s of t.toolCalls)
+      e.push({
         type: "data",
         data: {
-          toolCallId: toolCall.toolCallId,
-          toolId: toolCall.toolId,
-          arguments: toolCall.arguments
+          toolCallId: s.toolCallId,
+          toolId: s.toolId,
+          arguments: s.arguments
         }
       });
-    }
-  }
-  if (stored.toolResults) {
-    for (const toolResult of stored.toolResults) {
-      parts.push({
+  if (t.toolResults)
+    for (const s of t.toolResults)
+      e.push({
         type: "data",
         data: {
-          toolCallId: toolResult.toolCallId,
-          result: toolResult.result,
-          ...toolResult.error && { error: toolResult.error }
+          toolCallId: s.toolCallId,
+          result: s.result,
+          ...s.error && { error: s.error }
         }
       });
-    }
-  }
   return {
-    role: stored.role,
+    role: t.role,
     kind: "message",
-    parts,
-    messageId: generateMessageId(),
+    parts: e,
+    messageId: D(),
     metadata: {
-      timestamp: stored.timestamp
+      timestamp: t.timestamp
     }
   };
 }
-var conversationCache = /* @__PURE__ */ new Map();
-var maxCacheSize = 50;
-async function storeConversation(sessionId, messages, conversationStorageKey) {
-  const currentStorageKey = conversationStorageKey || sessionId;
-  conversationCache.set(currentStorageKey, [...messages]);
-  if (conversationCache.size > maxCacheSize) {
-    const firstKey = conversationCache.keys().next().value;
-    if (firstKey) {
-      conversationCache.delete(firstKey);
-    }
-  }
-  if (typeof sessionStorage === "undefined") {
-    return;
-  }
-  try {
-    const stored = {
-      storageKey: currentStorageKey,
-      messages: messages.map(extractStorableContent),
-      lastUpdated: Date.now()
-    };
-    sessionStorage.setItem(
-      `${STORAGE_KEY}_${currentStorageKey}`,
-      JSON.stringify(stored)
-    );
-  } catch (error) {
-    logger(
-      "Failed to store conversation in sessionStorage for key %s: %O",
-      currentStorageKey,
-      error
-    );
+const L = /* @__PURE__ */ new Map(), fe = 50;
+async function me(t, e, s) {
+  const n = s || t;
+  if (L.set(n, [...e]), L.size > fe) {
+    const a = L.keys().next().value;
+    a && L.delete(a);
   }
+  if (!(typeof sessionStorage > "u"))
+    try {
+      const a = {
+        storageKey: n,
+        messages: e.map(de),
+        lastUpdated: Date.now()
+      };
+      sessionStorage.setItem(
+        `${dt}_${n}`,
+        JSON.stringify(a)
+      );
+    } catch (a) {
+      N(
+        "Failed to store conversation in sessionStorage for key %s: %O",
+        n,
+        a
+      );
+    }
 }
-async function loadConversation(sessionId, conversationStorageKey) {
-  const currentStorageKey = conversationStorageKey || sessionId;
-  if (conversationCache.has(currentStorageKey)) {
-    return [...conversationCache.get(currentStorageKey)];
-  }
-  if (typeof sessionStorage === "undefined") {
+async function he(t, e) {
+  const s = e || t;
+  if (L.has(s))
+    return [...L.get(s)];
+  if (typeof sessionStorage > "u")
     return [];
-  }
   try {
-    const stored = sessionStorage.getItem(
-      `${STORAGE_KEY}_${currentStorageKey}`
+    const n = sessionStorage.getItem(
+      `${dt}_${s}`
     );
-    if (stored) {
-      const conversation = JSON.parse(stored);
-      const messages = conversation.messages.map(restoreMessage);
-      conversationCache.set(currentStorageKey, messages);
-      return [...messages];
+    if (n) {
+      const r = JSON.parse(n).messages.map(ge);
+      return L.set(s, r), [...r];
     }
-  } catch (error) {
-    logger(
+  } catch (n) {
+    N(
       "Failed to load conversation from sessionStorage for key %s: %O",
-      currentStorageKey,
-      error
+      s,
+      n
     );
   }
   return [];
 }
-async function clearConversation(sessionId, conversationStorageKey) {
-  const currentStorageKey = conversationStorageKey || sessionId;
-  conversationCache.delete(currentStorageKey);
-  if (typeof sessionStorage === "undefined") {
-    return;
-  }
-  try {
-    sessionStorage.removeItem(`${STORAGE_KEY}_${currentStorageKey}`);
-  } catch (error) {
-    logger(
-      "Failed to clear conversation from sessionStorage for key %s: %O",
-      currentStorageKey,
-      error
-    );
-  }
-}
-
-// src/react/conversationUtils.ts
-function extractNewContentFromMessage(message) {
-  const newParts = message.parts.filter((part) => {
-    if (part.type === "text") {
-      return true;
-    }
-    if (part.type === "data") {
-      if ("role" in part.data && "text" in part.data) {
-        return false;
-      }
-      if ("toolCallId" in part.data && "arguments" in part.data) {
-        return true;
-      }
-      if ("toolCallId" in part.data && "result" in part.data) {
-        return true;
-      }
-      return false;
+async function pe(t, e) {
+  const s = e || t;
+  if (L.delete(s), !(typeof sessionStorage > "u"))
+    try {
+      sessionStorage.removeItem(`${dt}_${s}`);
+    } catch (n) {
+      N(
+        "Failed to clear conversation from sessionStorage for key %s: %O",
+        s,
+        n
+      );
     }
-    return true;
-  });
+}
+function G(t) {
+  const e = t.parts.filter((s) => s.type === "text" ? !0 : s.type === "data" ? "role" in s.data && "text" in s.data ? !1 : "toolCallId" in s.data && "arguments" in s.data || "toolCallId" in s.data && "result" in s.data : !0);
   return {
-    ...message,
-    parts: newParts,
+    ...t,
+    parts: e,
     // Preserve metadata if it exists, otherwise add timestamp
-    metadata: message.metadata || {
+    metadata: t.metadata || {
       timestamp: Date.now()
     }
   };
 }
-function conversationMessagesToDataParts(conversationMessages) {
-  const historyParts = [];
-  for (const message of conversationMessages) {
-    for (const part of message.parts) {
-      if (part.type === "text") {
-        historyParts.push({
+function ye(t) {
+  const e = [];
+  for (const s of t)
+    for (const n of s.parts)
+      if (n.type === "text")
+        e.push({
           type: "data",
           data: {
-            role: message.role,
-            text: part.text
+            role: s.role,
+            text: n.text
           }
         });
-      } else if (part.type === "data") {
-        if ("role" in part.data && "text" in part.data) {
+      else if (n.type === "data") {
+        if ("role" in n.data && "text" in n.data)
           continue;
-        }
-        if ("toolCallId" in part.data && "arguments" in part.data) {
-          historyParts.push(part);
+        if ("toolCallId" in n.data && "arguments" in n.data) {
+          e.push(n);
           continue;
         }
-        if ("toolCallId" in part.data && "result" in part.data) {
-          historyParts.push(part);
+        if ("toolCallId" in n.data && "result" in n.data) {
+          e.push(n);
           continue;
         }
       }
-    }
-  }
-  return historyParts;
+  return e;
 }
-function createTextMessageWithHistory(text, conversationMessages = []) {
-  const historyParts = conversationMessagesToDataParts(conversationMessages);
+function wt(t, e = []) {
   return {
     role: "user",
     parts: [
-      ...historyParts,
+      ...ye(e),
       {
         type: "text",
-        text
+        text: t
       }
     ],
     kind: "message",
-    messageId: generateMessageId(),
+    messageId: D(),
     metadata: {
       timestamp: Date.now()
     }
   };
 }
-function extractToolResultsFromMessage(message) {
-  if (!message?.parts) {
-    return [];
-  }
-  return message.parts.filter(
-    (part) => part.type === "data" && "toolCallId" in part.data && "result" in part.data
-  );
-}
-
-// src/react/agentManager.ts
-async function resolvePromisesInConversationHistory(conversationHistory) {
-  const resolvedHistory = [];
-  for (const message of conversationHistory) {
-    if (message.parts && Array.isArray(message.parts)) {
-      const hasToolResults = message.parts.some(
-        (part) => part.type === "data" && "toolCallId" in part.data && "result" in part.data
-      );
-      if (hasToolResults) {
-        const updatedParts = updateToolResultsWithResolvedPromises(
-          message.parts
+function we(t) {
+  return t != null && t.parts ? t.parts.filter(
+    (e) => e.type === "data" && "toolCallId" in e.data && "result" in e.data
+  ) : [];
+}
+async function Ie(t) {
+  const e = [];
+  for (const s of t)
+    if (s.parts && Array.isArray(s.parts))
+      if (s.parts.some(
+        (a) => a.type === "data" && "toolCallId" in a.data && "result" in a.data
+      )) {
+        const a = ce(
+          s.parts
         );
-        resolvedHistory.push({
-          ...message,
-          parts: updatedParts
+        e.push({
+          ...s,
+          parts: a
         });
-      } else {
-        resolvedHistory.push(message);
-      }
-    } else {
-      resolvedHistory.push(message);
-    }
-  }
-  clearToolResultPromises();
-  return resolvedHistory;
-}
-function createAgentManager() {
-  const agents = /* @__PURE__ */ new Map();
-  async function persistConversationHistory(key, messages) {
-    const agent = agents.get(key);
-    if (agent?.sessionId) {
+      } else
+        e.push(s);
+    else
+      e.push(s);
+  return le(), e;
+}
+function Ce() {
+  const t = /* @__PURE__ */ new Map();
+  async function e(s, n) {
+    const a = t.get(s);
+    if (a != null && a.sessionId)
       try {
-        await storeConversation(
-          agent.sessionId,
-          messages,
-          agent.conversationStorageKey
+        await me(
+          a.sessionId,
+          n,
+          a.conversationStorageKey
         );
-      } catch (error) {
-        log(
-          `Failed to persist conversation history for agent ${key}:`,
-          error
+      } catch (r) {
+        ht(
+          `Failed to persist conversation history for agent ${s}:`,
+          r
         );
       }
-    }
   }
   return {
-    async createAgent(key, config) {
-      if (agents.has(key)) {
-        return agents.get(key).client;
-      }
-      const client = createClient(config);
-      const sessionId = config.sessionId || null;
-      const conversationStorageKey = config.conversationStorageKey;
-      let conversationHistory = [];
-      if (sessionId) {
+    async createAgent(s, n) {
+      if (t.has(s))
+        return t.get(s).client;
+      const a = ue(n), r = n.sessionId || null, o = n.conversationStorageKey;
+      let i = [];
+      if (r)
         try {
-          conversationHistory = await loadConversation(
-            sessionId,
-            conversationStorageKey
+          i = await he(
+            r,
+            o
           );
-        } catch (error) {
-          log(
-            `Failed to load conversation history for agent ${key} with session ${sessionId}:`,
-            error
+        } catch (c) {
+          ht(
+            `Failed to load conversation history for agent ${s} with session ${r}:`,
+            c
           );
         }
-      }
-      const managedAgent = {
-        client,
-        sessionId,
-        conversationStorageKey,
-        conversationHistory
+      const l = {
+        client: a,
+        sessionId: r,
+        conversationStorageKey: o,
+        conversationHistory: i
       };
-      agents.set(key, managedAgent);
-      return client;
+      return t.set(s, l), a;
     },
-    getAgent(key) {
-      const agent = agents.get(key);
-      return agent?.client || null;
+    getAgent(s) {
+      const n = t.get(s);
+      return (n == null ? void 0 : n.client) || null;
     },
-    hasAgent(key) {
-      return agents.has(key);
+    hasAgent(s) {
+      return t.has(s);
     },
-    removeAgent(key) {
-      return agents.delete(key);
+    removeAgent(s) {
+      return t.delete(s);
     },
-    async sendMessage(key, message, options = {}) {
-      const managedAgent = agents.get(key);
-      if (!managedAgent) {
-        throw new Error(`Agent with key "${key}" not found`);
-      }
-      const { withHistory = true, ...otherOptions } = options;
-      const { client, conversationHistory } = managedAgent;
-      const messageObj = options.message || createTextMessageWithHistory(message, conversationHistory);
-      const task = await client.sendMessage({
-        message: messageObj,
-        withHistory,
-        ...otherOptions
+    async sendMessage(s, n, a = {}) {
+      var M;
+      const r = t.get(s);
+      if (!r)
+        throw new Error(`Agent with key "${s}" not found`);
+      const { withHistory: o = !0, ...i } = a, { client: l, conversationHistory: c } = r, g = a.message || wt(n, c), y = await l.sendMessage({
+        message: g,
+        withHistory: o,
+        ...i
       });
-      let completeAgentMessage = null;
-      if (task.status?.message) {
-        const toolParts = task.status.message.parts.filter(
-          (part) => part.type === "data" && "toolCallId" in part.data && ("arguments" in part.data || "result" in part.data)
+      let b = null;
+      if ((M = y.status) != null && M.message) {
+        const x = y.status.message.parts.filter(
+          (u) => u.type === "data" && "toolCallId" in u.data && ("arguments" in u.data || "result" in u.data)
+        ), p = y.status.message.parts.filter(
+          (u) => u.type === "text"
         );
-        const textParts = task.status.message.parts.filter(
-          (part) => part.type === "text"
-        );
-        completeAgentMessage = {
+        b = {
           role: "agent",
           kind: "message",
-          parts: [...toolParts, ...textParts],
-          messageId: generateMessageId(),
+          parts: [...x, ...p],
+          messageId: D(),
           metadata: {
             timestamp: Date.now()
           }
         };
       }
-      const newConversationHistory = [
-        ...conversationHistory,
+      const A = [
+        ...c,
         // Store only the new content from the user message (without history parts)
-        createTextMessage(message),
+        rt(n),
         // Add complete agent response with tool calls/results if present
-        ...completeAgentMessage ? [extractNewContentFromMessage(completeAgentMessage)] : []
+        ...b ? [G(b)] : []
       ];
-      let finalConversationHistory = newConversationHistory;
-      if (task.agentMessage) {
-        const separateAgentMessage = extractNewContentFromMessage(
-          task.agentMessage
+      let S = A;
+      if (y.agentMessage) {
+        const x = G(
+          y.agentMessage
         );
-        finalConversationHistory = [
-          ...newConversationHistory,
-          separateAgentMessage
+        S = [
+          ...A,
+          x
         ];
       }
-      managedAgent.conversationHistory = finalConversationHistory;
-      if (withHistory) {
-        await persistConversationHistory(
-          key,
-          finalConversationHistory
-        );
-      }
-      return task;
+      return r.conversationHistory = S, o && await e(
+        s,
+        S
+      ), y;
     },
-    async *sendMessageStream(key, message, options = {}) {
-      const managedAgent = agents.get(key);
-      if (!managedAgent) {
-        throw new Error(`Agent with key "${key}" not found`);
-      }
-      const { withHistory = true, ...otherOptions } = options;
-      const { client } = managedAgent;
-      let currentConversationHistory = [
-        ...managedAgent.conversationHistory
-      ];
-      let currentToolCallIds = [];
-      const resolvedConversationHistory = await resolvePromisesInConversationHistory(
-        currentConversationHistory
+    async *sendMessageStream(s, n, a = {}) {
+      var S, M, x, p, u, h;
+      const r = t.get(s);
+      if (!r)
+        throw new Error(`Agent with key "${s}" not found`);
+      const { withHistory: o = !0, ...i } = a, { client: l } = r;
+      let c = [
+        ...r.conversationHistory
+      ], g = [];
+      const y = await Ie(
+        c
       );
-      managedAgent.conversationHistory = resolvedConversationHistory;
-      currentConversationHistory = resolvedConversationHistory;
-      if (withHistory) {
-        await persistConversationHistory(
-          key,
-          resolvedConversationHistory
-        );
-      }
-      const messageObj = options.message || createTextMessageWithHistory(
-        message,
-        resolvedConversationHistory
+      r.conversationHistory = y, c = y, o && await e(
+        s,
+        y
       );
-      const userMessage = createTextMessage(message);
-      currentConversationHistory = [
-        ...currentConversationHistory,
-        userMessage
-      ];
-      managedAgent.conversationHistory = currentConversationHistory;
-      if (withHistory) {
-        await persistConversationHistory(
-          key,
-          currentConversationHistory
-        );
-      }
-      for await (const update of client.sendMessageStream({
-        message: messageObj,
-        withHistory,
-        ...otherOptions
+      const b = a.message || wt(
+        n,
+        y
+      ), A = rt(n);
+      c = [
+        ...c,
+        A
+      ], r.conversationHistory = c, o && await e(
+        s,
+        c
+      );
+      for await (const d of l.sendMessageStream({
+        message: b,
+        withHistory: o,
+        ...i
       })) {
-        if (update.status?.state === "input-required" && update.status?.message) {
-          const toolCalls = extractToolCallsFromMessage(
-            update.status.message
+        if (((S = d.status) == null ? void 0 : S.state) === "input-required" && ((M = d.status) != null && M.message)) {
+          g = J(
+            d.status.message
+          ).map(
+            (I) => I.data.toolCallId
           );
-          currentToolCallIds = toolCalls.map(
-            (call) => call.data.toolCallId
+          const T = G(
+            d.status.message
           );
-          const toolMessage = extractNewContentFromMessage(
-            update.status.message
+          c = [
+            ...c,
+            T
+          ], r.conversationHistory = c, o && await e(
+            s,
+            c
           );
-          currentConversationHistory = [
-            ...currentConversationHistory,
-            toolMessage
-          ];
-          managedAgent.conversationHistory = currentConversationHistory;
-          if (withHistory) {
-            await persistConversationHistory(
-              key,
-              currentConversationHistory
-            );
-          }
         }
-        if (update.status?.state === "working" && update.status?.message && !update.final) {
-          const allToolResults = extractToolResultsFromMessage(
-            update.status.message
-          );
-          const currentToolResults = allToolResults.filter(
-            (result) => currentToolCallIds.includes(
-              result.data.toolCallId
+        if (((x = d.status) == null ? void 0 : x.state) === "working" && ((p = d.status) != null && p.message) && !d.final) {
+          const T = we(
+            d.status.message
+          ).filter(
+            (I) => g.includes(
+              I.data.toolCallId
             )
           );
-          if (currentToolResults.length > 0) {
-            const toolResultMessage = {
+          if (T.length > 0) {
+            const I = {
               role: "agent",
               kind: "message",
-              parts: currentToolResults,
-              messageId: generateMessageId()
+              parts: T,
+              messageId: D()
             };
-            currentConversationHistory = [
-              ...currentConversationHistory,
-              extractNewContentFromMessage(toolResultMessage)
-            ];
-            managedAgent.conversationHistory = currentConversationHistory;
-            if (withHistory) {
-              await persistConversationHistory(
-                key,
-                currentConversationHistory
-              );
-            }
-          }
-        }
-        if (update.final && update.status?.state !== "input-required") {
-          currentToolCallIds = [];
-          let finalAgentMessage = null;
-          if (update.status?.message) {
-            finalAgentMessage = extractNewContentFromMessage(
-              update.status.message
+            c = [
+              ...c,
+              G(I)
+            ], r.conversationHistory = c, o && await e(
+              s,
+              c
             );
-            currentConversationHistory = [
-              ...currentConversationHistory,
-              finalAgentMessage
-            ];
-            managedAgent.conversationHistory = currentConversationHistory;
-            if (withHistory) {
-              await persistConversationHistory(
-                key,
-                currentConversationHistory
-              );
-            }
           }
         }
-        yield update;
+        if (d.final && ((u = d.status) == null ? void 0 : u.state) !== "input-required") {
+          g = [];
+          let f = null;
+          (h = d.status) != null && h.message && (f = G(
+            d.status.message
+          ), c = [
+            ...c,
+            f
+          ], r.conversationHistory = c, o && await e(
+            s,
+            c
+          ));
+        }
+        yield d;
       }
     },
-    async resetConversation(key) {
-      const managedAgent = agents.get(key);
-      if (!managedAgent) {
-        throw new Error(`Agent with key "${key}" not found`);
-      }
-      managedAgent.conversationHistory = [];
-      if (managedAgent.sessionId) {
-        await clearConversation(
-          managedAgent.sessionId,
-          managedAgent.conversationStorageKey
-        );
-      }
+    async resetConversation(s) {
+      const n = t.get(s);
+      if (!n)
+        throw new Error(`Agent with key "${s}" not found`);
+      n.conversationHistory = [], n.sessionId && await pe(
+        n.sessionId,
+        n.conversationStorageKey
+      );
     },
-    getConversationHistory(key) {
-      const managedAgent = agents.get(key);
-      if (!managedAgent) {
-        throw new Error(`Agent with key "${key}" not found`);
-      }
-      return [...managedAgent.conversationHistory];
+    getConversationHistory(s) {
+      const n = t.get(s);
+      if (!n)
+        throw new Error(`Agent with key "${s}" not found`);
+      return [...n.conversationHistory];
     },
     clear() {
-      agents.clear();
+      t.clear();
     }
   };
 }
-var globalAgentManager = createAgentManager();
-function getAgentManager() {
-  return globalAgentManager;
-}
-
-// src/utils/createMessageRenderer.tsx
-import Markdown from "streamdown";
-
-// src/markdown-extensions/index.ts
-import remarkGfm from "remark-gfm";
-function processMarkdownExtensions(extensions) {
-  const components = {};
-  const remarkPlugins = [];
-  if (extensions?.charts?.enabled) {
-    components.code = createChartBlock(extensions.charts.config);
+const xe = Ce();
+function It() {
+  return xe;
+}
+class Me extends Dt {
+  constructor(e) {
+    super(e), this.state = {
+      hasError: !1,
+      error: null,
+      errorInfo: null
+    };
+  }
+  static getDerivedStateFromError(e) {
+    return {
+      hasError: !0,
+      error: e,
+      errorInfo: null
+    };
+  }
+  componentDidCatch(e, s) {
+    if (console.error("Chart rendering error:", e), console.error("Error info:", s), this.props.chartData) {
+      console.error(
+        "Chart data that caused the error:",
+        this.props.chartData
+      );
+      try {
+        const n = JSON.parse(this.props.chartData);
+        console.error("Parsed chart data:", n);
+      } catch {
+        console.error("Could not parse chart data as JSON");
+      }
+    }
+    this.setState({
+      errorInfo: s
+    });
   }
-  if (extensions?.gfm?.enabled) {
-    remarkPlugins.push(remarkGfm);
+  render() {
+    var e;
+    if (this.state.hasError) {
+      const s = ((e = this.state.error) == null ? void 0 : e.message) || "An error occurred while rendering the chart", n = [
+        "The chart could not be rendered due to an error.",
+        "The error has been logged to the console."
+      ];
+      return /* @__PURE__ */ $.jsx(
+        tt,
+        {
+          message: s,
+          details: n.join(`
+`)
+        }
+      );
+    }
+    return this.props.children;
   }
-  return { components, remarkPlugins };
 }
-function mergeMarkdownComponents(extensionComponents, userComponents = {}) {
-  return {
-    ...extensionComponents,
-    ...userComponents
+const Te = (t) => {
+  const {
+    data: e,
+    currency: s,
+    showLegend: n = !0,
+    withTooltips: a = !0,
+    renderTooltip: r,
+    margin: o,
+    withGradientFill: i = !0,
+    error: l,
+    ...c
+  } = t, g = {
+    ..._t(),
+    bottom: 80
+  }, y = {
+    data: e,
+    withTooltips: a,
+    renderTooltip: r,
+    showLegend: n,
+    withGradientFill: i,
+    withLegendGlyph: !1,
+    legendOrientation: "horizontal",
+    legendAlignmentHorizontal: "center",
+    legendAlignmentVertical: "bottom",
+    margin: g,
+    options: {
+      xScale: {
+        type: "time"
+      },
+      axis: {
+        x: {
+          ...jt(e)
+        }
+      }
+    },
+    ...s && { currency: s },
+    ...c
   };
-}
-
-// src/utils/createMessageRenderer.tsx
-import { jsx } from "react/jsx-runtime";
-function createMessageRenderer(options = {}) {
-  const { components = {}, extensions = {}, remarkPlugins = [] } = options;
-  const processed = processMarkdownExtensions(extensions);
-  const finalComponents = mergeMarkdownComponents(
-    processed.components,
-    components
+  return /* @__PURE__ */ $.jsx(Ft, { error: l, children: /* @__PURE__ */ $.jsx(Bt, { ...y }) });
+}, be = ({
+  data: t,
+  className: e = "",
+  config: s
+}) => {
+  const [n, a] = X(null), [r, o] = X(
+    null
+  ), [i, l] = X(300), c = xt(null), g = j(
+    (p) => {
+      var P;
+      const { tooltipData: u } = p, h = (P = u == null ? void 0 : u.nearestDatum) == null ? void 0 : P.datum;
+      if (!h)
+        return null;
+      const d = (w) => {
+        if (r != null && r.currency) {
+          const { symbol: m, symbolPosition: k } = r.currency;
+          let C;
+          return w >= 1e6 ? C = `${(w / 1e6).toFixed(
+            1
+          )}M` : w >= 1e3 ? C = `${(w / 1e3).toFixed(1)}K` : C = w.toLocaleString(), k === "right" ? `${C}${m}` : `${m}${C}`;
+        }
+        return w >= 1e6 ? `${(w / 1e6).toFixed(1)}M` : w >= 1e3 ? `${(w / 1e3).toFixed(1)}K` : w.toLocaleString();
+      }, f = (w) => {
+        const k = Math.floor(
+          ((/* @__PURE__ */ new Date()).getTime() - w.getTime()) / (1e3 * 60 * 60 * 24)
+        );
+        return k === 0 ? H("Today", "a8c-agenttic") : k === 1 ? H("Yesterday", "a8c-agenttic") : k < 7 ? ft(
+          /* translators: %d: number of days */
+          H("%d days ago", "a8c-agenttic"),
+          k
+        ) : w.toLocaleDateString("en-US", {
+          year: "numeric",
+          month: "short",
+          day: "numeric"
+        });
+      }, T = h.label, I = Object.entries(
+        (u == null ? void 0 : u.datumByKey) || {}
+      ).map(([w, m]) => {
+        const k = m.datum;
+        return {
+          key: w,
+          value: k.value
+        };
+      }).sort((w, m) => m.value - w.value);
+      return /* @__PURE__ */ $.jsxs("div", { children: [
+        T && /* @__PURE__ */ $.jsx(
+          "div",
+          {
+            style: {
+              fontSize: "12px",
+              fontWeight: "bold",
+              marginBottom: "4px",
+              color: "#1e1e1e",
+              borderBottom: "1px solid #eee",
+              paddingBottom: "2px"
+            },
+            children: T
+          }
+        ),
+        h.date && /* @__PURE__ */ $.jsx(
+          "div",
+          {
+            style: {
+              fontSize: "10px",
+              opacity: 0.8,
+              marginBottom: "4px"
+            },
+            children: f(h.date)
+          }
+        ),
+        I.map((w) => /* @__PURE__ */ $.jsxs(
+          "div",
+          {
+            style: { marginBottom: "2px" },
+            children: [
+              /* @__PURE__ */ $.jsxs("strong", { children: [
+                w.key,
+                ":"
+              ] }),
+              " ",
+              d(w.value)
+            ]
+          },
+          w.key
+        ))
+      ] });
+    },
+    [r == null ? void 0 : r.currency]
   );
-  const finalPlugins = [...processed.remarkPlugins, ...remarkPlugins];
-  return function MessageRenderer({ children }) {
-    return /* @__PURE__ */ jsx(
-      Markdown,
+  Y(() => {
+    if (a(null), o(null), !t || typeof t != "string") {
+      a({
+        message: H("Invalid chart data provided", "a8c-agenttic"),
+        details: `Input data: ${t}`
+      });
+      return;
+    }
+    try {
+      const p = JSON.parse(t.trim());
+      if (!p.chartType) {
+        a({
+          message: H(
+            "Chart data must include chartType",
+            "a8c-agenttic"
+          ),
+          details: H("Available types: line, bar", "a8c-agenttic")
+        });
+        return;
+      }
+      if (!p.data || !Array.isArray(p.data)) {
+        a({
+          message: H(
+            "Chart data must include a data array",
+            "a8c-agenttic"
+          ),
+          details: `Input data: ${t}`
+        });
+        return;
+      }
+      if (p.data.length === 0) {
+        a({
+          message: H(
+            "No data points found for chart",
+            "a8c-agenttic"
+          ),
+          details: `Input data: ${t}`
+        });
+        return;
+      }
+      const u = p.data.map((d) => ({
+        ...d,
+        data: d.data.map((f) => {
+          if (f.date) {
+            const T = new Date(f.date);
+            return isNaN(T.getTime()) ? (console.warn(
+              `Invalid date string: "${f.date}" in series "${d.label}"`
+            ), {
+              label: f.label,
+              value: f.value,
+              date: void 0
+            }) : {
+              label: f.label,
+              value: f.value,
+              date: T
+            };
+          }
+          return {
+            label: f.label,
+            value: f.value,
+            date: void 0
+          };
+        })
+      })), h = {
+        chartType: p.chartType,
+        title: p.title,
+        data: u,
+        currency: p.currency,
+        mode: p.mode || "time-comparison"
+      };
+      o(h);
+    } catch {
+      a({
+        message: H(
+          "Failed to parse chart data as JSON",
+          "a8c-agenttic"
+        ),
+        details: `Input data: ${t}`
+      });
+    }
+  }, [t]);
+  const y = j((p) => {
+    if (c.current && c.current.disconnect(), p) {
+      const { width: u } = p.getBoundingClientRect(), h = Math.max(280, u - 4);
+      l(h), c.current = new ResizeObserver((d) => {
+        for (const f of d) {
+          const T = f.contentRect.width, I = Math.max(
+            280,
+            T - 4
+          );
+          l(I);
+        }
+      }), c.current.observe(p);
+    }
+  }, []);
+  if (Y(() => () => {
+    c.current && (c.current.disconnect(), c.current = null);
+  }, []), n)
+    return /* @__PURE__ */ $.jsx(tt, { message: n.message, details: n.details });
+  if (!r)
+    return /* @__PURE__ */ $.jsx(
+      tt,
       {
-        components: finalComponents,
-        remarkPlugins: finalPlugins,
-        children
+        message: H("No chart data available", "a8c-agenttic")
       }
     );
+  const A = r.data.length > 1, S = i, M = {
+    data: r.data,
+    currency: r.currency,
+    showLegend: A,
+    withTooltips: !0,
+    renderTooltip: g,
+    error: null,
+    maxWidth: S,
+    aspectRatio: 1.2,
+    resizeDebounceTime: 300
+  }, x = () => {
+    switch (r.chartType) {
+      case "line":
+        return /* @__PURE__ */ $.jsx(Te, { ...M });
+      case "bar":
+        return /* @__PURE__ */ $.jsx(
+          Ht,
+          {
+            ...M,
+            mode: r.mode
+          }
+        );
+      default:
+        return /* @__PURE__ */ $.jsx(
+          tt,
+          {
+            message: ft(
+              /* translators: %s: chart type name */
+              H("Unsupported chart type: %s", "a8c-agenttic"),
+              r.chartType
+            )
+          }
+        );
+    }
   };
+  return /* @__PURE__ */ $.jsx(Me, { chartData: t, children: /* @__PURE__ */ $.jsxs(
+    "div",
+    {
+      ref: y,
+      className: `chart-block ${e}`,
+      children: [
+        r.title && /* @__PURE__ */ $.jsx("h3", { className: "chart-block-title", children: r.title }),
+        /* @__PURE__ */ $.jsx("div", { className: "chart-container", children: x() })
+      ]
+    }
+  ) });
+};
+function Se(t) {
+  return function(s) {
+    const { children: n, className: a, ...r } = s;
+    if (!(a == null ? void 0 : a.includes("language-chart")))
+      return gt.createElement(
+        "code",
+        { className: a, ...r },
+        n
+      );
+    const i = typeof n == "string" ? n : "";
+    return gt.createElement(be, {
+      data: i,
+      className: "markdown-chart",
+      config: t
+    });
+  };
+}
+function ke(t) {
+  var n, a;
+  const e = {}, s = [];
+  return (n = t == null ? void 0 : t.charts) != null && n.enabled && (e.code = Se(t.charts.config)), (a = t == null ? void 0 : t.gfm) != null && a.enabled && s.push(Ut), { components: e, remarkPlugins: s };
 }
-
-// src/message-actions/useMessageActions.ts
-import { useCallback as useCallback2, useState } from "react";
-
-// src/message-actions/factories.tsx
-var createFeedbackActions = (config) => {
-  const baseCondition = config.condition || (() => true);
-  const feedbackByMessageId = {};
-  const changeListeners = [];
-  const notifyListeners = () => {
-    changeListeners.forEach((listener) => listener());
+function Ae(t, e = {}) {
+  return {
+    ...t,
+    ...e
   };
-  const handleFeedback = async (messageId, feedback) => {
-    feedbackByMessageId[messageId] = feedback;
-    await config.onFeedback(messageId, feedback);
-    notifyListeners();
+}
+function ve(t = {}) {
+  const { components: e = {}, extensions: s = {}, remarkPlugins: n = [] } = t, a = ke(s), r = Ae(
+    a.components,
+    e
+  ), o = [...a.remarkPlugins, ...n];
+  return function({ children: l }) {
+    return /* @__PURE__ */ $.jsx(
+      qt,
+      {
+        components: r,
+        remarkPlugins: o,
+        children: l
+      }
+    );
+  };
+}
+const Re = (t) => {
+  const e = t.condition || (() => !0), s = {}, n = [], a = () => {
+    n.forEach((o) => o());
+  }, r = async (o, i) => {
+    s[o] = i, await t.onFeedback(o, i), a();
   };
   return {
-    getActionsForMessage: (message) => {
-      if (!baseCondition(message)) {
+    getActionsForMessage: (o) => {
+      if (!e(o))
         return [];
-      }
-      const feedbackState = feedbackByMessageId[message.id];
-      const actions = [];
-      actions.push({
+      const i = s[o.id], l = [];
+      return l.push({
         id: "feedback-up",
-        icon: config.icons.up,
+        icon: t.icons.up,
         label: "Good response",
         onClick: async () => {
-          if (feedbackState === "up") {
-            delete feedbackByMessageId[message.id];
-          } else {
-            await handleFeedback(message.id, "up");
-          }
-          notifyListeners();
+          i === "up" ? delete s[o.id] : await r(o.id, "up"), a();
         },
         tooltip: "This response was helpful",
-        pressed: feedbackState === "up",
-        disabled: feedbackState === "down"
+        pressed: i === "up",
+        disabled: i === "down"
         // Disable if other is selected
-      });
-      actions.push({
+      }), l.push({
         id: "feedback-down",
-        icon: config.icons.down,
+        icon: t.icons.down,
         label: "Bad response",
         onClick: async () => {
-          if (feedbackState === "down") {
-            delete feedbackByMessageId[message.id];
-          } else {
-            await handleFeedback(message.id, "down");
-          }
-          notifyListeners();
+          i === "down" ? delete s[o.id] : await r(o.id, "down"), a();
         },
         tooltip: "This response was not helpful",
-        pressed: feedbackState === "down",
-        disabled: feedbackState === "up"
+        pressed: i === "down",
+        disabled: i === "up"
         // Disable if other is selected
-      });
-      return actions;
+      }), l;
     },
-    clearFeedback: (messageId) => {
-      delete feedbackByMessageId[messageId];
-      notifyListeners();
+    clearFeedback: (o) => {
+      delete s[o], a();
     },
     clearAllFeedback: () => {
-      Object.keys(feedbackByMessageId).forEach((key) => {
-        delete feedbackByMessageId[key];
-      });
-      notifyListeners();
+      Object.keys(s).forEach((o) => {
+        delete s[o];
+      }), a();
     },
-    onChange: (listener) => {
-      changeListeners.push(listener);
+    onChange: (o) => {
+      n.push(o);
     },
-    offChange: (listener) => {
-      const index = changeListeners.indexOf(listener);
-      if (index > -1) {
-        changeListeners.splice(index, 1);
-      }
+    offChange: (o) => {
+      const i = n.indexOf(o);
+      i > -1 && n.splice(i, 1);
     }
   };
 };
-
-// src/message-actions/useMessageActions.ts
-function useMessageActions() {
-  const [registrations, setRegistrations] = useState([]);
-  const registerMessageActions = useCallback2(
-    (registration) => {
-      setRegistrations((prev) => {
-        const existingIndex = prev.findIndex(
-          (r) => r.id === registration.id
+function Ee() {
+  const [t, e] = X([]), s = j(
+    (r) => {
+      e((o) => {
+        const i = o.findIndex(
+          (l) => l.id === r.id
         );
-        if (existingIndex >= 0) {
-          const updated = [...prev];
-          updated[existingIndex] = registration;
-          return updated;
+        if (i >= 0) {
+          const l = [...o];
+          return l[i] = r, l;
         }
-        return [...prev, registration];
+        return [...o, r];
       });
     },
     []
-  );
-  const unregisterMessageActions = useCallback2((id) => {
-    setRegistrations((prev) => prev.filter((r) => r.id !== id));
-  }, []);
-  const clearAllMessageActions = useCallback2(() => {
-    setRegistrations([]);
+  ), n = j((r) => {
+    e((o) => o.filter((i) => i.id !== r));
+  }, []), a = j(() => {
+    e([]);
   }, []);
   return {
-    registerMessageActions,
-    unregisterMessageActions,
-    clearAllMessageActions,
-    createFeedbackActions,
-    registrations
+    registerMessageActions: s,
+    unregisterMessageActions: n,
+    clearAllMessageActions: a,
+    createFeedbackActions: Re,
+    registrations: t
   };
 }
-
-// src/message-actions/resolver.ts
-function resolveActionsForMessage(message, registrations) {
-  const allActions = registrations.flatMap((reg) => {
-    if (typeof reg.actions === "function") {
-      return reg.actions(message);
-    }
-    return reg.actions;
-  });
-  const filteredActions = allActions.filter((action) => {
-    if (action.condition && !action.condition(message)) {
-      return false;
-    }
-    return true;
-  }).map((action) => ({
-    id: action.id,
-    label: action.label,
-    icon: action.icon,
-    onClick: action.onClick,
-    tooltip: action.tooltip,
-    disabled: action.disabled || false,
-    pressed: action.pressed,
-    showLabel: action.showLabel
+function Pe(t, e) {
+  return e.flatMap((a) => typeof a.actions == "function" ? a.actions(t) : a.actions).filter((a) => !(a.condition && !a.condition(t))).map((a) => ({
+    id: a.id,
+    label: a.label,
+    icon: a.icon,
+    onClick: a.onClick,
+    tooltip: a.tooltip,
+    disabled: a.disabled || !1,
+    pressed: a.pressed,
+    showLabel: a.showLabel
   }));
-  return filteredActions;
 }
-
-// src/react/useAgentChat.ts
-var sortUIMessagesByTime = (messages) => {
-  return [...messages].sort((a, b) => a.timestamp - b.timestamp);
-};
-var transformClientMessageToUI = (clientMessage, messageActionsRegistrations = []) => {
-  const hasToolContent = clientMessage.parts.some((part) => {
-    if (part.type === "data") {
-      const data = part.data;
-      return data.toolCallId || data.toolId || data.result;
+const Q = (t) => [...t].sort((e, s) => e.timestamp - s.timestamp), V = (t, e = []) => {
+  var o;
+  if (t.parts.some((i) => {
+    if (i.type === "data") {
+      const l = i.data;
+      return l.toolCallId || l.toolId || l.result;
     }
-    return false;
-  });
-  if (hasToolContent) {
+    return !1;
+  }))
     return null;
-  }
-  const content = clientMessage.parts.map((part) => {
-    if (part.type === "text") {
+  const n = t.parts.map((i) => {
+    if (i.type === "text")
       return {
         type: "text",
-        text: part.text
+        text: i.text
       };
-    }
-    if (part.type === "file") {
+    if (i.type === "file")
       return {
         type: "image_url",
-        image_url: part.file.uri || `data:${part.file.mimeType};base64,${part.file.bytes}`
+        image_url: i.file.uri || `data:${i.file.mimeType};base64,${i.file.bytes}`
       };
-    }
-    if (part.type === "data") {
-      const data = part.data;
-      if (data.component && data.componentProps) {
-        return {
-          type: "component",
-          component: data.component,
-          componentProps: data.componentProps
-        };
-      }
-      return {
+    if (i.type === "data") {
+      const l = i.data;
+      return l.component && l.componentProps ? {
+        type: "component",
+        component: l.component,
+        componentProps: l.componentProps
+      } : {
         type: "text",
-        text: JSON.stringify(data)
+        text: JSON.stringify(l)
       };
     }
     return {
       type: "text",
       text: "[Unsupported content]"
     };
-  });
-  const timestamp = clientMessage.metadata?.timestamp ?? Date.now();
-  const uiMessage = {
-    id: clientMessage.messageId,
-    role: clientMessage.role === "agent" ? "agent" : "user",
-    content,
-    timestamp,
-    archived: false,
-    showIcon: clientMessage.role === "agent",
-    icon: clientMessage.role === "agent" ? "assistant" : void 0
+  }), a = ((o = t.metadata) == null ? void 0 : o.timestamp) ?? Date.now(), r = {
+    id: t.messageId,
+    role: t.role === "agent" ? "agent" : "user",
+    content: n,
+    timestamp: a,
+    archived: !1,
+    showIcon: t.role === "agent",
+    icon: t.role === "agent" ? "assistant" : void 0
   };
-  if (clientMessage.role === "agent" && messageActionsRegistrations.length > 0) {
-    const resolvedActions = resolveActionsForMessage(
-      uiMessage,
-      messageActionsRegistrations
+  if (t.role === "agent" && e.length > 0) {
+    const i = Pe(
+      r,
+      e
     );
-    if (resolvedActions.length > 0) {
-      uiMessage.actions = resolvedActions;
-    }
+    i.length > 0 && (r.actions = i);
   }
-  return uiMessage;
-};
-var createNoOpContextProvider = () => ({
+  return r;
+}, Oe = () => ({
   getClientContext: () => ({})
-});
-var createNoOpToolProvider = () => ({
+}), Ne = () => ({
   getAvailableTools: async () => [],
   executeTool: async () => ({
-    success: true,
+    success: !0,
     result: "No tools available"
   })
+}), $e = (t) => ["agentId", "agentUrl", "sessionId"].every((s) => {
+  const n = t[s];
+  return typeof n == "string" && n.trim().length > 0;
 });
-var validateAgentConfig = (config) => {
-  const required = ["agentId", "agentUrl", "sessionId"];
-  return required.every((key) => {
-    const value = config[key];
-    return typeof value === "string" && value.trim().length > 0;
-  });
-};
-function useAgentChat(config) {
-  const agentConfig = {
-    agentId: config.agentId,
-    agentUrl: config.agentUrl,
-    sessionId: config.sessionId
-  };
-  const isValidConfig = validateAgentConfig(agentConfig);
-  const [state, setState] = useState2({
+function Qe(t) {
+  const e = {
+    agentId: t.agentId,
+    agentUrl: t.agentUrl,
+    sessionId: t.sessionId
+  }, s = $e(e), [n, a] = X({
     clientMessages: [],
     uiMessages: [],
-    isProcessing: false,
-    error: isValidConfig ? null : "Invalid agent configuration",
+    isProcessing: !1,
+    error: s ? null : "Invalid agent configuration",
     suggestions: [],
     markdownComponents: {},
     markdownExtensions: {},
     currentAbortController: null
-  });
-  const {
-    registerMessageActions,
-    unregisterMessageActions,
-    clearAllMessageActions,
-    createFeedbackActions: createFeedbackActions2,
-    registrations
-  } = useMessageActions();
-  const registrationsRef = useRef(registrations);
-  useEffect(() => {
-    registrationsRef.current = registrations;
-  }, [registrations]);
-  useEffect(() => {
-    if (!isValidConfig) {
+  }), {
+    registerMessageActions: r,
+    unregisterMessageActions: o,
+    clearAllMessageActions: i,
+    createFeedbackActions: l,
+    registrations: c
+  } = Ee(), g = xt(c);
+  Y(() => {
+    g.current = c;
+  }, [c]), Y(() => {
+    if (!s)
       return;
-    }
-    const initializeAgent = async () => {
-      if (agentConfig.sessionId) {
-        const agentManager = getAgentManager();
-        const agentKey = `${agentConfig.agentId}-${agentConfig.sessionId}`;
-        if (!agentManager.hasAgent(agentKey)) {
-          await agentManager.createAgent(agentKey, {
-            agentId: agentConfig.agentId,
-            agentUrl: agentConfig.agentUrl,
-            sessionId: agentConfig.sessionId,
-            contextProvider: config.contextProvider || createNoOpContextProvider(),
-            toolProvider: config.toolProvider || createNoOpToolProvider(),
-            authProvider: config.authProvider,
-            enableStreaming: config.enableStreaming
+    (async () => {
+      if (e.sessionId) {
+        const d = It(), f = `${e.agentId}-${e.sessionId}`;
+        if (!d.hasAgent(f)) {
+          await d.createAgent(f, {
+            agentId: e.agentId,
+            agentUrl: e.agentUrl,
+            sessionId: e.sessionId,
+            contextProvider: t.contextProvider || Oe(),
+            toolProvider: t.toolProvider || Ne(),
+            authProvider: t.authProvider,
+            enableStreaming: t.enableStreaming
           });
-          const clientHistory = agentManager.getConversationHistory(agentKey);
-          setState((prev) => {
-            const uiHistory = clientHistory.map(
-              (msg) => transformClientMessageToUI(
-                msg,
-                registrationsRef.current
+          const T = d.getConversationHistory(f);
+          a((I) => {
+            const P = T.map(
+              (w) => V(
+                w,
+                g.current
               )
             ).filter(
-              (msg) => msg !== null
+              (w) => w !== null
             );
             return {
-              ...prev,
-              clientMessages: clientHistory,
-              uiMessages: uiHistory
+              ...I,
+              clientMessages: T,
+              uiMessages: P
             };
           });
         }
       }
-    };
-    initializeAgent();
+    })();
   }, [
-    agentConfig.sessionId,
-    agentConfig.agentId,
-    agentConfig.agentUrl,
-    config.contextProvider,
-    config.toolProvider,
-    config.authProvider,
-    config.enableStreaming,
-    isValidConfig
+    e.sessionId,
+    e.agentId,
+    e.agentUrl,
+    t.contextProvider,
+    t.toolProvider,
+    t.authProvider,
+    t.enableStreaming,
+    s
   ]);
-  const onSubmit = useCallback3(
-    async (message) => {
-      if (!isValidConfig) {
+  const y = j(
+    async (h) => {
+      var w;
+      if (!s)
         throw new Error("Invalid agent configuration");
-      }
-      const agentManager = getAgentManager();
-      const agentKey = `${agentConfig.agentId}-${agentConfig.sessionId}`;
-      const messageTimestamp = Date.now();
-      const userMessage = {
-        id: `user-${messageTimestamp}`,
+      const d = It(), f = `${e.agentId}-${e.sessionId}`, T = Date.now(), I = {
+        id: `user-${T}`,
         role: "user",
-        content: [{ type: "text", text: message }],
-        timestamp: messageTimestamp,
-        archived: false,
-        showIcon: false
-      };
-      const abortController = new AbortController();
-      setState((prev) => ({
-        ...prev,
-        uiMessages: [...prev.uiMessages, userMessage],
-        isProcessing: true,
+        content: [{ type: "text", text: h }],
+        timestamp: T,
+        archived: !1,
+        showIcon: !1
+      }, P = new AbortController();
+      a((m) => ({
+        ...m,
+        uiMessages: [...m.uiMessages, I],
+        isProcessing: !0,
         error: null,
-        currentAbortController: abortController
+        currentAbortController: P
       }));
       try {
-        let streamingMessageId = null;
-        let finalMessageAdded = false;
-        for await (const update of agentManager.sendMessageStream(
-          agentKey,
-          message,
+        let m = null, k = !1;
+        for await (const C of d.sendMessageStream(
+          f,
+          h,
           {
-            abortSignal: abortController.signal
+            abortSignal: P.signal
           }
         )) {
-          if (!update.final && update.text) {
-            if (!streamingMessageId) {
-              streamingMessageId = `agent-streaming-${Date.now()}`;
-              const streamingMessage = {
-                id: streamingMessageId,
+          if (!C.final && C.text)
+            if (m)
+              a((E) => ({
+                ...E,
+                uiMessages: E.uiMessages.map(
+                  (R) => R.id === m ? {
+                    ...R,
+                    content: [
+                      {
+                        type: "text",
+                        text: C.text
+                      }
+                    ]
+                  } : R
+                )
+              }));
+            else {
+              m = `agent-streaming-${Date.now()}`;
+              const E = {
+                id: m,
                 role: "agent",
                 content: [
-                  { type: "text", text: update.text }
+                  { type: "text", text: C.text }
                 ],
                 timestamp: Date.now(),
-                archived: false,
-                showIcon: true,
+                archived: !1,
+                showIcon: !0,
                 icon: "assistant"
               };
-              setState((prev) => ({
-                ...prev,
+              a((R) => ({
+                ...R,
                 uiMessages: [
-                  ...prev.uiMessages,
-                  streamingMessage
+                  ...R.uiMessages,
+                  E
                 ]
               }));
-            } else {
-              setState((prev) => ({
-                ...prev,
-                uiMessages: prev.uiMessages.map(
-                  (msg) => msg.id === streamingMessageId ? {
-                    ...msg,
-                    content: [
-                      {
-                        type: "text",
-                        text: update.text
-                      }
-                    ]
-                  } : msg
-                )
-              }));
             }
-          }
-          if (update.final && update.status?.message && streamingMessageId) {
-            finalMessageAdded = true;
-            const currentStreamingId = streamingMessageId;
-            const finalMessage = transformClientMessageToUI(
-              update.status.message,
-              registrationsRef.current
+          if (C.final && ((w = C.status) != null && w.message) && m) {
+            k = !0;
+            const E = m, R = V(
+              C.status.message,
+              g.current
             );
-            if (finalMessage) {
-              setState((prev) => {
-                const updatedMessages = prev.uiMessages.map(
-                  (msg) => msg.id === currentStreamingId ? finalMessage : msg
-                );
-                const updatedClientHistory = agentManager.getConversationHistory(
-                  agentKey
-                );
-                return {
-                  ...prev,
-                  clientMessages: updatedClientHistory,
-                  uiMessages: updatedMessages,
-                  isProcessing: false,
-                  currentAbortController: null
-                };
-              });
-            }
-            streamingMessageId = null;
+            R && a((O) => {
+              const v = O.uiMessages.map(
+                (B) => B.id === E ? R : B
+              ), F = d.getConversationHistory(
+                f
+              );
+              return {
+                ...O,
+                clientMessages: F,
+                uiMessages: v,
+                isProcessing: !1,
+                currentAbortController: null
+              };
+            }), m = null;
           }
         }
-        if (!finalMessageAdded) {
-          const updatedClientHistory = agentManager.getConversationHistory(agentKey);
-          setState((prev) => {
-            let filteredMessages = prev.uiMessages;
-            if (streamingMessageId) {
-              filteredMessages = prev.uiMessages.filter(
-                (msg) => msg.id !== streamingMessageId
-              );
-            }
-            const transformedClientMessages = updatedClientHistory.map(
-              (msg) => transformClientMessageToUI(
-                msg,
-                registrationsRef.current
+        if (!k) {
+          const C = d.getConversationHistory(f);
+          a((E) => {
+            let R = E.uiMessages;
+            m && (R = E.uiMessages.filter(
+              (_) => _.id !== m
+            ));
+            const O = C.map(
+              (_) => V(
+                _,
+                g.current
               )
             ).filter(
-              (msg) => msg !== null
-            );
-            const clientMessageIds = new Set(
-              updatedClientHistory.map((msg) => msg.messageId)
-            );
-            const uiOnlyMessages = filteredMessages.filter(
-              (msg) => !clientMessageIds.has(msg.id) && msg.content[0]?.type === "component"
-            );
-            const mergedUIMessages = sortUIMessagesByTime([
-              ...transformedClientMessages,
-              ...uiOnlyMessages
+              (_) => _ !== null
+            ), v = new Set(
+              C.map((_) => _.messageId)
+            ), F = R.filter(
+              (_) => {
+                var K;
+                return !v.has(_.id) && ((K = _.content[0]) == null ? void 0 : K.type) === "component";
+              }
+            ), B = Q([
+              ...O,
+              ...F
             ]);
             return {
-              ...prev,
-              clientMessages: updatedClientHistory,
-              uiMessages: mergedUIMessages,
-              isProcessing: false,
+              ...E,
+              clientMessages: C,
+              uiMessages: B,
+              isProcessing: !1,
               currentAbortController: null
             };
           });
         }
-      } catch (error) {
-        if (error instanceof Error && error.name === "AbortError") {
-          console.log("Request was aborted by user");
-          setState((prev) => ({
-            ...prev,
-            isProcessing: false,
+      } catch (m) {
+        if (m instanceof Error && m.name === "AbortError") {
+          console.log("Request was aborted by user"), a((C) => ({
+            ...C,
+            isProcessing: !1,
             error: null,
             // Don't show error for user-initiated abort
             currentAbortController: null
           }));
           return;
         }
-        const errorMessage = error instanceof Error ? error.message : "Failed to send message";
-        setState((prev) => ({
-          ...prev,
-          isProcessing: false,
-          error: errorMessage,
+        const k = m instanceof Error ? m.message : "Failed to send message";
+        throw a((C) => ({
+          ...C,
+          isProcessing: !1,
+          error: k,
           currentAbortController: null
-        }));
-        throw error;
+        })), m;
       }
     },
-    [agentConfig.agentId, agentConfig.sessionId, isValidConfig]
-  );
-  const addMessage = useCallback3((message) => {
-    setState((prev) => ({
-      ...prev,
-      uiMessages: sortUIMessagesByTime([...prev.uiMessages, message])
+    [e.agentId, e.sessionId, s]
+  ), b = j((h) => {
+    a((d) => ({
+      ...d,
+      uiMessages: Q([...d.uiMessages, h])
     }));
-  }, []);
-  const registerSuggestions = useCallback3((suggestions) => {
-    setState((prev) => ({
-      ...prev,
-      suggestions
+  }, []), A = j((h) => {
+    a((d) => ({
+      ...d,
+      suggestions: h
     }));
-  }, []);
-  const clearSuggestions = useCallback3(() => {
-    setState((prev) => ({
-      ...prev,
+  }, []), S = j(() => {
+    a((h) => ({
+      ...h,
       suggestions: []
     }));
-  }, []);
-  const registerMarkdownComponents = useCallback3(
-    (components) => {
-      setState((prev) => {
-        const updatedComponents = {
-          ...prev.markdownComponents,
-          ...components
-        };
-        const updatedUIMessages = prev.clientMessages.map(
-          (msg) => transformClientMessageToUI(
-            msg,
-            registrationsRef.current
+  }, []), M = j(
+    (h) => {
+      a((d) => {
+        const f = {
+          ...d.markdownComponents,
+          ...h
+        }, T = d.clientMessages.map(
+          (m) => V(
+            m,
+            g.current
           )
-        ).filter((msg) => msg !== null);
-        const clientMessageIds = new Set(
-          prev.clientMessages.map((msg) => msg.messageId)
-        );
-        const uiOnlyMessages = prev.uiMessages.filter(
-          (msg) => !clientMessageIds.has(msg.id) && msg.content[0]?.type === "component"
-        );
-        const mergedUIMessages = sortUIMessagesByTime([
-          ...updatedUIMessages,
-          ...uiOnlyMessages
+        ).filter((m) => m !== null), I = new Set(
+          d.clientMessages.map((m) => m.messageId)
+        ), P = d.uiMessages.filter(
+          (m) => {
+            var k;
+            return !I.has(m.id) && ((k = m.content[0]) == null ? void 0 : k.type) === "component";
+          }
+        ), w = Q([
+          ...T,
+          ...P
         ]);
         return {
-          ...prev,
-          markdownComponents: updatedComponents,
-          uiMessages: mergedUIMessages
+          ...d,
+          markdownComponents: f,
+          uiMessages: w
         };
       });
     },
     []
-  );
-  const registerMarkdownExtensions = useCallback3(
-    (extensions) => {
-      setState((prev) => {
-        const updatedExtensions = {
-          ...prev.markdownExtensions,
-          ...extensions
-        };
-        const updatedUIMessages = prev.clientMessages.map(
-          (msg) => transformClientMessageToUI(
-            msg,
-            registrationsRef.current
+  ), x = j(
+    (h) => {
+      a((d) => {
+        const f = {
+          ...d.markdownExtensions,
+          ...h
+        }, T = d.clientMessages.map(
+          (m) => V(
+            m,
+            g.current
           )
-        ).filter((msg) => msg !== null);
-        const clientMessageIds = new Set(
-          prev.clientMessages.map((msg) => msg.messageId)
-        );
-        const uiOnlyMessages = prev.uiMessages.filter(
-          (msg) => !clientMessageIds.has(msg.id) && msg.content[0]?.type === "component"
-        );
-        const mergedUIMessages = sortUIMessagesByTime([
-          ...updatedUIMessages,
-          ...uiOnlyMessages
+        ).filter((m) => m !== null), I = new Set(
+          d.clientMessages.map((m) => m.messageId)
+        ), P = d.uiMessages.filter(
+          (m) => {
+            var k;
+            return !I.has(m.id) && ((k = m.content[0]) == null ? void 0 : k.type) === "component";
+          }
+        ), w = Q([
+          ...T,
+          ...P
         ]);
         return {
-          ...prev,
-          markdownExtensions: updatedExtensions,
-          uiMessages: mergedUIMessages
+          ...d,
+          markdownExtensions: f,
+          uiMessages: w
         };
       });
     },
     []
   );
-  useEffect(() => {
-    setState((prev) => {
-      if (prev.clientMessages.length === 0) {
-        return prev;
-      }
-      const updatedUIMessages = prev.clientMessages.map(
-        (msg) => transformClientMessageToUI(msg, registrationsRef.current)
-      ).filter((msg) => msg !== null);
-      const clientMessageIds = new Set(
-        prev.clientMessages.map((msg) => msg.messageId)
-      );
-      const uiOnlyMessages = prev.uiMessages.filter(
-        (msg) => !clientMessageIds.has(msg.id) && msg.content[0]?.type === "component"
+  Y(() => {
+    a((h) => {
+      if (h.clientMessages.length === 0)
+        return h;
+      const d = h.clientMessages.map(
+        (I) => V(I, g.current)
+      ).filter((I) => I !== null), f = new Set(
+        h.clientMessages.map((I) => I.messageId)
+      ), T = h.uiMessages.filter(
+        (I) => {
+          var P;
+          return !f.has(I.id) && ((P = I.content[0]) == null ? void 0 : P.type) === "component";
+        }
       );
       return {
-        ...prev,
-        uiMessages: sortUIMessagesByTime([
-          ...updatedUIMessages,
-          ...uiOnlyMessages
+        ...h,
+        uiMessages: Q([
+          ...d,
+          ...T
         ])
       };
     });
-  }, [registrations]);
-  const messageRenderer = useMemo3(
-    () => createMessageRenderer({
-      components: state.markdownComponents,
-      extensions: state.markdownExtensions
+  }, [c]);
+  const p = it(
+    () => ve({
+      components: n.markdownComponents,
+      extensions: n.markdownExtensions
     }),
-    [state.markdownComponents, state.markdownExtensions]
-  );
-  const abortCurrentRequest = useCallback3(() => {
-    setState((currentState) => {
-      if (currentState.currentAbortController) {
-        currentState.currentAbortController.abort();
-      }
-      return currentState;
-    });
+    [n.markdownComponents, n.markdownExtensions]
+  ), u = j(() => {
+    a((h) => (h.currentAbortController && h.currentAbortController.abort(), h));
   }, []);
   return {
     // AgentUI props
-    messages: state.uiMessages,
-    isProcessing: state.isProcessing,
-    error: state.error,
-    onSubmit,
-    suggestions: state.suggestions,
-    messageRenderer,
+    messages: n.uiMessages,
+    isProcessing: n.isProcessing,
+    error: n.error,
+    onSubmit: y,
+    suggestions: n.suggestions,
+    messageRenderer: p,
     // UI management methods
-    registerSuggestions,
-    clearSuggestions,
-    registerMarkdownComponents,
-    registerMarkdownExtensions,
+    registerSuggestions: A,
+    clearSuggestions: S,
+    registerMarkdownComponents: M,
+    registerMarkdownExtensions: x,
     // Message actions methods
-    registerMessageActions,
-    unregisterMessageActions,
-    clearAllMessageActions,
-    createFeedbackActions: createFeedbackActions2,
+    registerMessageActions: r,
+    unregisterMessageActions: o,
+    clearAllMessageActions: i,
+    createFeedbackActions: l,
     // Tool integration
-    addMessage,
+    addMessage: b,
     // Abort control
-    abortCurrentRequest
+    abortCurrentRequest: u
   };
 }
-
-// src/client/types/index.ts
-var A2AErrorCodes = /* @__PURE__ */ ((A2AErrorCodes2) => {
-  A2AErrorCodes2[A2AErrorCodes2["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
-  A2AErrorCodes2[A2AErrorCodes2["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
-  A2AErrorCodes2[A2AErrorCodes2["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
-  A2AErrorCodes2[A2AErrorCodes2["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
-  A2AErrorCodes2[A2AErrorCodes2["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
-  A2AErrorCodes2[A2AErrorCodes2["SERVER_ERROR"] = -32e3] = "SERVER_ERROR";
-  return A2AErrorCodes2;
-})(A2AErrorCodes || {});
-
-// src/auth/jetpack.ts
-import apiFetch from "@wordpress/api-fetch";
-var JWT_TOKEN_ID = "jetpack-ai-jwt-token";
-var JWT_TOKEN_EXPIRATION_TIME = 30 * 60 * 1e3;
-function isSimpleSite() {
-  const hasJetpackConnection = Boolean(window.JP_CONNECTION_INITIAL_STATE);
-  if (hasJetpackConnection) {
-    return false;
-  }
-  const isSimple = Boolean(
-    window.Jetpack_Editor_Initial_State?.wpcomBlogId
-  );
-  return isSimple;
-}
-async function requestJetpackToken(errorHandler, useCachedToken = true) {
-  const token = localStorage.getItem(JWT_TOKEN_ID);
-  let tokenData;
-  if (token) {
+var De = /* @__PURE__ */ ((t) => (t[t.PARSE_ERROR = -32700] = "PARSE_ERROR", t[t.INVALID_REQUEST = -32600] = "INVALID_REQUEST", t[t.METHOD_NOT_FOUND = -32601] = "METHOD_NOT_FOUND", t[t.INVALID_PARAMS = -32602] = "INVALID_PARAMS", t[t.INTERNAL_ERROR = -32603] = "INTERNAL_ERROR", t[t.SERVER_ERROR = -32e3] = "SERVER_ERROR", t))(De || {});
+const Ct = "jetpack-ai-jwt-token", _e = 30 * 60 * 1e3;
+function je() {
+  var s;
+  return window.JP_CONNECTION_INITIAL_STATE ? !1 : !!((s = window.Jetpack_Editor_Initial_State) != null && s.wpcomBlogId);
+}
+async function Fe(t, e = !0) {
+  var l, c;
+  const s = localStorage.getItem(Ct);
+  let n;
+  if (s)
     try {
-      tokenData = JSON.parse(token);
-    } catch (error) {
-      console.warn("Invalid cached Jetpack token:", error);
+      n = JSON.parse(s);
+    } catch (g) {
+      console.warn("Invalid cached Jetpack token:", g);
     }
-  }
-  if (tokenData && tokenData?.token && tokenData?.expire && tokenData?.expire > Date.now() && useCachedToken) {
-    return tokenData;
-  }
-  const apiNonce = window.JP_CONNECTION_INITIAL_STATE?.apiNonce;
-  const siteId = window.Jetpack_Editor_Initial_State?.wpcomBlogId;
-  let data = {
+  if (n && (n != null && n.token) && (n != null && n.expire) && (n == null ? void 0 : n.expire) > Date.now() && e)
+    return n;
+  const a = (l = window.JP_CONNECTION_INITIAL_STATE) == null ? void 0 : l.apiNonce, r = (c = window.Jetpack_Editor_Initial_State) == null ? void 0 : c.wpcomBlogId;
+  let o = {
     token: "",
     blog_id: ""
   };
   try {
-    if (!isSimpleSite()) {
-      data = await apiFetch({
-        path: "/jetpack/v4/jetpack-ai-jwt?_cacheBuster=" + Date.now(),
-        credentials: "same-origin",
-        headers: {
-          "X-WP-Nonce": apiNonce || ""
-        },
-        method: "POST"
-      });
-    } else {
-      data = await apiFetch({
-        path: "/wpcom/v2/sites/" + siteId + "/jetpack-openai-query/jwt",
-        method: "POST"
-      });
-    }
-  } catch (error) {
-    console.log("Failed to fetch Jetpack token:", error);
-    throw new Error(errorHandler(error));
+    je() ? o = await mt({
+      path: "/wpcom/v2/sites/" + r + "/jetpack-openai-query/jwt",
+      method: "POST"
+    }) : o = await mt({
+      path: "/jetpack/v4/jetpack-ai-jwt?_cacheBuster=" + Date.now(),
+      credentials: "same-origin",
+      headers: {
+        "X-WP-Nonce": a || ""
+      },
+      method: "POST"
+    });
+  } catch (g) {
+    throw console.log("Failed to fetch Jetpack token:", g), new Error(t(g));
   }
-  if (!data?.token) {
+  if (!(o != null && o.token))
     throw new Error(
       "Authentication failed. Please ensure Jetpack is properly connected and try again."
     );
-  }
-  const newTokenData = {
-    token: data.token,
-    blogId: data.blog_id || "",
-    expire: Date.now() + JWT_TOKEN_EXPIRATION_TIME
+  const i = {
+    token: o.token,
+    blogId: o.blog_id || "",
+    expire: Date.now() + _e
   };
   try {
-    localStorage.setItem(JWT_TOKEN_ID, JSON.stringify(newTokenData));
-  } catch (storageError) {
-    console.log("Error storing token in localStorage:", storageError);
+    localStorage.setItem(Ct, JSON.stringify(i));
+  } catch (g) {
+    console.log("Error storing token in localStorage:", g);
   }
-  return newTokenData;
+  return i;
 }
-var createJetpackAuthProvider = (errorHandler) => {
-  return async () => {
-    const headers = {};
-    try {
-      const tokenData = await requestJetpackToken(errorHandler);
-      if (tokenData?.token) {
-        headers.Authorization = `${tokenData.token}`;
-      }
-    } catch (error) {
-      console.error("Failed to get Jetpack token for auth:", error);
-      throw error;
-    }
-    return headers;
-  };
+const Xe = (t) => async () => {
+  const e = {};
+  try {
+    const s = await Fe(t);
+    s != null && s.token && (e.Authorization = `${s.token}`);
+  } catch (s) {
+    throw console.error("Failed to get Jetpack token for auth:", s), s;
+  }
+  return e;
 };
 export {
-  A2AErrorCodes,
-  BarChart,
-  ChartBlock,
-  LineChart,
-  createAbortController,
-  createClient,
-  createFeedbackActions,
-  createJetpackAuthProvider,
-  createMessageRenderer,
-  createRequestId,
-  createTaskId,
-  createTextMessage,
-  extractTextFromMessage,
-  extractToolCallsFromMessage,
-  getAgentManager,
-  useAgentChat,
-  useClientContext,
-  useClientTools,
-  useMessageActions
+  De as A2AErrorCodes,
+  Ht as BarChart,
+  be as ChartBlock,
+  Te as LineChart,
+  Ge as createAbortController,
+  ue as createClient,
+  Re as createFeedbackActions,
+  Xe as createJetpackAuthProvider,
+  ve as createMessageRenderer,
+  Lt as createRequestId,
+  Wt as createTaskId,
+  rt as createTextMessage,
+  U as extractTextFromMessage,
+  J as extractToolCallsFromMessage,
+  It as getAgentManager,
+  Qe as useAgentChat,
+  Ve as useClientContext,
+  ze as useClientTools,
+  Ee as useMessageActions
 };