@antipopp/agno-client 0.9.0 → 0.11.0

package/dist/index.mjs

@@ -1,85 +1,9 @@
+// src/index.ts
+import { RunEvent as RunEvent2 } from "@antipopp/agno-types";
+
 // 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;
-  }
-  /**
-   * Update a specific message by index
-   */
-  updateMessage(index, updater) {
-    if (index < 0 || index >= this.messages.length)
-      return void 0;
-    const message = this.messages[index];
-    const updatedMessage = updater(message);
-    this.messages = [
-      ...this.messages.slice(0, index),
-      updatedMessage,
-      ...this.messages.slice(index + 1)
-    ];
-    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;
-  }
-};
+import EventEmitter from "eventemitter3";
 
 // src/managers/config-manager.ts
 var ConfigManager = class {
@@ -224,6 +148,18 @@ var ConfigManager = class {
   setParams(params) {
     this.updateField("params", params);
   }
+  /**
+   * Get global dependencies
+   */
+  getDependencies() {
+    return this.config.dependencies;
+  }
+  /**
+   * Set global dependencies
+   */
+  setDependencies(dependencies) {
+    this.updateField("dependencies", dependencies);
+  }
   /**
    * Get current entity ID (agent or team based on mode)
    */
@@ -237,14 +173,14 @@ var ConfigManager = class {
     const mode = this.getMode();
     const endpoint = this.getEndpoint();
     const entityId = this.getCurrentEntityId();
-    if (!entityId)
+    if (!entityId) {
       return null;
+    }
     const encodedEntityId = encodeURIComponent(entityId);
     if (mode === "team") {
       return `${endpoint}/teams/${encodedEntityId}/runs`;
-    } else {
-      return `${endpoint}/agents/${encodedEntityId}/runs`;
     }
+    return `${endpoint}/agents/${encodedEntityId}/runs`;
   }
   /**
    * Build request headers by merging global headers, per-request headers, and auth token.
@@ -267,7 +203,7 @@ var ConfigManager = class {
     }
     const authToken = this.getAuthToken();
     if (authToken) {
-      headers["Authorization"] = `Bearer ${authToken}`;
+      headers.Authorization = `Bearer ${authToken}`;
     }
     return headers;
   }
@@ -291,6 +227,29 @@ var ConfigManager = class {
     }
     return new URLSearchParams(params);
   }
+  /**
+   * Build dependencies by merging global dependencies and per-request dependencies.
+   * Merge order (lowest to highest precedence):
+   * 1. Global dependencies from config
+   * 2. Per-request dependencies (overrides global)
+   *
+   * @param perRequestDependencies - Optional dependencies for this specific request
+   * @returns Merged dependencies object, or undefined if no dependencies are configured
+   */
+  buildDependencies(perRequestDependencies) {
+    const dependencies = {};
+    const globalDependencies = this.getDependencies();
+    if (globalDependencies) {
+      Object.assign(dependencies, globalDependencies);
+    }
+    if (perRequestDependencies) {
+      Object.assign(dependencies, perRequestDependencies);
+    }
+    if (Object.keys(dependencies).length === 0) {
+      return void 0;
+    }
+    return dependencies;
+  }
 };
 
 // src/managers/session-manager.ts
@@ -377,75 +336,470 @@ var SessionManager = class {
   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;
-          const toolCall = {
-            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
-          };
-          toolCalls.push(toolCall);
-        }
-      }
-      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 timestamp = this.getRunTimestamp(run);
+      const inputMedia = this.mergeInputMedia(
+        this.extractInputMedia(run.input_media),
+        this.extractInputMediaFromMessages(run.messages)
+      );
+      if (run.run_input || this.hasAnyMedia(inputMedia)) {
+        messages.push(
+          this.buildUserMessage(run.run_input ?? "", timestamp, inputMedia)
+        );
       }
-      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;
+      const toolCalls = this.extractToolCalls(run, timestamp);
       messages.push({
         role: "agent",
-        content: contentStr,
+        content: this.normalizeRunContent(run.content),
         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,
+        extra_data: this.buildExtraData(run),
+        images: this.normalizeImages(run.images),
+        videos: this.normalizeVideos(run.videos),
+        audio: this.normalizeAudio(run.audio),
+        files: this.normalizeFiles(run.files),
+        response_audio: run.response_audio ?? void 0,
         created_at: timestamp + 1
         // Agent response is slightly after user message
       });
     }
     return messages;
   }
