@kuntur/a2a-carbon-chat-adapter 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2281 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+var AgentContext = react.createContext(null);
+function useAgentContext() {
+  const context = react.useContext(AgentContext);
+  if (!context) {
+    throw new Error("useAgentContext must be used within an AgentProvider");
+  }
+  return context;
+}
+function useAgentContextOptional() {
+  return react.useContext(AgentContext);
+}
+function AgentProvider({
+  children,
+  agent,
+  agents: agentsProp,
+  registry,
+  defaultAgentId,
+  persistSelection = false,
+  storageKey = "a2a-chat-selected-agent"
+}) {
+  const agents = react.useMemo(() => {
+    if (registry) {
+      return Object.values(registry.agents);
+    }
+    if (agentsProp) {
+      return agentsProp;
+    }
+    if (agent) {
+      return [agent];
+    }
+    return [];
+  }, [agent, agentsProp, registry]);
+  const getInitialAgentId = () => {
+    if (persistSelection && typeof window !== "undefined") {
+      const saved = localStorage.getItem(storageKey);
+      if (saved && agents.some((a) => a.id === saved)) {
+        return saved;
+      }
+    }
+    if (defaultAgentId && agents.some((a) => a.id === defaultAgentId)) {
+      return defaultAgentId;
+    }
+    if (registry?.defaultAgentId && agents.some((a) => a.id === registry.defaultAgentId)) {
+      return registry.defaultAgentId;
+    }
+    return agents[0]?.id ?? null;
+  };
+  const [currentAgentId, setCurrentAgentId] = react.useState(getInitialAgentId);
+  react.useEffect(() => {
+    if (persistSelection && currentAgentId && typeof window !== "undefined") {
+      localStorage.setItem(storageKey, currentAgentId);
+    }
+  }, [currentAgentId, persistSelection, storageKey]);
+  const currentAgent = react.useMemo(
+    () => agents.find((a) => a.id === currentAgentId) ?? null,
+    [agents, currentAgentId]
+  );
+  const selectAgent = react.useCallback(
+    (agentId) => {
+      if (agents.some((a) => a.id === agentId)) {
+        setCurrentAgentId(agentId);
+      } else {
+        console.warn(`[AgentProvider] Agent "${agentId}" not found in registry`);
+      }
+    },
+    [agents]
+  );
+  const getAgent = react.useCallback((agentId) => agents.find((a) => a.id === agentId), [agents]);
+  const hasAgent = react.useCallback((agentId) => agents.some((a) => a.id === agentId), [agents]);
+  const value = react.useMemo(
+    () => ({
+      currentAgent,
+      agents,
+      selectAgent,
+      getAgent,
+      hasAgent
+    }),
+    [currentAgent, agents, selectAgent, getAgent, hasAgent]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(AgentContext.Provider, { value, children });
+}
+
+// src/lib/a2a/extension-uris.ts
+var EXTENSION_URIS = {
+  // Service Extensions
+  LLM: "https://a2a-extensions.agentstack.beeai.dev/services/llm/v1",
+  EMBEDDING: "https://a2a-extensions.agentstack.beeai.dev/services/embedding/v1",
+  MCP: "https://a2a-extensions.agentstack.beeai.dev/services/mcp/v1",
+  OAUTH_PROVIDER: "https://a2a-extensions.agentstack.beeai.dev/services/oauth-provider/v1",
+  SECRETS: "https://a2a-extensions.agentstack.beeai.dev/services/secrets/v1",
+  PLATFORM_API: "https://a2a-extensions.agentstack.beeai.dev/services/platform-api/v1",
+  FORM_SERVICE: "https://a2a-extensions.agentstack.beeai.dev/services/form/v1",
+  // UI Extensions (Agent -> Platform)
+  CITATION: "https://a2a-extensions.agentstack.beeai.dev/ui/citation/v1",
+  TRAJECTORY: "https://a2a-extensions.agentstack.beeai.dev/ui/trajectory/v1",
+  ERROR: "https://a2a-extensions.agentstack.beeai.dev/ui/error/v1",
+  FORM_REQUEST: "https://a2a-extensions.agentstack.beeai.dev/ui/form-request/v1",
+  CANVAS: "https://a2a-extensions.agentstack.beeai.dev/ui/canvas/v1",
+  AGENT_DETAIL: "https://a2a-extensions.agentstack.beeai.dev/ui/agent-detail/v1",
+  OAUTH_REQUEST: "https://a2a-extensions.agentstack.beeai.dev/ui/oauth/v1",
+  SETTINGS: "https://a2a-extensions.agentstack.beeai.dev/ui/settings/v1"
+};
+
+// src/lib/a2a/extension-handler.ts
+function extractDemandsFromAgentCard(agentCard) {
+  const extensions = agentCard.extensions || [];
+  const demands = {
+    llmDemands: null,
+    embeddingDemands: null,
+    mcpDemands: null,
+    oauthDemands: null,
+    settingsDemands: null,
+    secretDemands: null,
+    formDemands: null
+  };
+  for (const extUri of extensions) {
+    const hashIndex = extUri.indexOf("#");
+    const uri = hashIndex >= 0 ? extUri.substring(0, hashIndex) : extUri;
+    const paramsStr = hashIndex >= 0 ? extUri.substring(hashIndex + 1) : null;
+    let params = {};
+    if (paramsStr) {
+      try {
+        params = JSON.parse(decodeURIComponent(paramsStr));
+      } catch {
+        console.warn(`Failed to parse extension params for ${uri}:`, paramsStr);
+      }
+    }
+    switch (uri) {
+      case EXTENSION_URIS.LLM:
+        demands.llmDemands = params;
+        break;
+      case EXTENSION_URIS.EMBEDDING:
+        demands.embeddingDemands = params;
+        break;
+      case EXTENSION_URIS.MCP:
+        demands.mcpDemands = params;
+        break;
+      case EXTENSION_URIS.OAUTH_PROVIDER:
+        demands.oauthDemands = params;
+        break;
+      case EXTENSION_URIS.SETTINGS:
+        demands.settingsDemands = params;
+        break;
+      case EXTENSION_URIS.SECRETS:
+        demands.secretDemands = params;
+        break;
+      case EXTENSION_URIS.FORM_SERVICE:
+        demands.formDemands = params;
+        break;
+    }
+  }
+  return demands;
+}
+function buildFulfillments(config) {
+  const fulfillments = {};
+  if (config.llm) {
+    const llmConfig = config.llm;
+    fulfillments.llm = async (demands) => {
+      const result = {};
+      for (const [key, demand] of Object.entries(demands.llm_demands)) {
+        const model = demand.suggested?.[0] || llmConfig.defaultModel;
+        result[key] = {
+          identifier: "custom_llm",
+          api_base: llmConfig.apiBase,
+          api_key: llmConfig.apiKey,
+          api_model: model
+        };
+      }
+      return { llm_fulfillments: result };
+    };
+  }
+  if (config.embedding) {
+    const embeddingConfig = config.embedding;
+    fulfillments.embedding = async (demands) => {
+      const result = {};
+      for (const [key, demand] of Object.entries(demands.embedding_demands)) {
+        const model = demand.suggested?.[0] || embeddingConfig.defaultModel;
+        result[key] = {
+          api_base: embeddingConfig.apiBase,
+          api_key: embeddingConfig.apiKey,
+          api_model: model
+        };
+      }
+      return { embedding_fulfillments: result };
+    };
+  }
+  if (config.mcp) {
+    const mcpConfig = config.mcp;
+    fulfillments.mcp = async (demands) => {
+      const result = {};
+      for (const [key, demand] of Object.entries(demands.mcp_demands)) {
+        const serverName = demand.suggested?.[0];
+        if (serverName && mcpConfig.servers[serverName]) {
+          result[key] = mcpConfig.servers[serverName];
+        }
+      }
+      return { mcp_fulfillments: result };
+    };
+  }
+  if (config.secrets) {
+    const secretsConfig = config.secrets;
+    fulfillments.secrets = async (demands) => {
+      const result = {};
+      for (const key of Object.keys(demands.secret_demands)) {
+        if (secretsConfig[key]) {
+          result[key] = { secret: secretsConfig[key] };
+        }
+      }
+      return { secret_fulfillments: result };
+    };
+  }
+  if (config.settings) {
+    const settingsConfig = config.settings;
+    fulfillments.settings = async (_demands) => {
+      return { values: settingsConfig };
+    };
+  }
+  if (config.oauth) {
+    const oauthConfig = config.oauth;
+    fulfillments.oauth = async (demands) => {
+      const result = {};
+      for (const key of Object.keys(demands.oauth_demands)) {
+        if (oauthConfig.providers[key]) {
+          result[key] = { access_token: oauthConfig.providers[key].accessToken };
+        }
+      }
+      return { oauth_fulfillments: result };
+    };
+    fulfillments.oauthRedirectUri = () => oauthConfig.redirectUri;
+  } else {
+    fulfillments.oauthRedirectUri = () => null;
+  }
+  fulfillments.form = async (_demands) => {
+    return { values: {} };
+  };
+  fulfillments.getContextToken = () => ({ token: "", expires_at: null });
+  return fulfillments;
+}
+async function resolveMetadata(demands, fulfillments) {
+  const metadata = {};
+  if (demands.llmDemands && fulfillments.llm) {
+    const llmFulfillment = await fulfillments.llm(demands.llmDemands);
+    metadata[EXTENSION_URIS.LLM] = llmFulfillment;
+  }
+  if (demands.embeddingDemands && fulfillments.embedding) {
+    const embeddingFulfillment = await fulfillments.embedding(demands.embeddingDemands);
+    metadata[EXTENSION_URIS.EMBEDDING] = embeddingFulfillment;
+  }
+  if (demands.mcpDemands && fulfillments.mcp) {
+    const mcpFulfillment = await fulfillments.mcp(demands.mcpDemands);
+    metadata[EXTENSION_URIS.MCP] = mcpFulfillment;
+  }
+  if (demands.oauthDemands && fulfillments.oauth) {
+    const oauthFulfillment = await fulfillments.oauth(demands.oauthDemands);
+    metadata[EXTENSION_URIS.OAUTH_PROVIDER] = oauthFulfillment;
+  }
+  if (demands.settingsDemands && fulfillments.settings) {
+    const settingsFulfillment = await fulfillments.settings(demands.settingsDemands);
+    metadata[EXTENSION_URIS.SETTINGS] = settingsFulfillment;
+  }
+  if (demands.secretDemands && fulfillments.secrets) {
+    const secretsFulfillment = await fulfillments.secrets(demands.secretDemands);
+    metadata[EXTENSION_URIS.SECRETS] = secretsFulfillment;
+  }
+  if (demands.formDemands && fulfillments.form) {
+    const formFulfillment = await fulfillments.form(demands.formDemands);
+    metadata[EXTENSION_URIS.FORM_SERVICE] = formFulfillment;
+  }
+  if (fulfillments.oauthRedirectUri) {
+    const redirectUri = fulfillments.oauthRedirectUri();
+    if (redirectUri) {
+      metadata[EXTENSION_URIS.OAUTH_REQUEST] = { redirect_uri: redirectUri };
+    }
+  }
+  if (fulfillments.getContextToken) {
+    const token = fulfillments.getContextToken();
+    if (token.token) {
+      metadata[EXTENSION_URIS.PLATFORM_API] = { context_token: token.token };
+    }
+  }
+  return metadata;
+}
+function handleAgentCard(agentCard) {
+  const demands = extractDemandsFromAgentCard(agentCard);
+  return {
+    demands,
+    resolveMetadata: (fulfillments) => resolveMetadata(demands, fulfillments)
+  };
+}
+
+// src/lib/a2a/client.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = (crypto.getRandomValues(new Uint8Array(1))[0] & 15) >> (c === "x" ? 0 : 3);
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+var A2AClient = class {
+  constructor(agentUrl, config = {}) {
+    this.agentCard = null;
+    this.platformConfig = null;
+    this.extractedDemands = null;
+    this.fulfillments = null;
+    this.baseUrl = agentUrl.replace(/\/$/, "");
+    this.jsonRpcUrl = `${this.baseUrl}/jsonrpc/`;
+    this.apiKey = config.apiKey || "";
+    this.extensions = config.extensions || {};
+    this.platformConfig = config.platformConfig || null;
+  }
+  /**
+   * Get configured extensions
+   */
+  getExtensions() {
+    return this.extensions;
+  }
+  /**
+   * Update extension configuration
+   */
+  setExtensions(extensions) {
+    this.extensions = extensions;
+  }
+  async initialize() {
+    const response = await fetch(this.baseUrl, {
+      method: "GET",
+      headers: {
+        "Accept": "application/json"
+      }
+    });
+    if (!response.ok) {
+      const fallbackUrl = `${this.baseUrl}/.well-known/agent-card.json`;
+      const fallbackResponse = await fetch(fallbackUrl, {
+        method: "GET",
+        headers: {
+          "Accept": "application/json"
+        }
+      });
+      if (!fallbackResponse.ok) {
+        throw new Error(`Failed to fetch agent card: ${response.status} ${response.statusText}`);
+      }
+      this.agentCard = await fallbackResponse.json();
+    } else {
+      this.agentCard = await response.json();
+    }
+    if (!this.agentCard?.name || !this.agentCard?.url) {
+      throw new Error("Invalid agent card: missing required fields");
+    }
+    this.extractedDemands = extractDemandsFromAgentCard(this.agentCard);
+    if (this.platformConfig) {
+      this.fulfillments = buildFulfillments(this.platformConfig);
+    }
+    return this.agentCard;
+  }
+  getAgentCard() {
+    return this.agentCard;
+  }
+  getJsonRpcUrl() {
+    return this.jsonRpcUrl;
+  }
+  /**
+   * Get resolved metadata for A2A requests
+   * Call this after initialize() to get metadata that fulfills agent demands
+   */
+  async getResolvedMetadata() {
+    if (!this.extractedDemands) {
+      return {};
+    }
+    if (!this.fulfillments) {
+      console.warn("No fulfillments configured. Agent may fall back to defaults.");
+      return {};
+    }
+    return resolveMetadata(this.extractedDemands, this.fulfillments);
+  }
+  /**
+   * Get extracted demands from agent card
+   */
+  getExtractedDemands() {
+    return this.extractedDemands;
+  }
+  /**
+   * Update platform configuration after initialization
+   */
+  setPlatformConfig(config) {
+    this.platformConfig = config;
+    this.fulfillments = buildFulfillments(config);
+  }
+  /**
+   * Get current platform configuration
+   */
+  getPlatformConfig() {
+    return this.platformConfig;
+  }
+  /**
+   * Build the base params object for A2A requests
+   */
+  async buildRequestParams(message) {
+    const resolvedMetadata = await this.getResolvedMetadata();
+    const params = {
+      message: {
+        role: "user",
+        messageId: generateUUID(),
+        parts: [{ kind: "text", text: message }]
+      }
+    };
+    if (Object.keys(this.extensions).length > 0) {
+      params.extensions = this.extensions;
+    }
+    const hasResolvedMetadata = Object.keys(resolvedMetadata).length > 0;
+    if (hasResolvedMetadata) {
+      params.metadata = {
+        ...resolvedMetadata,
+        ...params.extensions || {}
+      };
+    }
+    return params;
+  }
+  async sendMessage(message) {
+    const params = await this.buildRequestParams(message);
+    const payload = {
+      jsonrpc: "2.0",
+      method: "message/send",
+      params,
+      id: generateUUID()
+    };
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const response = await fetch(this.jsonRpcUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`Request failed: ${response.status} ${response.statusText}`);
+    }
+    const result = await response.json();
+    if (result.error) {
+      const error = result.error;
+      throw new Error(`Agent error: ${error.message} (code: ${error.code})`);
+    }
+    return result.result;
+  }
+  async streamMessage(message, onChunk, onComplete) {
+    const params = await this.buildRequestParams(message);
+    const payload = {
+      jsonrpc: "2.0",
+      method: "message/stream",
+      params,
+      id: generateUUID()
+    };
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "text/event-stream"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const response = await fetch(this.jsonRpcUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`Stream request failed: ${response.status} ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmedLine = line.trim();
+          if (trimmedLine.startsWith("data: ")) {
+            const dataStr = trimmedLine.slice(6);
+            if (!dataStr || dataStr === "[DONE]") continue;
+            try {
+              const data = JSON.parse(dataStr);
+              if (data.error) {
+                const error = data.error;
+                throw new Error(`Stream error: ${error.message} (code: ${error.code})`);
+              }
+              if (data.result) {
+                const chunk = data.result;
+                await onChunk(chunk);
+                if (chunk.final === true && onComplete) {
+                  await onComplete();
+                }
+              }
+            } catch (parseError) {
+              if (parseError instanceof SyntaxError) {
+                console.warn("Failed to parse SSE data:", dataStr);
+              } else {
+                throw parseError;
+              }
+            }
+          }
+        }
+      }
+      if (buffer.trim().startsWith("data: ")) {
+        const dataStr = buffer.trim().slice(6);
+        if (dataStr && dataStr !== "[DONE]") {
+          try {
+            const data = JSON.parse(dataStr);
+            if (data.result) {
+              const chunk = data.result;
+              await onChunk(chunk);
+              if (chunk.final === true && onComplete) {
+                await onComplete();
+              }
+            }
+          } catch (e) {
+            console.warn("Failed to parse final SSE data:", dataStr);
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/lib/a2a/ui-extension-parser.ts
+function parseUIExtensions(metadata) {
+  if (!metadata) return {};
+  const result = {};
+  const citationData = metadata[EXTENSION_URIS.CITATION];
+  if (citationData && typeof citationData === "object") {
+    result.citations = citationData;
+  }
+  const trajectoryData = metadata[EXTENSION_URIS.TRAJECTORY];
+  if (trajectoryData && typeof trajectoryData === "object") {
+    result.trajectory = trajectoryData;
+  }
+  const errorData = metadata[EXTENSION_URIS.ERROR];
+  if (errorData && typeof errorData === "object") {
+    result.error = errorData;
+  }
+  const formData = metadata[EXTENSION_URIS.FORM_REQUEST];
+  if (formData && typeof formData === "object") {
+    result.formRequest = formData;
+  }
+  const canvasData = metadata[EXTENSION_URIS.CANVAS];
+  if (canvasData && typeof canvasData === "object") {
+    result.canvas = canvasData;
+  }
+  const agentDetailData = metadata[EXTENSION_URIS.AGENT_DETAIL];
+  if (agentDetailData && typeof agentDetailData === "object") {
+    result.agentDetail = agentDetailData;
+  }
+  return result;
+}
+function extractCitations(metadata) {
+  const parsed = parseUIExtensions(metadata);
+  return parsed.citations?.citations || [];
+}
+function extractTrajectory(metadata) {
+  const parsed = parseUIExtensions(metadata);
+  return parsed.trajectory || null;
+}
+function extractError(metadata) {
+  const parsed = parseUIExtensions(metadata);
+  return parsed.error || null;
+}
+function extractFormRequest(metadata) {
+  const parsed = parseUIExtensions(metadata);
+  return parsed.formRequest || null;
+}
+
+// src/lib/translator/a2a-to-carbon.ts
+var MessageResponseTypes = {
+  TEXT: "text",
+  USER_DEFINED: "user_defined",
+  INLINE_ERROR: "inline_error",
+  OPTION: "option"
+};
+var ChainOfThoughtStepStatus = /* @__PURE__ */ ((ChainOfThoughtStepStatus2) => {
+  ChainOfThoughtStepStatus2["IN_PROGRESS"] = "in_progress";
+  ChainOfThoughtStepStatus2["SUCCESS"] = "success";
+  ChainOfThoughtStepStatus2["ERROR"] = "error";
+  return ChainOfThoughtStepStatus2;
+})(ChainOfThoughtStepStatus || {});
+var ReasoningStepOpenState = /* @__PURE__ */ ((ReasoningStepOpenState2) => {
+  ReasoningStepOpenState2["OPEN"] = "open";
+  ReasoningStepOpenState2["CLOSE"] = "close";
+  ReasoningStepOpenState2["DEFAULT"] = "default";
+  return ReasoningStepOpenState2;
+})(ReasoningStepOpenState || {});
+var UserType = /* @__PURE__ */ ((UserType2) => {
+  UserType2["HUMAN"] = "human";
+  UserType2["BOT"] = "bot";
+  UserType2["WATSONX"] = "watsonx";
+  return UserType2;
+})(UserType || {});
+var A2AToCarbonTranslator = class {
+  constructor(agentProfile) {
+    this.agentProfile = {
+      id: agentProfile?.id || "a2a-agent",
+      nickname: agentProfile?.nickname || "AI Assistant",
+      user_type: agentProfile?.user_type || "bot" /* BOT */,
+      profile_picture_url: agentProfile?.profile_picture_url
+    };
+    this.state = this.createInitialState();
+  }
+  /**
+   * Create initial translator state
+   */
+  createInitialState() {
+    return {
+      responseId: this.generateResponseId(),
+      itemId: "1",
+      accumulatedText: "",
+      reasoningSteps: [],
+      chainOfThought: [],
+      pendingToolCalls: /* @__PURE__ */ new Map(),
+      hasStartedStreaming: false,
+      shellMessageSent: false
+    };
+  }
+  /**
+   * Generate unique response ID
+   */
+  generateResponseId() {
+    return `response-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+  /**
+   * Reset state for new message
+   */
+  reset() {
+    this.state = this.createInitialState();
+  }
+  /**
+   * Get current response ID
+   */
+  getResponseId() {
+    return this.state.responseId;
+  }
+  /**
+   * Get current item ID
+   */
+  getItemId() {
+    return this.state.itemId;
+  }
+  /**
+   * Update agent profile
+   */
+  setAgentProfile(profile) {
+    this.agentProfile = { ...this.agentProfile, ...profile };
+  }
+  /**
+   * Get current agent profile
+   */
+  getAgentProfile() {
+    return this.agentProfile;
+  }
+  /**
+   * Check if shell message has been sent
+   */
+  hasShellBeenSent() {
+    return this.state.shellMessageSent;
+  }
+  /**
+   * Mark shell message as sent
+   */
+  markShellSent() {
+    this.state.shellMessageSent = true;
+  }
+  /**
+   * Get accumulated text
+   */
+  getAccumulatedText() {
+    return this.state.accumulatedText;
+  }
+  /**
+   * Get current reasoning steps
+   */
+  getReasoningSteps() {
+    return [...this.state.reasoningSteps];
+  }
+  /**
+   * Get current chain of thought
+   */
+  getChainOfThought() {
+    return [...this.state.chainOfThought];
+  }
+  /**
+   * Check if streaming has started
+   */
+  hasStartedStreaming() {
+    return this.state.hasStartedStreaming;
+  }
+  /**
+   * Get current state (for debugging/inspection)
+   */
+  getState() {
+    return { ...this.state };
+  }
+  // ===========================================================================
+  // SHELL MESSAGE CREATION
+  // ===========================================================================
+  /**
+   * Create shell message to initialize Carbon's reducer
+   *
+   * IMPORTANT: This MUST be called before sending any other chunks.
+   * It seeds the message shell so reducers create the container before
+   * reasoning steps or text stream in.
+   */
+  createShellMessage(includeReasoning = true) {
+    this.state.shellMessageSent = true;
+    const chunk = {
+      partial_item: {
+        response_type: MessageResponseTypes.TEXT,
+        text: "",
+        streaming_metadata: {
+          id: this.state.itemId
+        }
+      },
+      partial_response: {
+        message_options: {
+          response_user_profile: this.agentProfile
+        }
+      },
+      streaming_metadata: {
+        response_id: this.state.responseId
+      }
+    };
+    if (includeReasoning) {
+      chunk.partial_response.message_options.reasoning = { steps: [] };
+    }
+    return chunk;
+  }
+  // ===========================================================================
+  // A2A PART TRANSLATION
+  // ===========================================================================
+  /**
+   * Translate a single streaming A2A part to a legacy Carbon message
+   * Used for real-time streaming updates (backward compatibility with EnhancedChatWrapper)
+   * @param part The A2A part to translate
+   * @param metadata Optional extension metadata from the artifact
+   */
+  translateStreamingPart(part, metadata) {
+    const contentType = part.metadata?.content_type;
+    if ((contentType === "thinking" || contentType === "reasoning_step") && part.kind === "text" && part.text) {
+      return {
+        response_type: "reasoning_steps",
+        reasoning_steps: {
+          steps: [{ content: part.text }],
+          openState: "closed"
+        },
+        metadata
+      };
+    }
+    if (part.kind === "data" && part.data) {
+      const dataType = part.data.type;
+      if (dataType === "tool_call") {
+        const toolData = part.data;
+        return {
+          response_type: "chain_of_thought",
+          chain_of_thought: {
+            steps: [{
+              title: toolData.tool_name || "Tool Call",
+              description: `Calling ${toolData.tool_name || "tool"}`,
+              tool_name: toolData.tool_name,
+              request: { args: toolData.args },
+              status: "in_progress" /* IN_PROGRESS */
+            }]
+          },
+          metadata
+        };
+      }
+      if (dataType === "tool_result") {
+        const resultData = part.data;
+        return {
+          response_type: "chain_of_thought",
+          chain_of_thought: {
+            steps: [{
+              title: resultData.tool_name || "Tool Result",
+              description: `Result from ${resultData.tool_name || "tool"}`,
+              tool_name: resultData.tool_name,
+              response: { content: resultData.result_preview },
+              status: resultData.success === false ? "error" /* ERROR */ : "success" /* SUCCESS */
+            }]
+          },
+          metadata
+        };
+      }
+    }
+    if (part.kind === "text" && part.text) {
+      return {
+        response_type: "text",
+        text: part.text,
+        metadata
+      };
+    }
+    if (part.kind === "file" && part.file) {
+      return {
+        response_type: "user_defined",
+        user_defined: {
+          type: "file_attachment",
+          fileName: part.file.name,
+          mimeType: part.file.mimeType,
+          downloadUrl: part.file.uri || `data:${part.file.mimeType};base64,${part.file.bytes}`
+        },
+        metadata
+      };
+    }
+    return null;
+  }
+  /**
+   * Translate an A2A message part to Carbon format
+   *
+   * @param part - The A2A message part to translate
+   * @param artifactMetadata - Optional metadata from artifact level
+   * @returns Carbon stream chunk or null if no action needed
+   */
+  translatePart(part, artifactMetadata) {
+    const contentType = part.metadata?.content_type;
+    if ((contentType === "thinking" || contentType === "reasoning_step") && part.kind === "text" && part.text) {
+      return this.translateThinkingPart(part.text, part.metadata);
+    }
+    const partExtensions = parseUIExtensions(part.metadata);
+    if (partExtensions.trajectory) {
+      return this.translateTrajectoryPart(partExtensions.trajectory);
+    }
+    if (part.kind === "data" && part.data) {
+      const dataType = part.data.type;
+      if (dataType === "tool_call") {
+        return this.translateToolCallPart(part.data);
+      }
+      if (dataType === "tool_result") {
+        return this.translateToolResultPart(part.data);
+      }
+    }
+    if (part.kind === "text" && part.text) {
+      if (contentType === "thinking" || contentType === "reasoning_step") {
+        return null;
+      }
+      return this.translateTextPart(part.text, artifactMetadata);
+    }
+    if (part.kind === "file" && part.file) {
+      return this.translateFilePart(part.file);
+    }
+    return null;
+  }
+  /**
+   * Translate thinking/reasoning content to Carbon reasoning step
+   */
+  translateThinkingPart(text, metadata) {
+    const stepNumber = metadata?.step;
+    const stepTitle = metadata?.title;
+    const newStep = {
+      title: stepTitle || `Thinking Step ${(stepNumber ?? this.state.reasoningSteps.length) + 1}`,
+      content: text,
+      open_state: "default" /* DEFAULT */
+    };
+    this.state.reasoningSteps.push(newStep);
+    return {
+      partial_item: {
+        response_type: MessageResponseTypes.TEXT,
+        text: "",
+        streaming_metadata: {
+          id: this.state.itemId,
+          cancellable: true
+        }
+      },
+      partial_response: {
+        message_options: {
+          response_user_profile: this.agentProfile,
+          reasoning: {
+            steps: this.state.reasoningSteps,
+            open_state: "default" /* DEFAULT */
+            // Auto-expand during streaming
+          }
+        }
+      },
+      streaming_metadata: {
+        response_id: this.state.responseId
+      }
+    };
+  }
+  /**
+   * Translate trajectory extension to Carbon reasoning step
+   */
+  translateTrajectoryPart(trajectory) {
+    const newStep = {
+      title: trajectory.title || "Processing",
+      content: trajectory.content || "",
+      open_state: "default" /* DEFAULT */
+    };
+    this.state.reasoningSteps.push(newStep);
+    return {
+      partial_item: {
+        response_type: MessageResponseTypes.TEXT,
+        text: "",
+        streaming_metadata: {
+          id: this.state.itemId,
+          cancellable: true
+        }
+      },
+      partial_response: {
+        message_options: {
+          response_user_profile: this.agentProfile,
+          reasoning: {
+            steps: this.state.reasoningSteps,
+            open_state: "default" /* DEFAULT */
+            // Auto-expand during streaming
+          }
+        }
+      },
+      streaming_metadata: {
+        response_id: this.state.responseId
+      }
+    };
+  }
+  /**
+   * Translate tool call to Carbon chain of thought (IN_PROGRESS)
+   */
+  translateToolCallPart(toolData) {
+    const toolName = toolData.tool_name || "tool";
+    const cotStep = {
+      title: toolName,
+      description: `Calling ${toolName}`,
+      tool_name: toolName,
+      request: { args: toolData.args },
+      status: "in_progress" /* IN_PROGRESS */
+    };
+    const index = this.state.chainOfThought.length;
+    this.state.chainOfThought.push(cotStep);
+    this.state.pendingToolCalls.set(toolName, index);
+    return {
+      partial_item: {
+        response_type: MessageResponseTypes.TEXT,
+        text: "",
+        streaming_metadata: {
+          id: this.state.itemId,
+          cancellable: true
+        }
+      },
+      partial_response: {
+        message_options: {
+          response_user_profile: this.agentProfile,
+          chain_of_thought: this.state.chainOfThought
+        }
+      },
+      streaming_metadata: {
+        response_id: this.state.responseId
+      }
+    };
+  }
+  /**
+   * Translate tool result to Carbon chain of thought (SUCCESS/ERROR)
+   */
+  translateToolResultPart(resultData) {
+    const toolName = resultData.tool_name || "tool";
+    const index = this.state.pendingToolCalls.get(toolName);
+    if (index !== void 0 && index < this.state.chainOfThought.length) {
+      this.state.chainOfThought[index] = {
+        ...this.state.chainOfThought[index],
+        response: { content: resultData.result_preview },
+        status: resultData.success === false ? "error" /* ERROR */ : "success" /* SUCCESS */
+      };
+      this.state.pendingToolCalls.delete(toolName);
+    } else {
+      const cotStep = {
+        title: toolName,
+        description: `Result from ${toolName}`,
+        tool_name: toolName,
+        response: { content: resultData.result_preview },
+        status: resultData.success === false ? "error" /* ERROR */ : "success" /* SUCCESS */
+      };
+      this.state.chainOfThought.push(cotStep);
+    }
+    return {
+      partial_item: {
+        response_type: MessageResponseTypes.TEXT,
+        text: "",
+        streaming_metadata: {
+          id: this.state.itemId,
+          cancellable: true
+        }
+      },
+      partial_response: {
+        message_options: {
+          response_user_profile: this.agentProfile,
+          chain_of_thought: this.state.chainOfThought
+        }
+      },
+      streaming_metadata: {
+        response_id: this.state.responseId
+      }
+    };
+  }
+  /**
+   * Translate text part to Carbon partial item
+   */
+  translateTextPart(text, _artifactMetadata) {
+    this.state.accumulatedText += text;
+    this.state.hasStartedStreaming = true;
+    return {
+      partial_item: {
+        response_type: MessageResponseTypes.TEXT,
+        text,
+        // Send just the new text chunk
+        streaming_metadata: {
+          id: this.state.itemId,
+          cancellable: true
+        }
+      },
+      partial_response: {
+        message_options: {
+          response_user_profile: this.agentProfile
+        }
+      },
+      streaming_metadata: {
+        response_id: this.state.responseId
+      }
+    };
+  }
+  /**
+   * Translate file part to Carbon user defined item
+   */
+  translateFilePart(file) {
+    return {
+      partial_item: {
+        response_type: MessageResponseTypes.USER_DEFINED,
+        user_defined: {
+          type: "file_attachment",
+          fileName: file.name,
+          mimeType: file.mimeType,
+          downloadUrl: file.uri || `data:${file.mimeType};base64,${file.bytes}`
+        },
+        streaming_metadata: {
+          id: `file-${Date.now()}`
+        }
+      },
+      streaming_metadata: {
+        response_id: this.state.responseId
+      }
+    };
+  }
+  // ===========================================================================
+  // COMPLETE AND FINAL RESPONSE
+  // ===========================================================================
+  /**
+   * Create complete item chunk
+   *
+   * Call this to finalize a specific item while other items may still be streaming.
+   * Optional but useful for accessibility and corrections.
+   */
+  createCompleteItem(wasStopped = false) {
+    return {
+      complete_item: {
+        response_type: MessageResponseTypes.TEXT,
+        text: this.state.accumulatedText,
+        streaming_metadata: {
+          id: this.state.itemId,
+          stream_stopped: wasStopped
+        }
+      },
+      partial_response: {
+        message_options: {
+          response_user_profile: this.agentProfile,
+          reasoning: this.state.reasoningSteps.length > 0 ? {
+            steps: this.state.reasoningSteps,
+            open_state: "close" /* CLOSE */
+            // Collapse after completion
+          } : void 0,
+          chain_of_thought: this.state.chainOfThought.length > 0 ? this.state.chainOfThought : void 0
+        }
+      },
+      streaming_metadata: {
+        response_id: this.state.responseId
+      }
+    };
+  }
+  /**
+   * Create final response chunk
+   *
+   * CRITICAL: This MUST be called to end streaming and clear the typing indicator.
+   * Without this, the UI will remain in a loading state.
+   */
+  createFinalResponse() {
+    return {
+      final_response: {
+        id: this.state.responseId,
+        output: {
+          generic: [
+            {
+              response_type: MessageResponseTypes.TEXT,
+              text: this.state.accumulatedText,
+              streaming_metadata: {
+                id: this.state.itemId
+              }
+            }
+          ]
+        },
+        message_options: {
+          response_user_profile: this.agentProfile,
+          reasoning: this.state.reasoningSteps.length > 0 ? {
+            steps: this.state.reasoningSteps,
+            open_state: "close" /* CLOSE */
+            // Collapse after completion
+          } : void 0,
+          chain_of_thought: this.state.chainOfThought.length > 0 ? this.state.chainOfThought : void 0
+        }
+      }
+    };
+  }
+  /**
+   * Create error response
+   */
+  createErrorResponse(errorMessage) {
+    return {
+      final_response: {
+        id: this.state.responseId,
+        output: {
+          generic: [
+            {
+              response_type: MessageResponseTypes.TEXT,
+              text: errorMessage,
+              streaming_metadata: {
+                id: this.state.itemId
+              }
+            }
+          ]
+        },
+        message_options: {
+          response_user_profile: this.agentProfile
+        }
+      }
+    };
+  }
+  // ===========================================================================
+  // CITATION HANDLING
+  // ===========================================================================
+  /**
+   * Create citations message
+   *
+   * Call this after the main response to add a sources list.
+   */
+  createCitationsMessage(citations) {
+    return {
+      output: {
+        generic: [
+          {
+            response_type: MessageResponseTypes.USER_DEFINED,
+            user_defined: {
+              type: "sources_list",
+              citations
+            }
+          }
+        ]
+      },
+      message_options: {
+        response_user_profile: this.agentProfile
+      }
+    };
+  }
+  // ===========================================================================
+  // FULL A2A STREAM CHUNK TRANSLATION
+  // ===========================================================================
+  /**
+   * Translate a complete A2A stream chunk to Carbon format
+   *
+   * This is the main entry point for processing A2A SSE events.
+   * Returns an array of Carbon chunks since one A2A event may produce
+   * multiple Carbon updates (e.g., multiple parts in a message).
+   */
+  translateStreamChunk(chunk) {
+    const results = [];
+    if (!this.state.shellMessageSent) {
+      results.push(this.createShellMessage());
+    }
+    if (chunk.kind === "status-update" && chunk.status?.message) {
+      const message = chunk.status.message;
+      for (const part of message.parts) {
+        const carbonChunk = this.translatePart(
+          part,
+          message.metadata
+        );
+        if (carbonChunk) {
+          results.push(carbonChunk);
+        }
+      }
+    }
+    if (chunk.kind === "artifact-update" && chunk.artifact?.parts) {
+      for (const part of chunk.artifact.parts) {
+        const carbonChunk = this.translatePart(
+          part,
+          chunk.artifact.metadata
+        );
+        if (carbonChunk) {
+          results.push(carbonChunk);
+        }
+      }
+    }
+    if (chunk.final === true || chunk.status?.state === "completed") {
+      results.push(this.createFinalResponse());
+    }
+    return results;
+  }
+};
+function createTranslator(agentName, agentIconUrl) {
+  return new A2AToCarbonTranslator({
+    nickname: agentName,
+    profile_picture_url: agentIconUrl
+  });
+}
+function isFinalResponse(chunk) {
+  return "final_response" in chunk;
+}
+function isPartialItem(chunk) {
+  return "partial_item" in chunk;
+}
+function isCompleteItem(chunk) {
+  return "complete_item" in chunk;
+}
+
+// src/components/renderers/citation-utils.ts
+function generateCitationId() {
+  return `cite-${Math.random().toString(36).substring(2, 9)}`;
+}
+function processCitations(text, citations) {
+  const sortedCitations = [...citations].filter((c) => c.start_index != null && c.end_index != null).sort((a, b) => (a.start_index ?? 0) - (b.start_index ?? 0));
+  return sortedCitations.map((citation, index) => ({
+    ...citation,
+    id: generateCitationId(),
+    number: index + 1,
+    highlightedText: text.substring(citation.start_index ?? 0, citation.end_index ?? text.length)
+  }));
+}
+function segmentTextWithCitations(text, citations) {
+  const processedCitations = processCitations(text, citations);
+  if (processedCitations.length === 0) {
+    return [{ text, isCited: false }];
+  }
+  const segments = [];
+  let currentIndex = 0;
+  for (const citation of processedCitations) {
+    const startIndex = citation.start_index ?? 0;
+    const endIndex = citation.end_index ?? text.length;
+    if (currentIndex < startIndex) {
+      segments.push({
+        text: text.substring(currentIndex, startIndex),
+        isCited: false
+      });
+    }
+    segments.push({
+      text: text.substring(startIndex, endIndex),
+      citation,
+      isCited: true
+    });
+    currentIndex = endIndex;
+  }
+  if (currentIndex < text.length) {
+    segments.push({
+      text: text.substring(currentIndex),
+      isCited: false
+    });
+  }
+  return segments;
+}
+function getUniqueCitations(citations) {
+  const seen = /* @__PURE__ */ new Set();
+  return citations.filter((citation) => {
+    if (!citation.url || seen.has(citation.url)) {
+      return false;
+    }
+    seen.add(citation.url);
+    return true;
+  });
+}
+var CitationTooltip = ({ citation, position }) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: "fixed z-50 max-w-xs p-3 bg-gray-900 text-white rounded-lg shadow-lg text-sm",
+      style: {
+        left: position.x,
+        top: position.y + 20,
+        transform: "translateX(-50%)"
+      },
+      children: [
+        citation.title && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "font-semibold mb-1", children: citation.title }),
+        citation.description && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-gray-300 text-xs mb-2", children: citation.description }),
+        citation.url && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-blue-300 text-xs truncate", children: citation.url }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute -top-2 left-1/2 transform -translate-x-1/2 border-8 border-transparent border-b-gray-900" })
+      ]
+    }
+  );
+};
+var CitationHighlight = ({ segment, onHover }) => {
+  if (!segment.isCited || !segment.citation) {
+    return /* @__PURE__ */ jsxRuntime.jsx("span", { children: segment.text });
+  }
+  const handleMouseEnter = (e) => {
+    onHover(segment.citation, e);
+  };
+  const handleMouseLeave = () => {
+    onHover(null, {});
+  };
+  const handleClick = () => {
+    if (segment.citation?.url) {
+      window.open(segment.citation.url, "_blank", "noopener,noreferrer");
+    }
+  };
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" || e.key === " ") {
+      e.preventDefault();
+      handleClick();
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "span",
+    {
+      className: "bg-blue-100 dark:bg-blue-900/30 text-blue-800 dark:text-blue-200 cursor-pointer hover:bg-blue-200 dark:hover:bg-blue-800/40 transition-colors rounded px-0.5",
+      onMouseEnter: handleMouseEnter,
+      onMouseLeave: handleMouseLeave,
+      onClick: handleClick,
+      onKeyDown: handleKeyDown,
+      role: "button",
+      tabIndex: 0,
+      "aria-label": `Citation ${segment.citation.number}: ${segment.citation.title || "Source"}`,
+      children: [
+        segment.text,
+        /* @__PURE__ */ jsxRuntime.jsxs("sup", { className: "text-xs font-semibold ml-0.5", children: [
+          "[",
+          segment.citation.number,
+          "]"
+        ] })
+      ]
+    }
+  );
+};
+var SourcesList = ({ citations }) => {
+  const uniqueCitations = getUniqueCitations(citations);
+  if (uniqueCitations.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mt-4 pt-4 border-t border-gray-200 dark:border-gray-700", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("h4", { className: "text-sm font-semibold text-gray-600 dark:text-gray-400 mb-2", children: "Sources" }),
+    /* @__PURE__ */ jsxRuntime.jsx("ol", { className: "list-decimal list-inside space-y-1", children: uniqueCitations.map((citation) => /* @__PURE__ */ jsxRuntime.jsxs("li", { className: "text-sm", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "a",
+        {
+          href: citation.url || "#",
+          target: "_blank",
+          rel: "noopener noreferrer",
+          className: "text-blue-600 dark:text-blue-400 hover:underline",
+          children: citation.title || citation.url || `Source ${citation.number}`
+        }
+      ),
+      citation.description && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-gray-500 dark:text-gray-400 ml-2", children: [
+        "\u2014 ",
+        citation.description
+      ] })
+    ] }, citation.id)) })
+  ] });
+};
+var CitationRenderer = ({ text, citations, className = "" }) => {
+  const [hoveredCitation, setHoveredCitation] = react.useState(null);
+  const [tooltipPosition, setTooltipPosition] = react.useState({ x: 0, y: 0 });
+  const segments = segmentTextWithCitations(text, citations);
+  const processedCitations = processCitations(text, citations);
+  const handleHover = react.useCallback((citation, event) => {
+    setHoveredCitation(citation);
+    if (citation && event.currentTarget) {
+      const rect = event.currentTarget.getBoundingClientRect();
+      setTooltipPosition({
+        x: rect.left + rect.width / 2,
+        y: rect.bottom
+      });
+    }
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `relative ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "prose dark:prose-invert max-w-none", children: segments.map((segment, index) => /* @__PURE__ */ jsxRuntime.jsx(CitationHighlight, { segment, onHover: handleHover }, index)) }),
+    hoveredCitation && /* @__PURE__ */ jsxRuntime.jsx(CitationTooltip, { citation: hoveredCitation, position: tooltipPosition }),
+    /* @__PURE__ */ jsxRuntime.jsx(SourcesList, { citations: processedCitations })
+  ] });
+};
+var ErrorRenderer = ({ error, className = "" }) => {
+  const [showDetails, setShowDetails] = react.useState(false);
+  const hasDetails = error.stacktrace || error.context;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `border border-red-200 bg-red-50 dark:bg-red-900/20 dark:border-red-800 rounded-lg p-4 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-start gap-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-shrink-0 text-red-500 dark:text-red-400", children: /* @__PURE__ */ jsxRuntime.jsx("svg", { className: "w-5 h-5", fill: "currentColor", viewBox: "0 0 20 20", children: /* @__PURE__ */ jsxRuntime.jsx(
+        "path",
+        {
+          fillRule: "evenodd",
+          d: "M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z",
+          clipRule: "evenodd"
+        }
+      ) }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-1", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("h4", { className: "text-sm font-semibold text-red-800 dark:text-red-200", children: error.code ? `Error: ${error.code}` : "Error" }),
+          hasDetails && /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              onClick: () => setShowDetails(!showDetails),
+              className: "text-xs text-red-600 dark:text-red-400 hover:underline",
+              children: showDetails ? "Hide details" : "Show details"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "mt-1 text-sm text-red-700 dark:text-red-300", children: error.message })
+      ] })
+    ] }),
+    hasDetails && showDetails && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mt-4 pt-4 border-t border-red-200 dark:border-red-800", children: [
+      error.stacktrace && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mb-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("h5", { className: "text-xs font-semibold text-red-600 dark:text-red-400 mb-1", children: "Stack Trace" }),
+        /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "text-xs bg-red-100 dark:bg-red-900/40 p-3 rounded overflow-x-auto text-red-800 dark:text-red-200", children: error.stacktrace })
+      ] }),
+      error.context && /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("h5", { className: "text-xs font-semibold text-red-600 dark:text-red-400 mb-1", children: "Context" }),
+        /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "text-xs bg-red-100 dark:bg-red-900/40 p-3 rounded overflow-x-auto text-red-800 dark:text-red-200", children: JSON.stringify(error.context, null, 2) })
+      ] })
+    ] })
+  ] });
+};
+var FormFieldRenderer = ({ field, value, onChange }) => {
+  const handleChange = react.useCallback(
+    (newValue) => {
+      onChange(field.id, newValue);
+    },
+    [field.id, onChange]
+  );
+  const baseInputClasses = "w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-md bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:ring-2 focus:ring-blue-500 focus:border-blue-500 outline-none";
+  switch (field.type) {
+    case "text":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "text",
+          id: field.id,
+          value: value || "",
+          onChange: (e) => handleChange(e.target.value),
+          placeholder: field.description,
+          required: field.required,
+          className: baseInputClasses
+        }
+      );
+    case "date":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "date",
+          id: field.id,
+          value: value || "",
+          onChange: (e) => handleChange(e.target.value),
+          required: field.required,
+          className: baseInputClasses
+        }
+      );
+    case "file":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "file",
+          id: field.id,
+          onChange: (e) => {
+            const file = e.target.files?.[0];
+            if (file) {
+              const reader = new FileReader();
+              reader.onload = () => {
+                handleChange({
+                  name: file.name,
+                  type: file.type,
+                  size: file.size,
+                  data: reader.result
+                });
+              };
+              reader.readAsDataURL(file);
+            }
+          },
+          required: field.required,
+          className: baseInputClasses
+        }
+      );
+    case "single_select":
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        "select",
+        {
+          id: field.id,
+          value: value || "",
+          onChange: (e) => handleChange(e.target.value),
+          required: field.required,
+          className: baseInputClasses,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: "Select..." }),
+            field.options?.map((option) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: option.value, children: option.label }, option.value))
+          ]
+        }
+      );
+    case "multi_select":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "select",
+        {
+          id: field.id,
+          multiple: true,
+          value: value || [],
+          onChange: (e) => {
+            const selected = Array.from(e.target.selectedOptions, (option) => option.value);
+            handleChange(selected);
+          },
+          required: field.required,
+          className: `${baseInputClasses} min-h-[100px]`,
+          children: field.options?.map((option) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: option.value, children: option.label }, option.value))
+        }
+      );
+    case "checkbox":
+      return /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "flex items-center gap-2 cursor-pointer", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            type: "checkbox",
+            id: field.id,
+            checked: Boolean(value),
+            onChange: (e) => handleChange(e.target.checked),
+            required: field.required,
+            className: "w-4 h-4 text-blue-600 border-gray-300 rounded focus:ring-blue-500"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-gray-700 dark:text-gray-300", children: field.description })
+      ] });
+    case "checkbox_group":
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-2", children: field.options?.map((option) => {
+        const selectedValues = value || [];
+        const isChecked = selectedValues.includes(option.value);
+        return /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "flex items-center gap-2 cursor-pointer", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              type: "checkbox",
+              checked: isChecked,
+              onChange: (e) => {
+                const newValues = e.target.checked ? [...selectedValues, option.value] : selectedValues.filter((v) => v !== option.value);
+                handleChange(newValues);
+              },
+              className: "w-4 h-4 text-blue-600 border-gray-300 rounded focus:ring-blue-500"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-gray-700 dark:text-gray-300", children: option.label })
+        ] }, option.value);
+      }) });
+    default:
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "text",
+          id: field.id,
+          value: value || "",
+          onChange: (e) => handleChange(e.target.value),
+          className: baseInputClasses
+        }
+      );
+  }
+};
+var FormRenderer = ({ form, onSubmit, onCancel, className = "" }) => {
+  const [values, setValues] = react.useState(() => {
+    const initial = {};
+    form.fields.forEach((field) => {
+      if (field.default_value !== void 0) {
+        initial[field.id] = field.default_value;
+      }
+    });
+    return initial;
+  });
+  const [isSubmitting, setIsSubmitting] = react.useState(false);
+  const handleFieldChange = react.useCallback((fieldId, value) => {
+    setValues((prev) => ({ ...prev, [fieldId]: value }));
+  }, []);
+  const handleSubmit = react.useCallback(
+    async (e) => {
+      e.preventDefault();
+      setIsSubmitting(true);
+      try {
+        await onSubmit(values);
+      } finally {
+        setIsSubmitting(false);
+      }
+    },
+    [values, onSubmit]
+  );
+  const gridCols = form.columns || 1;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `border border-gray-200 dark:border-gray-700 rounded-lg bg-white dark:bg-gray-800 p-6 ${className}`, children: [
+    (form.title || form.description) && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mb-6", children: [
+      form.title && /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-lg font-semibold text-gray-900 dark:text-gray-100", children: form.title }),
+      form.description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "mt-1 text-sm text-gray-500 dark:text-gray-400", children: form.description })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("form", { onSubmit: handleSubmit, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: "grid gap-4",
+          style: {
+            gridTemplateColumns: `repeat(${gridCols}, minmax(0, 1fr))`
+          },
+          children: form.fields.map((field) => /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              style: {
+                gridColumn: field.col_span ? `span ${field.col_span}` : void 0
+              },
+              children: [
+                field.type !== "checkbox" && /* @__PURE__ */ jsxRuntime.jsxs(
+                  "label",
+                  {
+                    htmlFor: field.id,
+                    className: "block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1",
+                    children: [
+                      field.label,
+                      field.required && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-red-500 ml-1", children: "*" })
+                    ]
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx(FormFieldRenderer, { field, value: values[field.id], onChange: handleFieldChange }),
+                field.description && field.type !== "checkbox" && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "mt-1 text-xs text-gray-500 dark:text-gray-400", children: field.description })
+              ]
+            },
+            field.id
+          ))
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mt-6 flex items-center justify-end gap-3", children: [
+        onCancel && /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            onClick: onCancel,
+            disabled: isSubmitting,
+            className: "px-4 py-2 text-sm font-medium text-gray-700 dark:text-gray-300 bg-white dark:bg-gray-700 border border-gray-300 dark:border-gray-600 rounded-md hover:bg-gray-50 dark:hover:bg-gray-600 focus:outline-none focus:ring-2 focus:ring-blue-500 disabled:opacity-50",
+            children: "Cancel"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "submit",
+            disabled: isSubmitting,
+            className: "px-4 py-2 text-sm font-medium text-white bg-blue-600 rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 disabled:opacity-50",
+            children: isSubmitting ? "Submitting..." : form.submit_label || "Submit"
+          }
+        )
+      ] })
+    ] })
+  ] });
+};
+function A2AChat({
+  // Agent configuration
+  agent: agentProp,
+  agentId,
+  agentUrl,
+  apiKey,
+  // Display options
+  layout = "fullscreen",
+  allowLayoutSwitch = false,
+  defaultOpen = true,
+  className = "",
+  agentName,
+  agentIconUrl,
+  // Behavior options
+  showThinking = true,
+  showChainOfThought = true,
+  allowCancel = true,
+  extensions,
+  // Callbacks
+  onOpen,
+  onClose,
+  onSend,
+  onResponse,
+  onConnectionChange,
+  onError,
+  onDisconnect,
+  // Custom renderers
+  renderCitations,
+  renderError,
+  renderForm,
+  renderUserDefined
+}) {
+  const agentContext = useAgentContextOptional();
+  const agent = react.useMemo(() => {
+    if (agentProp) {
+      return agentProp;
+    }
+    if (agentId && agentContext) {
+      return agentContext.getAgent(agentId) ?? null;
+    }
+    if (!agentProp && !agentId && agentContext?.currentAgent) {
+      return agentContext.currentAgent;
+    }
+    if (agentUrl) {
+      return {
+        id: "default",
+        name: agentName ?? "AI Assistant",
+        url: agentUrl,
+        apiKey,
+        iconUrl: agentIconUrl
+      };
+    }
+    return null;
+  }, [agentProp, agentId, agentUrl, apiKey, agentName, agentIconUrl, agentContext]);
+  const [connectionState, setConnectionState] = react.useState("disconnected");
+  const [isStreaming, setIsStreaming] = react.useState(false);
+  const [currentFormRequest, setCurrentFormRequest] = react.useState(null);
+  const [pendingTaskId, setPendingTaskId] = react.useState(null);
+  const [carbonLoaded, setCarbonLoaded] = react.useState(false);
+  const [CarbonComponents, setCarbonComponents] = react.useState({});
+  const instanceRef = react.useRef(null);
+  const translatorRef = react.useRef(null);
+  const abortControllerRef = react.useRef(null);
+  react.useEffect(() => {
+    if (typeof window !== "undefined") {
+      import('@carbon/ai-chat').then((mod) => {
+        setCarbonComponents({
+          ChatCustomElement: mod.ChatCustomElement,
+          ChatContainer: mod.ChatContainer
+        });
+        setCarbonLoaded(true);
+      }).catch((err) => {
+        console.error("[A2AChat] Failed to load @carbon/ai-chat:", err);
+      });
+    }
+  }, []);
+  react.useEffect(() => {
+    onConnectionChange?.(connectionState);
+  }, [connectionState, onConnectionChange]);
+  const handleSendMessage = react.useCallback(
+    async (message) => {
+      if (!agent) {
+        console.error("[A2AChat] No agent configured");
+        return;
+      }
+      const instance = instanceRef.current;
+      if (!instance) {
+        console.error("[A2AChat] Chat instance not ready");
+        return;
+      }
+      onSend?.(message);
+      setIsStreaming(true);
+      setConnectionState("streaming");
+      translatorRef.current = createTranslator(
+        agent.name,
+        agent.iconUrl ?? "/bot.svg"
+      );
+      abortControllerRef.current = new AbortController();
+      try {
+        const response = await fetch("/api/agent/chat", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            agentUrl: agent.url,
+            apiKey: agent.apiKey,
+            message,
+            extensions: extensions ?? agent.extensions
+          }),
+          signal: abortControllerRef.current.signal
+        });
+        if (!response.ok) {
+          throw new Error(`Request failed: ${response.status}`);
+        }
+        if (!response.body) {
+          throw new Error("Response body is null");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (trimmedLine.startsWith("data: ")) {
+              const dataStr = trimmedLine.slice(6);
+              if (!dataStr || dataStr === "[DONE]") continue;
+              try {
+                const data = JSON.parse(dataStr);
+                if (data.result) {
+                  const carbonChunks = translatorRef.current?.translateStreamChunk(data.result) ?? [];
+                  for (const chunk of carbonChunks) {
+                    await instance.messaging.addMessageChunk(chunk);
+                  }
+                  if (data.result.status?.state === "input-required") {
+                    const formRequest = extractFormRequest2(data.result);
+                    if (formRequest) {
+                      setCurrentFormRequest(formRequest);
+                      setPendingTaskId(data.result.taskId);
+                    }
+                  }
+                }
+              } catch (e) {
+                console.warn("[A2AChat] Failed to parse SSE data:", e);
+              }
+            }
+          }
+        }
+        setConnectionState("connected");
+        onResponse?.(translatorRef.current?.getState?.() ?? {});
+      } catch (error) {
+        if (error.name === "AbortError") {
+          console.log("[A2AChat] Request cancelled");
+        } else {
+          console.error("[A2AChat] Error:", error);
+          setConnectionState("error");
+          onError?.(error);
+        }
+      } finally {
+        setIsStreaming(false);
+        abortControllerRef.current = null;
+      }
+    },
+    [agent, extensions, onSend, onResponse, onError]
+  );
+  react.useCallback(() => {
+    abortControllerRef.current?.abort();
+    setIsStreaming(false);
+    setConnectionState("connected");
+  }, []);
+  const renderCustomResponse = react.useCallback(
+    (state, _instance) => {
+      const messageItem = state.messageItem;
+      const userDefined = messageItem?.user_defined;
+      if (!userDefined) return null;
+      if (renderUserDefined) {
+        return renderUserDefined(userDefined, messageItem);
+      }
+      if (userDefined.type === "text_with_citations") {
+        if (renderCitations) {
+          return renderCitations(userDefined.citations || [], userDefined.text);
+        }
+        return /* @__PURE__ */ jsxRuntime.jsx(CitationRenderer, { text: userDefined.text, citations: userDefined.citations || [] });
+      }
+      if (userDefined.type === "sources_list" && userDefined.citations) {
+        const citations = userDefined.citations;
+        if (citations.length === 0) return null;
+        const uniqueCitations = citations.filter(
+          (c, i, arr) => c.url && arr.findIndex((x) => x.url === c.url) === i
+        );
+        return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "a2a-sources-list", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("h4", { className: "a2a-sources-list__title", children: "Sources" }),
+          /* @__PURE__ */ jsxRuntime.jsx("ol", { className: "a2a-sources-list__items", children: uniqueCitations.map((citation, idx) => /* @__PURE__ */ jsxRuntime.jsx("li", { className: "a2a-sources-list__item", children: /* @__PURE__ */ jsxRuntime.jsx("a", { href: citation.url ?? "#", target: "_blank", rel: "noopener noreferrer", children: citation.title || citation.url }) }, idx)) })
+        ] });
+      }
+      if (userDefined.type === "error" && userDefined.error) {
+        if (renderError) {
+          return renderError(userDefined.error);
+        }
+        return /* @__PURE__ */ jsxRuntime.jsx(ErrorRenderer, { error: userDefined.error });
+      }
+      return null;
+    },
+    [renderCitations, renderError, renderUserDefined]
+  );
+  const handleFormSubmit = react.useCallback(
+    async (values) => {
+      if (!pendingTaskId) return;
+      setCurrentFormRequest(null);
+      const taskId = pendingTaskId;
+      setPendingTaskId(null);
+      const formResponseMessage = JSON.stringify({
+        type: "form_response",
+        taskId,
+        values
+      });
+      await handleSendMessage(formResponseMessage);
+    },
+    [pendingTaskId, handleSendMessage]
+  );
+  const handleFormCancel = react.useCallback(() => {
+    setCurrentFormRequest(null);
+    setPendingTaskId(null);
+  }, []);
+  const chatConfig = react.useMemo(
+    () => ({
+      layout: {
+        showCloseAndRestartButton: layout !== "fullscreen",
+        hasContentMaxWidth: true
+      },
+      header: {
+        title: agent?.name ?? "AI Assistant",
+        icons: {
+          agent: agent?.iconUrl ?? "/bot.svg"
+        }
+      },
+      input: {
+        placeholder: "Type a message..."
+      },
+      messaging: {
+        customSendMessage: async (request, options, instance) => {
+          instanceRef.current = instance;
+          const text = request?.input?.text;
+          if (text) {
+            await handleSendMessage(text);
+          }
+        },
+        skipWelcome: true
+      },
+      userDefinedResponses: {
+        text_with_citations: renderCustomResponse,
+        sources_list: renderCustomResponse,
+        error: renderCustomResponse
+      }
+    }),
+    [agent, layout, handleSendMessage, renderCustomResponse]
+  );
+  if (!agent) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: `a2a-chat a2a-chat--error ${className}`, children: /* @__PURE__ */ jsxRuntime.jsx("p", { children: "No agent configured. Provide `agent`, `agentId`, or `agentUrl` prop." }) });
+  }
+  if (!carbonLoaded) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: `a2a-chat a2a-chat--loading ${className}`, children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "a2a-chat__spinner" }) });
+  }
+  const { ChatCustomElement, ChatContainer } = CarbonComponents;
+  const formOverlay = currentFormRequest && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "a2a-chat__form-overlay", children: renderForm ? renderForm(currentFormRequest, handleFormSubmit) : /* @__PURE__ */ jsxRuntime.jsx(
+    FormRenderer,
+    {
+      form: currentFormRequest,
+      onSubmit: handleFormSubmit,
+      onCancel: handleFormCancel
+    }
+  ) });
+  if (layout === "float" && ChatContainer) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `a2a-chat a2a-chat--float ${className}`, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ChatContainer, { config: chatConfig }),
+      formOverlay
+    ] });
+  }
+  if (ChatCustomElement) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: `a2a-chat a2a-chat--${layout} ${className}`,
+        style: {
+          height: layout === "fullscreen" ? "100vh" : void 0,
+          width: layout === "sidebar" ? "400px" : void 0
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ChatCustomElement, { config: chatConfig }),
+          formOverlay
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: `a2a-chat a2a-chat--loading ${className}`, children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "a2a-chat__spinner" }) });
+}
+function extractFormRequest2(chunk) {
+  const metadata = chunk.status?.message?.metadata;
+  if (!metadata) return null;
+  const formData = metadata["https://a2a-extensions.agentstack.beeai.dev/ui/form-request/v1"];
+  if (!formData) return null;
+  return formData;
+}
+function AgentSwitcher({
+  agents,
+  currentAgentId,
+  onSelect,
+  variant = "dropdown",
+  showDescriptions = false,
+  showIcons = true,
+  className = "",
+  disabled = false,
+  label = "Select Agent"
+}) {
+  if (agents.length === 0) {
+    return null;
+  }
+  if (variant === "tabs") {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: `a2a-agent-switcher a2a-agent-switcher--tabs ${className}`, children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "a2a-agent-switcher__tabs", role: "tablist", "aria-label": label, children: agents.map((agent) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        role: "tab",
+        "aria-selected": agent.id === currentAgentId,
+        className: `a2a-agent-switcher__tab ${agent.id === currentAgentId ? "a2a-agent-switcher__tab--active" : ""}`,
+        onClick: () => onSelect(agent.id),
+        disabled,
+        children: [
+          showIcons && agent.iconUrl && /* @__PURE__ */ jsxRuntime.jsx(
+            "img",
+            {
+              src: agent.iconUrl,
+              alt: "",
+              className: "a2a-agent-switcher__icon",
+              width: 20,
+              height: 20
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: agent.name })
+        ]
+      },
+      agent.id
+    )) }) });
+  }
+  if (variant === "cards") {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: `a2a-agent-switcher a2a-agent-switcher--cards ${className}`, children: /* @__PURE__ */ jsxRuntime.jsxs("fieldset", { disabled, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("legend", { className: "a2a-agent-switcher__label", children: label }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "a2a-agent-switcher__cards", children: agents.map((agent) => /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          className: `a2a-agent-switcher__card ${agent.id === currentAgentId ? "a2a-agent-switcher__card--active" : ""}`,
+          onClick: () => onSelect(agent.id),
+          children: [
+            showIcons && agent.iconUrl && /* @__PURE__ */ jsxRuntime.jsx(
+              "img",
+              {
+                src: agent.iconUrl,
+                alt: "",
+                className: "a2a-agent-switcher__card-icon",
+                width: 32,
+                height: 32
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "a2a-agent-switcher__card-content", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "a2a-agent-switcher__card-name", children: agent.name }),
+              showDescriptions && agent.description && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "a2a-agent-switcher__card-description", children: agent.description })
+            ] })
+          ]
+        },
+        agent.id
+      )) })
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: `a2a-agent-switcher a2a-agent-switcher--dropdown ${className}`, children: /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "a2a-agent-switcher__label", children: [
+    label,
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "select",
+      {
+        value: currentAgentId ?? "",
+        onChange: (e) => onSelect(e.target.value),
+        disabled,
+        className: "a2a-agent-switcher__select",
+        children: agents.map((agent) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: agent.id, children: agent.name }, agent.id))
+      }
+    )
+  ] }) });
+}
+function useA2AAgent(options = {}) {
+  const { agent: agentProp, agentId, autoConnect = false, onConnect, onDisconnect, onError, onMessage } = options;
+  const agentContext = useAgentContextOptional();
+  const agent = agentProp ?? (agentId ? agentContext?.getAgent(agentId) : agentContext?.currentAgent) ?? null;
+  const [connectionState, setConnectionState] = react.useState("disconnected");
+  const [isStreaming, setIsStreaming] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [taskId, setTaskId] = react.useState();
+  const [contextId, setContextId] = react.useState();
+  const abortControllerRef = react.useRef(null);
+  const translatorRef = react.useRef(null);
+  const historyRef = react.useRef([]);
+  const sendMessage = react.useCallback(
+    async (message) => {
+      if (!agent) {
+        const err = new Error("No agent configured");
+        setError(err);
+        onError?.(err);
+        throw err;
+      }
+      setIsStreaming(true);
+      setConnectionState("streaming");
+      setError(null);
+      translatorRef.current = createTranslator(agent.name, agent.iconUrl);
+      abortControllerRef.current = new AbortController();
+      try {
+        const response = await fetch("/api/agent/chat", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            agentUrl: agent.url,
+            apiKey: agent.apiKey,
+            message,
+            extensions: agent.extensions
+          }),
+          signal: abortControllerRef.current.signal
+        });
+        if (!response.ok) {
+          throw new Error(`Request failed: ${response.status}`);
+        }
+        if (!response.body) {
+          throw new Error("Response body is null");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let result = null;
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.trim().startsWith("data: ")) {
+              const dataStr = line.trim().slice(6);
+              if (!dataStr || dataStr === "[DONE]") continue;
+              try {
+                const data = JSON.parse(dataStr);
+                if (data.result) {
+                  result = data.result;
+                  setTaskId(data.result.taskId);
+                  setContextId(data.result.contextId);
+                  onMessage?.(data.result);
+                }
+              } catch (e) {
+              }
+            }
+          }
+        }
+        setConnectionState("connected");
+        onConnect?.();
+        return result;
+      } catch (err) {
+        if (err.name !== "AbortError") {
+          setError(err);
+          setConnectionState("error");
+          onError?.(err);
+        }
+        throw err;
+      } finally {
+        setIsStreaming(false);
+        abortControllerRef.current = null;
+      }
+    },
+    [agent, onConnect, onError, onMessage]
+  );
+  const cancelStream = react.useCallback(() => {
+    abortControllerRef.current?.abort();
+    setIsStreaming(false);
+    setConnectionState("connected");
+  }, []);
+  const disconnect = react.useCallback(() => {
+    cancelStream();
+    setConnectionState("disconnected");
+    setTaskId(void 0);
+    setContextId(void 0);
+    onDisconnect?.();
+  }, [cancelStream, onDisconnect]);
+  const reconnect = react.useCallback(() => {
+    disconnect();
+    setConnectionState("connecting");
+    setConnectionState("connected");
+  }, [disconnect]);
+  const clearHistory = react.useCallback(() => {
+    historyRef.current = [];
+    setTaskId(void 0);
+    setContextId(void 0);
+  }, []);
+  react.useEffect(() => {
+    if (autoConnect && agent && connectionState === "disconnected") {
+      setConnectionState("connected");
+      onConnect?.();
+    }
+  }, [autoConnect, agent, connectionState, onConnect]);
+  return {
+    agent,
+    state: {
+      connectionState,
+      error: error ?? void 0,
+      taskId,
+      contextId
+    },
+    sendMessage,
+    cancelStream,
+    disconnect,
+    reconnect,
+    clearHistory,
+    isStreaming,
+    isConnected: connectionState === "connected" || connectionState === "streaming",
+    error
+  };
+}
+function useMultiAgent(options = {}) {
+  const { agents: initialAgents = [], defaultAgentId, onAgentChange } = options;
+  const [agents, setAgents] = react.useState(initialAgents);
+  const [currentAgentId, setCurrentAgentId] = react.useState(
+    defaultAgentId ?? initialAgents[0]?.id ?? null
+  );
+  const currentAgent = react.useMemo(
+    () => agents.find((a) => a.id === currentAgentId) ?? null,
+    [agents, currentAgentId]
+  );
+  const switchAgent = react.useCallback(
+    (agentId) => {
+      const agent = agents.find((a) => a.id === agentId);
+      if (agent) {
+        setCurrentAgentId(agentId);
+        onAgentChange?.(agent);
+      } else {
+        console.warn(`[useMultiAgent] Agent "${agentId}" not found`);
+      }
+    },
+    [agents, onAgentChange]
+  );
+  const registerAgent = react.useCallback((agent) => {
+    setAgents((prev) => {
+      if (prev.some((a) => a.id === agent.id)) {
+        console.warn(`[useMultiAgent] Agent "${agent.id}" already exists, updating`);
+        return prev.map((a) => a.id === agent.id ? agent : a);
+      }
+      return [...prev, agent];
+    });
+  }, []);
+  const unregisterAgent = react.useCallback(
+    (agentId) => {
+      setAgents((prev) => prev.filter((a) => a.id !== agentId));
+      if (currentAgentId === agentId) {
+        setCurrentAgentId(agents[0]?.id ?? null);
+      }
+    },
+    [currentAgentId, agents]
+  );
+  const updateAgent = react.useCallback((agentId, updates) => {
+    setAgents(
+      (prev) => prev.map((a) => a.id === agentId ? { ...a, ...updates, id: agentId } : a)
+    );
+  }, []);
+  const getAgent = react.useCallback((agentId) => agents.find((a) => a.id === agentId), [agents]);
+  const hasAgent = react.useCallback((agentId) => agents.some((a) => a.id === agentId), [agents]);
+  return {
+    agents,
+    currentAgent,
+    switchAgent,
+    registerAgent,
+    unregisterAgent,
+    updateAgent,
+    getAgent,
+    hasAgent
+  };
+}
+
+exports.A2AChat = A2AChat;
+exports.A2AClient = A2AClient;
+exports.A2AToCarbonTranslator = A2AToCarbonTranslator;
+exports.AgentProvider = AgentProvider;
+exports.AgentSwitcher = AgentSwitcher;
+exports.ChainOfThoughtStepStatus = ChainOfThoughtStepStatus;
+exports.CitationRenderer = CitationRenderer;
+exports.EXTENSION_URIS = EXTENSION_URIS;
+exports.ErrorRenderer = ErrorRenderer;
+exports.FormRenderer = FormRenderer;
+exports.MessageResponseTypes = MessageResponseTypes;
+exports.ReasoningStepOpenState = ReasoningStepOpenState;
+exports.UserType = UserType;
+exports.buildFulfillments = buildFulfillments;
+exports.createTranslator = createTranslator;
+exports.extractCitations = extractCitations;
+exports.extractDemandsFromAgentCard = extractDemandsFromAgentCard;
+exports.extractError = extractError;
+exports.extractFormRequest = extractFormRequest;
+exports.extractTrajectory = extractTrajectory;
+exports.getUniqueCitations = getUniqueCitations;
+exports.handleAgentCard = handleAgentCard;
+exports.isCompleteItem = isCompleteItem;
+exports.isFinalResponse = isFinalResponse;
+exports.isPartialItem = isPartialItem;
+exports.parseUIExtensions = parseUIExtensions;
+exports.processCitations = processCitations;
+exports.resolveMetadata = resolveMetadata;
+exports.segmentTextWithCitations = segmentTextWithCitations;
+exports.useA2AAgent = useA2AAgent;
+exports.useAgentContext = useAgentContext;
+exports.useAgentContextOptional = useAgentContextOptional;
+exports.useMultiAgent = useMultiAgent;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map