@automattic/agenttic-client 0.1.0

package/dist/index.js

@@ -0,0 +1,2137 @@
+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);
+  }
+};
+function isDebugEnabled() {
+  return typeof globalThis !== "undefined" && "window" in globalThis && globalThis.window?.DEBUG === "agenttic-client";
+}
+function formatObject(obj) {
+  return JSON.stringify(obj, null, 2);
+}
+function log(message, ...args) {
+  console.log(`[agenttic-client] ${message}`, ...args);
+}
+
+// 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 {};
+        }
+      }
+    };
+    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);
+      return [];
+    }
+  }, [getClientTools]);
+  const stableExecuteTool = useCallback(
+    async (toolId, args) => {
+      if (!executeTool) {
+        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;
+      }
+    },
+    [executeTool]
+  );
+  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;
+}
+function generateMessageId() {
+  return generateRandomId();
+}
+function createRequestId() {
+  return `req-${generateRandomId()}`;
+}
+function createTaskId() {
+  return `task-${generateRandomId()}`;
+}
+function createTextPart(text) {
+  return {
+    type: "text",
+    text
+  };
+}
+function createSendMessageRequest(params, method = "message/send") {
+  return {
+    jsonrpc: "2.0",
+    id: createRequestId(),
+    method,
+    params: {
+      id: params.id || createTaskId(),
+      ...params
+    }
+  };
+}
+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 createToolDataPart(tool) {
+  return {
+    type: "data",
+    data: {
+      toolId: tool.id,
+      toolName: tool.name,
+      description: tool.description,
+      inputSchema: tool.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 createToolResultDataPart(toolCallId, toolId, result, error) {
+  return {
+    type: "data",
+    data: {
+      toolCallId,
+      toolId,
+      result
+    },
+    metadata: error ? { error } : void 0
+  };
+}
+function createContextDataPart(clientContext) {
+  return {
+    type: "data",
+    data: {
+      clientContext
+    },
+    metadata: {}
+  };
+}
+function createTextMessage(text) {
+  return {
+    role: "user",
+    parts: [createTextPart(text)],
+    kind: "message",
+    messageId: generateMessageId(),
+    metadata: {
+      timestamp: Date.now()
+    }
+  };
+}
+function createAgentTextMessage(text) {
+  return {
+    role: "agent",
+    parts: [createTextPart(text)],
+    kind: "message",
+    messageId: generateMessageId(),
+    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 createToolResultMessage(toolResults, historyDataParts = []) {
+  return {
+    role: "user",
+    kind: "message",
+    parts: [...historyDataParts, ...toolResults],
+    messageId: generateMessageId(),
+    metadata: {
+      timestamp: Date.now()
+    }
+  };
+}
+
+// src/client/utils/internal/messages.ts
+async function enhanceMessageWithTools(message, toolProvider) {
+  if (!toolProvider) {
+    return message;
+  }
+  try {
+    const tools = await toolProvider.getAvailableTools();
+    if (tools.length === 0) {
+      return message;
+    }
+    const toolParts = tools.map(createToolDataPart);
+    return {
+      ...message,
+      parts: [...message.parts, ...toolParts]
+    };
+  } catch (error) {
+    logger("Warning: Failed to get tools: %s", error);
+    return message;
+  }
+}
+function enhanceMessageWithContext(message, contextProvider) {
+  if (!contextProvider) {
+    return message;
+  }
+  try {
+    const clientContext = contextProvider.getClientContext();
+    if (!clientContext || Object.keys(clientContext).length === 0) {
+      return message;
+    }
+    const contextPart = createContextDataPart(clientContext);
+    return {
+      ...message,
+      parts: [...message.parts, contextPart]
+    };
+  } catch (error) {
+    logger("Warning: Failed to get context: %s", error);
+    return message;
+  }
+}
+async function enhanceMessage(message, toolProvider, contextProvider) {
+  let enhancedMessage = await enhanceMessageWithTools(
+    message,
+    toolProvider
+  );
+  enhancedMessage = enhanceMessageWithContext(
+    enhancedMessage,
+    contextProvider
+  );
+  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
+      );
+    } 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 = "";
+      }
+    }
+    if (newlineIndex === -1) {
+      searchStartIndex = currentStreamData.length;
+    } else {
+      searchStartIndex = newlineIndex + 1;
+    }
+  }
+  const nextBuffer = currentStreamData.substring(lastCompleteEventEnd);
+  return { events, nextBuffer };
+}
+async function* parseSSEStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      const chunk = decoder.decode(value, { stream: true });
+      const { events, nextBuffer } = parseStreamChunk(chunk, buffer);
+      if (events && Array.isArray(events)) {
+        for (const event of events) {
+          if (event.error) {
+            throw new Error(
+              `Streaming error: ${event.error.message}`
+            );
+          }
+          if (event.result && 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;
+          }
+        }
+      }
+      buffer = nextBuffer;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// 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);
+  }
+  throw error;
+}
+function validateHttpResponse(response, operation = "request") {
+  if (!response.ok) {
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+}
+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 validateStreamingResponse(response, operation = "streaming request") {
+  validateHttpResponse(response, operation);
+  if (!response.body) {
+    throw new Error(`No response body for ${operation}`);
+  }
+}
+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));
+  }
+}
+async function getHeaders(authProvider, isStreaming = false) {
+  const baseHeaders = {
+    "Content-Type": "application/json"
+  };
+  if (isStreaming) {
+    baseHeaders.Accept = "text/event-stream";
+  }
+  if (authProvider) {
+    const authHeaders = await authProvider();
+    return { ...baseHeaders, ...authHeaders };
+  }
+  return baseHeaders;
+}
+function createFetchOptions(headers, body, signal) {
+  return {
+    method: "POST",
+    headers,
+    body,
+    signal
+  };
+}
+async function prepareRequest(params, config, options, toolProvider, contextProvider, defaultSessionId) {
+  const { message, sessionId, taskId, metadata } = params;
+  const { agentId, agentUrl, authProvider, proxy } = config;
+  const { isStreaming = false } = options;
+  const effectiveSessionId = sessionId || defaultSessionId;
+  const fullAgentUrl = constructAgentUrl(agentUrl, agentId);
+  const enhancedMessage = await enhanceMessage(
+    message,
+    toolProvider,
+    contextProvider
+  );
+  const request = createSendMessageRequest(
+    {
+      id: taskId,
+      sessionId: effectiveSessionId,
+      message: enhancedMessage,
+      metadata
+    },
+    isStreaming ? "message/stream" : "message/send"
+  );
+  const headers = await getHeaders(authProvider, isStreaming);
+  logRequest("POST", fullAgentUrl, headers, request);
+  return {
+    request,
+    headers,
+    enhancedMessage,
+    effectiveSessionId,
+    fullAgentUrl
+  };
+}
+async function executeRequest(preparedRequest, config) {
+  const { request, headers, fullAgentUrl } = preparedRequest;
+  const { timeout } = config;
+  const { timeoutId, controller } = createTimeoutHandler(
+    timeout,
+    "request"
+  );
+  try {
+    const options = createFetchOptions(
+      headers,
+      JSON.stringify(request),
+      controller.signal
+    );
+    logger("Making request to %s with options: %O", fullAgentUrl, {
+      method: options.method,
+      headers: options.headers
+    });
+    const response = await fetch(fullAgentUrl, options);
+    clearTimeout(timeoutId);
+    validateHttpResponse(response, "request");
+    const data = await response.json();
+    logger(
+      "Response from %s: %d %O",
+      fullAgentUrl,
+      response.status,
+      formatObject(data)
+    );
+    return validateJsonRpcResponse(data, "request");
+  } catch (error) {
+    handleRequestError(error, timeoutId, "request");
+  }
+}
+async function* executeStreamingRequest(preparedRequest, config, options) {
+  const { request, headers, fullAgentUrl } = preparedRequest;
+  const {} = config;
+  const { streamingTimeout = 6e4 } = options;
+  const { timeoutId, controller } = createTimeoutHandler(
+    streamingTimeout,
+    "streaming request"
+  );
+  try {
+    const fetchOptions = createFetchOptions(
+      headers,
+      JSON.stringify(request),
+      controller.signal
+    );
+    const response = await fetch(fullAgentUrl, fetchOptions);
+    clearTimeout(timeoutId);
+    validateStreamingResponse(response, "streaming request");
+    yield* parseSSEStream(response.body);
+  } catch (error) {
+    handleRequestError(error, timeoutId, "streaming request");
+  }
+}
+
+// src/client/index.ts
+var DEFAULT_TIMEOUT = 12e4;
+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;
+    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
+        )
+      );
+    } catch (error) {
+      shouldReturnToAgent = true;
+      results.push(
+        createToolResultDataPart(
+          toolCallId,
+          toolId,
+          void 0,
+          error instanceof Error ? error.message : String(error)
+        )
+      );
+    }
+  }
+  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;
+}
+async function continueTask(taskId, message, requestConfig, toolProvider, contextProvider, sessionId) {
+  const continueParams = {
+    message,
+    taskId,
+    sessionId: void 0
+    // Use task's session
+  };
+  const preparedRequest = await prepareRequest(
+    continueParams,
+    requestConfig,
+    { isStreaming: false },
+    toolProvider,
+    contextProvider,
+    sessionId
+  );
+  return await executeRequest(preparedRequest, requestConfig);
+}
+async function continueTaskStreamed(taskId, message, requestConfig, toolProvider, contextProvider, sessionId) {
+  const continueParams = {
+    message,
+    taskId,
+    sessionId: void 0
+    // Use task's session
+  };
+  const preparedRequest = await prepareRequest(
+    continueParams,
+    requestConfig,
+    { isStreaming: true },
+    toolProvider,
+    contextProvider,
+    sessionId
+  );
+  const stream = executeStreamingRequest(preparedRequest, requestConfig, {
+    isStreaming: true
+  });
+  return processAgentResponseStream(
+    stream,
+    toolProvider,
+    contextProvider,
+    requestConfig,
+    sessionId,
+    true,
+    // withHistory
+    []
+    // newConversationParts - empty for continueTask
+  );
+}
+async function* processAgentResponseStream(stream, toolProvider, contextProvider, requestConfig, sessionId, withHistory = true, newConversationParts = []) {
+  for await (const update of stream) {
+    yield update;
+    if (update.status.state === "input-required" && update.status.message && toolProvider) {
+      const toolCalls = extractToolCallsFromMessage(
+        update.status.message
+      );
+      if (toolCalls.length > 0) {
+        const toolResults = [];
+        let shouldReturnToAgent = false;
+        const toolParts = [];
+        const agentMessages = [];
+        for (const toolCall of toolCalls) {
+          const {
+            toolCallId,
+            toolId,
+            arguments: args
+          } = toolCall.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)
+              );
+            }
+            const toolResult = createToolResultDataPart(
+              toolCallId,
+              toolId,
+              result
+            );
+            toolResults.push(toolResult);
+            toolParts.push(toolResult);
+          } catch (error) {
+            const toolResult = createToolResultDataPart(
+              toolCallId,
+              toolId,
+              void 0,
+              error instanceof Error ? error.message : String(error)
+            );
+            toolResults.push(toolResult);
+            toolParts.push(toolResult);
+          }
+        }
+        newConversationParts.push(update.status.message);
+        if (shouldReturnToAgent) {
+          const historyDataParts = conversationHistoryToDataParts(newConversationParts);
+          const toolResultMessage = createToolResultMessage(
+            toolResults,
+            historyDataParts
+          );
+          yield {
+            id: update.id,
+            status: {
+              state: "working",
+              message: toolResultMessage
+            },
+            final: false,
+            text: ""
+          };
+          const continuedTaskStream = await continueTaskStreamed(
+            update.id,
+            toolResultMessage,
+            requestConfig,
+            toolProvider,
+            contextProvider,
+            sessionId
+          );
+          let continuedTaskUpdate = null;
+          for await (const streamUpdate of continuedTaskStream) {
+            if (!streamUpdate.final) {
+              yield streamUpdate;
+            } else {
+              continuedTaskUpdate = streamUpdate;
+            }
+          }
+          if (!continuedTaskUpdate) {
+            throw new Error(
+              "Continue task stream ended without final result"
+            );
+          }
+          let continuedToolCalls = continuedTaskUpdate.status?.message ? extractToolCallsFromMessage(
+            continuedTaskUpdate.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",
+                  parts: [],
+                  messageId: generateMessageId()
+                }
+              )
+            };
+            while (continuedToolCalls.length > 0) {
+              if (finalTask.status?.message) {
+                newConversationParts.push(
+                  finalTask.status.message
+                );
+              }
+              const {
+                results: moreResults,
+                shouldReturnToAgent: moreShouldReturn
+              } = await executeToolCallBatch(
+                continuedToolCalls,
+                toolProvider,
+                finalTask.status?.message?.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
+                );
+                let moreFinalTask = null;
+                for await (const streamUpdate of moreTaskStream) {
+                  if (!streamUpdate.final) {
+                    yield streamUpdate;
+                  } else {
+                    moreFinalTask = streamUpdate;
+                  }
+                }
+                if (!moreFinalTask) {
+                  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 {
+                break;
+              }
+            }
+          }
+          yield {
+            ...finalTask,
+            final: true,
+            text: extractTextFromMessage(
+              finalTask.status?.message || {
+                role: "agent",
+                kind: "message",
+                parts: [],
+                messageId: generateMessageId()
+              }
+            )
+          };
+        } else {
+          const enhancedMessage = {
+            ...update.status.message,
+            parts: toolParts
+          };
+          const enhancedUpdate = {
+            ...update,
+            status: {
+              ...update.status,
+              message: enhancedMessage
+            },
+            final: agentMessages.length === 0,
+            // Only final if no agent messages to follow
+            text: extractTextFromMessage(enhancedMessage)
+          };
+          yield enhancedUpdate;
+          if (agentMessages.length > 0) {
+            const combinedAgentText = agentMessages.map((msg) => extractTextFromMessage(msg)).join(" ");
+            const finalAgentMessage = createAgentTextMessage(combinedAgentText);
+            yield {
+              id: enhancedUpdate.id,
+              status: {
+                state: "completed",
+                message: finalAgentMessage
+              },
+              final: true,
+              text: combinedAgentText
+            };
+          }
+        }
+      }
+    }
+  }
+}
+function createClient(config) {
+  const {
+    agentId,
+    agentUrl,
+    authProvider,
+    defaultSessionId,
+    timeout = DEFAULT_TIMEOUT,
+    toolProvider,
+    contextProvider
+  } = config;
+  const requestConfig = {
+    agentId,
+    agentUrl,
+    authProvider,
+    timeout
+  };
+  return {
+    async sendMessage(params) {
+      const { withHistory = true } = params;
+      const sessionId = params.sessionId || defaultSessionId || void 0;
+      const newConversationParts = [];
+      newConversationParts.push(params.message);
+      const preparedRequest = await prepareRequest(
+        params,
+        requestConfig,
+        { isStreaming: false },
+        toolProvider,
+        contextProvider,
+        sessionId
+      );
+      let currentTask = await executeRequest(
+        preparedRequest,
+        requestConfig
+      );
+      const allToolParts = [];
+      const agentMessages = [];
+      while (currentTask.status.message && toolProvider) {
+        const toolCalls = extractToolCallsFromMessage(
+          currentTask.status.message
+        );
+        if (toolCalls.length === 0) {
+          break;
+        }
+        allToolParts.push(...toolCalls);
+        const toolResults = [];
+        let shouldReturnToAgent = false;
+        for (const toolCall of toolCalls) {
+          const {
+            toolCallId,
+            toolId,
+            arguments: args
+          } = toolCall.data;
+          try {
+            const executionResult = await toolProvider.executeTool(
+              toolId,
+              args
+            );
+            const { result, returnToAgent, agentMessage } = processToolExecutionResult(executionResult);
+            if (returnToAgent) {
+              shouldReturnToAgent = true;
+            }
+            if (agentMessage) {
+              agentMessages.push(
+                createAgentTextMessage(agentMessage)
+              );
+            }
+            const toolResult = createToolResultDataPart(
+              toolCallId,
+              toolId,
+              result
+            );
+            toolResults.push(toolResult);
+            allToolParts.push(toolResult);
+          } catch (error) {
+            const toolResult = createToolResultDataPart(
+              toolCallId,
+              toolId,
+              void 0,
+              error instanceof Error ? error.message : String(error)
+            );
+            toolResults.push(toolResult);
+            allToolParts.push(toolResult);
+          }
+        }
+        newConversationParts.push(currentTask.status.message);
+        if (shouldReturnToAgent) {
+          const toolResultMessage = createToolResultMessage(toolResults);
+          currentTask = await continueTask(
+            currentTask.id,
+            toolResultMessage,
+            requestConfig,
+            toolProvider,
+            contextProvider,
+            sessionId
+          );
+        } 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 (agentMessages.length > 0) {
+        const combinedAgentText = agentMessages.map((msg) => extractTextFromMessage(msg)).join(" ");
+        const finalAgentMessage = createAgentTextMessage(combinedAgentText);
+        return {
+          ...currentTask,
+          // Keep the enhanced message with tool results
+          // The agent message will be handled separately by the caller
+          text: combinedAgentText,
+          agentMessage: finalAgentMessage
+          // Add this for the caller to handle
+        };
+      }
+      return {
+        ...currentTask,
+        text: extractTextFromMessage(
+          currentTask.status?.message || {
+            role: "agent",
+            kind: "message",
+            parts: [],
+            messageId: generateMessageId()
+          }
+        )
+      };
+    },
+    async *sendMessageStream(params) {
+      const { withHistory = true } = params;
+      const sessionId = params.sessionId || defaultSessionId || void 0;
+      const newConversationParts = [];
+      newConversationParts.push(params.message);
+      const preparedRequest = await prepareRequest(
+        params,
+        requestConfig,
+        { isStreaming: true, streamingTimeout: timeout },
+        toolProvider,
+        contextProvider,
+        sessionId
+      );
+      const stream = executeStreamingRequest(
+        preparedRequest,
+        requestConfig,
+        {
+          isStreaming: true,
+          streamingTimeout: timeout
+        }
+      );
+      yield* processAgentResponseStream(
+        stream,
+        toolProvider,
+        contextProvider,
+        requestConfig,
+        sessionId,
+        withHistory,
+        newConversationParts
+      );
+    },
+    async continueTask(taskId, userInput, sessionId) {
+      const userMessage = createTextMessage(userInput);
+      const continuedTask = await continueTask(
+        taskId,
+        userMessage,
+        requestConfig,
+        toolProvider,
+        contextProvider,
+        sessionId
+      );
+      let currentTask = continuedTask;
+      while (currentTask.status.state === "input-required" && currentTask.status.message && toolProvider) {
+        const toolCalls = extractToolCallsFromMessage(
+          currentTask.status.message
+        );
+        if (toolCalls.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
+          );
+        } else {
+          break;
+        }
+      }
+      return {
+        ...currentTask,
+        text: extractTextFromMessage(
+          currentTask.status?.message || {
+            role: "agent",
+            kind: "message",
+            parts: [],
+            messageId: generateMessageId()
+          }
+        )
+      };
+    },
+    async getTask(taskId) {
+      throw new Error("getTask not implemented yet");
+    },
+    async cancelTask(taskId) {
+      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();
+  return {
+    role: storageRole,
+    content: textParts || "(No text content)",
+    timestamp,
+    ...toolCalls.length > 0 && { toolCalls },
+    ...toolResults.length > 0 && { toolResults }
+  };
+}
+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({
+        type: "data",
+        data: {
+          toolCallId: toolCall.toolCallId,
+          toolId: toolCall.toolId,
+          arguments: toolCall.arguments
+        }
+      });
+    }
+  }
+  if (stored.toolResults) {
+    for (const toolResult of stored.toolResults) {
+      parts.push({
+        type: "data",
+        data: {
+          toolCallId: toolResult.toolCallId,
+          result: toolResult.result,
+          ...toolResult.error && { error: toolResult.error }
+        }
+      });
+    }
+  }
+  return {
+    role: stored.role,
+    kind: "message",
+    parts,
+    messageId: generateMessageId(),
+    metadata: {
+      timestamp: stored.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
+    );
+  }
+}
+async function loadConversation(sessionId, conversationStorageKey) {
+  const currentStorageKey = conversationStorageKey || sessionId;
+  if (conversationCache.has(currentStorageKey)) {
+    return [...conversationCache.get(currentStorageKey)];
+  }
+  if (typeof sessionStorage === "undefined") {
+    return [];
+  }
+  try {
+    const stored = sessionStorage.getItem(
+      `${STORAGE_KEY}_${currentStorageKey}`
+    );
+    if (stored) {
+      const conversation = JSON.parse(stored);
+      const messages = conversation.messages.map(restoreMessage);
+      conversationCache.set(currentStorageKey, messages);
+      return [...messages];
+    }
+  } catch (error) {
+    logger(
+      "Failed to load conversation from sessionStorage for key %s: %O",
+      currentStorageKey,
+      error
+    );
+  }
+  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;
+    }
+    return true;
+  });
+  return {
+    ...message,
+    parts: newParts,
+    // Preserve metadata if it exists, otherwise add timestamp
+    metadata: message.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({
+          type: "data",
+          data: {
+            role: message.role,
+            text: part.text
+          }
+        });
+      } else if (part.type === "data") {
+        if ("role" in part.data && "text" in part.data) {
+          continue;
+        }
+        if ("toolCallId" in part.data && "arguments" in part.data) {
+          historyParts.push(part);
+          continue;
+        }
+        if ("toolCallId" in part.data && "result" in part.data) {
+          historyParts.push(part);
+          continue;
+        }
+      }
+    }
+  }
+  return historyParts;
+}
+function createTextMessageWithHistory(text, conversationMessages = []) {
+  const historyParts = conversationMessagesToDataParts(conversationMessages);
+  return {
+    role: "user",
+    parts: [
+      ...historyParts,
+      {
+        type: "text",
+        text
+      }
+    ],
+    kind: "message",
+    messageId: generateMessageId(),
+    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
+function createAgentManager() {
+  const agents = /* @__PURE__ */ new Map();
+  async function persistConversationHistory(key, messages) {
+    const agent = agents.get(key);
+    if (agent?.sessionId) {
+      try {
+        await storeConversation(
+          agent.sessionId,
+          messages,
+          agent.conversationStorageKey
+        );
+      } catch (error) {
+        log(
+          `Failed to persist conversation history for agent ${key}:`,
+          error
+        );
+      }
+    }
+  }
+  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) {
+        try {
+          conversationHistory = await loadConversation(
+            sessionId,
+            conversationStorageKey
+          );
+        } catch (error) {
+          log(
+            `Failed to load conversation history for agent ${key} with session ${sessionId}:`,
+            error
+          );
+        }
+      }
+      const managedAgent = {
+        client,
+        sessionId,
+        conversationStorageKey,
+        conversationHistory
+      };
+      agents.set(key, managedAgent);
+      return client;
+    },
+    getAgent(key) {
+      const agent = agents.get(key);
+      return agent?.client || null;
+    },
+    hasAgent(key) {
+      return agents.has(key);
+    },
+    removeAgent(key) {
+      return agents.delete(key);
+    },
+    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
+      });
+      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)
+        );
+        const textParts = task.status.message.parts.filter(
+          (part) => part.type === "text"
+        );
+        completeAgentMessage = {
+          role: "agent",
+          kind: "message",
+          parts: [...toolParts, ...textParts],
+          messageId: generateMessageId(),
+          metadata: {
+            timestamp: Date.now()
+          }
+        };
+      }
+      const newConversationHistory = [
+        ...conversationHistory,
+        // Store only the new content from the user message (without history parts)
+        createTextMessage(message),
+        // Add complete agent response with tool calls/results if present
+        ...completeAgentMessage ? [extractNewContentFromMessage(completeAgentMessage)] : []
+      ];
+      let finalConversationHistory = newConversationHistory;
+      if (task.agentMessage) {
+        const separateAgentMessage = extractNewContentFromMessage(
+          task.agentMessage
+        );
+        finalConversationHistory = [
+          ...newConversationHistory,
+          separateAgentMessage
+        ];
+      }
+      managedAgent.conversationHistory = finalConversationHistory;
+      if (withHistory) {
+        await persistConversationHistory(
+          key,
+          finalConversationHistory
+        );
+      }
+      return task;
+    },
+    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 messageObj = options.message || createTextMessageWithHistory(
+        message,
+        currentConversationHistory
+      );
+      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
+      })) {
+        if (update.status?.state === "input-required" && update.status?.message) {
+          const toolCalls = extractToolCallsFromMessage(
+            update.status.message
+          );
+          currentToolCallIds = toolCalls.map(
+            (call) => call.data.toolCallId
+          );
+          const toolMessage = extractNewContentFromMessage(
+            update.status.message
+          );
+          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 (currentToolResults.length > 0) {
+            const toolResultMessage = {
+              role: "agent",
+              kind: "message",
+              parts: currentToolResults,
+              messageId: generateMessageId()
+            };
+            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
+            );
+            currentConversationHistory = [
+              ...currentConversationHistory,
+              finalAgentMessage
+            ];
+            managedAgent.conversationHistory = currentConversationHistory;
+            if (withHistory) {
+              await persistConversationHistory(
+                key,
+                currentConversationHistory
+              );
+            }
+          }
+        }
+        yield update;
+      }
+    },
+    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
+        );
+      }
+    },
+    getConversationHistory(key) {
+      const managedAgent = agents.get(key);
+      if (!managedAgent) {
+        throw new Error(`Agent with key "${key}" not found`);
+      }
+      return [...managedAgent.conversationHistory];
+    },
+    clear() {
+      agents.clear();
+    }
+  };
+}
+var globalAgentManager = createAgentManager();
+function getAgentManager() {
+  return globalAgentManager;
+}
+
+// src/utils/createMessageRenderer.tsx
+import Markdown from "react-markdown";
+
+// 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);
+  }
+  if (extensions?.gfm?.enabled) {
+    remarkPlugins.push(remarkGfm);
+  }
+  return { components, remarkPlugins };
+}
+function mergeMarkdownComponents(extensionComponents, userComponents = {}) {
+  return {
+    ...extensionComponents,
+    ...userComponents
+  };
+}
+
+// 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
+  );
+  const finalPlugins = [...processed.remarkPlugins, ...remarkPlugins];
+  return function MessageRenderer({ children }) {
+    return /* @__PURE__ */ jsx(
+      Markdown,
+      {
+        components: finalComponents,
+        remarkPlugins: finalPlugins,
+        children
+      }
+    );
+  };
+}
+
+// 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());
+  };
+  const handleFeedback = async (messageId, feedback) => {
+    feedbackByMessageId[messageId] = feedback;
+    await config.onFeedback(messageId, feedback);
+    notifyListeners();
+  };
+  return {
+    getActionsForMessage: (message) => {
+      if (!baseCondition(message)) {
+        return [];
+      }
+      const feedbackState = feedbackByMessageId[message.id];
+      const actions = [];
+      if (feedbackState !== "down") {
+        actions.push({
+          id: "feedback-up",
+          icon: config.icons.up,
+          label: "Good response",
+          onClick: async () => {
+            await handleFeedback(message.id, "up");
+          },
+          tooltip: "This response was helpful",
+          disabled: feedbackState === "up"
+        });
+      }
+      if (feedbackState !== "up") {
+        actions.push({
+          id: "feedback-down",
+          icon: config.icons.down,
+          label: "Bad response",
+          onClick: async () => {
+            await handleFeedback(message.id, "down");
+          },
+          tooltip: "This response was not helpful",
+          disabled: feedbackState === "down"
+        });
+      }
+      return actions;
+    },
+    clearFeedback: (messageId) => {
+      delete feedbackByMessageId[messageId];
+      notifyListeners();
+    },
+    clearAllFeedback: () => {
+      Object.keys(feedbackByMessageId).forEach((key) => {
+        delete feedbackByMessageId[key];
+      });
+      notifyListeners();
+    },
+    onChange: (listener) => {
+      changeListeners.push(listener);
+    },
+    offChange: (listener) => {
+      const index = changeListeners.indexOf(listener);
+      if (index > -1) {
+        changeListeners.splice(index, 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
+        );
+        if (existingIndex >= 0) {
+          const updated = [...prev];
+          updated[existingIndex] = registration;
+          return updated;
+        }
+        return [...prev, registration];
+      });
+    },
+    []
+  );
+  const unregisterMessageActions = useCallback2((id) => {
+    setRegistrations((prev) => prev.filter((r) => r.id !== id));
+  }, []);
+  const clearAllMessageActions = useCallback2(() => {
+    setRegistrations([]);
+  }, []);
+  return {
+    registerMessageActions,
+    unregisterMessageActions,
+    clearAllMessageActions,
+    createFeedbackActions,
+    registrations
+  };
+}
+
+// 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
+  }));
+  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;
+    }
+    return false;
+  });
+  if (hasToolContent) {
+    return null;
+  }
+  const content = clientMessage.parts.map((part) => {
+    if (part.type === "text") {
+      return {
+        type: "text",
+        text: part.text
+      };
+    }
+    if (part.type === "file") {
+      return {
+        type: "image_url",
+        image_url: part.file.uri || `data:${part.file.mimeType};base64,${part.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 {
+        type: "text",
+        text: JSON.stringify(data)
+      };
+    }
+    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
+  };
+  if (clientMessage.role === "agent" && messageActionsRegistrations.length > 0) {
+    const resolvedActions = resolveActionsForMessage(
+      uiMessage,
+      messageActionsRegistrations
+    );
+    if (resolvedActions.length > 0) {
+      uiMessage.actions = resolvedActions;
+    }
+  }
+  return uiMessage;
+};
+var createNoOpContextProvider = () => ({
+  getClientContext: () => ({})
+});
+var createNoOpToolProvider = () => ({
+  getAvailableTools: async () => [],
+  executeTool: async () => ({
+    success: true,
+    result: "No tools available"
+  })
+});
+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({
+    clientMessages: [],
+    uiMessages: [],
+    isProcessing: false,
+    error: isValidConfig ? null : "Invalid agent configuration",
+    suggestions: [],
+    markdownComponents: {},
+    markdownExtensions: {}
+  });
+  const {
+    registerMessageActions,
+    unregisterMessageActions,
+    clearAllMessageActions,
+    createFeedbackActions: createFeedbackActions2,
+    registrations
+  } = useMessageActions();
+  const registrationsRef = useRef(registrations);
+  useEffect(() => {
+    registrationsRef.current = registrations;
+  }, [registrations]);
+  useEffect(() => {
+    if (!isValidConfig) {
+      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
+          });
+          const clientHistory = agentManager.getConversationHistory(agentKey);
+          setState((prev) => {
+            const uiHistory = clientHistory.map(
+              (msg) => transformClientMessageToUI(
+                msg,
+                registrationsRef.current
+              )
+            ).filter(
+              (msg) => msg !== null
+            );
+            return {
+              ...prev,
+              clientMessages: clientHistory,
+              uiMessages: uiHistory
+            };
+          });
+        }
+      }
+    };
+    initializeAgent();
+  }, [
+    agentConfig.sessionId,
+    agentConfig.agentId,
+    agentConfig.agentUrl,
+    config.contextProvider,
+    config.toolProvider,
+    config.authProvider,
+    isValidConfig
+  ]);
+  const onSubmit = useCallback3(
+    async (message) => {
+      if (!isValidConfig) {
+        throw new Error("Invalid agent configuration");
+      }
+      const agentManager = getAgentManager();
+      const agentKey = `${agentConfig.agentId}-${agentConfig.sessionId}`;
+      const messageTimestamp = Date.now();
+      const userMessage = {
+        id: `user-${messageTimestamp}`,
+        role: "user",
+        content: [{ type: "text", text: message }],
+        timestamp: messageTimestamp,
+        archived: false,
+        showIcon: false
+      };
+      setState((prev) => ({
+        ...prev,
+        uiMessages: [...prev.uiMessages, userMessage],
+        isProcessing: true,
+        error: null
+      }));
+      try {
+        let lastUpdate = null;
+        for await (const update of agentManager.sendMessageStream(
+          agentKey,
+          message
+        )) {
+          lastUpdate = update;
+        }
+        const updatedClientHistory = agentManager.getConversationHistory(agentKey);
+        setState((prev) => {
+          const transformedClientMessages = updatedClientHistory.map(
+            (msg) => transformClientMessageToUI(
+              msg,
+              registrationsRef.current
+            )
+          ).filter((msg) => msg !== null);
+          const clientMessageIds = new Set(
+            updatedClientHistory.map((msg) => msg.messageId)
+          );
+          const uiOnlyMessages = prev.uiMessages.filter(
+            (msg) => !clientMessageIds.has(msg.id) && msg.content[0]?.type === "component"
+          );
+          const mergedUIMessages = sortUIMessagesByTime([
+            ...transformedClientMessages,
+            ...uiOnlyMessages
+          ]);
+          return {
+            ...prev,
+            clientMessages: updatedClientHistory,
+            uiMessages: mergedUIMessages,
+            isProcessing: false
+          };
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Failed to send message";
+        setState((prev) => ({
+          ...prev,
+          isProcessing: false,
+          error: errorMessage
+        }));
+        throw error;
+      }
+    },
+    [agentConfig.agentId, agentConfig.sessionId, isValidConfig]
+  );
+  const addMessage = useCallback3((message) => {
+    setState((prev) => ({
+      ...prev,
+      uiMessages: sortUIMessagesByTime([...prev.uiMessages, message])
+    }));
+  }, []);
+  const registerSuggestions = useCallback3((suggestions) => {
+    setState((prev) => ({
+      ...prev,
+      suggestions
+    }));
+  }, []);
+  const clearSuggestions = useCallback3(() => {
+    setState((prev) => ({
+      ...prev,
+      suggestions: []
+    }));
+  }, []);
+  const registerMarkdownComponents = useCallback3(
+    (components) => {
+      setState((prev) => {
+        const updatedComponents = {
+          ...prev.markdownComponents,
+          ...components
+        };
+        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"
+        );
+        const mergedUIMessages = sortUIMessagesByTime([
+          ...updatedUIMessages,
+          ...uiOnlyMessages
+        ]);
+        return {
+          ...prev,
+          markdownComponents: updatedComponents,
+          uiMessages: mergedUIMessages
+        };
+      });
+    },
+    []
+  );
+  const registerMarkdownExtensions = useCallback3(
+    (extensions) => {
+      setState((prev) => {
+        const updatedExtensions = {
+          ...prev.markdownExtensions,
+          ...extensions
+        };
+        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"
+        );
+        const mergedUIMessages = sortUIMessagesByTime([
+          ...updatedUIMessages,
+          ...uiOnlyMessages
+        ]);
+        return {
+          ...prev,
+          markdownExtensions: updatedExtensions,
+          uiMessages: mergedUIMessages
+        };
+      });
+    },
+    []
+  );
+  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"
+      );
+      return {
+        ...prev,
+        uiMessages: sortUIMessagesByTime([
+          ...updatedUIMessages,
+          ...uiOnlyMessages
+        ])
+      };
+    });
+  }, [registrations]);
+  const messageRenderer = useMemo3(
+    () => createMessageRenderer({
+      components: state.markdownComponents,
+      extensions: state.markdownExtensions
+    }),
+    [state.markdownComponents, state.markdownExtensions]
+  );
+  return {
+    // AgentUI props
+    messages: state.uiMessages,
+    isProcessing: state.isProcessing,
+    error: state.error,
+    onSubmit,
+    suggestions: state.suggestions,
+    messageRenderer,
+    // UI management methods
+    registerSuggestions,
+    clearSuggestions,
+    registerMarkdownComponents,
+    registerMarkdownExtensions,
+    // Message actions methods
+    registerMessageActions,
+    unregisterMessageActions,
+    clearAllMessageActions,
+    createFeedbackActions: createFeedbackActions2,
+    // Tool integration
+    addMessage
+  };
+}
+
+// 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 || {});
+export {
+  A2AErrorCodes,
+  BarChart,
+  ChartBlock,
+  LineChart,
+  createClient,
+  createFeedbackActions,
+  createMessageRenderer,
+  createRequestId,
+  createTaskId,
+  createTextMessage,
+  extractTextFromMessage,
+  extractToolCallsFromMessage,
+  getAgentManager,
+  useAgentChat,
+  useClientContext,
+  useClientTools,
+  useMessageActions
+};