+  getRunTimestamp(run) {
+    return run.created_at ? new Date(run.created_at).getTime() / 1e3 : Math.floor(Date.now() / 1e3);
+  }
+  buildUserMessage(content, createdAt, media) {
+    return {
+      role: "user",
+      content,
+      images: media?.images,
+      videos: media?.videos,
+      audio: media?.audio,
+      files: media?.files,
+      created_at: createdAt
+    };
+  }
+  hasAnyMedia(media) {
+    return Boolean(
+      media.images && media.images.length > 0 || media.videos && media.videos.length > 0 || media.audio && media.audio.length > 0 || media.files && media.files.length > 0
+    );
+  }
+  isRecord(value) {
+    return typeof value === "object" && value !== null;
+  }
+  getStringValue(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  }
+  getNumberOrStringValue(record, key) {
+    const value = record[key];
+    return typeof value === "number" || typeof value === "string" ? value : void 0;
+  }
+  buildDataUrl(content, mimeType, fallbackMimeType) {
+    const safeMimeType = mimeType || fallbackMimeType;
+    return `data:${safeMimeType};base64,${content}`;
+  }
+  normalizeImage(item) {
+    if (!this.isRecord(item)) {
+      return void 0;
+    }
+    const mimeType = this.getStringValue(item, "mime_type");
+    const content = this.getStringValue(item, "content");
+    const url = this.getStringValue(item, "url") || (content ? this.buildDataUrl(content, mimeType, "image/png") : void 0);
+    if (!url) {
+      return void 0;
+    }
+    return {
+      url,
+      revised_prompt: this.getStringValue(item, "revised_prompt"),
+      original_prompt: this.getStringValue(item, "original_prompt"),
+      alt_text: this.getStringValue(item, "alt_text"),
+      id: this.getStringValue(item, "id"),
+      mime_type: mimeType,
+      format: this.getStringValue(item, "format")
+    };
+  }
+  normalizeVideo(item) {
+    if (!this.isRecord(item)) {
+      return void 0;
+    }
+    const mimeType = this.getStringValue(item, "mime_type");
+    const content = this.getStringValue(item, "content");
+    const url = this.getStringValue(item, "url") || (content ? this.buildDataUrl(content, mimeType, "video/mp4") : void 0);
+    const normalized = {
+      url,
+      id: this.getNumberOrStringValue(item, "id"),
+      eta: this.getNumberOrStringValue(item, "eta"),
+      mime_type: mimeType,
+      format: this.getStringValue(item, "format"),
+      original_prompt: this.getStringValue(item, "original_prompt"),
+      revised_prompt: this.getStringValue(item, "revised_prompt"),
+      width: typeof item.width === "number" ? item.width : void 0,
+      height: typeof item.height === "number" ? item.height : void 0,
+      fps: typeof item.fps === "number" ? item.fps : void 0,
+      duration: typeof item.duration === "number" ? item.duration : void 0
+    };
+    if (normalized.url || normalized.id !== void 0 || normalized.eta !== void 0) {
+      return normalized;
+    }
+    return void 0;
+  }
+  normalizeAudioEntry(item) {
+    if (!this.isRecord(item)) {
+      return void 0;
+    }
+    const mimeType = this.getStringValue(item, "mime_type");
+    const content = this.getStringValue(item, "content");
+    const url = this.getStringValue(item, "url") || (content ? this.buildDataUrl(content, mimeType, "audio/wav") : void 0);
+    const normalized = {
+      base64_audio: this.getStringValue(item, "base64_audio"),
+      mime_type: mimeType,
+      url,
+      id: this.getNumberOrStringValue(item, "id"),
+      content,
+      channels: typeof item.channels === "number" ? item.channels : void 0,
+      sample_rate: typeof item.sample_rate === "number" ? item.sample_rate : void 0,
+      format: this.getStringValue(item, "format"),
+      duration: typeof item.duration === "number" ? item.duration : void 0
+    };
+    if (normalized.url || normalized.base64_audio || normalized.content || normalized.id !== void 0) {
+      return normalized;
+    }
+    return void 0;
+  }
+  normalizeFileEntry(item) {
+    if (!this.isRecord(item)) {
+      return void 0;
+    }
+    const normalized = {
+      id: this.getStringValue(item, "id"),
+      url: this.getStringValue(item, "url"),
+      filename: this.getStringValue(item, "filename"),
+      name: this.getStringValue(item, "name"),
+      mime_type: this.getStringValue(item, "mime_type"),
+      format: this.getStringValue(item, "format"),
+      size: typeof item.size === "number" ? item.size : void 0
+    };
+    if (normalized.url || normalized.filename || normalized.name || normalized.id) {
+      return normalized;
+    }
+    return void 0;
+  }
+  normalizeArray(value, normalizer) {
+    if (!Array.isArray(value)) {
+      return void 0;
+    }
+    const items = value.map((item) => normalizer(item)).filter((item) => item !== void 0);
+    return items.length > 0 ? items : void 0;
+  }
+  normalizeImages(value) {
+    return this.normalizeArray(value, (item) => this.normalizeImage(item));
+  }
+  normalizeVideos(value) {
+    return this.normalizeArray(value, (item) => this.normalizeVideo(item));
+  }
+  normalizeAudio(value) {
+    return this.normalizeArray(value, (item) => this.normalizeAudioEntry(item));
+  }
+  normalizeFiles(value) {
+    return this.normalizeArray(value, (item) => this.normalizeFileEntry(item));
+  }
+  extractInputMedia(inputMedia) {
+    if (!this.isRecord(inputMedia)) {
+      return {};
+    }
+    return {
+      images: this.normalizeImages(inputMedia.images),
+      videos: this.normalizeVideos(inputMedia.videos),
+      audio: this.normalizeAudio(inputMedia.audios ?? inputMedia.audio),
+      files: this.normalizeFiles(inputMedia.files)
+    };
+  }
+  extractInputMediaFromMessages(messages) {
+    if (!Array.isArray(messages)) {
+      return {};
+    }
+    for (const message of messages) {
+      if (!this.isRecord(message)) {
+        continue;
+      }
+      if (this.getStringValue(message, "role") !== "user") {
+        continue;
+      }
+      const media = {
+        images: this.normalizeImages(message.images ?? message.image),
+        videos: this.normalizeVideos(message.videos ?? message.video),
+        audio: this.normalizeAudio(message.audios ?? message.audio),
+        files: this.normalizeFiles(message.files)
+      };
+      if (this.hasAnyMedia(media)) {
+        return media;
+      }
+    }
+    return {};
+  }
+  mergeInputMedia(primary, fallback) {
+    return {
+      images: primary.images ?? fallback.images,
+      videos: primary.videos ?? fallback.videos,
+      audio: primary.audio ?? fallback.audio,
+      files: primary.files ?? fallback.files
+    };
+  }
+  normalizeRunContent(content) {
+    if (typeof content === "string") {
+      return content;
+    }
+    if (content && typeof content === "object") {
+      return JSON.stringify(content);
+    }
+    return "";
+  }
+  buildToolCall(rawTool, fallbackTimestamp) {
+    return {
+      role: "tool",
+      content: rawTool.content ?? "",
+      tool_call_id: rawTool.tool_call_id ?? "",
+      tool_name: rawTool.tool_name ?? "",
+      tool_args: rawTool.tool_args ?? {},
+      tool_call_error: rawTool.tool_call_error ?? false,
+      metrics: rawTool.metrics ?? { time: 0 },
+      created_at: rawTool.created_at ?? fallbackTimestamp
+    };
+  }
+  extractToolCalls(run, timestamp) {
+    const toolCalls = [];
+    if (run.tools && Array.isArray(run.tools)) {
+      for (const tool of run.tools) {
+        toolCalls.push(this.buildToolCall(tool, timestamp));
+      }
+    }
+    if (run.reasoning_messages && Array.isArray(run.reasoning_messages)) {
+      for (const message of run.reasoning_messages) {
+        if (message.role === "tool") {
+          toolCalls.push(this.buildToolCall(message, timestamp));
+        }
+      }
+    }
+    return toolCalls;
+  }
+  buildExtraData(run) {
+    if (!(run.reasoning_messages || run.reasoning_steps || run.references)) {
+      return void 0;
+    }
+    return {
+      reasoning_messages: run.reasoning_messages,
+      reasoning_steps: run.reasoning_steps,
+      references: run.references
+    };
+  }
+};
+
+// src/parsers/stream-parser.ts
+var StreamResponseHttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.name = "StreamResponseHttpError";
+    this.status = status;
+  }
 };
