@antipopp/agno-client 0.10.0 → 0.11.0

package/dist/index.mjs

@@ -148,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)
    */
@@ -215,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
@@ -301,79 +336,271 @@ 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";
 }
@@ -397,72 +624,139 @@ function convertNewFormatToLegacy(newFormatData) {
 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;
-        }
-      }
+function updateJsonParserState(char, state) {
+  if (state.inString) {
+    if (state.escapeNext) {
+      state.escapeNext = false;
+      return false;
     }
-    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);
+    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);
   }
-  return buffer;
 }
 async function streamResponse(options) {
   const {
@@ -475,54 +769,30 @@ async function streamResponse(options) {
     onComplete,
     signal
   } = options;
-  let buffer = "";
   const finalUrl = params?.toString() ? `${apiUrl}?${params.toString()}` : apiUrl;
   try {
     const response = await fetch(finalUrl, {
       method: "POST",
-      headers: {
-        ...!(requestBody instanceof FormData) && {
-          "Content-Type": "application/json"
-        },
-        ...headers
-      },
+      headers: buildRequestHeaders(headers, requestBody),
       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);
+      const errorMessage = await buildErrorMessage(response);
+      throw new StreamResponseHttpError(response.status, 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();
+    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 {
@@ -554,10 +824,15 @@ 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;
   }
   return [...prevToolCalls, toolCall];
@@ -578,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
    */
@@ -604,57 +978,11 @@ 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]
-        };
+        this.appendReasoningSteps(chunk, lastMessage, updatedMessage);
         break;
       }
       case RunEventEnum.ReasoningCompleted:
@@ -668,29 +996,7 @@ 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
-        };
+        this.applyCompletedFields(chunk, lastMessage, updatedMessage);
         break;
       }
       case RunEventEnum.UpdatingMemory:
@@ -704,6 +1010,8 @@ var EventProcessor = class {
       case RunEventEnum.TeamRunCancelled:
         updatedMessage.streamingError = true;
         break;
+      default:
+        break;
     }
     return updatedMessage;
   }
@@ -831,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 || "");
   }
@@ -878,16 +1186,100 @@ 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,
@@ -930,6 +1322,8 @@ 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();
@@ -943,42 +1337,84 @@ var AgnoClient = class extends EventEmitter {
     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) {
-      throw new Error("No agent or team selected");
-    }
-    const runId = this.state.pausedRunId || this.currentRunId;
-    if (!runId) {
-      throw new Error("No run ID available to cancel");
+      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();
-    this.state.isCancelling = true;
-    this.emit("state:change", this.getState());
     try {
       const response = await fetch(cancelUrl, {
         method: "POST",
         headers
       });
-      if (!response.ok) {
-        throw new Error("Failed to cancel run");
+      if (response.ok) {
+        return void 0;
       }
-      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;
-      this.emit("run:cancelled", { runId });
-      this.emit("state:change", this.getState());
-    } catch (error) {
-      this.state.isCancelling = false;
-      this.emit("state:change", this.getState());
-      throw new Error(
-        `Error cancelling run: ${error instanceof Error ? error.message : String(error)}`
+      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)
    */
@@ -999,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({
@@ -1022,34 +1472,40 @@ 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")
-          );
+          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");
@@ -1062,6 +1518,7 @@ var AgnoClient = class extends EventEmitter {
         }
       });
     } catch (error) {
+      this.currentAbortController = null;
       this.handleError(
         error instanceof Error ? error : new Error(String(error)),
         newSessionId
@@ -1147,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.
@@ -1159,22 +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() || "";
@@ -1190,22 +1706,15 @@ 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:",
@@ -1254,6 +1763,7 @@ var AgnoClient = class extends EventEmitter {
       "[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...");
@@ -1405,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());
     }
   }
@@ -1435,15 +1945,48 @@ var AgnoClient = class extends EventEmitter {
     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");
@@ -1457,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;
     }
   }
   /**
@@ -1598,7 +2150,13 @@ var AgnoClient = class extends EventEmitter {
    * 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();