dooers-agents-client 0.14.0 → 0.15.0

package/dist/main.cjs

@@ -211,6 +211,20 @@ function toThreadEvent(w) {
     clientEventId: w.client_event_id
   };
 }
+function toThreadArtifact(w) {
+  return {
+    eventId: w.event_id,
+    direction: w.direction,
+    kind: w.kind,
+    filename: w.filename,
+    mimeType: w.mime_type,
+    url: w.url,
+    refId: w.ref_id,
+    createdAt: w.created_at,
+    userId: w.user_id,
+    userName: w.user_name
+  };
+}
 function toRun(w) {
   return {
     id: w.id,
@@ -308,12 +322,13 @@ function toWireContentPart(p) {
 }
 
 // src/version.ts
-var PACKAGE_VERSION = "0.14.0";
+var PACKAGE_VERSION = "0.15.0";
 
 // src/client.ts
 var MAX_RECONNECT_ATTEMPTS = 5;
 var RECONNECT_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3];
 var SEND_MESSAGE_TIMEOUT = 3e4;
+var ARTIFACTS_LIST_TIMEOUT = 3e4;
 var PING_INTERVAL_MS = 3e4;
 function blobPartFilename(blob, override) {
   const o = (override ?? "").trim();
@@ -467,6 +482,7 @@ var AgentClient = class {
   pendingOptimistic = /* @__PURE__ */ new Map();
   // Pending message promises — keyed by outbound frame id (same as client_event_id for sends).
   pendingMessages = /* @__PURE__ */ new Map();
+  pendingArtifactsRequests = /* @__PURE__ */ new Map();
   // Track last event ID per thread for gap recovery on reconnect
   lastEventIds = /* @__PURE__ */ new Map();
   // Pagination
@@ -604,6 +620,13 @@ var AgentClient = class {
     }
     this.pendingMessages.clear();
   }
+  abortPendingArtifacts(reason) {
+    for (const [frameId, pending] of this.pendingArtifactsRequests) {
+      clearTimeout(pending.timer);
+      this.pendingArtifactsRequests.delete(frameId);
+      pending.reject(new Error(reason));
+    }
+  }
   disconnect() {
     this.isIntentionallyClosed = true;
     this.stopHeartbeat();
@@ -612,6 +635,7 @@ var AgentClient = class {
       this.reconnectTimer = null;
     }
     this.abortPendingMessages("Disconnected");
+    this.abortPendingArtifacts("Disconnected");
     if (this.ws) {
       this.ws.onopen = null;
       this.ws.onmessage = null;
@@ -670,6 +694,40 @@ var AgentClient = class {
       limit
     });
   }
+  requestThreadArtifactsList(threadId, options) {
+    if (!this.isConnected()) {
+      return Promise.reject(new Error("Not connected"));
+    }
+    const frameId = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingArtifactsRequests.delete(frameId);
+        reject(new Error("thread.artifacts.list timed out"));
+      }, ARTIFACTS_LIST_TIMEOUT);
+      this.pendingArtifactsRequests.set(frameId, {
+        threadId,
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        },
+        reject: (err) => {
+          clearTimeout(timer);
+          reject(err);
+        },
+        timer
+      });
+      this.sendRaw({
+        id: frameId,
+        type: "thread.artifacts.list",
+        payload: {
+          thread_id: threadId,
+          cursor: options?.cursor ?? null,
+          limit: options?.limit,
+          direction: options?.direction ?? "all"
+        }
+      });
+    });
+  }
   // --- Settings ---
   subscribeSettings(options) {
     const audience = options?.audience ?? "user";
@@ -915,6 +973,13 @@ var AgentClient = class {
               pending.reject(new Error(msg));
               this.callbacks.setSendError(msg);
             }
+            const artifactsPending = this.pendingArtifactsRequests.get(ackId);
+            if (artifactsPending) {
+              clearTimeout(artifactsPending.timer);
+              this.pendingArtifactsRequests.delete(ackId);
+              const msg = err.message || "Request rejected";
+              artifactsPending.reject(new Error(msg));
+            }
           }
           this.onError?.({
             code: err.code,
@@ -999,6 +1064,21 @@ var AgentClient = class {
         );
         break;
       }
+      case "thread.artifacts.list.result": {
+        const threadId = frame.payload.thread_id;
+        for (const [frameId, pending] of this.pendingArtifactsRequests) {
+          if (pending.threadId !== threadId) continue;
+          clearTimeout(pending.timer);
+          this.pendingArtifactsRequests.delete(frameId);
+          pending.resolve({
+            artifacts: this.resolveArtifactUrls(frame.payload.artifacts.map(toThreadArtifact)),
+            cursor: frame.payload.cursor,
+            hasMore: frame.payload.has_more
+          });
+          break;
+        }
+        break;
+      }
       case "thread.upsert":
         this.callbacks.onThreadUpsert(toThread(frame.payload.thread));
         break;
@@ -1060,6 +1140,7 @@ var AgentClient = class {
     this.stopHeartbeat();
     if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
       this.abortPendingMessages("Connection lost after maximum retries");
+      this.abortPendingArtifacts("Connection lost after maximum retries");
       this.callbacks.setReconnectFailed();
       this.callbacks.setConnectionStatus("error", "Connection lost after maximum retries");
       return;
@@ -1104,6 +1185,14 @@ var AgentClient = class {
       };
     });
   }
