@antipopp/agno-client 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1227 @@
+// src/client.ts
+import EventEmitter from "eventemitter3";
+import { RunEvent } from "@antipopp/agno-types";
+
+// src/stores/message-store.ts
+var MessageStore = class {
+  constructor() {
+    this.messages = [];
+  }
+  /**
+   * Get all messages
+   */
+  getMessages() {
+    return [...this.messages];
+  }
+  /**
+   * Set messages (replaces all)
+   */
+  setMessages(messages) {
+    this.messages = [...messages];
+  }
+  /**
+   * Add a message
+   */
+  addMessage(message) {
+    this.messages = [...this.messages, message];
+  }
+  /**
+   * Update the last message
+   */
+  updateLastMessage(updater) {
+    if (this.messages.length === 0)
+      return void 0;
+    const lastMessage = this.messages[this.messages.length - 1];
+    const updatedMessage = updater(lastMessage);
+    this.messages = [
+      ...this.messages.slice(0, -1),
+      updatedMessage
+    ];
+    return updatedMessage;
+  }
+  /**
+   * Remove last N messages
+   */
+  removeLastMessages(count) {
+    this.messages = this.messages.slice(0, -count);
+  }
+  /**
+   * Clear all messages
+   */
+  clear() {
+    this.messages = [];
+  }
+  /**
+   * Get the last message
+   */
+  getLastMessage() {
+    return this.messages.length > 0 ? this.messages[this.messages.length - 1] : void 0;
+  }
+  /**
+   * Check if last message has streaming error
+   */
+  hasLastMessageError() {
+    const lastMessage = this.getLastMessage();
+    return lastMessage?.streamingError === true;
+  }
+};
+
+// src/managers/config-manager.ts
+var ConfigManager = class {
+  constructor(initialConfig) {
+    this.config = { ...initialConfig };
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+  }
+  /**
+   * Helper to update a single field immutably
+   */
+  updateField(key, value) {
+    this.config = { ...this.config, [key]: value };
+  }
+  /**
+   * Get endpoint URL
+   */
+  getEndpoint() {
+    return this.config.endpoint;
+  }
+  /**
+   * Set endpoint URL
+   */
+  setEndpoint(endpoint) {
+    this.updateField("endpoint", endpoint);
+  }
+  /**
+   * Get auth token
+   */
+  getAuthToken() {
+    return this.config.authToken;
+  }
+  /**
+   * Set auth token
+   */
+  setAuthToken(token) {
+    this.updateField("authToken", token);
+  }
+  /**
+   * Get mode (agent or team)
+   */
+  getMode() {
+    return this.config.mode || "agent";
+  }
+  /**
+   * Set mode
+   */
+  setMode(mode) {
+    this.updateField("mode", mode);
+  }
+  /**
+   * Get agent ID
+   */
+  getAgentId() {
+    return this.config.agentId;
+  }
+  /**
+   * Set agent ID
+   */
+  setAgentId(agentId) {
+    this.updateField("agentId", agentId);
+  }
+  /**
+   * Get team ID
+   */
+  getTeamId() {
+    return this.config.teamId;
+  }
+  /**
+   * Set team ID
+   */
+  setTeamId(teamId) {
+    this.updateField("teamId", teamId);
+  }
+  /**
+   * Get database ID
+   */
+  getDbId() {
+    return this.config.dbId;
+  }
+  /**
+   * Set database ID
+   */
+  setDbId(dbId) {
+    this.updateField("dbId", dbId);
+  }
+  /**
+   * Get session ID
+   */
+  getSessionId() {
+    return this.config.sessionId;
+  }
+  /**
+   * Set session ID
+   */
+  setSessionId(sessionId) {
+    this.updateField("sessionId", sessionId);
+  }
+  /**
+   * Get current entity ID (agent or team based on mode)
+   */
+  getCurrentEntityId() {
+    return this.getMode() === "agent" ? this.getAgentId() : this.getTeamId();
+  }
+  /**
+   * Construct the run URL based on current config
+   */
+  getRunUrl() {
+    const mode = this.getMode();
+    const endpoint = this.getEndpoint();
+    const entityId = this.getCurrentEntityId();
+    if (!entityId)
+      return null;
+    const encodedEntityId = encodeURIComponent(entityId);
+    if (mode === "team") {
+      return `${endpoint}/teams/${encodedEntityId}/runs`;
+    } else {
+      return `${endpoint}/agents/${encodedEntityId}/runs`;
+    }
+  }
+};
+
+// src/managers/session-manager.ts
+var SessionManager = class {
+  /**
+   * Fetch all sessions for an entity
+   */
+  async fetchSessions(endpoint, entityType, entityId, dbId, authToken) {
+    const url = new URL(`${endpoint}/sessions`);
+    url.searchParams.set("type", entityType);
+    url.searchParams.set("component_id", entityId);
+    url.searchParams.set("db_id", dbId);
+    const headers = {};
+    if (authToken) {
+      headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    const response = await fetch(url.toString(), { headers });
+    if (!response.ok) {
+      if (response.status === 404) {
+        return [];
+      }
+      throw new Error(`Failed to fetch sessions: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.data ?? [];
+  }
+  /**
+   * Fetch a specific session's runs
+   * Returns an array of RunSchema directly (not wrapped in { data, meta })
+   */
+  async fetchSession(endpoint, entityType, sessionId, dbId, authToken) {
+    const url = new URL(`${endpoint}/sessions/${sessionId}/runs`);
+    url.searchParams.set("type", entityType);
+    if (dbId) {
+      url.searchParams.set("db_id", dbId);
+    }
+    const headers = {};
+    if (authToken) {
+      headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    const response = await fetch(url.toString(), { headers });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch session: ${response.statusText}`);
+    }
+    return await response.json();
+  }
+  /**
+   * Delete a session
+   */
+  async deleteSession(endpoint, sessionId, dbId, authToken) {
+    const url = new URL(`${endpoint}/sessions/${sessionId}`);
+    if (dbId) {
+      url.searchParams.set("db_id", dbId);
+    }
+    const headers = {};
+    if (authToken) {
+      headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    const response = await fetch(url.toString(), {
+      method: "DELETE",
+      headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to delete session: ${response.statusText}`);
+    }
+  }
+  /**
+   * Delete a team session
+   * Note: The API route has a typo with double slashes (/v1//teams), keeping it as-is for compatibility
+   */
+  async deleteTeamSession(endpoint, teamId, sessionId, authToken) {
+    const url = `${endpoint}/v1//teams/${teamId}/sessions/${sessionId}`;
+    const headers = {};
+    if (authToken) {
+      headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to delete team session: ${response.statusText}`);
+    }
+  }
+  /**
+   * Convert session runs array to chat messages
+   */
+  convertSessionToMessages(runs) {
+    console.log("[SessionManager] convertSessionToMessages received:", runs.length, "runs");
+    const messages = this.convertRunsToMessages(runs);
+    console.log("[SessionManager] Converted to messages:", messages.length, "messages");
+    return messages;
+  }
+  /**
+   * Convert RunSchema[] to ChatMessage[]
+   * Each run represents a user input + agent response pair
+   */
+  convertRunsToMessages(runs) {
+    const messages = [];
+    for (const run of runs) {
+      const timestamp = run.created_at ? new Date(run.created_at).getTime() / 1e3 : Math.floor(Date.now() / 1e3);
+      if (run.run_input) {
+        messages.push({
+          role: "user",
+          content: run.run_input,
+          created_at: timestamp
+        });
+      }
+      const toolCalls = [];
+      if (run.tools && Array.isArray(run.tools)) {
+        for (const tool of run.tools) {
+          const toolObj = tool;
+          toolCalls.push({
+            role: "tool",
+            content: toolObj.content ?? "",
+            tool_call_id: toolObj.tool_call_id ?? "",
+            tool_name: toolObj.tool_name ?? "",
+            tool_args: toolObj.tool_args ?? {},
+            tool_call_error: toolObj.tool_call_error ?? false,
+            metrics: toolObj.metrics ?? { time: 0 },
+            created_at: timestamp
+          });
+        }
+      }
+      if (run.reasoning_messages && Array.isArray(run.reasoning_messages)) {
+        for (const msg of run.reasoning_messages) {
+          const reasoningMsg = msg;
+          if (reasoningMsg.role === "tool") {
+            toolCalls.push({
+              role: "tool",
+              content: reasoningMsg.content ?? "",
+              tool_call_id: reasoningMsg.tool_call_id ?? "",
+              tool_name: reasoningMsg.tool_name ?? "",
+              tool_args: reasoningMsg.tool_args ?? {},
+              tool_call_error: reasoningMsg.tool_call_error ?? false,
+              metrics: reasoningMsg.metrics ?? { time: 0 },
+              created_at: reasoningMsg.created_at ?? timestamp
+            });
+          }
+        }
+      }
+      let contentStr = "";
+      if (typeof run.content === "string") {
+        contentStr = run.content;
+      } else if (run.content && typeof run.content === "object") {
+        contentStr = JSON.stringify(run.content);
+      }
+      const extraData = run.reasoning_messages || run.reasoning_steps || run.references ? {
+        reasoning_messages: run.reasoning_messages,
+        reasoning_steps: run.reasoning_steps,
+        references: run.references
+      } : void 0;
+      messages.push({
+        role: "agent",
+        content: contentStr,
+        tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+        extra_data: extraData,
+        images: run.images,
+        videos: run.videos,
+        audio: run.audio,
+        response_audio: run.response_audio,
+        created_at: timestamp + 1
+        // Agent response is slightly after user message
+      });
+    }
+    return messages;
+  }
+};
+
+// src/processors/event-processor.ts
+import { RunEvent as RunEventEnum } from "@antipopp/agno-types";
+
+// src/utils/json-markdown.ts
+function getJsonMarkdown(content) {
+  try {
+    const jsonString = JSON.stringify(content, null, 2);
+    return `\`\`\`json
+${jsonString}
+\`\`\``;
+  } catch {
+    return "```\nError formatting JSON\n```";
+  }
+}
+
+// src/processors/event-processor.ts
+function processToolCall(toolCall, prevToolCalls = []) {
+  const toolCallId = toolCall.tool_call_id || `${toolCall.tool_name}-${toolCall.created_at}`;
+  const existingToolCallIndex = prevToolCalls.findIndex(
+    (tc) => tc.tool_call_id && tc.tool_call_id === toolCall.tool_call_id || !tc.tool_call_id && toolCall.tool_name && toolCall.created_at && `${tc.tool_name}-${tc.created_at}` === toolCallId
+  );
+  if (existingToolCallIndex >= 0) {
+    const updatedToolCalls = [...prevToolCalls];
+    updatedToolCalls[existingToolCallIndex] = {
+      ...updatedToolCalls[existingToolCallIndex],
+      ...toolCall
+    };
+    return updatedToolCalls;
+  } else {
+    return [...prevToolCalls, toolCall];
+  }
+}
+function processChunkToolCalls(chunk, existingToolCalls = []) {
+  let updatedToolCalls = [...existingToolCalls];
+  if (chunk.tool) {
+    updatedToolCalls = processToolCall(chunk.tool, updatedToolCalls);
+  }
+  if (chunk.tools && chunk.tools.length > 0) {
+    for (const toolCall of chunk.tools) {
+      updatedToolCalls = processToolCall(toolCall, updatedToolCalls);
+    }
+  }
+  return updatedToolCalls;
+}
+var EventProcessor = class {
+  constructor() {
+    this.lastContent = "";
+  }
+  /**
+   * Process a chunk and update the last message
+   */
+  processChunk(chunk, lastMessage) {
+    if (!lastMessage || lastMessage.role !== "agent") {
+      return lastMessage;
+    }
+    const event = chunk.event;
+    const updatedMessage = { ...lastMessage };
+    switch (event) {
+      case RunEventEnum.RunStarted:
+      case RunEventEnum.TeamRunStarted:
+      case RunEventEnum.ReasoningStarted:
+      case RunEventEnum.TeamReasoningStarted:
+        break;
+      case RunEventEnum.ToolCallStarted:
+      case RunEventEnum.TeamToolCallStarted:
+      case RunEventEnum.ToolCallCompleted:
+      case RunEventEnum.TeamToolCallCompleted:
+        updatedMessage.tool_calls = processChunkToolCalls(
+          chunk,
+          lastMessage.tool_calls
+        );
+        break;
+      case RunEventEnum.RunContent:
+      case RunEventEnum.TeamRunContent:
+        if (typeof chunk.content === "string") {
+          const uniqueContent = chunk.content.replace(this.lastContent, "");
+          updatedMessage.content = updatedMessage.content + uniqueContent;
+          this.lastContent = chunk.content;
+        } else if (typeof chunk.content !== "string" && chunk.content !== null) {
+          const jsonBlock = getJsonMarkdown(chunk.content);
+          updatedMessage.content = updatedMessage.content + jsonBlock;
+          this.lastContent = jsonBlock;
+        }
+        updatedMessage.tool_calls = processChunkToolCalls(
+          chunk,
+          lastMessage.tool_calls
+        );
+        if (chunk.extra_data?.reasoning_steps) {
+          updatedMessage.extra_data = {
+            ...updatedMessage.extra_data,
+            reasoning_steps: chunk.extra_data.reasoning_steps
+          };
+        }
+        if (chunk.extra_data?.references) {
+          updatedMessage.extra_data = {
+            ...updatedMessage.extra_data,
+            references: chunk.extra_data.references
+          };
+        }
+        updatedMessage.created_at = chunk.created_at ?? lastMessage.created_at;
+        if (chunk.images) {
+          updatedMessage.images = chunk.images;
+        }
+        if (chunk.videos) {
+          updatedMessage.videos = chunk.videos;
+        }
+        if (chunk.audio) {
+          updatedMessage.audio = chunk.audio;
+        }
+        if (chunk.response_audio?.transcript && typeof chunk.response_audio.transcript === "string") {
+          const transcript = chunk.response_audio.transcript;
+          updatedMessage.response_audio = {
+            ...updatedMessage.response_audio,
+            transcript: (updatedMessage.response_audio?.transcript || "") + transcript
+          };
+        }
+        break;
+      case RunEventEnum.ReasoningStep:
+      case RunEventEnum.TeamReasoningStep:
+        const existingSteps = lastMessage.extra_data?.reasoning_steps ?? [];
+        const incomingSteps = chunk.extra_data?.reasoning_steps ?? [];
+        updatedMessage.extra_data = {
+          ...updatedMessage.extra_data,
+          reasoning_steps: [...existingSteps, ...incomingSteps]
+        };
+        break;
+      case RunEventEnum.ReasoningCompleted:
+      case RunEventEnum.TeamReasoningCompleted:
+        if (chunk.extra_data?.reasoning_steps) {
+          updatedMessage.extra_data = {
+            ...updatedMessage.extra_data,
+            reasoning_steps: chunk.extra_data.reasoning_steps
+          };
+        }
+        break;
+      case RunEventEnum.RunCompleted:
+      case RunEventEnum.TeamRunCompleted:
+        let updatedContent;
+        if (typeof chunk.content === "string") {
+          updatedContent = chunk.content;
+        } else {
+          try {
+            updatedContent = JSON.stringify(chunk.content);
+          } catch {
+            updatedContent = "Error parsing response";
+          }
+        }
+        updatedMessage.content = updatedContent;
+        updatedMessage.tool_calls = processChunkToolCalls(
+          chunk,
+          lastMessage.tool_calls
+        );
+        updatedMessage.images = chunk.images ?? lastMessage.images;
+        updatedMessage.videos = chunk.videos ?? lastMessage.videos;
+        updatedMessage.response_audio = chunk.response_audio;
+        updatedMessage.created_at = chunk.created_at ?? lastMessage.created_at;
+        updatedMessage.extra_data = {
+          reasoning_steps: chunk.extra_data?.reasoning_steps ?? lastMessage.extra_data?.reasoning_steps,
+          references: chunk.extra_data?.references ?? lastMessage.extra_data?.references
+        };
+        break;
+      case RunEventEnum.UpdatingMemory:
+      case RunEventEnum.TeamMemoryUpdateStarted:
+      case RunEventEnum.TeamMemoryUpdateCompleted:
+        break;
+      case RunEventEnum.RunPaused:
+        break;
+      case RunEventEnum.RunError:
+      case RunEventEnum.TeamRunError:
+      case RunEventEnum.TeamRunCancelled:
+        updatedMessage.streamingError = true;
+        break;
+    }
+    return updatedMessage;
+  }
+  /**
+   * Reset the processor state (e.g., between messages)
+   */
+  reset() {
+    this.lastContent = "";
+  }
+};
+
+// src/parsers/stream-parser.ts
+function isLegacyFormat(data) {
+  return typeof data === "object" && data !== null && "event" in data && !("data" in data) && typeof data.event === "string";
+}
+function convertNewFormatToLegacy(newFormatData) {
+  const { event, data } = newFormatData;
+  let parsedData;
+  if (typeof data === "string") {
+    try {
+      parsedData = JSON.parse(data);
+    } catch {
+      parsedData = {};
+    }
+  } else {
+    parsedData = data;
+  }
+  return {
+    event,
+    ...parsedData
+  };
+}
+function processChunk(chunk, onChunk) {
+  onChunk(chunk);
+}
+function parseBuffer(buffer, onChunk) {
+  let currentIndex = 0;
+  let jsonStartIndex = buffer.indexOf("{", currentIndex);
+  while (jsonStartIndex !== -1 && jsonStartIndex < buffer.length) {
+    let braceCount = 0;
+    let inString = false;
+    let escapeNext = false;
+    let jsonEndIndex = -1;
+    let i = jsonStartIndex;
+    for (; i < buffer.length; i++) {
+      const char = buffer[i];
+      if (inString) {
+        if (escapeNext) {
+          escapeNext = false;
+        } else if (char === "\\") {
+          escapeNext = true;
+        } else if (char === '"') {
+          inString = false;
+        }
+      } else {
+        if (char === '"') {
+          inString = true;
+        } else if (char === "{") {
+          braceCount++;
+        } else if (char === "}") {
+          braceCount--;
+          if (braceCount === 0) {
+            jsonEndIndex = i;
+            break;
+          }
+        }
+      }
+    }
+    if (jsonEndIndex !== -1) {
+      const jsonString = buffer.slice(jsonStartIndex, jsonEndIndex + 1);
+      try {
+        const parsed = JSON.parse(jsonString);
+        if (isLegacyFormat(parsed)) {
+          processChunk(parsed, onChunk);
+        } else {
+          const legacyChunk = convertNewFormatToLegacy(parsed);
+          processChunk(legacyChunk, onChunk);
+        }
+      } catch (error) {
+        if (typeof process !== "undefined" && process.env?.NODE_ENV === "development") {
+          console.error("Failed to parse JSON chunk:", {
+            error,
+            chunk: jsonString.substring(0, 100) + (jsonString.length > 100 ? "..." : ""),
+            position: jsonStartIndex
+          });
+        }
+        if (jsonString.length > 1e4) {
+          throw new Error(`Failed to parse large JSON chunk at position ${jsonStartIndex}`);
+        }
+        jsonStartIndex = buffer.indexOf("{", jsonStartIndex + 1);
+        continue;
+      }
+      currentIndex = jsonEndIndex + 1;
+      buffer = buffer.slice(currentIndex).trim();
+      currentIndex = 0;
+      jsonStartIndex = buffer.indexOf("{", currentIndex);
+    } else {
+      break;
+    }
+  }
+  return buffer;
+}
+async function streamResponse(options) {
+  const {
+    apiUrl,
+    headers = {},
+    requestBody,
+    onChunk,
+    onError,
+    onComplete,
+    signal
+  } = options;
+  let buffer = "";
+  try {
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        ...!(requestBody instanceof FormData) && {
+          "Content-Type": "application/json"
+        },
+        ...headers
+      },
+      body: requestBody instanceof FormData ? requestBody : JSON.stringify(requestBody),
+      signal
+    });
+    if (!response.ok) {
+      let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        try {
+          const errorData = await response.json();
+          errorMessage = errorData.detail || errorData.message || errorMessage;
+        } catch {
+        }
+      }
+      throw new Error(errorMessage);
+    }
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const processStream = async () => {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          buffer = parseBuffer(buffer, onChunk);
+          onComplete();
+          return;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        buffer = parseBuffer(buffer, onChunk);
+      }
+    };
+    await processStream();
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    if (typeof error === "object" && error !== null && "detail" in error) {
+      onError(new Error(String(error.detail)));
+    } else {
+      onError(new Error(String(error)));
+    }
+  }
+}
+
+// src/utils/logger.ts
+var SENSITIVE_KEYS = ["authToken", "Authorization", "token", "password", "apiKey"];
+function sanitizeObject(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(sanitizeObject);
+  }
+  const sanitized = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (SENSITIVE_KEYS.some(
+      (sensitiveKey) => key.toLowerCase().includes(sensitiveKey.toLowerCase())
+    )) {
+      sanitized[key] = value ? "[REDACTED]" : void 0;
+    } else if (typeof value === "object" && value !== null) {
+      sanitized[key] = sanitizeObject(value);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+function isDevelopment() {
+  return typeof process !== "undefined" && process.env?.NODE_ENV === "development";
+}
+var Logger = class {
+  /**
+   * Log debug information (only in development)
+   */
+  static debug(message, data) {
+    if (isDevelopment()) {
+      const sanitized = data ? sanitizeObject(data) : void 0;
+      console.debug(`[DEBUG] ${message}`, sanitized || "");
+    }
+  }
+  /**
+   * Log informational messages (only in development)
+   */
+  static info(message, data) {
+    if (isDevelopment()) {
+      const sanitized = data ? sanitizeObject(data) : void 0;
+      console.info(`[INFO] ${message}`, sanitized || "");
+    }
+  }
+  /**
+   * Log warnings (always logs)
+   */
+  static warn(message, data) {
+    const sanitized = data ? sanitizeObject(data) : void 0;
+    console.warn(`[WARN] ${message}`, sanitized || "");
+  }
+  /**
+   * Log errors (always logs)
+   */
+  static error(message, data) {
+    const sanitized = data ? sanitizeObject(data) : void 0;
+    console.error(`[ERROR] ${message}`, sanitized || "");
+  }
+};
+
+// src/client.ts
+function toSafeISOString(timestamp) {
+  const now = Date.now();
+  const ts = timestamp ? timestamp * 1e3 : now;
+  const MIN_TIMESTAMP = 9466848e5;
+  const MAX_TIMESTAMP = 41024448e5;
+  if (ts < MIN_TIMESTAMP || ts > MAX_TIMESTAMP || !Number.isFinite(ts)) {
+    Logger.warn(`Invalid timestamp: ${timestamp}, using current time`);
+    return new Date(now).toISOString();
+  }
+  return new Date(ts).toISOString();
+}
+var AgnoClient = class extends EventEmitter {
+  constructor(config) {
+    super();
+    this.messageStore = new MessageStore();
+    this.configManager = new ConfigManager(config);
+    this.sessionManager = new SessionManager();
+    this.eventProcessor = new EventProcessor();
+    this.state = {
+      isStreaming: false,
+      isEndpointActive: false,
+      agents: [],
+      teams: [],
+      sessions: [],
+      isPaused: false,
+      pausedRunId: void 0,
+      toolsAwaitingExecution: void 0
+    };
+  }
+  /**
+   * Get current messages
+   */
+  getMessages() {
+    return this.messageStore.getMessages();
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return this.configManager.getConfig();
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.configManager.updateConfig(updates);
+    this.emit("config:change", this.configManager.getConfig());
+  }
+  /**
+   * Clear all messages
+   */
+  clearMessages() {
+    this.messageStore.clear();
+    this.configManager.setSessionId(void 0);
+    this.emit("message:update", this.messageStore.getMessages());
+    this.emit("state:change", this.getState());
+  }
+  /**
+   * Send a message to the agent/team (streaming)
+   */
+  async sendMessage(message, options) {
+    if (this.state.isStreaming) {
+      throw new Error("Already streaming a message");
+    }
+    const runUrl = this.configManager.getRunUrl();
+    if (!runUrl) {
+      throw new Error("No agent or team selected");
+    }
+    this.state.isStreaming = true;
+    this.state.errorMessage = void 0;
+    this.emit("stream:start");
+    this.emit("state:change", this.getState());
+    const formData = message instanceof FormData ? message : new FormData();
+    if (typeof message === "string") {
+      formData.append("message", message);
+    }
+    const lastMessage = this.messageStore.getLastMessage();
+    if (lastMessage?.streamingError) {
+      const secondLast = this.messageStore.getMessages()[this.messageStore.getMessages().length - 2];
+      if (secondLast?.role === "user") {
+        this.messageStore.removeLastMessages(2);
+      }
+    }
+    this.messageStore.addMessage({
+      role: "user",
+      content: formData.get("message"),
+      created_at: Math.floor(Date.now() / 1e3)
+    });
+    this.messageStore.addMessage({
+      role: "agent",
+      content: "",
+      tool_calls: [],
+      streamingError: false,
+      created_at: Math.floor(Date.now() / 1e3) + 1
+    });
+    this.emit("message:update", this.messageStore.getMessages());
+    this.eventProcessor.reset();
+    let newSessionId = this.configManager.getSessionId();
+    try {
+      formData.append("stream", "true");
+      formData.append("session_id", newSessionId ?? "");
+      const headers = { ...options?.headers };
+      const authToken = this.configManager.getAuthToken();
+      if (authToken) {
+        headers["Authorization"] = `Bearer ${authToken}`;
+      }
+      await streamResponse({
+        apiUrl: runUrl,
+        headers,
+        requestBody: formData,
+        onChunk: (chunk) => {
+          this.handleChunk(chunk, newSessionId, formData.get("message"));
+          if (chunk.event === RunEvent.RunStarted || chunk.event === RunEvent.TeamRunStarted || chunk.event === RunEvent.ReasoningStarted || chunk.event === RunEvent.TeamReasoningStarted) {
+            if (chunk.session_id) {
+              newSessionId = chunk.session_id;
+              this.configManager.setSessionId(chunk.session_id);
+            }
+          }
+        },
+        onError: (error) => {
+          this.handleError(error, newSessionId);
+        },
+        onComplete: () => {
+          this.state.isStreaming = false;
+          this.emit("stream:end");
+          this.emit("message:complete", this.messageStore.getMessages());
+          this.emit("state:change", this.getState());
+        }
+      });
+    } catch (error) {
+      this.handleError(
+        error instanceof Error ? error : new Error(String(error)),
+        newSessionId
+      );
+    }
+  }
+  /**
+   * Handle streaming chunk
+   */
+  handleChunk(chunk, currentSessionId, messageContent) {
+    const event = chunk.event;
+    if (event === RunEvent.RunStarted || event === RunEvent.TeamRunStarted || event === RunEvent.ReasoningStarted || event === RunEvent.TeamReasoningStarted) {
+      if (chunk.session_id && (!currentSessionId || currentSessionId !== chunk.session_id)) {
+        const sessionData = {
+          session_id: chunk.session_id,
+          session_name: messageContent,
+          created_at: toSafeISOString(chunk.created_at)
+        };
+        const sessionExists = this.state.sessions.some(
+          (s) => s.session_id === chunk.session_id
+        );
+        if (!sessionExists) {
+          this.state.sessions = [sessionData, ...this.state.sessions];
+          this.emit("session:created", sessionData);
+        }
+      }
+    }
+    if (event === RunEvent.RunPaused) {
+      this.state.isStreaming = false;
+      this.state.isPaused = true;
+      this.state.pausedRunId = chunk.run_id;
+      this.state.toolsAwaitingExecution = chunk.tools_awaiting_external_execution || chunk.tools_requiring_confirmation || chunk.tools_requiring_user_input || chunk.tools || [];
+      this.emit("run:paused", {
+        runId: chunk.run_id,
+        sessionId: chunk.session_id,
+        tools: this.state.toolsAwaitingExecution
+      });
+      this.emit("state:change", this.getState());
+      return;
+    }
+    if (event === RunEvent.RunError || event === RunEvent.TeamRunError || event === RunEvent.TeamRunCancelled) {
+      const errorContent = chunk.content || (event === RunEvent.TeamRunCancelled ? "Run cancelled" : "Error during run");
+      this.state.errorMessage = errorContent;
+      this.messageStore.updateLastMessage((msg) => ({
+        ...msg,
+        streamingError: true
+      }));
+      if (chunk.session_id) {
+        this.state.sessions = this.state.sessions.filter(
+          (s) => s.session_id !== chunk.session_id
+        );
+      }
+      this.emit("message:error", errorContent);
+      return;
+    }
+    this.messageStore.updateLastMessage((lastMessage) => {
+      const updated = this.eventProcessor.processChunk(chunk, lastMessage);
+      return updated || lastMessage;
+    });
+    this.emit("message:update", this.messageStore.getMessages());
+  }
+  /**
+   * Handle error
+   */
+  handleError(error, sessionId) {
+    this.state.isStreaming = false;
+    this.state.errorMessage = error.message;
+    this.messageStore.updateLastMessage((msg) => ({
+      ...msg,
+      streamingError: true
+    }));
+    if (sessionId) {
+      this.state.sessions = this.state.sessions.filter(
+        (s) => s.session_id !== sessionId
+      );
+    }
+    this.emit("message:error", error.message);
+    this.emit("stream:end");
+    this.emit("state:change", this.getState());
+  }
+  /**
+   * Load a session
+   */
+  async loadSession(sessionId) {
+    Logger.debug("[AgnoClient] loadSession called with sessionId:", sessionId);
+    const config = this.configManager.getConfig();
+    const entityType = this.configManager.getMode();
+    const dbId = this.configManager.getDbId() || "";
+    Logger.debug("[AgnoClient] Loading session with:", { entityType, dbId });
+    const response = await this.sessionManager.fetchSession(
+      config.endpoint,
+      entityType,
+      sessionId,
+      dbId,
+      config.authToken
+    );
+    const messages = this.sessionManager.convertSessionToMessages(response);
+    Logger.debug("[AgnoClient] Setting messages to store:", `${messages.length} messages`);
+    this.messageStore.setMessages(messages);
+    this.configManager.setSessionId(sessionId);
+    Logger.debug("[AgnoClient] Emitting events...");
+    this.emit("session:loaded", sessionId);
+    this.emit("message:update", this.messageStore.getMessages());
+    this.emit("state:change", this.getState());
+    Logger.debug("[AgnoClient] Events emitted, returning messages");
+    return messages;
+  }
+  /**
+   * Fetch all sessions
+   */
+  async fetchSessions() {
+    const config = this.configManager.getConfig();
+    const entityType = this.configManager.getMode();
+    const entityId = this.configManager.getCurrentEntityId();
+    const dbId = this.configManager.getDbId() || "";
+    if (!entityId) {
+      throw new Error("Entity ID must be configured");
+    }
+    const sessions = await this.sessionManager.fetchSessions(
+      config.endpoint,
+      entityType,
+      entityId,
+      dbId,
+      config.authToken
+    );
+    this.state.sessions = sessions;
+    this.emit("state:change", this.getState());
+    return sessions;
+  }
+  /**
+   * Delete a session
+   */
+  async deleteSession(sessionId) {
+    const config = this.configManager.getConfig();
+    const dbId = this.configManager.getDbId() || "";
+    await this.sessionManager.deleteSession(
+      config.endpoint,
+      sessionId,
+      dbId,
+      config.authToken
+    );
+    this.state.sessions = this.state.sessions.filter(
+      (s) => s.session_id !== sessionId
+    );
+    if (this.configManager.getSessionId() === sessionId) {
+      this.clearMessages();
+    }
+    this.emit("state:change", this.getState());
+  }
+  /**
+   * Delete a team session
+   */
+  async deleteTeamSession(teamId, sessionId) {
+    const config = this.configManager.getConfig();
+    await this.sessionManager.deleteTeamSession(
+      config.endpoint,
+      teamId,
+      sessionId,
+      config.authToken
+    );
+    this.state.sessions = this.state.sessions.filter(
+      (s) => s.session_id !== sessionId
+    );
+    if (this.configManager.getSessionId() === sessionId) {
+      this.clearMessages();
+    }
+    this.emit("state:change", this.getState());
+  }
+  /**
+   * Continue a paused run after executing external tools
+   */
+  async continueRun(tools, options) {
+    if (!this.state.isPaused || !this.state.pausedRunId) {
+      throw new Error("No paused run to continue");
+    }
+    const runUrl = this.configManager.getRunUrl();
+    if (!runUrl) {
+      throw new Error("No agent or team selected");
+    }
+    const continueUrl = `${runUrl}/${this.state.pausedRunId}/continue`;
+    this.state.isPaused = false;
+    this.state.isStreaming = true;
+    this.emit("run:continued", { runId: this.state.pausedRunId });
+    this.emit("state:change", this.getState());
+    const formData = new FormData();
+    formData.append("tools", JSON.stringify(tools));
+    formData.append("stream", "true");
+    const currentSessionId = this.configManager.getSessionId();
+    if (currentSessionId) {
+      formData.append("session_id", currentSessionId);
+    }
+    const headers = { ...options?.headers };
+    const authToken = this.configManager.getAuthToken();
+    if (authToken) {
+      headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    try {
+      await streamResponse({
+        apiUrl: continueUrl,
+        headers,
+        requestBody: formData,
+        onChunk: (chunk) => {
+          this.handleChunk(chunk, currentSessionId, "");
+        },
+        onError: (error) => {
+          this.handleError(error, currentSessionId);
+        },
+        onComplete: () => {
+          this.state.isStreaming = false;
+          this.state.pausedRunId = void 0;
+          this.state.toolsAwaitingExecution = void 0;
+          this.emit("stream:end");
+          this.emit("message:complete", this.messageStore.getMessages());
+          this.emit("state:change", this.getState());
+        }
+      });
+    } catch (error) {
+      this.handleError(
+        error instanceof Error ? error : new Error(String(error)),
+        currentSessionId
+      );
+    }
+  }
+  /**
+   * Check endpoint status
+   */
+  async checkStatus() {
+    try {
+      const response = await fetch(`${this.configManager.getEndpoint()}/health`);
+      const isActive = response.ok;
+      this.state.isEndpointActive = isActive;
+      this.emit("state:change", this.getState());
+      return isActive;
+    } catch {
+      this.state.isEndpointActive = false;
+      this.emit("state:change", this.getState());
+      return false;
+    }
+  }
+  /**
+   * Fetch agents from endpoint
+   */
+  async fetchAgents() {
+    const config = this.configManager.getConfig();
+    const headers = {};
+    if (config.authToken) {
+      headers["Authorization"] = `Bearer ${config.authToken}`;
+    }
+    const response = await fetch(`${config.endpoint}/agents`, { headers });
+    if (!response.ok) {
+      throw new Error("Failed to fetch agents");
+    }
+    const agents = await response.json();
+    this.state.agents = agents;
+    this.emit("state:change", this.getState());
+    return agents;
+  }
+  /**
+   * Fetch teams from endpoint
+   */
+  async fetchTeams() {
+    const config = this.configManager.getConfig();
+    const headers = {};
+    if (config.authToken) {
+      headers["Authorization"] = `Bearer ${config.authToken}`;
+    }
+    const response = await fetch(`${config.endpoint}/teams`, { headers });
+    if (!response.ok) {
+      throw new Error("Failed to fetch teams");
+    }
+    const teams = await response.json();
+    this.state.teams = teams;
+    this.emit("state:change", this.getState());
+    return teams;
+  }
+  /**
+   * Initialize client (check status and fetch agents/teams)
+   * Automatically selects the first available agent or team if none is configured
+   */
+  async initialize() {
+    const isActive = await this.checkStatus();
+    if (!isActive) {
+      return { agents: [], teams: [] };
+    }
+    const [agents, teams] = await Promise.all([
+      this.fetchAgents(),
+      this.fetchTeams()
+    ]);
+    const currentConfig = this.configManager.getConfig();
+    const hasAgentConfigured = currentConfig.agentId;
+    const hasTeamConfigured = currentConfig.teamId;
+    if (!hasAgentConfigured && !hasTeamConfigured) {
+      if (agents.length > 0) {
+        const firstAgent = agents[0];
+        this.configManager.updateConfig({
+          mode: "agent",
+          agentId: firstAgent.id,
+          dbId: firstAgent.db_id || void 0
+        });
+        this.emit("config:change", this.configManager.getConfig());
+      } else if (teams.length > 0) {
+        const firstTeam = teams[0];
+        this.configManager.updateConfig({
+          mode: "team",
+          teamId: firstTeam.id,
+          dbId: firstTeam.db_id || void 0
+        });
+        this.emit("config:change", this.configManager.getConfig());
+      }
+    }
+    return { agents, teams };
+  }
+};
+
+// src/index.ts
+import { RunEvent as RunEvent2 } from "@antipopp/agno-types";
+export {
+  AgnoClient,
+  Logger,
+  RunEvent2 as RunEvent
+};