+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 updateJsonParserState(char, state) {
+  if (state.inString) {
+    if (state.escapeNext) {
+      state.escapeNext = false;
+      return false;
+    }
+    if (char === "\\") {
+      state.escapeNext = true;
+      return false;
+    }
+    if (char === '"') {
+      state.inString = false;
+    }
+    return false;
+  }
+  if (char === '"') {
+    state.inString = true;
+    return false;
+  }
+  if (char === "{") {
+    state.braceCount++;
+    return false;
+  }
+  if (char !== "}") {
+    return false;
+  }
+  state.braceCount--;
+  return state.braceCount === 0;
+}
+function findJsonSlice(buffer, fromIndex) {
+  const startIndex = buffer.indexOf("{", fromIndex);
+  if (startIndex === -1) {
+    return void 0;
+  }
+  const parserState = {
+    braceCount: 0,
+    inString: false,
+    escapeNext: false
+  };
+  for (let i = startIndex; i < buffer.length; i++) {
+    const isJsonComplete = updateJsonParserState(buffer[i], parserState);
+    if (isJsonComplete) {
+      return { startIndex, endIndex: i };
+    }
+  }
+  return void 0;
+}
+function logChunkParseError(error, jsonString, position) {
+  if (typeof process === "undefined" || process.env?.NODE_ENV !== "development") {
+    return;
+  }
+  console.error("Failed to parse JSON chunk:", {
+    error,
+    chunk: jsonString.substring(0, 100) + (jsonString.length > 100 ? "..." : ""),
+    position
+  });
+}
+function processJsonSlice(jsonString, startIndex, onChunk) {
+  try {
+    const parsed = JSON.parse(jsonString);
+    if (isLegacyFormat(parsed)) {
+      processChunk(parsed, onChunk);
+    } else {
+      processChunk(convertNewFormatToLegacy(parsed), onChunk);
+    }
+    return true;
+  } catch (error) {
+    logChunkParseError(error, jsonString, startIndex);
+    if (jsonString.length > 1e4) {
+      throw new Error(
+        `Failed to parse large JSON chunk at position ${startIndex}`
+      );
+    }
+    return false;
+  }
+}
+function parseBuffer(buffer, onChunk) {
+  let searchIndex = 0;
+  let remainingBuffer = buffer;
+  while (true) {
+    const jsonSlice = findJsonSlice(remainingBuffer, searchIndex);
+    if (!jsonSlice) {
+      break;
+    }
+    const jsonString = remainingBuffer.slice(
+      jsonSlice.startIndex,
+      jsonSlice.endIndex + 1
+    );
+    const parsed = processJsonSlice(jsonString, jsonSlice.startIndex, onChunk);
+    if (!parsed) {
+      searchIndex = jsonSlice.startIndex + 1;
+      continue;
+    }
+    remainingBuffer = remainingBuffer.slice(jsonSlice.endIndex + 1).trim();
+    searchIndex = 0;
+  }
+  return remainingBuffer;
+}
+function buildRequestHeaders(headers, requestBody) {
+  return {
+    ...!(requestBody instanceof FormData) && {
+      "Content-Type": "application/json"
+    },
+    ...headers
+  };
+}
+async function buildErrorMessage(response) {
+  const defaultMessage = `HTTP ${response.status}: ${response.statusText}`;
+  const contentType = response.headers.get("content-type");
+  if (!contentType?.includes("application/json")) {
+    return defaultMessage;
+  }
+  try {
+    const errorData = await response.json();
+    return errorData.detail || errorData.message || defaultMessage;
+  } catch {
+    return defaultMessage;
+  }
+}
+async function consumeResponseStream(body, onChunk, onComplete) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      parseBuffer(buffer, onChunk);
+      onComplete();
+      return;
+    }
+    buffer += decoder.decode(value, { stream: true });
+    buffer = parseBuffer(buffer, onChunk);
+  }
+}
+async function streamResponse(options) {
+  const {
+    apiUrl,
+    headers = {},
+    params,
+    requestBody,
+    onChunk,
+    onError,
+    onComplete,
+    signal
+  } = options;
+  const finalUrl = params?.toString() ? `${apiUrl}?${params.toString()}` : apiUrl;
+  try {
+    const response = await fetch(finalUrl, {
+      method: "POST",
+      headers: buildRequestHeaders(headers, requestBody),
+      body: requestBody instanceof FormData ? requestBody : JSON.stringify(requestBody),
+      signal
+    });
+    if (!response.ok) {
+      const errorMessage = await buildErrorMessage(response);
+      throw new StreamResponseHttpError(response.status, errorMessage);
+    }
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    await consumeResponseStream(response.body, onChunk, onComplete);
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    if (error instanceof Error) {
+      onError(error);
+      return;
+    }
+    if (typeof error === "object" && error !== null && "detail" in error) {
+      onError(new Error(String(error.detail)));
+    } else {
+      onError(new Error(String(error)));
+    }
+  }
+}
 
 // src/processors/event-processor.ts
 import { RunEvent as RunEventEnum } from "@antipopp/agno-types";
@@ -470,14 +824,18 @@ function processToolCall(toolCall, prevToolCalls = []) {
   );
   if (existingToolCallIndex >= 0) {
     const updatedToolCalls = [...prevToolCalls];
-    updatedToolCalls[existingToolCallIndex] = {
-      ...updatedToolCalls[existingToolCallIndex],
-      ...toolCall
-    };
+    const existing = updatedToolCalls[existingToolCallIndex];
+    const merged = { ...existing, ...toolCall };
+    if (existing.external_execution && existing.result !== void 0) {
+      merged.result = existing.result;
+    }
+    if (existing.ui_component !== void 0 && !toolCall.ui_component) {
+      merged.ui_component = existing.ui_component;
+    }
+    updatedToolCalls[existingToolCallIndex] = merged;
     return updatedToolCalls;
-  } else {
-    return [...prevToolCalls, toolCall];
   }