+  resolveArtifactUrls(artifacts) {
+    if (!this.httpBaseUrl) return artifacts;
+    const base = this.httpBaseUrl;
+    return artifacts.map((artifact) => {
+      if (!artifact.url?.startsWith("/")) return artifact;
+      return { ...artifact, url: `${base}${artifact.url}` };
+    });
+  }
 };
 function mergeDisplayContentParts(prev, next) {
   if (!next?.length) return prev;
@@ -2025,6 +2114,60 @@ function useThreadEvents(threadId) {
   );
   return { hasOlderEvents, loadOlderEvents };
 }
+function useThreadArtifacts(threadId, options) {
+  const { client } = useAgentContext();
+  const direction = options?.direction ?? "all";
+  const enabled = options?.enabled !== false;
+  const limit = options?.limit;
+  const [artifacts, setArtifacts] = react.useState([]);
+  const [cursor, setCursor] = react.useState(null);
+  const [hasMore, setHasMore] = react.useState(false);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const cursorRef = react.useRef(null);
+  const load = react.useCallback(
+    async (append) => {
+      if (!threadId) return;
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await client.requestThreadArtifactsList(threadId, {
+          cursor: append ? cursorRef.current : null,
+          limit,
+          direction
+        });
+        cursorRef.current = result.cursor;
+        setCursor(result.cursor);
+        setHasMore(result.hasMore);
+        setArtifacts((prev) => append ? [...prev, ...result.artifacts] : result.artifacts);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load artifacts");
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [threadId, client, limit, direction]
+  );
+  react.useEffect(() => {
+    if (!threadId || !enabled) {
+      setArtifacts([]);
+      setCursor(null);
+      cursorRef.current = null;
+      setHasMore(false);
+      setError(null);
+      return;
+    }
+    void load(false);
+  }, [threadId, enabled, direction, load]);
+  const loadMore = react.useCallback(() => {
+    if (!hasMore || isLoading) return;
+    void load(true);
+  }, [hasMore, isLoading, load]);
+  const refresh = react.useCallback(() => {
+    void load(false);
+  }, [load]);
+  return { artifacts, cursor, hasMore, isLoading, error, loadMore, refresh };
+}
 function useThreadsList() {
   const threadOrder = useStore((s) => s.threadOrder);
   const threadMap = useStore((s) => s.threads);
@@ -2087,6 +2230,7 @@ exports.useFormFileUpload = useFormFileUpload;
 exports.useMessage = useMessage;
 exports.useSettings = useSettings;
 exports.useSettingsFileUpload = useSettingsFileUpload;
+exports.useThreadArtifacts = useThreadArtifacts;
 exports.useThreadDetails = useThreadDetails;
 exports.useThreadEvents = useThreadEvents;
 exports.useThreadsActions = useThreadsActions;