@standardagents/client 0.1.0-dev.ffffff

package/dist/index.js

@@ -0,0 +1,746 @@
+// src/client/AgentBuilderClient.ts
+var AgentBuilderClient = class {
+  endpoint;
+  token;
+  constructor(endpoint) {
+    this.endpoint = endpoint.replace(/\/$/, "");
+    this.token = typeof localStorage !== "undefined" ? localStorage.getItem("agentbuilder_auth_token") : null;
+  }
+  /**
+   * Get the current endpoint
+   */
+  getEndpoint() {
+    return this.endpoint;
+  }
+  /**
+   * Create a new thread
+   */
+  async createThread(payload) {
+    const response = await fetch(`${this.endpoint}/threads`, {
+      method: "POST",
+      headers: {
+        ...this.getHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to create thread: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Get thread metadata
+   */
+  async getThread(id) {
+    const response = await fetch(`${this.endpoint}/threads/${id}`, {
+      method: "GET",
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get thread: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Get messages from a thread with optional pagination and filtering
+   */
+  async getMessages(id, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) params.set("limit", String(options.limit));
+    if (options.offset !== void 0) params.set("offset", String(options.offset));
+    if (options.depth !== void 0) params.set("depth", String(options.depth));
+    if (options.includeSilent !== void 0) params.set("includeSilent", String(options.includeSilent));
+    const queryString = params.toString();
+    const url = `${this.endpoint}/threads/${id}/messages${queryString ? `?${queryString}` : ""}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get messages: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.messages || [];
+  }
+  /**
+   * Send a message to a thread
+   */
+  async sendMessage(id, payload) {
+    const response = await fetch(`${this.endpoint}/threads/${id}/messages`, {
+      method: "POST",
+      headers: {
+        ...this.getHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to send message: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Stop execution of a thread
+   */
+  async stopExecution(id) {
+    const response = await fetch(`${this.endpoint}/threads/${id}/stop`, {
+      method: "POST",
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to stop execution: ${response.statusText}`);
+    }
+    await response.json();
+  }
+  /**
+   * Options for file upload
+   */
+  /**
+   * Upload a file to a thread's filesystem
+   * @param threadId - The thread ID
+   * @param file - The file to upload
+   * @param options - Optional upload options
+   * @param options.thumbnail - Base64-encoded thumbnail data (for images)
+   * @param options.width - Image width in pixels
+   * @param options.height - Image height in pixels
+   * @returns AttachmentRef with file metadata
+   */
+  async uploadFile(threadId, file, options) {
+    const encodedFilename = encodeURIComponent(file.name);
+    const url = `${this.endpoint}/threads/${threadId}/fs/${encodedFilename}`;
+    if (options?.thumbnail) {
+      const base64Data = await this.fileToBase64(file);
+      const response2 = await fetch(url, {
+        method: "PUT",
+        headers: {
+          ...this.getHeaders(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          data: base64Data,
+          mimeType: file.type,
+          thumbnail: options.thumbnail,
+          metadata: {
+            width: options.width,
+            height: options.height
+          }
+        })
+      });
+      if (!response2.ok) {
+        throw new Error(`Failed to upload file: ${response2.statusText}`);
+      }
+      return response2.json();
+    }
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: {
+        ...this.getHeaders(),
+        "Content-Type": file.type
+      },
+      body: file
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to upload file: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Convert a File to base64 string
+   */
+  fileToBase64(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => {
+        const result = reader.result;
+        const base64 = result.split(",")[1];
+        resolve(base64);
+      };
+      reader.onerror = () => reject(new Error("Failed to read file"));
+      reader.readAsDataURL(file);
+    });
+  }
+  /**
+   * Get the full URL for a file in a thread's filesystem
+   */
+  getFileUrl(threadId, path) {
+    const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+    const encodedPath = normalizedPath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+    return `${this.endpoint}/threads/${threadId}/fs/${encodedPath}`;
+  }
+  /**
+   * Get the thumbnail URL for an image in a thread's filesystem
+   */
+  getThumbnailUrl(threadId, path) {
+    return `${this.getFileUrl(threadId, path)}?thumbnail=true`;
+  }
+  /**
+   * Connect to message WebSocket for real-time message updates
+   */
+  connectMessageWebSocket(id, callbacks = {}, options = {}) {
+    const params = new URLSearchParams();
+    if (this.token) params.set("token", this.token);
+    if (options.includeSilent !== void 0) params.set("includeSilent", String(options.includeSilent));
+    if (options.depth !== void 0) params.set("depth", String(options.depth));
+    const wsProtocol = this.endpoint.startsWith("https") ? "wss" : "ws";
+    const wsEndpoint = this.endpoint.replace(/^https?/, wsProtocol);
+    const url = `${wsEndpoint}/threads/${id}/stream?${params.toString()}`;
+    const ws = new WebSocket(url);
+    ws.onopen = () => {
+      callbacks.onOpen?.();
+    };
+    ws.onmessage = (event) => {
+      try {
+        if (typeof event.data === "string" && event.data === "pong") {
+          return;
+        }
+        const data = JSON.parse(event.data);
+        switch (data.type) {
+          case "message_data":
+            callbacks.onMessage?.(data);
+            break;
+          case "message_chunk":
+            callbacks.onChunk?.(data);
+            break;
+          case "event":
+            callbacks.onEvent?.(data);
+            break;
+          case "error":
+            callbacks.onError?.(data);
+            break;
+        }
+      } catch (error) {
+        console.error("Failed to parse WebSocket message:", error);
+      }
+    };
+    ws.onerror = (event) => {
+      console.error("WebSocket error:", event);
+      callbacks.onError?.({ type: "error", error: "WebSocket connection error" });
+    };
+    ws.onclose = (event) => {
+      console.log(`[AgentBuilderClient] Message WebSocket closed - code: ${event.code}, reason: ${event.reason || "none"}, wasClean: ${event.wasClean}`);
+      callbacks.onClose?.();
+    };
+    return ws;
+  }
+  /**
+   * Connect to log WebSocket for custom events
+   */
+  connectLogWebSocket(id, callbacks = {}) {
+    const params = new URLSearchParams();
+    if (this.token) params.set("token", this.token);
+    const wsProtocol = this.endpoint.startsWith("https") ? "wss" : "ws";
+    const wsEndpoint = this.endpoint.replace(/^https?/, wsProtocol);
+    const url = `${wsEndpoint}/threads/${id}?${params.toString()}`;
+    const ws = new WebSocket(url);
+    ws.onopen = () => {
+      callbacks.onOpen?.();
+    };
+    ws.onmessage = (event) => {
+      try {
+        if (typeof event.data === "string" && event.data === "pong") {
+          return;
+        }
+        const data = JSON.parse(event.data);
+        switch (data.type) {
+          case "log_data":
+            callbacks.onLog?.(data);
+            break;
+          case "custom":
+            callbacks.onCustom?.(data);
+            break;
+          case "stopped_by_user":
+            callbacks.onStopped?.(data);
+            break;
+        }
+      } catch (error) {
+        console.error("Failed to parse WebSocket message:", error);
+      }
+    };
+    ws.onerror = (event) => {
+      console.error("WebSocket error:", event);
+    };
+    ws.onclose = () => {
+      callbacks.onClose?.();
+    };
+    return ws;
+  }
+  /**
+   * Get headers for HTTP requests
+   */
+  getHeaders() {
+    const headers = {};
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    return headers;
+  }
+};
+
+// src/connection/ThreadConnectionManager.ts
+var ThreadConnectionManager = class {
+  client;
+  threadId;
+  callbacks;
+  options;
+  ws = null;
+  status = "disconnected";
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  heartbeatInterval = null;
+  isReconnecting = false;
+  shouldReconnect = true;
+  constructor(client, threadId, callbacks = {}, options = {}) {
+    this.client = client;
+    this.threadId = threadId;
+    this.callbacks = callbacks;
+    this.options = {
+      depth: options.depth ?? 0,
+      includeSilent: options.includeSilent ?? false,
+      heartbeatInterval: options.heartbeatInterval ?? 3e4,
+      maxReconnectDelay: options.maxReconnectDelay ?? 3e4
+    };
+  }
+  /**
+   * Get current connection status
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Get the thread ID this manager is connected to
+   */
+  getThreadId() {
+    return this.threadId;
+  }
+  /**
+   * Connect to the thread WebSocket
+   */
+  connect() {
+    if (this.ws && this.ws.readyState !== WebSocket.CLOSED) {
+      return;
+    }
+    this.shouldReconnect = true;
+    this.isReconnecting = false;
+    this.setStatus("connecting");
+    this.ws = this.client.connectMessageWebSocket(
+      this.threadId,
+      {
+        onOpen: () => {
+          this.setStatus("connected");
+          this.reconnectAttempts = 0;
+          this.isReconnecting = false;
+          this.startHeartbeat();
+        },
+        onMessage: (event) => {
+          this.callbacks.onMessage?.(event);
+        },
+        onChunk: (event) => {
+          this.callbacks.onChunk?.(event);
+        },
+        onEvent: (event) => {
+          this.callbacks.onEvent?.(event);
+        },
+        onError: (event) => {
+          this.callbacks.onError?.(event);
+        },
+        onClose: () => {
+          this.clearTimers();
+          this.scheduleReconnect();
+        }
+      },
+      {
+        depth: this.options.depth,
+        includeSilent: this.options.includeSilent
+      }
+    );
+  }
+  /**
+   * Disconnect from the thread WebSocket
+   */
+  disconnect() {
+    this.shouldReconnect = false;
+    this.clearTimers();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.reconnectAttempts = 0;
+    this.isReconnecting = false;
+    this.setStatus("disconnected");
+  }
+  /**
+   * Update callbacks without reconnecting
+   */
+  updateCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
+  /**
+   * Update options (requires reconnect to take effect for depth/includeSilent)
+   */
+  updateOptions(options) {
+    this.options = { ...this.options, ...options };
+  }
+  setStatus(status) {
+    if (this.status !== status) {
+      this.status = status;
+      this.callbacks.onStatusChange?.(status);
+    }
+  }
+  startHeartbeat() {
+    this.clearHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.ws.send("ping");
+      }
+    }, this.options.heartbeatInterval);
+  }
+  clearHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  clearReconnectTimeout() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+  clearTimers() {
+    this.clearHeartbeat();
+    this.clearReconnectTimeout();
+  }
+  scheduleReconnect() {
+    if (!this.shouldReconnect || this.isReconnecting) {
+      this.setStatus("disconnected");
+      return;
+    }
+    this.isReconnecting = true;
+    this.setStatus("reconnecting");
+    const delay = Math.min(
+      1e3 * Math.pow(2, this.reconnectAttempts),
+      this.options.maxReconnectDelay
+    );
+    this.reconnectAttempts++;
+    this.reconnectTimeout = setTimeout(() => {
+      if (this.shouldReconnect) {
+        this.connect();
+      }
+    }, delay);
+  }
+};
+
+// src/utils/attachments.ts
+function parseAttachments(message) {
+  if (!message.attachments) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(message.attachments);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed;
+  } catch {
+    return [];
+  }
+}
+function isImageMimeType(mimeType) {
+  return mimeType.toLowerCase().startsWith("image/");
+}
+function messagesToFiles(messages) {
+  const files = [];
+  for (const message of messages) {
+    const attachments = parseAttachments(message);
+    for (const attachment of attachments) {
+      files.push({
+        id: attachment.id,
+        name: attachment.name,
+        mimeType: attachment.mimeType,
+        size: attachment.size,
+        isImage: isImageMimeType(attachment.mimeType),
+        localPreviewUrl: null,
+        // Committed files don't have local preview
+        status: "committed",
+        path: attachment.path,
+        width: attachment.width,
+        height: attachment.height,
+        messageId: message.id
+      });
+    }
+  }
+  return files;
+}
+
+// src/utils/imageProcessing.ts
+var THUMBNAIL_SIZE = 256;
+function loadImage(file) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    const objectUrl = URL.createObjectURL(file);
+    img.onload = () => {
+      URL.revokeObjectURL(objectUrl);
+      resolve(img);
+    };
+    img.onerror = () => {
+      URL.revokeObjectURL(objectUrl);
+      reject(new Error("Failed to load image"));
+    };
+    img.src = objectUrl;
+  });
+}
+function createThumbnailFromImage(img) {
+  const { width, height } = img;
+  const aspectRatio = width / height;
+  let thumbWidth;
+  let thumbHeight;
+  if (aspectRatio > 1) {
+    thumbWidth = Math.min(THUMBNAIL_SIZE, width);
+    thumbHeight = Math.floor(thumbWidth / aspectRatio);
+  } else {
+    thumbHeight = Math.min(THUMBNAIL_SIZE, height);
+    thumbWidth = Math.floor(thumbHeight * aspectRatio);
+  }
+  const canvas = document.createElement("canvas");
+  canvas.width = thumbWidth;
+  canvas.height = thumbHeight;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Failed to get canvas context");
+  }
+  ctx.drawImage(img, 0, 0, thumbWidth, thumbHeight);
+  const dataUrl = canvas.toDataURL("image/webp", 0.8);
+  return dataUrl.split(",")[1];
+}
+async function generateImageThumbnail(file) {
+  const img = await loadImage(file);
+  return {
+    thumbnail: createThumbnailFromImage(img),
+    width: img.width,
+    height: img.height
+  };
+}
+function canGenerateThumbnails() {
+  return typeof document !== "undefined" && typeof document.createElement === "function";
+}
+
+// src/utils/fileHelpers.ts
+function generatePendingFileId() {
+  return `pending-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function readFileAsDataUrl(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+  });
+}
+
+// src/uploads/FileUploadManager.ts
+var FileUploadManager = class {
+  /**
+   * Create a pending file object from a File.
+   * The returned object can be immediately added to state for UI feedback.
+   */
+  createPendingFile(file) {
+    return {
+      id: generatePendingFileId(),
+      name: file.name,
+      mimeType: file.type,
+      size: file.size,
+      isImage: isImageMimeType(file.type),
+      localPreviewUrl: null,
+      status: "uploading"
+    };
+  }
+  /**
+   * Queue multiple files for upload.
+   * Returns an array of pending file objects paired with their source File objects.
+   *
+   * @param files - Files to queue (File array or FileList)
+   * @returns Array of [ThreadFile, File] tuples
+   */
+  queueFiles(files) {
+    return Array.from(files).map((file) => ({
+      pending: this.createPendingFile(file),
+      file
+    }));
+  }
+  /**
+   * Execute the upload for a file.
+   *
+   * This method:
+   * 1. Generates a local preview for images (async, non-blocking)
+   * 2. Generates a thumbnail for images (if supported)
+   * 3. Uploads the file to the server
+   * 4. Calls onUpdate with state changes at each step
+   *
+   * @param threadId - The thread to upload to
+   * @param file - The file to upload
+   * @param pendingId - The ID of the pending file (from queueFiles)
+   * @param client - The AgentBuilderClient instance
+   * @param onUpdate - Callback for state updates
+   * @param options - Upload options
+   */
+  async executeUpload(threadId, file, pendingId, client, onUpdate, options = {}) {
+    const {
+      generateThumbnail = true,
+      generatePreview = true
+    } = options;
+    const isImage = isImageMimeType(file.type);
+    if (isImage && generatePreview) {
+      readFileAsDataUrl(file).then((dataUrl) => onUpdate({ localPreviewUrl: dataUrl })).catch((err) => console.error("Failed to generate preview:", err));
+    }
+    try {
+      let uploadOptions;
+      if (isImage && generateThumbnail) {
+        try {
+          const result = await generateImageThumbnail(file);
+          uploadOptions = {
+            thumbnail: result.thumbnail,
+            width: result.width,
+            height: result.height
+          };
+        } catch (err) {
+          console.warn("Failed to generate thumbnail:", err);
+        }
+      }
+      const attachment = await client.uploadFile(threadId, file, uploadOptions);
+      onUpdate({
+        id: attachment.id,
+        status: "ready",
+        path: attachment.path,
+        width: attachment.width,
+        height: attachment.height
+      });
+      return attachment;
+    } catch (err) {
+      onUpdate({
+        status: "error",
+        error: err instanceof Error ? err.message : "Failed to upload file"
+      });
+      throw err;
+    }
+  }
+  /**
+   * Execute uploads for multiple files in parallel.
+   *
+   * @param threadId - The thread to upload to
+   * @param items - Array of pending/file pairs from queueFiles()
+   * @param client - The AgentBuilderClient instance
+   * @param onUpdate - Callback receiving (pendingId, updates) for each file
+   * @param options - Upload options
+   * @returns Array of upload results (AttachmentRef or Error for each file)
+   */
+  async executeUploads(threadId, items, client, onUpdate, options = {}) {
+    const promises = items.map(
+      ({ pending, file }) => this.executeUpload(
+        threadId,
+        file,
+        pending.id,
+        client,
+        (updates) => onUpdate(pending.id, updates),
+        options
+      ).catch((err) => err instanceof Error ? err : new Error(String(err)))
+    );
+    return Promise.all(promises);
+  }
+};
+
+// src/utils/workblocks.ts
+function transformToWorkblocks(messages) {
+  if (messages.length === 0) {
+    return [];
+  }
+  const result = [];
+  let i = 0;
+  while (i < messages.length) {
+    const message = messages[i];
+    if (message.role === "assistant" && message.tool_calls) {
+      let toolCalls;
+      try {
+        toolCalls = JSON.parse(message.tool_calls);
+      } catch (error) {
+        result.push(message);
+        i++;
+        continue;
+      }
+      const workItems = [];
+      for (const toolCall of toolCalls) {
+        workItems.push({
+          id: toolCall.id || message.id,
+          type: "tool_call",
+          name: toolCall.function?.name,
+          content: toolCall.function?.arguments || null,
+          status: null,
+          // Will be updated below based on matching results
+          tool_call_id: toolCall.id
+        });
+      }
+      let j = i + 1;
+      while (j < messages.length && messages[j].role === "tool") {
+        const toolMessage = messages[j];
+        const resultStatus = toolMessage.tool_status || "pending";
+        workItems.push({
+          id: toolMessage.id,
+          type: "tool_result",
+          name: toolMessage.name || void 0,
+          content: toolMessage.content,
+          status: resultStatus,
+          tool_call_id: toolMessage.tool_call_id || void 0
+        });
+        j++;
+      }
+      for (const item of workItems) {
+        if (item.type === "tool_call" && item.tool_call_id) {
+          const matchingResult = workItems.find(
+            (wi) => wi.type === "tool_result" && wi.tool_call_id === item.tool_call_id
+          );
+          if (matchingResult) {
+            item.status = matchingResult.status;
+          } else {
+            item.status = "pending";
+          }
+        }
+      }
+      let status = "completed";
+      if (message.status === "pending") {
+        status = "pending";
+      } else if (message.status === "failed") {
+        status = "failed";
+      }
+      const workblock = {
+        id: message.id,
+        type: "workblock",
+        content: message.content,
+        reasoning_content: message.reasoning_content,
+        workItems,
+        status,
+        created_at: message.created_at,
+        depth: message.depth
+      };
+      result.push(workblock);
+      i = j;
+    } else {
+      result.push(message);
+      i++;
+    }
+  }
+  return result;
+}
+export {
+  AgentBuilderClient,
+  FileUploadManager,
+  ThreadConnectionManager,
+  canGenerateThumbnails,
+  generateImageThumbnail,
+  generatePendingFileId,
+  isImageMimeType,
+  messagesToFiles,
+  parseAttachments,
+  readFileAsDataUrl,
+  transformToWorkblocks
+};
+//# sourceMappingURL=index.js.map