+  return [...prevToolCalls, toolCall];
 }
 function processChunkToolCalls(chunk, existingToolCalls = []) {
   let updatedToolCalls = [...existingToolCalls];
@@ -495,6 +853,105 @@ var EventProcessor = class {
   constructor() {
     this.lastContent = "";
   }
+  appendRunContent(chunk, updatedMessage) {
+    if (typeof chunk.content === "string") {
+      const uniqueContent = chunk.content.replace(this.lastContent, "");
+      updatedMessage.content = updatedMessage.content + uniqueContent;
+      this.lastContent = chunk.content;
+      return;
+    }
+    if (typeof chunk.content !== "string" && chunk.content !== null) {
+      const jsonBlock = getJsonMarkdown(chunk.content);
+      updatedMessage.content = updatedMessage.content + jsonBlock;
+      this.lastContent = jsonBlock;
+    }
+  }
+  applyRunContentFields(chunk, lastMessage, updatedMessage) {
+    this.appendRunContent(chunk, updatedMessage);
+    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.image) {
+      const existingImages = updatedMessage.images ?? lastMessage.images ?? [];
+      const hasImage = existingImages.some((image) => {
+        if (image.id && chunk.image?.id) {
+          return image.id === chunk.image.id;
+        }
+        return image.url === chunk.image?.url;
+      });
+      if (!hasImage) {
+        updatedMessage.images = [...existingImages, chunk.image];
+      }
+    }
+    if (chunk.videos) {
+      updatedMessage.videos = chunk.videos;
+    }
+    if (chunk.audio) {
+      updatedMessage.audio = chunk.audio;
+    }
+    if (chunk.files) {
+      updatedMessage.files = chunk.files;
+    }
+    if (chunk.response_audio?.transcript && typeof chunk.response_audio.transcript === "string") {
+      updatedMessage.response_audio = {
+        ...updatedMessage.response_audio,
+        transcript: (updatedMessage.response_audio?.transcript || "") + chunk.response_audio.transcript
+      };
+    }
+  }
+  applyCompletedFields(chunk, lastMessage, updatedMessage) {
+    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
+    );
+    const completedImages = chunk.images ?? (chunk.image ? [chunk.image] : void 0);
+    updatedMessage.images = completedImages ?? lastMessage.images;
+    updatedMessage.videos = chunk.videos ?? lastMessage.videos;
+    updatedMessage.audio = chunk.audio ?? lastMessage.audio;
+    updatedMessage.files = chunk.files ?? lastMessage.files;
+    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
+    };
+  }
+  appendReasoningSteps(chunk, lastMessage, updatedMessage) {
+    const existingSteps = lastMessage.extra_data?.reasoning_steps ?? [];
+    const incomingSteps = chunk.extra_data?.reasoning_steps ?? [];
+    updatedMessage.extra_data = {
+      ...updatedMessage.extra_data,
+      reasoning_steps: [...existingSteps, ...incomingSteps]
+    };
+  }
   /**
    * Process a chunk and update the last message
    */
@@ -521,58 +978,13 @@ var EventProcessor = class {
         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
-          };
-        }
+        this.applyRunContentFields(chunk, lastMessage, updatedMessage);
         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]
-        };
+      case RunEventEnum.TeamReasoningStep: {
+        this.appendReasoningSteps(chunk, lastMessage, updatedMessage);
         break;
+      }
       case RunEventEnum.ReasoningCompleted:
       case RunEventEnum.TeamReasoningCompleted:
         if (chunk.extra_data?.reasoning_steps) {
@@ -583,31 +995,10 @@ var EventProcessor = class {
         }
         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
-        };
+      case RunEventEnum.TeamRunCompleted: {
+        this.applyCompletedFields(chunk, lastMessage, updatedMessage);
         break;
+      }
       case RunEventEnum.UpdatingMemory:
       case RunEventEnum.TeamMemoryUpdateStarted:
       case RunEventEnum.TeamMemoryUpdateCompleted:
@@ -619,6 +1010,8 @@ var EventProcessor = class {
       case RunEventEnum.TeamRunCancelled:
         updatedMessage.streamingError = true;
         break;
+      default:
+        break;
     }
     return updatedMessage;
   }
@@ -630,166 +1023,95 @@ var EventProcessor = class {
   }
 };
 
