@agno-hq/chat-react 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1967 @@
+'use client';
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/useAgnoChat.ts
+
+// src/stream.ts
+function isEnvelope(data) {
+  return typeof data === "object" && data !== null && "event" in data && "data" in data && typeof data.event === "string";
+}
+function isFlatEvent(data) {
+  return typeof data === "object" && data !== null && "event" in data && !("data" in data) && typeof data.event === "string";
+}
+function normaliseEnvelope(env) {
+  let parsed = {};
+  if (typeof env.data === "string") {
+    try {
+      parsed = JSON.parse(env.data);
+    } catch {
+      parsed = {};
+    }
+  } else if (env.data && typeof env.data === "object") {
+    parsed = env.data;
+  }
+  return { event: env.event, ...parsed };
+}
+function drainBuffer(buffer, onEvent) {
+  let start = buffer.indexOf("{");
+  while (start !== -1 && start < buffer.length) {
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    let end = -1;
+    for (let i = start; i < buffer.length; i++) {
+      const ch = buffer[i];
+      if (inString) {
+        if (escape) escape = false;
+        else if (ch === "\\") escape = true;
+        else if (ch === '"') inString = false;
+      } else if (ch === '"') {
+        inString = true;
+      } else if (ch === "{") {
+        depth++;
+      } else if (ch === "}") {
+        depth--;
+        if (depth === 0) {
+          end = i;
+          break;
+        }
+      }
+    }
+    if (end === -1) break;
+    const slice = buffer.slice(start, end + 1);
+    try {
+      const parsed = JSON.parse(slice);
+      if (isEnvelope(parsed)) onEvent(normaliseEnvelope(parsed));
+      else if (isFlatEvent(parsed)) onEvent(parsed);
+    } catch {
+      start = buffer.indexOf("{", start + 1);
+      continue;
+    }
+    buffer = buffer.slice(end + 1).trim();
+    start = buffer.indexOf("{");
+  }
+  return buffer;
+}
+async function streamRun(options) {
+  const { url, body, headers = {}, signal, onEvent, onError, onComplete } = options;
+  let buffer = "";
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...!(body instanceof FormData) && { "Content-Type": "application/json" },
+        ...headers
+      },
+      body: body instanceof FormData ? body : JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      let detail;
+      try {
+        const err = await response.json();
+        detail = err?.detail ? String(err.detail) : `${response.status} ${response.statusText}`;
+      } catch {
+        detail = `${response.status} ${response.statusText}`;
+      }
+      throw new Error(detail);
+    }
+    if (!response.body) throw new Error("No response body");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        buffer = drainBuffer(buffer, onEvent);
+        onComplete();
+        return;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      buffer = drainBuffer(buffer, onEvent);
+    }
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+      onComplete();
+      return;
+    }
+    onError(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+
+// src/client.ts
+function normaliseBaseUrl(value) {
+  if (!value) return "";
+  let url = value.trim();
+  if (!/^https?:\/\//.test(url)) {
+    const isLocal = url.startsWith("localhost") || /^\d{1,3}(\.\d{1,3}){3}/.test(url);
+    url = `${isLocal ? "http" : "https"}://${url}`;
+  }
+  return url.replace(/\/+$/, "");
+}
+var RUN_PATH = {
+  agent: "agents",
+  team: "teams",
+  workflow: "workflows"
+};
+var AgnoClient = class {
+  constructor(options) {
+    this.baseUrl = normaliseBaseUrl(options.baseUrl);
+    this.headers = options.headers ?? {};
+    this.dbId = options.dbId;
+  }
+  async getJson(path) {
+    const res = await fetch(`${this.baseUrl}${path}`, { headers: this.headers });
+    if (!res.ok) throw new Error(`GET ${path} failed: ${res.status} ${res.statusText}`);
+    return res.json();
+  }
+  /** Liveness check against /health. Returns the HTTP status code. */
+  async health() {
+    try {
+      const res = await fetch(`${this.baseUrl}/health`, { headers: this.headers });
+      return res.status;
+    } catch {
+      return 0;
+    }
+  }
+  /* ----------------------------- discovery ----------------------------- */
+  async getAgents() {
+    const data = await this.getJson("/agents").catch(() => []);
+    return data.map((a) => ({
+      type: "agent",
+      id: a.agent_id ?? a.id,
+      name: a.name ?? a.agent_id ?? a.id,
+      description: a.description,
+      model: a.model,
+      db_id: a.db_id
+    }));
+  }
+  async getTeams() {
+    const data = await this.getJson("/teams").catch(() => []);
+    return data.map((t) => ({
+      type: "team",
+      id: t.team_id ?? t.id,
+      name: t.name ?? t.team_id ?? t.id,
+      description: t.description,
+      model: t.model,
+      db_id: t.db_id
+    }));
+  }
+  async getWorkflows() {
+    const data = await this.getJson("/workflows").catch(() => []);
+    return data.map((w) => ({
+      type: "workflow",
+      id: w.workflow_id ?? w.id,
+      name: w.name ?? w.workflow_id ?? w.id,
+      description: w.description,
+      model: w.model,
+      db_id: w.db_id
+    }));
+  }
+  /** All runnable entities (agents, teams, workflows) in one list. */
+  async getEntities() {
+    const [agents, teams, workflows] = await Promise.all([
+      this.getAgents(),
+      this.getTeams(),
+      this.getWorkflows()
+    ]);
+    return [...agents, ...teams, ...workflows];
+  }
+  /* ------------------------------ sessions ----------------------------- */
+  async getSessions(type, componentId, dbId) {
+    const url = new URL(`${this.baseUrl}/sessions`);
+    url.searchParams.set("type", type);
+    url.searchParams.set("component_id", componentId);
+    const db = dbId ?? this.dbId;
+    if (db) url.searchParams.set("db_id", db);
+    try {
+      const res = await fetch(url.toString(), { headers: this.headers });
+      if (!res.ok) return { data: [] };
+      return await res.json();
+    } catch {
+      return { data: [] };
+    }
+  }
+  /** Runs (with messages/tools/events) for a session — used to rehydrate chat history. */
+  async getSessionRuns(type, sessionId, dbId) {
+    const url = new URL(`${this.baseUrl}/sessions/${sessionId}/runs`);
+    url.searchParams.set("type", type);
+    const db = dbId ?? this.dbId;
+    if (db) url.searchParams.set("db_id", db);
+    const res = await fetch(url.toString(), { headers: this.headers });
+    if (!res.ok) throw new Error(`Failed to load session: ${res.statusText}`);
+    return res.json();
+  }
+  async deleteSession(sessionId, dbId) {
+    const url = new URL(`${this.baseUrl}/sessions/${sessionId}`);
+    const db = dbId ?? this.dbId;
+    if (db) url.searchParams.set("db_id", db);
+    const res = await fetch(url.toString(), { method: "DELETE", headers: this.headers });
+    return res.ok;
+  }
+  /* -------------------------------- runs ------------------------------- */
+  /** Start a streaming run for an agent, team or workflow. */
+  async run(args) {
+    const form = new FormData();
+    if (args.message != null) form.append("message", args.message);
+    form.append("stream", "true");
+    if (args.sessionId) form.append("session_id", args.sessionId);
+    if (args.userId) form.append("user_id", args.userId);
+    for (const file of args.files ?? []) form.append("files", file);
+    for (const [k, v] of Object.entries(args.extra ?? {})) form.append(k, v);
+    const url = `${this.baseUrl}/${RUN_PATH[args.type]}/${args.id}/runs`;
+    return streamRun({
+      url,
+      body: form,
+      headers: this.headers,
+      signal: args.signal,
+      onEvent: (e) => args.onEvent(e),
+      onError: args.onError,
+      onComplete: args.onComplete
+    });
+  }
+  /** Continue a paused run (resolving a human-in-the-loop requirement). */
+  async continueRun(args) {
+    const form = new FormData();
+    form.append("stream", "true");
+    if (args.sessionId) form.append("session_id", args.sessionId);
+    if (args.userId) form.append("user_id", args.userId);
+    if (args.type === "workflow") {
+      if (args.stepRequirements) form.append("step_requirements", JSON.stringify(args.stepRequirements));
+    } else if (args.tools) {
+      form.append("tools", JSON.stringify(args.tools));
+    }
+    const url = `${this.baseUrl}/${RUN_PATH[args.type]}/${args.id}/runs/${args.runId}/continue`;
+    return streamRun({
+      url,
+      body: form,
+      headers: this.headers,
+      signal: args.signal,
+      onEvent: (e) => args.onEvent(e),
+      onError: args.onError,
+      onComplete: args.onComplete
+    });
+  }
+  /** Cancel an in-flight run. */
+  async cancelRun(type, id2, runId, sessionId) {
+    const url = new URL(`${this.baseUrl}/${RUN_PATH[type]}/${id2}/runs/${runId}/cancel`);
+    if (sessionId) url.searchParams.set("session_id", sessionId);
+    try {
+      const res = await fetch(url.toString(), { method: "POST", headers: this.headers });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/events.ts
+var name = (e) => String(e.event ?? "");
+var isStartedEvent = (e) => name(e) === "RunStarted" || name(e) === "TeamRunStarted" || name(e) === "WorkflowStarted" || name(e) === "ReasoningStarted" || name(e) === "TeamReasoningStarted";
+var isContentEvent = (e) => name(e) === "RunContent" || name(e) === "TeamRunContent" || name(e) === "WorkflowAgentCompleted";
+var isCompletedEvent = (e) => name(e) === "RunCompleted" || name(e) === "TeamRunCompleted" || name(e) === "WorkflowCompleted";
+var isErrorEvent = (e) => name(e) === "RunError" || name(e) === "TeamRunError" || name(e) === "WorkflowError" || name(e) === "StepError" || name(e) === "ToolCallError" || name(e) === "TeamToolCallError";
+var isCancelledEvent = (e) => name(e) === "RunCancelled" || name(e) === "TeamRunCancelled" || name(e) === "WorkflowCancelled";
+var isPausedEvent = (e) => name(e) === "RunPaused" || name(e) === "TeamRunPaused" || name(e) === "WorkflowPaused" || name(e) === "StepPaused" || name(e) === "RouterPaused" || name(e) === "ConditionPaused";
+var isToolStartedEvent = (e) => name(e) === "ToolCallStarted" || name(e) === "TeamToolCallStarted";
+var isToolCompletedEvent = (e) => name(e) === "ToolCallCompleted" || name(e) === "TeamToolCallCompleted";
+var isToolEvent = (e) => isToolStartedEvent(e) || isToolCompletedEvent(e) || name(e) === "ToolCallError" || name(e) === "TeamToolCallError";
+var isReasoningStepEvent = (e) => name(e) === "ReasoningStep" || name(e) === "TeamReasoningStep";
+var isReasoningCompletedEvent = (e) => name(e) === "ReasoningCompleted" || name(e) === "TeamReasoningCompleted";
+function isSubRunEvent(e) {
+  if (!e.parent_run_id) return false;
+  const ev = name(e);
+  return isContentEvent(e) || isToolEvent(e) || isCompletedEvent(e) || isErrorEvent(e) || ev === "RunStarted" || ev === "TeamRunStarted";
+}
+function isStepEvent(e) {
+  const ev = name(e);
+  return ev === "StepStarted" || ev === "StepCompleted" || ev === "StepOutput" || ev === "StepError";
+}
+function toolsFromEvent(e) {
+  const out = [];
+  if (e.tool) out.push(e.tool);
+  if (Array.isArray(e.tools)) out.push(...e.tools);
+  return out;
+}
+function activityLabel(e) {
+  const ev = name(e);
+  switch (ev) {
+    case "RunStarted":
+    case "TeamRunStarted":
+    case "WorkflowStarted":
+      return "Thinking";
+    case "ModelRequestStarted":
+    case "TeamModelRequestStarted":
+      return "Generating";
+    case "ReasoningStarted":
+    case "TeamReasoningStarted":
+    case "ReasoningStep":
+    case "TeamReasoningStep":
+    case "ReasoningContentDelta":
+    case "TeamReasoningContentDelta":
+      return "Reasoning";
+    case "MemoryUpdateStarted":
+    case "TeamMemoryUpdateStarted":
+      return "Updating memory";
+    case "SessionSummaryStarted":
+    case "TeamSessionSummaryStarted":
+      return "Summarising session";
+    case "CompressionStarted":
+      return "Compressing context";
+    case "ToolCallStarted":
+    case "TeamToolCallStarted": {
+      const tool = e.tool?.tool_name;
+      return tool ? `Calling ${tool}` : "Calling tool";
+    }
+    case "ToolCallCompleted":
+    case "TeamToolCallCompleted":
+      return "Generating";
+    case "StepStarted":
+      return e.step_name ? `Running step: ${e.step_name}` : "Running step";
+    case "LoopIterationStarted":
+      return `Loop iteration ${e.iteration ?? ""}`.trim();
+    case "ParallelExecutionStarted":
+      return "Running parallel steps";
+    case "RouterExecutionStarted":
+      return "Routing";
+    case "ConditionExecutionStarted":
+      return "Evaluating condition";
+    default:
+      return null;
+  }
+}
+function textOf(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") return "```json\n" + JSON.stringify(value, null, 2) + "\n```";
+  return void 0;
+}
+function applySubRunEvent(message, e, kind) {
+  const rid = e.run_id || e.parent_run_id || "sub";
+  const members = message.members ? [...message.members] : [];
+  const idx = members.findIndex((s) => s.run_id === rid);
+  const base = idx >= 0 ? { ...members[idx] } : { run_id: rid, kind, content: "", status: "running" };
+  base.name = base.name || e.agent_name || e.team_name || e.agent_id;
+  const tools = toolsFromEvent(e);
+  if (tools.length) {
+    let tc = base.tool_calls ?? [];
+    for (const t of tools) tc = mergeTool(tc, t);
+    base.tool_calls = tc;
+  }
+  if (isErrorEvent(e)) {
+    base.status = "error";
+  } else if (isCompletedEvent(e)) {
+    base.status = "completed";
+    const final = textOf(e.content);
+    if (final) base.content = final;
+  } else if (isContentEvent(e)) {
+    const delta = typeof e.content === "string" ? e.content : "";
+    if (delta) base.content += delta;
+  }
+  if (idx >= 0) members[idx] = base;
+  else members.push(base);
+  return { ...message, members };
+}
+function applyStepEvent(message, e) {
+  const ev = name(e);
+  const key = e.step_name || `step-${JSON.stringify(e.step_index ?? "")}`;
+  const steps = message.steps ? [...message.steps] : [];
+  const idx = steps.findIndex((s) => s.key === key);
+  const step = idx >= 0 ? { ...steps[idx] } : { key, name: e.step_name, index: e.step_index, status: "running" };
+  if (ev === "StepStarted") {
+    step.status = "running";
+  } else if (ev === "StepError") {
+    step.status = "error";
+    step.error = e.error || (typeof e.content === "string" ? e.content : void 0);
+  } else {
+    step.status = "completed";
+    const stepResponse = e.step_response ?? e.step_output;
+    const content = textOf(e.content) ?? textOf(stepResponse?.content);
+    if (content) step.content = content;
+  }
+  if (idx >= 0) steps[idx] = step;
+  else steps.push(step);
+  return { ...message, steps };
+}
+function mergeTool(list, tool) {
+  const key = tool.tool_call_id || `${tool.tool_name}-${tool.created_at}`;
+  const idx = list.findIndex((t) => {
+    if (t.tool_call_id && tool.tool_call_id) return t.tool_call_id === tool.tool_call_id;
+    return `${t.tool_name}-${t.created_at}` === key;
+  });
+  if (idx >= 0) {
+    const next = [...list];
+    next[idx] = { ...next[idx], ...tool };
+    return next;
+  }
+  return [...list, tool];
+}
+
+// src/session.ts
+function toText(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    return value.map(
+      (part) => part && typeof part === "object" && "text" in part ? String(part.text) : ""
+    ).filter(Boolean).join(" ");
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    if (typeof obj.input_content === "string") return obj.input_content;
+    if (typeof obj.message === "string") return obj.message;
+    if (typeof obj.content === "string") return obj.content;
+    return "```json\n" + JSON.stringify(value, null, 2) + "\n```";
+  }
+  return String(value);
+}
+var seq = 0;
+var id = (prefix) => `${prefix}-${seq++}`;
+function sessionRunsToMessages(runs) {
+  if (!Array.isArray(runs)) return [];
+  const messages = [];
+  for (const run of runs) {
+    const created = run.created_at ?? Math.floor(Date.now() / 1e3);
+    const userContent = toText(run.run_input);
+    if (userContent) {
+      messages.push({
+        id: id("hist-u"),
+        role: "user",
+        content: userContent,
+        created_at: created
+      });
+    }
+    messages.push({
+      id: id("hist-a"),
+      role: "agent",
+      content: toText(run.content),
+      created_at: created,
+      status: "completed",
+      run_id: run.run_id,
+      session_id: run.session_id,
+      tool_calls: run.tools && run.tools.length ? run.tools : void 0,
+      reasoning_steps: run.reasoning_steps ?? run.extra_data?.reasoning_steps,
+      references: run.references ?? run.extra_data?.references,
+      images: run.images,
+      videos: run.videos,
+      audio: run.audio,
+      response_audio: run.response_audio
+    });
+  }
+  return messages;
+}
+
+// src/useAgnoChat.ts
+var messageCounter = 0;
+var nextId = () => `m${Date.now().toString(36)}-${(messageCounter++).toString(36)}`;
+var nowSeconds = () => Math.floor(Date.now() / 1e3);
+function useAgnoChat(options) {
+  const { entity, userId, onEvent, onSessionId } = options;
+  const client = react.useMemo(() => {
+    if (options.client) return options.client;
+    return new AgnoClient({ baseUrl: options.baseUrl ?? "", headers: options.headers });
+  }, [options.client, options.baseUrl, JSON.stringify(options.headers)]);
+  const [messages, setMessages] = react.useState(options.initialMessages ?? []);
+  const [events, setEvents] = react.useState([]);
+  const [currentEvent, setCurrentEvent] = react.useState(null);
+  const [status, setStatus] = react.useState("idle");
+  const [activity, setActivity] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const [sessionId, setSessionId] = react.useState(options.sessionId);
+  const [sessions, setSessions] = react.useState([]);
+  const [sessionsLoading, setSessionsLoading] = react.useState(false);
+  const abortRef = react.useRef(null);
+  const activeMsgIdRef = react.useRef(null);
+  const lastContentRef = react.useRef("");
+  const runIdRef = react.useRef(void 0);
+  const entityRef = react.useRef(entity);
+  const sessionIdRef = react.useRef(options.sessionId);
+  react.useEffect(() => {
+    entityRef.current = entity;
+  }, [entity]);
+  react.useEffect(() => {
+    sessionIdRef.current = sessionId;
+  }, [sessionId]);
+  const patchActive = react.useCallback((patch) => {
+    const id2 = activeMsgIdRef.current;
+    if (!id2) return;
+    setMessages((prev) => prev.map((m) => m.id === id2 ? patch(m) : m));
+  }, []);
+  const applyEvent = react.useCallback(
+    (e) => {
+      setEvents((prev) => [...prev, e]);
+      setCurrentEvent(e);
+      onEvent?.(e);
+      const label2 = activityLabel(e);
+      if (label2) setActivity(label2);
+      if (e.session_id && e.session_id !== sessionIdRef.current) {
+        sessionIdRef.current = e.session_id;
+        setSessionId(e.session_id);
+        onSessionId?.(e.session_id);
+      }
+      if (e.run_id && !e.parent_run_id) runIdRef.current = e.run_id;
+      if (isSubRunEvent(e)) {
+        const kind = entityRef.current?.type === "workflow" ? "executor" : "member";
+        patchActive((m) => applySubRunEvent(m, e, kind));
+        return;
+      }
+      if (isStepEvent(e)) {
+        patchActive((m) => applyStepEvent(m, e));
+        return;
+      }
+      if (isStartedEvent(e)) {
+        patchActive((m) => ({ ...m, run_id: e.run_id ?? m.run_id, session_id: e.session_id ?? m.session_id, status: "streaming" }));
+        return;
+      }
+      if (isToolEvent(e)) {
+        const incoming = toolsFromEvent(e);
+        if (incoming.length) {
+          patchActive((m) => {
+            let tool_calls = m.tool_calls ?? [];
+            for (const t of incoming) tool_calls = mergeTool(tool_calls, t);
+            return { ...m, tool_calls };
+          });
+        }
+        return;
+      }
+      if (isContentEvent(e)) {
+        patchActive((m) => {
+          const next = { ...m };
+          if (typeof e.content === "string" && e.content) {
+            const unique = e.content.startsWith(lastContentRef.current) ? e.content.slice(lastContentRef.current.length) : e.content;
+            next.content = (m.content ?? "") + unique;
+            lastContentRef.current = e.content.length >= lastContentRef.current.length ? e.content : lastContentRef.current;
+          } else if (e.content && typeof e.content === "object") {
+            next.content = (m.content ?? "") + "\n```json\n" + JSON.stringify(e.content, null, 2) + "\n```\n";
+          }
+          if (e.reasoning_steps?.length) next.reasoning_steps = e.reasoning_steps;
+          if (e.extra_data?.reasoning_steps?.length) next.reasoning_steps = e.extra_data.reasoning_steps;
+          if (e.references?.length) next.references = e.references;
+          if (e.extra_data?.references?.length) next.references = e.extra_data.references;
+          if (e.citations) next.citations = e.citations;
+          const tools = toolsFromEvent(e);
+          if (tools.length) {
+            let tc = m.tool_calls ?? [];
+            for (const t of tools) tc = mergeTool(tc, t);
+            next.tool_calls = tc;
+          }
+          if (e.images?.length) next.images = e.images;
+          if (e.videos?.length) next.videos = e.videos;
+          if (e.audio?.length) next.audio = e.audio;
+          if (e.response_audio?.transcript) {
+            next.response_audio = {
+              ...m.response_audio,
+              transcript: (m.response_audio?.transcript ?? "") + e.response_audio.transcript
+            };
+          }
+          return next;
+        });
+        return;
+      }
+      if (isReasoningStepEvent(e)) {
+        const incoming = e.reasoning_steps ?? e.extra_data?.reasoning_steps ?? [];
+        if (incoming.length) {
+          patchActive((m) => ({
+            ...m,
+            reasoning_steps: [...m.reasoning_steps ?? [], ...incoming]
+          }));
+        }
+        return;
+      }
+      if (isReasoningCompletedEvent(e)) {
+        const steps = e.reasoning_steps ?? e.extra_data?.reasoning_steps;
+        if (steps?.length) patchActive((m) => ({ ...m, reasoning_steps: steps }));
+        return;
+      }
+      if (isPausedEvent(e)) {
+        const requirements = e.requirements ?? [];
+        const pausedTools2 = toolsFromEvent(e);
+        setStatus("paused");
+        setActivity("Waiting for input");
+        patchActive((m) => {
+          let tool_calls = m.tool_calls ?? [];
+          for (const t of pausedTools2) tool_calls = mergeTool(tool_calls, t);
+          return { ...m, status: "paused", streaming: false, requirements, tool_calls };
+        });
+        return;
+      }
+      if (isCompletedEvent(e)) {
+        patchActive((m) => {
+          const next = { ...m, streaming: false, status: "completed" };
+          if (typeof e.content === "string" && e.content) next.content = e.content;
+          const tools = toolsFromEvent(e);
+          if (tools.length) {
+            let tc = m.tool_calls ?? [];
+            for (const t of tools) tc = mergeTool(tc, t);
+            next.tool_calls = tc;
+          }
+          if (e.reasoning_steps?.length) next.reasoning_steps = e.reasoning_steps;
+          if (e.references?.length) next.references = e.references;
+          if (e.images?.length) next.images = e.images;
+          if (e.videos?.length) next.videos = e.videos;
+          if (e.audio?.length) next.audio = e.audio;
+          if (e.response_audio) next.response_audio = e.response_audio;
+          return next;
+        });
+        return;
+      }
+      if (isCancelledEvent(e)) {
+        patchActive((m) => ({ ...m, streaming: false, status: "cancelled" }));
+        setStatus("cancelled");
+        return;
+      }
+      if (isErrorEvent(e)) {
+        const msg = typeof e.content === "string" ? e.content : e.error || "Error during run";
+        patchActive((m) => ({ ...m, streaming: false, status: "error", error: msg }));
+        setError(msg);
+        setStatus("error");
+        return;
+      }
+    },
+    [onEvent, onSessionId, patchActive]
+  );
+  const drive = react.useCallback(
+    async (starter) => {
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setError(null);
+      setStatus("streaming");
+      lastContentRef.current = "";
+      await starter({
+        signal: controller.signal,
+        onEvent: applyEvent,
+        onError: (err) => {
+          patchActive((m) => ({ ...m, streaming: false, status: "error", error: err.message }));
+          setError(err.message);
+          setStatus("error");
+        },
+        onComplete: () => {
+          setActivity(null);
+          patchActive((m) => m.streaming ? { ...m, streaming: false } : m);
+          setStatus((s) => s === "streaming" ? "completed" : s);
+        }
+      });
+      abortRef.current = null;
+    },
+    [applyEvent, patchActive]
+  );
+  const sendMessage = react.useCallback(
+    async (message, sendOptions) => {
+      const ent = entityRef.current;
+      if (!ent) {
+        setError("No agent, team or workflow selected.");
+        return;
+      }
+      const userMsg = {
+        id: nextId(),
+        role: "user",
+        content: message,
+        created_at: nowSeconds()
+      };
+      const agentMsg = {
+        id: nextId(),
+        role: "agent",
+        content: "",
+        created_at: nowSeconds() + 1,
+        streaming: true,
+        status: "streaming",
+        tool_calls: [],
+        events: []
+      };
+      activeMsgIdRef.current = agentMsg.id;
+      setEvents([]);
+      setCurrentEvent(null);
+      setMessages((prev) => [...prev, userMsg, agentMsg]);
+      await drive(
+        (cb) => client.run({
+          type: ent.type,
+          id: ent.id,
+          message,
+          sessionId: sessionIdRef.current,
+          userId,
+          files: sendOptions?.files,
+          ...cb
+        })
+      );
+    },
+    [client, drive, userId]
+  );
+  const continueRun = react.useCallback(
+    async (resolution) => {
+      const ent = entityRef.current;
+      const runId = runIdRef.current;
+      if (!ent || !runId) {
+        setError("No paused run to continue.");
+        return;
+      }
+      patchActive((m) => ({ ...m, streaming: true, status: "streaming", requirements: void 0 }));
+      await drive(
+        (cb) => client.continueRun({
+          type: ent.type,
+          id: ent.id,
+          runId,
+          sessionId: sessionIdRef.current,
+          userId,
+          tools: resolution.tools,
+          stepRequirements: resolution.stepRequirements,
+          ...cb
+        })
+      );
+    },
+    [client, drive, patchActive, userId]
+  );
+  const activeMessage = react.useMemo(
+    () => messages.find((m) => m.id === activeMsgIdRef.current) ?? null,
+    [messages]
+  );
+  const pausedTools = react.useMemo(
+    () => (activeMessage?.tool_calls ?? []).filter((t) => t.requires_confirmation || t.requires_user_input),
+    [activeMessage]
+  );
+  const respondToConfirmation = react.useCallback(
+    async (approve) => {
+      const ent = entityRef.current;
+      if (ent?.type === "workflow") {
+        const reqs = (activeMessage?.requirements ?? []).map((r) => ({ ...r, confirmation: approve }));
+        await continueRun({ stepRequirements: reqs });
+        return;
+      }
+      const resolved = pausedTools.map((t) => ({ ...t, confirmed: approve }));
+      await continueRun({ tools: resolved });
+    },
+    [activeMessage, continueRun, pausedTools]
+  );
+  const submitUserInput = react.useCallback(
+    async (values) => {
+      const ent = entityRef.current;
+      if (ent?.type === "workflow") {
+        const reqs = (activeMessage?.requirements ?? []).map((r) => ({
+          ...r,
+          user_input_schema: (r.user_input_schema ?? []).map((f) => ({
+            ...f,
+            value: f.name in values ? values[f.name] : f.value
+          }))
+        }));
+        await continueRun({ stepRequirements: reqs });
+        return;
+      }
+      const resolved = pausedTools.map((t) => ({
+        ...t,
+        confirmed: true,
+        user_input_schema: (t.user_input_schema ?? []).map((f) => ({
+          ...f,
+          value: f.name in values ? values[f.name] : f.value
+        }))
+      }));
+      await continueRun({ tools: resolved });
+    },
+    [activeMessage, continueRun, pausedTools]
+  );
+  const cancel = react.useCallback(async () => {
+    abortRef.current?.abort();
+    const ent = entityRef.current;
+    const runId = runIdRef.current;
+    setStatus("cancelled");
+    setActivity(null);
+    patchActive((m) => m.streaming ? { ...m, streaming: false, status: "cancelled" } : m);
+    if (ent && runId) await client.cancelRun(ent.type, ent.id, runId, sessionIdRef.current);
+  }, [client, patchActive]);
+  const refreshSessions = react.useCallback(async () => {
+    const ent = entityRef.current;
+    if (!ent) {
+      setSessions([]);
+      return;
+    }
+    setSessionsLoading(true);
+    try {
+      const res = await client.getSessions(ent.type, ent.id, ent.db_id);
+      setSessions(res.data ?? []);
+    } finally {
+      setSessionsLoading(false);
+    }
+  }, [client]);
+  const loadSession = react.useCallback(
+    async (id2) => {
+      const ent = entityRef.current;
+      if (!ent) return;
+      abortRef.current?.abort();
+      activeMsgIdRef.current = null;
+      runIdRef.current = void 0;
+      lastContentRef.current = "";
+      setEvents([]);
+      setCurrentEvent(null);
+      setStatus("idle");
+      setActivity(null);
+      setError(null);
+      sessionIdRef.current = id2;
+      setSessionId(id2);
+      onSessionId?.(id2);
+      try {
+        const runs = await client.getSessionRuns(ent.type, id2, ent.db_id);
+        setMessages(sessionRunsToMessages(runs));
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+      }
+    },
+    [client, onSessionId]
+  );
+  const deleteSession = react.useCallback(
+    async (id2) => {
+      const ent = entityRef.current;
+      const ok = await client.deleteSession(id2, ent?.db_id);
+      if (ok) {
+        setSessions((prev) => prev.filter((s) => s.session_id !== id2));
+        if (sessionIdRef.current === id2) {
+          sessionIdRef.current = void 0;
+          setSessionId(void 0);
+          setMessages([]);
+        }
+      }
+    },
+    [client]
+  );
+  const reset = react.useCallback(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+    activeMsgIdRef.current = null;
+    runIdRef.current = void 0;
+    lastContentRef.current = "";
+    sessionIdRef.current = void 0;
+    setMessages([]);
+    setEvents([]);
+    setCurrentEvent(null);
+    setStatus("idle");
+    setActivity(null);
+    setError(null);
+    setSessionId(void 0);
+  }, []);
+  react.useEffect(() => () => abortRef.current?.abort(), []);
+  const streamingMessage = react.useMemo(
+    () => messages.find((m) => m.role === "agent" && m.streaming) ?? null,
+    [messages]
+  );
+  return {
+    messages,
+    streamingMessage,
+    events,
+    currentEvent,
+    status,
+    activity,
+    isStreaming: status === "streaming",
+    isPaused: status === "paused",
+    error,
+    sessionId,
+    entityType: entity?.type,
+    tools: activeMessage?.tool_calls ?? [],
+    reasoning: activeMessage?.reasoning_steps,
+    pendingRequirements: activeMessage?.requirements ?? [],
+    sessions,
+    sessionsLoading,
+    sendMessage,
+    cancel,
+    continueRun,
+    respondToConfirmation,
+    submitUserInput,
+    refreshSessions,
+    loadSession,
+    deleteSession,
+    reset,
+    setMessages,
+    client
+  };
+}
+function ChatInput({
+  onSend,
+  onStop,
+  disabled,
+  busy,
+  placeholder = "Ask anything",
+  allowFiles = false
+}) {
+  const [value, setValue] = react.useState("");
+  const [files, setFiles] = react.useState([]);
+  const fileRef = react.useRef(null);
+  const submit = () => {
+    const text = value.trim();
+    if (!text && files.length === 0) return;
+    onSend(text, files.length ? files : void 0);
+    setValue("");
+    setFiles([]);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-input", children: [
+    files.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-input__files", children: files.map((f, i) => /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "agno-input__file", children: [
+      f.name,
+      /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", onClick: () => setFiles((prev) => prev.filter((_, j) => j !== i)), "aria-label": "Remove", children: "\xD7" })
+    ] }, i)) }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-input__row", children: [
+      allowFiles && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            className: "agno-input__attach",
+            onClick: () => fileRef.current?.click(),
+            disabled,
+            "aria-label": "Attach files",
+            children: "\u{1F4CE}"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            ref: fileRef,
+            type: "file",
+            multiple: true,
+            hidden: true,
+            onChange: (e) => setFiles((prev) => [...prev, ...Array.from(e.target.files ?? [])])
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "textarea",
+        {
+          className: "agno-input__textarea",
+          value,
+          placeholder,
+          disabled,
+          rows: 1,
+          onChange: (e) => setValue(e.target.value),
+          onKeyDown: (e) => {
+            if (e.key === "Enter" && !e.shiftKey) {
+              e.preventDefault();
+              submit();
+            }
+          }
+        }
+      ),
+      busy && onStop ? /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "agno-input__send agno-input__send--stop", onClick: onStop, "aria-label": "Stop", children: /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, children: "\u25A0" }) }) : /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: "agno-input__send",
+          onClick: submit,
+          disabled: disabled || !value.trim() && files.length === 0,
+          "aria-label": "Send",
+          children: /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, children: "\u27A4" })
+        }
+      )
+    ] })
+  ] });
+}
+var isBoolField = (f) => f.field_type === "bool" || f.field_type === "boolean";
+function buildAsks(message, entityType) {
+  const fromTools = (message.tool_calls ?? []).filter((t) => t.requires_confirmation || t.requires_user_input).map((t) => ({
+    id: t.tool_call_id ?? `${t.tool_name}`,
+    name: t.tool_name,
+    args: t.tool_args,
+    needsConfirmation: Boolean(t.requires_confirmation) && t.confirmed == null,
+    fields: t.requires_user_input ? t.user_input_schema ?? [] : [],
+    tool: t
+  }));
+  const fromReqs = (message.requirements ?? []).map((r) => ({
+    id: r.id,
+    name: r.tool_execution?.tool_name,
+    args: r.tool_execution?.tool_args,
+    needsConfirmation: Boolean(r.tool_execution?.requires_confirmation) || r.confirmation == null,
+    fields: r.user_input_schema ?? r.tool_execution?.user_input_schema ?? [],
+    requirement: r
+  }));
+  if (entityType === "workflow") return fromReqs.length ? fromReqs : fromTools;
+  return fromTools.length ? fromTools : fromReqs;
+}
+function HumanInput({ message, entityType, busy, onResolve }) {
+  const asks = react.useMemo(() => buildAsks(message, entityType), [message, entityType]);
+  const [choices, setChoices] = react.useState({});
+  const [values, setValues] = react.useState({});
+  const [reasons, setReasons] = react.useState({});
+  const [openArgs, setOpenArgs] = react.useState({});
+  if (asks.length === 0) return null;
+  const setValue = (id2, name2, value) => setValues((v) => ({ ...v, [id2]: { ...v[id2] ?? {}, [name2]: value } }));
+  const valueFor = (ask, field) => values[ask.id]?.[field.name] ?? field.value ?? (isBoolField(field) ? false : "");
+  const fillFields = (ask) => ask.fields.map((f) => ({ ...f, value: valueFor(ask, f) }));
+  const ready = asks.every((a) => !a.needsConfirmation || choices[a.id]);
+  const submit = () => {
+    if (entityType === "workflow") {
+      const stepRequirements = asks.map((a) => {
+        const approved = a.needsConfirmation ? choices[a.id] === "confirm" : true;
+        return {
+          id: a.id,
+          confirmation: approved,
+          ...a.fields.length ? { user_input_schema: fillFields(a) } : {},
+          tool_execution: a.requirement?.tool_execution,
+          ...reasons[a.id] ? { confirmation_note: reasons[a.id] } : {}
+        };
+      });
+      onResolve({ stepRequirements });
+      return;
+    }
+    const tools = asks.map((a) => {
+      const base = a.tool ?? { tool_call_id: a.id, tool_name: a.name };
+      const approved = a.needsConfirmation ? choices[a.id] === "confirm" : true;
+      return {
+        ...base,
+        ...a.needsConfirmation ? { confirmed: approved } : {},
+        ...a.fields.length ? { answered: true, user_input_schema: fillFields(a) } : {},
+        ...reasons[a.id] ? { confirmation_note: reasons[a.id] } : {}
+      };
+    });
+    onResolve({ tools });
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-hitl", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-hitl__title", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, children: "\u270B" }),
+      " Your input is needed"
+    ] }),
+    asks.map((ask) => {
+      const choice = choices[ask.id];
+      const hasArgs = ask.args && Object.keys(ask.args).length > 0;
+      const argsOpen = openArgs[ask.id] ?? true;
+      return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-hitl-card", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-hitl-card__head", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "agno-hitl-card__tool", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-hitl-card__icon", "aria-hidden": true, children: "\u{1F527}" }),
+            ask.name ?? "tool"
+          ] }),
+          ask.needsConfirmation && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "agno-hitl-card__choices", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                className: `agno-hitl-card__choice ${choice === "reject" ? "is-active is-reject" : ""}`,
+                "aria-label": "Reject",
+                disabled: busy,
+                onClick: () => setChoices((c) => ({ ...c, [ask.id]: "reject" })),
+                children: "\u2715"
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                className: `agno-hitl-card__choice ${choice === "confirm" ? "is-active is-confirm" : ""}`,
+                "aria-label": "Approve",
+                disabled: busy,
+                onClick: () => setChoices((c) => ({ ...c, [ask.id]: "confirm" })),
+                children: "\u2713"
+              }
+            )
+          ] })
+        ] }),
+        hasArgs && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-hitl-card__args", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "button",
+            {
+              type: "button",
+              className: "agno-hitl-card__args-head",
+              onClick: () => setOpenArgs((o) => ({ ...o, [ask.id]: !argsOpen })),
+              children: [
+                "Arguments",
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-hitl-card__chev", children: argsOpen ? "\u25B2" : "\u25BC" })
+              ]
+            }
+          ),
+          argsOpen && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-hitl-card__args-body", children: Object.entries(ask.args ?? {}).map(([k, v]) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-hitl-card__arg", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-hitl-card__arg-key", children: k }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-hitl-card__arg-val", children: typeof v === "object" ? JSON.stringify(v) : String(v) })
+          ] }, k)) })
+        ] }),
+        choice === "reject" && /* @__PURE__ */ jsxRuntime.jsx(
+          "textarea",
+          {
+            className: "agno-hitl-card__reason",
+            placeholder: "Reason for rejection (optional)\u2026",
+            rows: 2,
+            value: reasons[ask.id] ?? "",
+            disabled: busy,
+            onChange: (e) => setReasons((r) => ({ ...r, [ask.id]: e.target.value }))
+          }
+        ),
+        ask.fields.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-hitl-card__fields", children: ask.fields.map((field) => /* @__PURE__ */ jsxRuntime.jsxs("label", { className: `agno-hitl-card__field ${isBoolField(field) ? "is-bool" : ""}`, children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-hitl-card__field-name", children: field.description || field.name }),
+          isBoolField(field) ? /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              type: "checkbox",
+              checked: Boolean(valueFor(ask, field)),
+              disabled: busy,
+              onChange: (e) => setValue(ask.id, field.name, e.target.checked)
+            }
+          ) : /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              className: "agno-hitl-card__input",
+              value: String(valueFor(ask, field) ?? ""),
+              placeholder: field.field_type ?? "text",
+              disabled: busy,
+              onChange: (e) => setValue(ask.id, field.name, e.target.value)
+            }
+          )
+        ] }, field.name)) })
+      ] }, ask.id);
+    }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-hitl__actions", children: /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "agno-btn agno-btn--primary", disabled: busy || !ready, onClick: submit, children: "Continue" }) })
+  ] });
+}
+function Citations({
+  references,
+  citations
+}) {
+  const [open, setOpen] = react.useState(false);
+  const refCount = references?.reduce((n, r) => n + (r.references?.length ?? 0), 0) ?? 0;
+  const urls = citations?.urls ?? [];
+  const total = refCount + urls.length;
+  if (total === 0) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-citations", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("button", { type: "button", className: "agno-citations__toggle", onClick: () => setOpen((v) => !v), children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, children: "\u{1F4DA}" }),
+      " ",
+      total,
+      " source",
+      total > 1 ? "s" : "",
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-citations__chev", children: open ? "\u25B2" : "\u25BC" })
+    ] }),
+    open && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-citations__body", children: [
+      references?.map(
+        (group, gi) => (group.references ?? []).map((ref, ri) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-citations__item", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-citations__name", children: ref.name ?? "reference" }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-citations__snippet", children: ref.content })
+        ] }, `r-${gi}-${ri}`))
+      ),
+      urls.map((u, i) => /* @__PURE__ */ jsxRuntime.jsx(
+        "a",
+        {
+          className: "agno-citations__url",
+          href: u.url,
+          target: "_blank",
+          rel: "noreferrer noopener",
+          children: u.title ?? u.url
+        },
+        `u-${i}`
+      ))
+    ] })
+  ] });
+}
+function renderInline(text, keyPrefix) {
+  const nodes = [];
+  const regex = /(`[^`]+`)|(\*\*[^*]+\*\*)|(\*[^*]+\*)|(\[[^\]]+\]\([^)]+\))/g;
+  let last = 0;
+  let match;
+  let i = 0;
+  while ((match = regex.exec(text)) !== null) {
+    if (match.index > last) nodes.push(text.slice(last, match.index));
+    const token = match[0];
+    const key = `${keyPrefix}-${i++}`;
+    if (token.startsWith("`")) {
+      nodes.push(/* @__PURE__ */ jsxRuntime.jsx("code", { className: "agno-md-code", children: token.slice(1, -1) }, key));
+    } else if (token.startsWith("**")) {
+      nodes.push(/* @__PURE__ */ jsxRuntime.jsx("strong", { children: token.slice(2, -2) }, key));
+    } else if (token.startsWith("*")) {
+      nodes.push(/* @__PURE__ */ jsxRuntime.jsx("em", { children: token.slice(1, -1) }, key));
+    } else {
+      const m = /\[([^\]]+)\]\(([^)]+)\)/.exec(token);
+      if (m) {
+        nodes.push(
+          /* @__PURE__ */ jsxRuntime.jsx("a", { href: m[2], target: "_blank", rel: "noreferrer noopener", children: m[1] }, key)
+        );
+      } else {
+        nodes.push(token);
+      }
+    }
+    last = match.index + token.length;
+  }
+  if (last < text.length) nodes.push(text.slice(last));
+  return nodes;
+}
+function Markdown({ content, className }) {
+  const blocks = [];
+  const segments = content.split(/(```[\s\S]*?```)/g);
+  segments.forEach((segment, si) => {
+    if (segment.startsWith("```")) {
+      const body = segment.replace(/^```[^\n]*\n?/, "").replace(/```$/, "");
+      blocks.push(
+        /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "agno-md-pre", children: /* @__PURE__ */ jsxRuntime.jsx("code", { children: body }) }, `pre-${si}`)
+      );
+      return;
+    }
+    const lines = segment.split("\n");
+    let listBuffer = [];
+    const flushList = (key) => {
+      if (!listBuffer.length) return;
+      blocks.push(
+        /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "agno-md-list", children: listBuffer.map((item, ii) => /* @__PURE__ */ jsxRuntime.jsx("li", { children: renderInline(item, `${key}-${ii}`) }, ii)) }, key)
+      );
+      listBuffer = [];
+    };
+    lines.forEach((line, li) => {
+      const key = `${si}-${li}`;
+      const heading = /^(#{1,4})\s+(.*)$/.exec(line);
+      const listItem = /^\s*[-*]\s+(.*)$/.exec(line);
+      if (listItem) {
+        listBuffer.push(listItem[1]);
+        return;
+      }
+      flushList(`ul-${key}`);
+      if (heading) {
+        const level = heading[1].length;
+        const Tag = `h${Math.min(level + 1, 6)}`;
+        blocks.push(
+          /* @__PURE__ */ jsxRuntime.jsx(Tag, { className: "agno-md-heading", children: renderInline(heading[2], `h-${key}`) }, `h-${key}`)
+        );
+      } else if (line.trim() === "") ; else {
+        blocks.push(
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "agno-md-p", children: renderInline(line, `p-${key}`) }, `p-${key}`)
+        );
+      }
+    });
+    flushList(`ul-end-${si}`);
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: ["agno-md", className].filter(Boolean).join(" "), children: blocks });
+}
+function statusOf(tool) {
+  if (tool.tool_call_error) return { label: "error", cls: "error" };
+  if (tool.requires_confirmation && tool.confirmed == null) return { label: "awaiting approval", cls: "paused" };
+  if (tool.requires_user_input && !tool.answered) return { label: "awaiting input", cls: "paused" };
+  if (tool.result != null) return { label: "done", cls: "done" };
+  return { label: "running", cls: "running" };
+}
+function ToolCall({ tool }) {
+  const [open, setOpen] = react.useState(false);
+  const status = statusOf(tool);
+  const hasDetail = Boolean(tool.tool_args && Object.keys(tool.tool_args).length) || tool.result != null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `agno-tool agno-tool--${status.cls}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        className: "agno-tool__head",
+        onClick: () => hasDetail && setOpen((v) => !v),
+        "aria-expanded": open,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-tool__icon", "aria-hidden": true, children: "\u{1F527}" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-tool__name", children: tool.tool_name ?? "tool" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: `agno-tool__status agno-tool__status--${status.cls}`, children: status.label }),
+          hasDetail && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-tool__chev", children: open ? "\u25B2" : "\u25BC" })
+        ]
+      }
+    ),
+    open && hasDetail && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-tool__body", children: [
+      tool.tool_args && Object.keys(tool.tool_args).length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-tool__section", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-tool__label", children: "Arguments" }),
+        /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "agno-tool__pre", children: JSON.stringify(tool.tool_args, null, 2) })
+      ] }),
+      tool.result != null && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-tool__section", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-tool__label", children: "Result" }),
+        /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "agno-tool__pre", children: String(tool.result) })
+      ] })
+    ] })
+  ] });
+}
+function ToolCalls({ tools }) {
+  if (!tools || tools.length === 0) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-tools", children: tools.map((tool, i) => /* @__PURE__ */ jsxRuntime.jsx(ToolCall, { tool }, tool.tool_call_id ?? `${tool.tool_name}-${i}`)) });
+}
+function statusDot(status) {
+  if (status === "error") return "error";
+  if (status === "completed") return "done";
+  return "running";
+}
+function MemberCard({ member, renderMarkdown }) {
+  const [open, setOpen] = react.useState(true);
+  const label2 = member.kind === "executor" ? "Step executor" : "Member";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-member", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("button", { type: "button", className: "agno-member__head", onClick: () => setOpen((v) => !v), "aria-expanded": open, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: `agno-member__dot agno-member__dot--${statusDot(member.status)}`, "aria-hidden": true }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-member__name", children: member.name ?? member.agent_id ?? label2 }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-member__kind", children: label2 }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-member__chev", children: open ? "\u25B2" : "\u25BC" })
+    ] }),
+    open && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-member__body", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ToolCalls, { tools: member.tool_calls }),
+      member.content && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-member__content", children: renderMarkdown ? renderMarkdown(member.content) : /* @__PURE__ */ jsxRuntime.jsx(Markdown, { content: member.content }) })
+    ] })
+  ] });
+}
+function MemberResponses({
+  members,
+  renderMarkdown,
+  title = "Member responses"
+}) {
+  if (!members || members.length === 0) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-members", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-members__title", children: [
+      title,
+      " (",
+      members.length,
+      ")"
+    ] }),
+    members.map((m) => /* @__PURE__ */ jsxRuntime.jsx(MemberCard, { member: m, renderMarkdown }, m.run_id))
+  ] });
+}
+function audioSrc(a) {
+  if (a.url) return a.url;
+  if (a.base64_audio) return `data:${a.mime_type ?? "audio/mpeg"};base64,${a.base64_audio}`;
+  if (a.content) return `data:${a.mime_type ?? "audio/wav"};base64,${a.content}`;
+  return void 0;
+}
+function Multimedia({
+  images,
+  videos,
+  audio,
+  responseAudio
+}) {
+  const audios = [...audio ?? [], ...responseAudio ? [responseAudio] : []];
+  if (!images?.length && !videos?.length && !audios.length) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-media", children: [
+    images?.map(
+      (img, i) => img.url ? /* @__PURE__ */ jsxRuntime.jsx("img", { className: "agno-media__img", src: img.url, alt: img.revised_prompt ?? "image" }, `img-${i}`) : null
+    ),
+    videos?.map(
+      (v, i) => v.url ? /* @__PURE__ */ jsxRuntime.jsx("video", { className: "agno-media__video", src: v.url, controls: true }, `vid-${i}`) : null
+    ),
+    audios.map((a, i) => {
+      const src = audioSrc(a);
+      return src ? /* @__PURE__ */ jsxRuntime.jsx("audio", { className: "agno-media__audio", src, controls: true }, `aud-${i}`) : null;
+    })
+  ] });
+}
+function Reasoning({
+  steps,
+  defaultOpen = false
+}) {
+  const [open, setOpen] = react.useState(defaultOpen);
+  if (!steps || steps.length === 0) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-reasoning", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("button", { type: "button", className: "agno-reasoning__toggle", onClick: () => setOpen((v) => !v), children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, children: "\u{1F4AD}" }),
+      " Reasoning (",
+      steps.length,
+      " step",
+      steps.length > 1 ? "s" : "",
+      ")",
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-reasoning__chev", children: open ? "\u25B2" : "\u25BC" })
+    ] }),
+    open && /* @__PURE__ */ jsxRuntime.jsx("ol", { className: "agno-reasoning__list", children: steps.map((step, i) => /* @__PURE__ */ jsxRuntime.jsxs("li", { className: "agno-reasoning__step", children: [
+      step.title && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-reasoning__title", children: step.title }),
+      step.reasoning && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-reasoning__text", children: step.reasoning }),
+      step.action && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-reasoning__meta", children: [
+        "Action: ",
+        step.action
+      ] }),
+      step.result && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-reasoning__meta", children: [
+        "Result: ",
+        step.result
+      ] }),
+      typeof step.confidence === "number" && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-reasoning__meta", children: [
+        "Confidence: ",
+        Math.round(step.confidence * 100),
+        "%"
+      ] })
+    ] }, i)) })
+  ] });
+}
+function StepRow({ step, renderMarkdown }) {
+  const [open, setOpen] = react.useState(false);
+  const hasBody = Boolean(step.content || step.error);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `agno-step agno-step--${step.status}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        className: "agno-step__head",
+        onClick: () => hasBody && setOpen((v) => !v),
+        "aria-expanded": open,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: `agno-step__icon agno-step__icon--${step.status}`, "aria-hidden": true, children: step.status === "completed" ? "\u2713" : step.status === "error" ? "!" : "\u25CF" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-step__name", children: step.name ?? step.key }),
+          hasBody && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-step__chev", children: open ? "\u25B2" : "\u25BC" })
+        ]
+      }
+    ),
+    open && hasBody && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-step__body", children: step.error ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-step__error", children: step.error }) : step.content ? renderMarkdown ? renderMarkdown(step.content) : /* @__PURE__ */ jsxRuntime.jsx(Markdown, { content: step.content }) : null })
+  ] });
+}
+function WorkflowSteps({
+  steps,
+  renderMarkdown,
+  title = "Steps"
+}) {
+  if (!steps || steps.length === 0) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-steps", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-steps__title", children: [
+      title,
+      " (",
+      steps.length,
+      ")"
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-steps__list", children: steps.map((s) => /* @__PURE__ */ jsxRuntime.jsx(StepRow, { step: s, renderMarkdown }, s.key)) })
+  ] });
+}
+function Message({ message, renderMarkdown, activity, hideReasoning, hideTools }) {
+  const isUser = message.role === "user";
+  const isAgent = message.role === "agent";
+  const hasActivity = !message.content && !message.tool_calls?.length && !message.steps?.length && !message.members?.length && !message.reasoning_steps?.length;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `agno-msg agno-msg--${message.role}`, "data-status": message.status, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-msg__avatar", "aria-hidden": true, children: isUser ? "\u{1F464}" : isAgent ? "A" : "\u2699" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-msg__body", children: [
+      isAgent && !hideReasoning && /* @__PURE__ */ jsxRuntime.jsx(Reasoning, { steps: message.reasoning_steps }),
+      isAgent && /* @__PURE__ */ jsxRuntime.jsx(WorkflowSteps, { steps: message.steps, renderMarkdown }),
+      isAgent && /* @__PURE__ */ jsxRuntime.jsx(MemberResponses, { members: message.members, renderMarkdown }),
+      isAgent && !hideTools && /* @__PURE__ */ jsxRuntime.jsx(ToolCalls, { tools: message.tool_calls }),
+      message.content ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-msg__content", children: [
+        renderMarkdown ? renderMarkdown(message.content) : /* @__PURE__ */ jsxRuntime.jsx(Markdown, { content: message.content }),
+        message.streaming && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-msg__caret", "aria-hidden": true })
+      ] }) : isAgent && message.streaming && hasActivity && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-msg__activity", role: "status", "aria-live": "polite", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "agno-status__dots", "aria-hidden": true, children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", {}),
+          /* @__PURE__ */ jsxRuntime.jsx("span", {}),
+          /* @__PURE__ */ jsxRuntime.jsx("span", {})
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-msg__activity-label", children: activity ?? "Working" })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        Multimedia,
+        {
+          images: message.images,
+          videos: message.videos,
+          audio: message.audio,
+          responseAudio: message.response_audio
+        }
+      ),
+      isAgent && /* @__PURE__ */ jsxRuntime.jsx(Citations, { references: message.references, citations: message.citations }),
+      message.error && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-msg__error", children: message.error })
+    ] })
+  ] });
+}
+function MessageList({
+  messages,
+  status,
+  activity,
+  renderMarkdown,
+  emptyState,
+  footer
+}) {
+  const endRef = react.useRef(null);
+  const stick = react.useRef(true);
+  const containerRef = react.useRef(null);
+  const onScroll = () => {
+    const el = containerRef.current;
+    if (!el) return;
+    stick.current = el.scrollHeight - el.scrollTop - el.clientHeight < 80;
+  };
+  react.useEffect(() => {
+    if (stick.current) endRef.current?.scrollIntoView({ behavior: "smooth", block: "end" });
+  }, [messages, activity, status]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-list", ref: containerRef, onScroll, children: [
+    messages.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-list__empty", children: emptyState ?? "Start the conversation." }),
+    messages.map((m) => /* @__PURE__ */ jsxRuntime.jsx(
+      Message,
+      {
+        message: m,
+        renderMarkdown,
+        activity: m.streaming && status === "streaming" ? activity : void 0
+      },
+      m.id
+    )),
+    footer,
+    /* @__PURE__ */ jsxRuntime.jsx("div", { ref: endRef })
+  ] });
+}
+function ChatWindow({
+  chat,
+  placeholder,
+  emptyState,
+  allowFiles,
+  disabled,
+  renderMarkdown,
+  className
+}) {
+  const pausedMessage = chat.isPaused ? [...chat.messages].reverse().find((m) => m.status === "paused") : void 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: ["agno-chat", className].filter(Boolean).join(" "), children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      MessageList,
+      {
+        messages: chat.messages,
+        status: chat.status,
+        activity: chat.activity,
+        renderMarkdown,
+        emptyState,
+        footer: pausedMessage ? /* @__PURE__ */ jsxRuntime.jsx(
+          HumanInput,
+          {
+            message: pausedMessage,
+            entityType: chat.entityType,
+            busy: chat.isStreaming,
+            onResolve: chat.continueRun
+          }
+        ) : null
+      }
+    ),
+    chat.error && !chat.isPaused && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-chat__error", children: chat.error }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      ChatInput,
+      {
+        onSend: (message, files) => chat.sendMessage(message, files ? { files } : void 0),
+        onStop: chat.cancel,
+        busy: chat.isStreaming,
+        disabled: disabled || chat.isPaused,
+        placeholder,
+        allowFiles
+      }
+    )
+  ] });
+}
+var TYPE_LABEL = {
+  agent: "Agents",
+  team: "Teams",
+  workflow: "Workflows"
+};
+var ORDER = ["agent", "team", "workflow"];
+function EntitySelector({
+  entities,
+  value,
+  onChange,
+  disabled,
+  placeholder = "Select an agent, team or workflow"
+}) {
+  const [open, setOpen] = react.useState(false);
+  const rootRef = react.useRef(null);
+  const key = (e) => `${e.type}:${e.id}`;
+  react.useEffect(() => {
+    if (!open) return;
+    const onDocClick = (e) => {
+      if (rootRef.current && !rootRef.current.contains(e.target)) setOpen(false);
+    };
+    const onKey = (e) => {
+      if (e.key === "Escape") setOpen(false);
+    };
+    document.addEventListener("mousedown", onDocClick);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("mousedown", onDocClick);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [open]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-select", ref: rootRef, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        className: "agno-select__trigger",
+        disabled,
+        "aria-haspopup": "listbox",
+        "aria-expanded": open,
+        onClick: () => setOpen((v) => !v),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-select__value", children: value ? value.name : placeholder }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: `agno-select__chev ${open ? "is-open" : ""}`, "aria-hidden": true, children: "\u2304" })
+        ]
+      }
+    ),
+    open && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-select__panel", role: "listbox", children: [
+      entities.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-select__empty", children: "Nothing available" }),
+      ORDER.map((type) => {
+        const items = entities.filter((e) => e.type === type);
+        if (items.length === 0) return null;
+        return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-select__group", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-select__group-label", children: TYPE_LABEL[type] }),
+          items.map((ent) => {
+            const selected = value ? key(value) === key(ent) : false;
+            return /* @__PURE__ */ jsxRuntime.jsxs(
+              "button",
+              {
+                type: "button",
+                role: "option",
+                "aria-selected": selected,
+                className: `agno-select__option ${selected ? "is-selected" : ""}`,
+                onClick: () => {
+                  onChange(ent);
+                  setOpen(false);
+                },
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-select__check", "aria-hidden": true, children: selected ? "\u2713" : "" }),
+                  /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-select__label", children: ent.name }),
+                  ent.model?.model && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-select__model", children: ent.model.model })
+                ]
+              },
+              key(ent)
+            );
+          })
+        ] }, type);
+      })
+    ] })
+  ] });
+}
+function sourceOf(e) {
+  return e.agent_name || e.team_name || e.workflow_name || e.agent_id || e.team_id || e.workflow_id || void 0;
+}
+function fold(events) {
+  const rows = [];
+  for (const e of events) {
+    const name2 = String(e.event);
+    const source = sourceOf(e);
+    const last = rows[rows.length - 1];
+    if (last && last.event === name2 && last.source === source) {
+      last.count += 1;
+      last.created_at = e.created_at ?? last.created_at;
+      continue;
+    }
+    rows.push({ event: name2, source, count: 1, created_at: e.created_at, detail: activityLabel(e) });
+  }
+  return rows;
+}
+function EventLog({
+  events,
+  autoScroll = true,
+  maxHeight = 240
+}) {
+  const ref = react.useRef(null);
+  const rows = react.useMemo(() => fold(events), [events]);
+  react.useEffect(() => {
+    if (autoScroll && ref.current) ref.current.scrollTop = ref.current.scrollHeight;
+  }, [rows, autoScroll]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-eventlog", ref, style: { maxHeight }, children: [
+    rows.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-eventlog__empty", children: "No events yet." }),
+    rows.map((row, i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-eventlog__row", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-eventlog__name", children: row.event }),
+      row.count > 1 && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "agno-eventlog__count", children: [
+        "\xD7",
+        row.count
+      ] }),
+      row.source && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-eventlog__source", children: row.source }),
+      row.created_at && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-eventlog__time", children: new Date(row.created_at * 1e3).toLocaleTimeString() })
+    ] }, i))
+  ] });
+}
+function label(session) {
+  return session.session_name?.trim() || session.session_id;
+}
+function formatDate(value) {
+  if (value == null) return "";
+  let date;
+  if (typeof value === "number") {
+    date = new Date(value < 1e12 ? value * 1e3 : value);
+  } else {
+    date = new Date(value);
+  }
+  if (Number.isNaN(date.getTime())) return "";
+  return date.toLocaleDateString();
+}
+function SessionList({
+  sessions,
+  activeSessionId,
+  loading,
+  onSelect,
+  onDelete,
+  onNew,
+  title = "Sessions"
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-sessions", children: [
+    onNew && /* @__PURE__ */ jsxRuntime.jsxs("button", { type: "button", className: "agno-sessions__new", onClick: onNew, "aria-label": "New chat", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, children: "+" }),
+      " New Chat"
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-sessions__head", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-sessions__title", children: title }) }),
+    loading && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-sessions__empty", children: "Loading\u2026" }),
+    !loading && sessions.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-sessions__empty", children: "No past sessions." }),
+    /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "agno-sessions__list", children: sessions.map((session) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "li",
+      {
+        className: `agno-sessions__item ${session.session_id === activeSessionId ? "is-active" : ""}`,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("button", { type: "button", className: "agno-sessions__select", onClick: () => onSelect(session.session_id), children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-sessions__name", children: label(session) }),
+            formatDate(session.created_at) && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-sessions__date", children: formatDate(session.created_at) })
+          ] }),
+          onDelete && /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              className: "agno-sessions__delete",
+              "aria-label": "Delete session",
+              onClick: () => onDelete(session.session_id),
+              children: "\u{1F5D1}"
+            }
+          )
+        ]
+      },
+      session.session_id
+    )) })
+  ] });
+}
+function AgnoChat(props) {
+  const client = react.useMemo(
+    () => props.client ?? new AgnoClient({ baseUrl: props.baseUrl ?? "", headers: props.headers }),
+    [props.client, props.baseUrl, props.headers]
+  );
+  const [discovered, setDiscovered] = react.useState(props.entities ?? []);
+  const [selected, setSelected] = react.useState(props.entity ?? null);
+  const [showLog, setShowLog] = react.useState(false);
+  const [discoveryDone, setDiscoveryDone] = react.useState(Boolean(props.entity || props.entities));
+  react.useEffect(() => {
+    if (props.entity || props.entities) return;
+    let cancelled = false;
+    setDiscoveryDone(false);
+    client.getEntities().then((list) => {
+      if (cancelled) return;
+      setDiscovered(list);
+      setSelected((cur) => cur ?? list[0] ?? null);
+      setDiscoveryDone(true);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client, props.entity, props.entities]);
+  const entity = props.entity ?? selected;
+  const chat = useAgnoChat({ client, entity, userId: props.userId });
+  const { refreshSessions } = chat;
+  react.useEffect(() => {
+    if (props.showSessions && entity) refreshSessions();
+  }, [props.showSessions, entity?.type, entity?.id, refreshSessions]);
+  react.useEffect(() => {
+    if (props.showSessions && entity && chat.status === "completed") refreshSessions();
+  }, [chat.status]);
+  const onSelect = (e) => {
+    setSelected(e);
+    chat.reset();
+  };
+  const showSelector = !props.entity;
+  const entities = props.entities ?? discovered;
+  const noEntities = showSelector && discoveryDone && entities.length === 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: ["agno-root", props.className].filter(Boolean).join(" "),
+      style: { height: props.height ?? 560 },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-header", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-header__brand", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-logo", "aria-hidden": true, children: "A" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-header__title", children: props.title ?? entity?.name ?? "Agent UI" })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-header__controls", children: [
+            showSelector && /* @__PURE__ */ jsxRuntime.jsx(EntitySelector, { entities, value: entity, onChange: onSelect, disabled: chat.isStreaming }),
+            props.showEventLog && /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                className: `agno-btn agno-btn--ghost ${showLog ? "is-active" : ""}`,
+                onClick: () => setShowLog((v) => !v),
+                children: "Events"
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "agno-btn agno-btn--ghost", onClick: chat.reset, disabled: chat.isStreaming, children: "New chat" })
+          ] })
+        ] }),
+        noEntities && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-banner", children: [
+          "No agents, teams or workflows found at ",
+          /* @__PURE__ */ jsxRuntime.jsx("code", { children: client.baseUrl || "(no URL)" }),
+          ". Check the URL is correct, that AgentOS is running, and that this origin is in its CORS allowlist (",
+          /* @__PURE__ */ jsxRuntime.jsx("code", { children: "cors_allowed_origins" }),
+          ")."
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-main", children: [
+          props.showSessions && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-sidebar agno-sidebar--left", children: /* @__PURE__ */ jsxRuntime.jsx(
+            SessionList,
+            {
+              sessions: chat.sessions,
+              activeSessionId: chat.sessionId,
+              loading: chat.sessionsLoading,
+              onSelect: chat.loadSession,
+              onDelete: chat.deleteSession,
+              onNew: chat.reset
+            }
+          ) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ChatWindow,
+            {
+              chat,
+              placeholder: props.placeholder,
+              allowFiles: props.allowFiles,
+              disabled: !entity,
+              renderMarkdown: props.renderMarkdown,
+              emptyState: entity ? `Chat with ${entity.name}.` : "Select an agent, team or workflow to begin."
+            }
+          ),
+          props.showEventLog && showLog && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "agno-sidebar", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "agno-sidebar__title", children: "Event stream" }),
+            /* @__PURE__ */ jsxRuntime.jsx(EventLog, { events: chat.events })
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+function StatusIndicator({
+  status,
+  activity
+}) {
+  if (status !== "streaming" && status !== "paused") return null;
+  const label2 = activity ?? (status === "paused" ? "Waiting for input" : "Working");
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `agno-status agno-status--${status}`, role: "status", "aria-live": "polite", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "agno-status__dots", "aria-hidden": true, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", {}),
+      /* @__PURE__ */ jsxRuntime.jsx("span", {}),
+      /* @__PURE__ */ jsxRuntime.jsx("span", {})
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "agno-status__label", children: label2 })
+  ] });
+}
+
+// src/types.ts
+var RunEvent = /* @__PURE__ */ ((RunEvent2) => {
+  RunEvent2["RunStarted"] = "RunStarted";
+  RunEvent2["RunContent"] = "RunContent";
+  RunEvent2["RunContentCompleted"] = "RunContentCompleted";
+  RunEvent2["RunIntermediateContent"] = "RunIntermediateContent";
+  RunEvent2["RunCompleted"] = "RunCompleted";
+  RunEvent2["RunError"] = "RunError";
+  RunEvent2["RunCancelled"] = "RunCancelled";
+  RunEvent2["RunPaused"] = "RunPaused";
+  RunEvent2["RunContinued"] = "RunContinued";
+  RunEvent2["PreHookStarted"] = "PreHookStarted";
+  RunEvent2["PreHookCompleted"] = "PreHookCompleted";
+  RunEvent2["PostHookStarted"] = "PostHookStarted";
+  RunEvent2["PostHookCompleted"] = "PostHookCompleted";
+  RunEvent2["ToolCallStarted"] = "ToolCallStarted";
+  RunEvent2["ToolCallCompleted"] = "ToolCallCompleted";
+  RunEvent2["ToolCallError"] = "ToolCallError";
+  RunEvent2["ReasoningStarted"] = "ReasoningStarted";
+  RunEvent2["ReasoningStep"] = "ReasoningStep";
+  RunEvent2["ReasoningContentDelta"] = "ReasoningContentDelta";
+  RunEvent2["ReasoningCompleted"] = "ReasoningCompleted";
+  RunEvent2["MemoryUpdateStarted"] = "MemoryUpdateStarted";
+  RunEvent2["MemoryUpdateCompleted"] = "MemoryUpdateCompleted";
+  RunEvent2["SessionSummaryStarted"] = "SessionSummaryStarted";
+  RunEvent2["SessionSummaryCompleted"] = "SessionSummaryCompleted";
+  RunEvent2["ParserModelResponseStarted"] = "ParserModelResponseStarted";
+  RunEvent2["ParserModelResponseCompleted"] = "ParserModelResponseCompleted";
+  RunEvent2["OutputModelResponseStarted"] = "OutputModelResponseStarted";
+  RunEvent2["OutputModelResponseCompleted"] = "OutputModelResponseCompleted";
+  RunEvent2["ModelRequestStarted"] = "ModelRequestStarted";
+  RunEvent2["ModelRequestCompleted"] = "ModelRequestCompleted";
+  RunEvent2["CompressionStarted"] = "CompressionStarted";
+  RunEvent2["CompressionCompleted"] = "CompressionCompleted";
+  RunEvent2["FollowupsStarted"] = "FollowupsStarted";
+  RunEvent2["FollowupsCompleted"] = "FollowupsCompleted";
+  RunEvent2["CustomEvent"] = "CustomEvent";
+  return RunEvent2;
+})(RunEvent || {});
+var TeamRunEvent = /* @__PURE__ */ ((TeamRunEvent2) => {
+  TeamRunEvent2["TeamRunStarted"] = "TeamRunStarted";
+  TeamRunEvent2["TeamRunContent"] = "TeamRunContent";
+  TeamRunEvent2["TeamRunIntermediateContent"] = "TeamRunIntermediateContent";
+  TeamRunEvent2["TeamRunContentCompleted"] = "TeamRunContentCompleted";
+  TeamRunEvent2["TeamRunCompleted"] = "TeamRunCompleted";
+  TeamRunEvent2["TeamRunError"] = "TeamRunError";
+  TeamRunEvent2["TeamRunCancelled"] = "TeamRunCancelled";
+  TeamRunEvent2["TeamRunPaused"] = "TeamRunPaused";
+  TeamRunEvent2["TeamRunContinued"] = "TeamRunContinued";
+  TeamRunEvent2["TeamToolCallStarted"] = "TeamToolCallStarted";
+  TeamRunEvent2["TeamToolCallCompleted"] = "TeamToolCallCompleted";
+  TeamRunEvent2["TeamToolCallError"] = "TeamToolCallError";
+  TeamRunEvent2["TeamReasoningStarted"] = "TeamReasoningStarted";
+  TeamRunEvent2["TeamReasoningStep"] = "TeamReasoningStep";
+  TeamRunEvent2["TeamReasoningContentDelta"] = "TeamReasoningContentDelta";
+  TeamRunEvent2["TeamReasoningCompleted"] = "TeamReasoningCompleted";
+  TeamRunEvent2["TeamMemoryUpdateStarted"] = "TeamMemoryUpdateStarted";
+  TeamRunEvent2["TeamMemoryUpdateCompleted"] = "TeamMemoryUpdateCompleted";
+  TeamRunEvent2["TeamTaskIterationStarted"] = "TeamTaskIterationStarted";
+  TeamRunEvent2["TeamTaskIterationCompleted"] = "TeamTaskIterationCompleted";
+  TeamRunEvent2["TeamTaskStateUpdated"] = "TeamTaskStateUpdated";
+  TeamRunEvent2["TeamTaskCreated"] = "TeamTaskCreated";
+  TeamRunEvent2["TeamTaskUpdated"] = "TeamTaskUpdated";
+  return TeamRunEvent2;
+})(TeamRunEvent || {});
+var WorkflowRunEvent = /* @__PURE__ */ ((WorkflowRunEvent2) => {
+  WorkflowRunEvent2["WorkflowStarted"] = "WorkflowStarted";
+  WorkflowRunEvent2["WorkflowCompleted"] = "WorkflowCompleted";
+  WorkflowRunEvent2["WorkflowPaused"] = "WorkflowPaused";
+  WorkflowRunEvent2["WorkflowCancelled"] = "WorkflowCancelled";
+  WorkflowRunEvent2["WorkflowError"] = "WorkflowError";
+  WorkflowRunEvent2["WorkflowAgentStarted"] = "WorkflowAgentStarted";
+  WorkflowRunEvent2["WorkflowAgentCompleted"] = "WorkflowAgentCompleted";
+  WorkflowRunEvent2["StepStarted"] = "StepStarted";
+  WorkflowRunEvent2["StepCompleted"] = "StepCompleted";
+  WorkflowRunEvent2["StepPaused"] = "StepPaused";
+  WorkflowRunEvent2["StepContinued"] = "StepContinued";
+  WorkflowRunEvent2["StepError"] = "StepError";
+  WorkflowRunEvent2["StepOutput"] = "StepOutput";
+  WorkflowRunEvent2["StepOutputReview"] = "StepOutputReview";
+  WorkflowRunEvent2["LoopExecutionStarted"] = "LoopExecutionStarted";
+  WorkflowRunEvent2["LoopIterationStarted"] = "LoopIterationStarted";
+  WorkflowRunEvent2["LoopIterationCompleted"] = "LoopIterationCompleted";
+  WorkflowRunEvent2["LoopExecutionCompleted"] = "LoopExecutionCompleted";
+  WorkflowRunEvent2["ParallelExecutionStarted"] = "ParallelExecutionStarted";
+  WorkflowRunEvent2["ParallelExecutionCompleted"] = "ParallelExecutionCompleted";
+  WorkflowRunEvent2["ConditionExecutionStarted"] = "ConditionExecutionStarted";
+  WorkflowRunEvent2["ConditionExecutionCompleted"] = "ConditionExecutionCompleted";
+  WorkflowRunEvent2["ConditionPaused"] = "ConditionPaused";
+  WorkflowRunEvent2["RouterExecutionStarted"] = "RouterExecutionStarted";
+  WorkflowRunEvent2["RouterExecutionCompleted"] = "RouterExecutionCompleted";
+  WorkflowRunEvent2["RouterPaused"] = "RouterPaused";
+  WorkflowRunEvent2["StepsExecutionStarted"] = "StepsExecutionStarted";
+  WorkflowRunEvent2["StepsExecutionCompleted"] = "StepsExecutionCompleted";
+  return WorkflowRunEvent2;
+})(WorkflowRunEvent || {});
+
+exports.AgnoChat = AgnoChat;
+exports.AgnoClient = AgnoClient;
+exports.ChatInput = ChatInput;
+exports.ChatWindow = ChatWindow;
+exports.Citations = Citations;
+exports.EntitySelector = EntitySelector;
+exports.EventLog = EventLog;
+exports.HumanInput = HumanInput;
+exports.Markdown = Markdown;
+exports.MemberResponses = MemberResponses;
+exports.Message = Message;
+exports.MessageList = MessageList;
+exports.Multimedia = Multimedia;
+exports.Reasoning = Reasoning;
+exports.RunEvent = RunEvent;
+exports.SessionList = SessionList;
+exports.StatusIndicator = StatusIndicator;
+exports.TeamRunEvent = TeamRunEvent;
+exports.ToolCalls = ToolCalls;
+exports.WorkflowRunEvent = WorkflowRunEvent;
+exports.WorkflowSteps = WorkflowSteps;
+exports.activityLabel = activityLabel;
+exports.applyStepEvent = applyStepEvent;
+exports.applySubRunEvent = applySubRunEvent;
+exports.isCompletedEvent = isCompletedEvent;
+exports.isContentEvent = isContentEvent;
+exports.isErrorEvent = isErrorEvent;
+exports.isPausedEvent = isPausedEvent;
+exports.isReasoningStepEvent = isReasoningStepEvent;
+exports.isStepEvent = isStepEvent;
+exports.isSubRunEvent = isSubRunEvent;
+exports.isToolEvent = isToolEvent;
+exports.mergeTool = mergeTool;
+exports.normaliseBaseUrl = normaliseBaseUrl;
+exports.sessionRunsToMessages = sessionRunsToMessages;
+exports.streamRun = streamRun;
+exports.toolsFromEvent = toolsFromEvent;
+exports.useAgnoChat = useAgnoChat;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map