-// 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 = {},
-    params,
-    requestBody,
-    onChunk,
-    onError,
-    onComplete,
-    signal
-  } = options;
-  let buffer = "";
-  const finalUrl = params && params.toString() ? `${apiUrl}?${params.toString()}` : apiUrl;
-  try {
-    const response = await fetch(finalUrl, {
-      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");
+// 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 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;
+    const lastMessage = this.messages.at(-1);
+    if (!lastMessage) {
+      return void 0;
     }
-    if (typeof error === "object" && error !== null && "detail" in error) {
-      onError(new Error(String(error.detail)));
-    } else {
-      onError(new Error(String(error)));
+    const updatedMessage = updater(lastMessage);
+    this.messages = [...this.messages.slice(0, -1), updatedMessage];
+    return updatedMessage;
+  }
+  /**
+   * Update a specific message by index
+   */
+  updateMessage(index, updater) {
+    if (index < 0 || index >= this.messages.length) {
+      return void 0;
     }
+    const message = this.messages[index];
+    const updatedMessage = updater(message);
+    this.messages = [
+      ...this.messages.slice(0, index),
+      updatedMessage,
+      ...this.messages.slice(index + 1)
+    ];
+    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.at(-1) : void 0;
+  }
+  /**
+   * Check if last message has streaming error
+   */
+  hasLastMessageError() {
+    const lastMessage = this.getLastMessage();
+    return lastMessage?.streamingError === true;
+  }
+};
 
 // src/utils/logger.ts
-var SENSITIVE_KEYS = ["authToken", "Authorization", "token", "password", "apiKey"];
+var SENSITIVE_KEYS = [
+  "authToken",
+  "Authorization",
+  "token",
+  "password",
+  "apiKey"
+];
 function sanitizeObject(obj) {
   if (obj === null || obj === void 0) {
     return obj;
@@ -817,36 +1139,36 @@ function sanitizeObject(obj) {
 function isDevelopment() {
   return typeof process !== "undefined" && process.env?.NODE_ENV === "development";
 }
-var Logger = class {
+var Logger = {
   /**
    * Log debug information (only in development)
    */
-  static debug(message, data) {
+  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) {
+  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) {
+  warn(message, data) {
     const sanitized = data ? sanitizeObject(data) : void 0;
     console.warn(`[WARN] ${message}`, sanitized || "");
-  }
+  },
   /**
    * Log errors (always logs)
    */
-  static error(message, data) {
+  error(message, data) {
     const sanitized = data ? sanitizeObject(data) : void 0;
     console.error(`[ERROR] ${message}`, sanitized || "");
   }
@@ -864,19 +1186,104 @@ function toSafeISOString(timestamp) {
   }
   return new Date(ts).toISOString();
 }
+function getFileName(file, index) {
+  if ("name" in file && typeof file.name === "string" && file.name) {
+    return file.name;
+  }
+  return `file-${index}`;
+}
+function getFileFormat(mimeType) {
+  if (!mimeType) {
+    return void 0;
+  }
+  const [, subtype] = mimeType.split("/");
+  if (!subtype) {
+    return void 0;
+  }
+  return subtype.split(";")[0]?.trim().toLowerCase() || void 0;
+}
+function createPreviewUrl(file) {
+  if (typeof URL === "undefined" || typeof URL.createObjectURL !== "function") {
+    return void 0;
+  }
+  try {
+    return URL.createObjectURL(file);
+  } catch {
+    return void 0;
+  }
+}
+function buildMessageMediaPayload(files) {
+  const images = [];
+  const videos = [];
+  const audio = [];
+  const fileAttachments = [];
+  const objectUrls = [];
+  files.forEach((file, index) => {
+    const filename = getFileName(file, index);
+    const mimeType = file.type || "application/octet-stream";
+    const format = getFileFormat(mimeType);
+    const previewUrl = createPreviewUrl(file);
+    if (previewUrl) {
+      objectUrls.push(previewUrl);
+    }
+    if (mimeType.startsWith("image/") && previewUrl) {
+      images.push({
+        url: previewUrl,
+        mime_type: mimeType,
+        format
+      });
+      return;
+    }
+    if (mimeType.startsWith("video/")) {
+      videos.push({
+        url: previewUrl,
+        id: filename,
+        mime_type: mimeType,
+        format
+      });
+      return;
+    }
+    if (mimeType.startsWith("audio/")) {
+      audio.push({
+        url: previewUrl,
+        id: filename,
+        mime_type: mimeType,
+        format
+      });
+      return;
+    }
+    fileAttachments.push({
+      filename,
+      name: filename,
+      mime_type: mimeType,
+      format,
+      size: file.size,
+      url: previewUrl
+    });
+  });
+  return {
+    images: images.length > 0 ? images : void 0,
+    videos: videos.length > 0 ? videos : void 0,
+    audio: audio.length > 0 ? audio : void 0,
+    files: fileAttachments.length > 0 ? fileAttachments : void 0,
+    objectUrls
+  };
+}
 var AgnoClient = class extends EventEmitter {
   constructor(config) {
     super();
-    // toolCallId -> UIComponentSpec
     this.runCompletedSuccessfully = false;
+    this.currentAbortController = null;
     this.messageStore = new MessageStore();
     this.configManager = new ConfigManager(config);
     this.sessionManager = new SessionManager();
     this.eventProcessor = new EventProcessor();
     this.pendingUISpecs = /* @__PURE__ */ new Map();
+    this.localAttachmentUrls = /* @__PURE__ */ new Set();
     this.state = {
       isStreaming: false,
       isRefreshing: false,
+      isCancelling: false,
       isEndpointActive: false,
       agents: [],
       teams: [],
@@ -915,12 +1322,99 @@ var AgnoClient = class extends EventEmitter {
    * Clear all messages
    */
   clearMessages() {
+    this.revokeAttachmentUrlsFromMessages(this.messageStore.getMessages());
+    this.localAttachmentUrls.clear();
     this.messageStore.clear();
     this.configManager.setSessionId(void 0);
     this.pendingUISpecs.clear();
     this.emit("message:update", this.messageStore.getMessages());
     this.emit("state:change", this.getState());
   }
+  /**
+   * Cancel an active or paused run
+   */
+  async cancelRun() {
+    if (!(this.state.isStreaming || this.state.isPaused)) {
+      throw new Error("No active or paused run to cancel");
+    }
+    const runId = this.state.pausedRunId || this.currentRunId;
+    if (this.currentAbortController) {
+      this.currentAbortController.abort();
+      this.currentAbortController = null;
+    }
+    this.state.isCancelling = true;
+    this.emit("state:change", this.getState());
+    const cancelErrorMessage = runId ? await this.requestBackendCancel(runId) : this.logMissingRunIdForCancel();
+    this.state.isStreaming = false;
+    this.state.isPaused = false;
+    this.state.isCancelling = false;
+    this.state.pausedRunId = void 0;
+    this.state.toolsAwaitingExecution = void 0;
+    this.currentRunId = void 0;
+    if (cancelErrorMessage) {
+      this.state.errorMessage = cancelErrorMessage;
+      this.emit("message:error", cancelErrorMessage);
+    }
+    this.emit("run:cancelled", { runId });
+    this.emit("state:change", this.getState());
+  }
+  logMissingRunIdForCancel() {
+    Logger.warn(
+      "[AgnoClient] No run ID available, skipping backend cancel request"
+    );
+    return void 0;
+  }
+  async requestBackendCancel(runId) {
+    const runUrl = this.configManager.getRunUrl();
+    if (!runUrl) {
+      const message = "Run cancelled locally, but backend cancel could not be sent: no agent or team selected";
+      Logger.warn(`[AgnoClient] ${message}`);
+      return message;
+    }
+    const cancelUrl = `${runUrl}/${runId}/cancel`;
+    const headers = this.configManager.buildRequestHeaders();
+    try {
+      const response = await fetch(cancelUrl, {
+        method: "POST",
+        headers
+      });
+      if (response.ok) {
+        return void 0;
+      }
+      if (response.status === 401 || response.status === 403) {
+        const message = `Run cancelled locally, but backend cancel was rejected (${response.status})`;
+        Logger.warn(`[AgnoClient] ${message}`);
+        return message;
+      }
+      Logger.warn(
+        `[AgnoClient] Backend cancel returned ${response.status} \u2014 run may have already completed`
+      );
+      return void 0;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      const message = `Run cancelled locally, but backend cancel failed: ${reason}`;
+      Logger.warn(`[AgnoClient] ${message}`);
+      return message;
+    }
+  }
+  /**
+   * Abort the active stream without calling the backend cancel endpoint.
+   * Since streamResponse handles AbortError by returning silently
+   * (no onComplete/onError called), state cleanup is done here.
+   */
+  abortStream() {
+    if (!this.state.isStreaming) {
+      return;
+    }
+    if (this.currentAbortController) {
+      this.currentAbortController.abort();
+      this.currentAbortController = null;
+    }
+    this.state.isStreaming = false;
+    this.currentRunId = void 0;
+    this.emit("stream:end");
+    this.emit("state:change", this.getState());
+  }
   /**
    * Send a message to the agent/team (streaming)
    */
@@ -941,16 +1435,30 @@ var AgnoClient = class extends EventEmitter {
     if (typeof message === "string") {
       formData.append("message", message);
     }
+    if (options?.files) {
+      options.files.forEach((file, index) => {
+        formData.append("files", file, getFileName(file, index));
+      });
+    }
+    const requestFiles = formData.getAll("files").filter((entry) => typeof entry !== "string");
+    const userMessageMedia = buildMessageMediaPayload(requestFiles);
+    this.trackAttachmentUrls(userMessageMedia.objectUrls);
+    const userMessageContent = String(formData.get("message") ?? "");
     const lastMessage = this.messageStore.getLastMessage();
     if (lastMessage?.streamingError) {
       const secondLast = this.messageStore.getMessages()[this.messageStore.getMessages().length - 2];
       if (secondLast?.role === "user") {
+        this.revokeAttachmentUrlsFromMessages([secondLast, lastMessage]);
         this.messageStore.removeLastMessages(2);
       }
     }
     this.messageStore.addMessage({
       role: "user",
-      content: formData.get("message"),
+      content: userMessageContent,
+      images: userMessageMedia.images,
+      videos: userMessageMedia.videos,
+      audio: userMessageMedia.audio,
+      files: userMessageMedia.files,
       created_at: Math.floor(Date.now() / 1e3)
     });
     this.messageStore.addMessage({
@@ -964,33 +1472,42 @@ var AgnoClient = class extends EventEmitter {
     this.eventProcessor.reset();
     let newSessionId = this.configManager.getSessionId();
     try {
-      formData.append("stream", "true");
-      formData.append("session_id", newSessionId ?? "");
+      formData.set("stream", "true");
+      formData.set("session_id", newSessionId ?? "");
       const userId = this.configManager.getUserId();
       if (userId) {
-        formData.append("user_id", userId);
+        formData.set("user_id", userId);
+      }
+      const dependencies = this.configManager.buildDependencies(
+        options?.dependencies
+      );
+      if (dependencies) {
+        formData.set("dependencies", JSON.stringify(dependencies));
       }
       const headers = this.configManager.buildRequestHeaders(options?.headers);
       const params = this.configManager.buildQueryString(options?.params);
+      this.currentAbortController = new AbortController();
       await streamResponse({
         apiUrl: runUrl,
         headers,
         params,
         requestBody: formData,
+        signal: this.currentAbortController.signal,
         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);
-            }
+          this.handleChunk(chunk, newSessionId, userMessageContent);
+          if ((chunk.event === RunEvent.RunStarted || chunk.event === RunEvent.TeamRunStarted || chunk.event === RunEvent.ReasoningStarted || chunk.event === RunEvent.TeamReasoningStarted) && chunk.session_id) {
+            newSessionId = chunk.session_id;
+            this.configManager.setSessionId(chunk.session_id);
           }
         },
         onError: (error) => {
+          this.currentAbortController = null;
           this.handleError(error, newSessionId);
         },
         onComplete: async () => {
+          this.currentAbortController = null;
           this.state.isStreaming = false;
+          this.currentRunId = void 0;
           this.emit("stream:end");
           this.emit("message:complete", this.messageStore.getMessages());
           this.emit("state:change", this.getState());
@@ -1001,6 +1518,7 @@ var AgnoClient = class extends EventEmitter {
         }
       });
     } catch (error) {
+      this.currentAbortController = null;
       this.handleError(
         error instanceof Error ? error : new Error(String(error)),
         newSessionId
@@ -1012,20 +1530,21 @@ var AgnoClient = class extends EventEmitter {
    */
   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.RunStarted || event === RunEvent.TeamRunStarted) && chunk.run_id) {
+      this.currentRunId = chunk.run_id;
+    }
+    if ((event === RunEvent.RunStarted || event === RunEvent.TeamRunStarted || event === RunEvent.ReasoningStarted || event === RunEvent.TeamReasoningStarted) && 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) {
@@ -1085,6 +1604,73 @@ var AgnoClient = class extends EventEmitter {
     this.emit("stream:end");
     this.emit("state:change", this.getState());
   }
+  trackAttachmentUrls(urls) {
+    for (const url of urls) {
+      this.localAttachmentUrls.add(url);
+    }
+  }
+  collectAttachmentUrls(message) {
+    const imageUrls = message.images?.map((image) => image.url) ?? [];
+    const videoUrls = message.videos?.map((video) => video.url).filter((url) => Boolean(url)) ?? [];
+    const audioUrls = message.audio?.map((audio) => audio.url).filter((url) => Boolean(url)) ?? [];
+    const fileUrls = message.files?.map((file) => file.url).filter((url) => Boolean(url)) ?? [];
+    return [...imageUrls, ...videoUrls, ...audioUrls, ...fileUrls];
+  }
+  revokeAttachmentUrls(urls) {
+    if (typeof URL === "undefined" || typeof URL.revokeObjectURL !== "function") {
+      return;
+    }
+    for (const url of urls) {
+      if (!this.localAttachmentUrls.has(url)) {
+        continue;
+      }
+      URL.revokeObjectURL(url);
+      this.localAttachmentUrls.delete(url);
+    }
+  }
+  revokeAttachmentUrlsFromMessages(messages) {
+    const urls = [];
+    for (const message of messages) {
+      if (!message) {
+        continue;
+      }
+      urls.push(...this.collectAttachmentUrls(message));
+    }
+    this.revokeAttachmentUrls(urls);
+  }
+  collectExistingUIComponents() {
+    const existingUIComponents = /* @__PURE__ */ new Map();
+    for (const message of this.messageStore.getMessages()) {
+      if (!message.tool_calls) {
+        continue;
+      }
+      for (const toolCall of message.tool_calls) {
+        if (toolCall.ui_component) {
+          existingUIComponents.set(
+            toolCall.tool_call_id,
+            toolCall.ui_component
+          );
+        }
+      }
+    }
+    return existingUIComponents;
+  }
+  restoreUIComponents(messages, uiComponents) {
+    if (uiComponents.size === 0) {
+      return;
+    }
+    for (const message of messages) {
+      if (!message.tool_calls) {
+        continue;
+      }
+      for (const toolCall of message.tool_calls) {
+        const uiComponent = uiComponents.get(toolCall.tool_call_id);
+        if (uiComponent) {
+          toolCall.ui_component = uiComponent;
+        }
+      }
+    }
+  }
   /**
    * Refresh messages from the session API after run completion.
    * Replaces streamed messages with authoritative session data.
@@ -1097,19 +1683,14 @@ var AgnoClient = class extends EventEmitter {
       Logger.debug("[AgnoClient] Cannot refresh: no session ID");
       return;
     }
+    if (this.state.isStreaming) {
+      Logger.debug("[AgnoClient] Skipping refresh: stream is active");
+      return;
+    }
     this.state.isRefreshing = true;
     this.emit("state:change", this.getState());
     try {
-      const existingUIComponents = /* @__PURE__ */ new Map();
-      for (const message of this.messageStore.getMessages()) {
-        if (message.tool_calls) {
-          for (const toolCall of message.tool_calls) {
-            if (toolCall.ui_component) {
-              existingUIComponents.set(toolCall.tool_call_id, toolCall.ui_component);
-            }
-          }
-        }
-      }
+      const existingUIComponents = this.collectExistingUIComponents();
       const config = this.configManager.getConfig();
       const entityType = this.configManager.getMode();
       const dbId = this.configManager.getDbId() || "";
@@ -1125,27 +1706,28 @@ var AgnoClient = class extends EventEmitter {
         userId,
         params
       );
-      const messages = this.sessionManager.convertSessionToMessages(response);
-      if (existingUIComponents.size > 0) {
-        for (const message of messages) {
-          if (message.tool_calls) {
-            for (let i = 0; i < message.tool_calls.length; i++) {
-              const toolCall = message.tool_calls[i];
-              const uiComponent = existingUIComponents.get(toolCall.tool_call_id);
-              if (uiComponent) {
-                message.tool_calls[i].ui_component = uiComponent;
-              }
-            }
-          }
-        }
+      if (this.state.isStreaming) {
+        Logger.debug(
+          "[AgnoClient] Aborting refresh: stream started during fetch"
+        );
+        return;
       }
+      const messages = this.sessionManager.convertSessionToMessages(response);
+      this.restoreUIComponents(messages, existingUIComponents);
+      this.revokeAttachmentUrlsFromMessages(this.messageStore.getMessages());
       this.messageStore.setMessages(messages);
-      Logger.debug("[AgnoClient] Session refreshed:", `${messages.length} messages`);
+      Logger.debug(
+        "[AgnoClient] Session refreshed:",
+        `${messages.length} messages`
+      );
       this.emit("message:refreshed", messages);
       this.emit("message:update", messages);
     } catch (error) {
       Logger.error("[AgnoClient] Failed to refresh session:", error);
-      this.emit("message:error", `Session refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+      this.emit(
+        "message:error",
+        `Session refresh failed: ${error instanceof Error ? error.message : String(error)}`
+      );
     } finally {
       this.state.isRefreshing = false;
       this.emit("state:change", this.getState());
@@ -1160,7 +1742,11 @@ var AgnoClient = class extends EventEmitter {
     const entityType = this.configManager.getMode();
     const dbId = this.configManager.getDbId() || "";
     const userId = this.configManager.getUserId();
-    Logger.debug("[AgnoClient] Loading session with:", { entityType, dbId, userId });
+    Logger.debug("[AgnoClient] Loading session with:", {
+      entityType,
+      dbId,
+      userId
+    });
     const headers = this.configManager.buildRequestHeaders();
     const params = this.configManager.buildQueryString(options?.params);
     const response = await this.sessionManager.fetchSession(
@@ -1173,7 +1759,11 @@ var AgnoClient = class extends EventEmitter {
       params
     );
     const messages = this.sessionManager.convertSessionToMessages(response);
-    Logger.debug("[AgnoClient] Setting messages to store:", `${messages.length} messages`);
+    Logger.debug(
+      "[AgnoClient] Setting messages to store:",
+      `${messages.length} messages`
+    );
+    this.revokeAttachmentUrlsFromMessages(this.messageStore.getMessages());
     this.messageStore.setMessages(messages);
     this.configManager.setSessionId(sessionId);
     Logger.debug("[AgnoClient] Emitting events...");
@@ -1242,7 +1832,9 @@ var AgnoClient = class extends EventEmitter {
     }
     const existingToolCalls = lastMessage.tool_calls || [];
     const existingIds = new Set(existingToolCalls.map((t) => t.tool_call_id));
-    const newToolCalls = toolCalls.filter((t) => !existingIds.has(t.tool_call_id));
+    const newToolCalls = toolCalls.filter(
+      (t) => !existingIds.has(t.tool_call_id)
+    );
     if (newToolCalls.length > 0) {
       this.messageStore.updateLastMessage((msg) => ({
         ...msg,
@@ -1289,8 +1881,9 @@ var AgnoClient = class extends EventEmitter {
    * Batches all updates to emit only one message:update event
    */
   applyPendingUISpecs() {
-    if (this.pendingUISpecs.size === 0)
+    if (this.pendingUISpecs.size === 0) {
       return;
+    }
     const messages = this.messageStore.getMessages();
     const updatedMessages = [];
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -1322,9 +1915,9 @@ var AgnoClient = class extends EventEmitter {
       }
     }
     if (updatedMessages.length > 0) {
-      updatedMessages.forEach(({ index, message }) => {
+      for (const { index, message } of updatedMessages) {
         this.messageStore.updateMessage(index, () => message);
-      });
+      }
       this.emit("message:update", this.messageStore.getMessages());
     }
   }
@@ -1345,22 +1938,55 @@ var AgnoClient = class extends EventEmitter {
         "HITL (Human-in-the-Loop) frontend tool execution is not supported for teams. Only agents support the continue endpoint."
       );
     }
-    if (!this.state.isPaused || !this.state.pausedRunId) {
+    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;
+    const pausedRunId = this.state.pausedRunId;
+    const continueUrl = `${runUrl}/${pausedRunId}/continue`;
     this.state.isStreaming = true;
-    this.emit("run:continued", { runId: this.state.pausedRunId });
+    this.state.errorMessage = void 0;
     this.emit("state:change", this.getState());
-    const cleanedTools = tools.map((tool) => {
-      const { ui_component, ...backendTool } = tool;
-      return backendTool;
-    });
+    let hasContinued = false;
+    let streamError;
+    const markRunContinued = (runId) => {
+      if (hasContinued) {
+        return;
+      }
+      hasContinued = true;
+      this.state.isPaused = false;
+      this.state.toolsAwaitingExecution = void 0;
+      this.emit("run:continued", { runId: runId || pausedRunId });
+      this.emit("state:change", this.getState());
+    };
+    const handleContinueError = (error) => {
+      streamError = error;
+      this.state.isStreaming = false;
+      this.state.errorMessage = error.message;
+      const isConflictError = error instanceof StreamResponseHttpError && error.status === 409;
+      if (isConflictError || !hasContinued) {
+        this.state.isPaused = true;
+      } else {
+        this.state.isPaused = false;
+        this.state.pausedRunId = void 0;
+        this.state.toolsAwaitingExecution = void 0;
+        this.messageStore.updateLastMessage((msg) => ({
+          ...msg,
+          streamingError: true
+        }));
+      }
+      this.emit("message:error", error.message);
+      this.emit("stream:end");
+      this.emit("state:change", this.getState());
+    };
+    const cleanedTools = tools.map(
+      ({ ui_component: _uiComponent, ...tool }) => {
+        return tool;
+      }
+    );
     const formData = new FormData();
     formData.append("tools", JSON.stringify(cleanedTools));
     formData.append("stream", "true");
@@ -1374,36 +2000,45 @@ var AgnoClient = class extends EventEmitter {
     }
     const headers = this.configManager.buildRequestHeaders(options?.headers);
     const params = this.configManager.buildQueryString(options?.params);
-    try {
-      await streamResponse({
-        apiUrl: continueUrl,
-        headers,
-        params,
-        requestBody: formData,
-        onChunk: (chunk) => {
-          this.handleChunk(chunk, currentSessionId, "");
-        },
-        onError: (error) => {
-          this.handleError(error, currentSessionId);
-        },
-        onComplete: async () => {
-          this.state.isStreaming = false;
+    this.currentAbortController = new AbortController();
+    await streamResponse({
+      apiUrl: continueUrl,
+      headers,
+      params,
+      requestBody: formData,
+      signal: this.currentAbortController.signal,
+      onChunk: (chunk) => {
+        const event = chunk.event;
+        if (!hasContinued && event !== RunEvent.RunPaused) {
+          markRunContinued(chunk.run_id);
+        }
+        this.handleChunk(chunk, currentSessionId, "");
+      },
+      onError: (error) => {
+        this.currentAbortController = null;
+        handleContinueError(error);
+      },
+      onComplete: async () => {
+        this.currentAbortController = null;
+        if (!(hasContinued || this.state.isPaused)) {
+          markRunContinued(pausedRunId);
+        }
+        this.state.isStreaming = false;
+        if (!this.state.isPaused) {
           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());
-          if (this.runCompletedSuccessfully) {
-            this.runCompletedSuccessfully = false;
-            await this.refreshSessionMessages();
-          }
         }
-      });
-    } catch (error) {
-      this.handleError(
-        error instanceof Error ? error : new Error(String(error)),
-        currentSessionId
-      );
+        this.emit("stream:end");
+        this.emit("message:complete", this.messageStore.getMessages());
+        this.emit("state:change", this.getState());
+        if (this.runCompletedSuccessfully) {
+          this.runCompletedSuccessfully = false;
+          await this.refreshSessionMessages();
+        }
+      }
+    });
+    if (streamError) {
+      throw streamError;
     }
   }
   /**
@@ -1488,7 +2123,7 @@ var AgnoClient = class extends EventEmitter {
     const currentConfig = this.configManager.getConfig();
     const hasAgentConfigured = currentConfig.agentId;
     const hasTeamConfigured = currentConfig.teamId;
-    if (!hasAgentConfigured && !hasTeamConfigured) {
+    if (!(hasAgentConfigured || hasTeamConfigured)) {
       if (agents.length > 0) {
         const firstAgent = agents[0];
         this.configManager.updateConfig({
@@ -1509,10 +2144,34 @@ var AgnoClient = class extends EventEmitter {
     }
     return { agents, teams };
   }
+  /**
+   * Dispose of the client and clean up all resources.
+   * Call this method when the client is no longer needed to prevent memory leaks.
+   * After calling dispose(), the client instance should not be reused.
+   */
+  dispose() {
+    if (this.currentAbortController) {
+      this.currentAbortController.abort();
+      this.currentAbortController = null;
+    }
+    this.removeAllListeners();
+    this.revokeAttachmentUrlsFromMessages(this.messageStore.getMessages());
+    this.localAttachmentUrls.clear();
+    this.messageStore.clear();
+    this.pendingUISpecs.clear();
+    this.eventProcessor.reset();
+    this.state.isStreaming = false;
+    this.state.isRefreshing = false;
+    this.state.isEndpointActive = false;
+    this.state.agents = [];
+    this.state.teams = [];
+    this.state.sessions = [];
+    this.state.isPaused = false;
+    this.state.pausedRunId = void 0;
+    this.state.toolsAwaitingExecution = void 0;
+    this.state.errorMessage = void 0;
+  }
 };
-
-// src/index.ts
-import { RunEvent as RunEvent2 } from "@antipopp/agno-types";
 export {
   AgnoClient,
   Logger,