dooers-agents-client 0.14.0 → 0.15.1

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.1";
 
 // 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 = 5e3;
 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";
@@ -883,6 +941,8 @@ var AgentClient = class {
       case "ack": {
         if (frame.payload.ack_id === this.connectFrameId) {
           if (frame.payload.ok) {
+            const sv = frame.payload.server?.version?.trim();
+            this.callbacks.setServerVersion(sv || null);
             this.callbacks.setConnectionStatus("connected");
             this.callbacks.resetReconnect();
             this.requestThreadList();
@@ -915,6 +975,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 +1066,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 +1142,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,7 +1187,38 @@ 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}` };
+    });
+  }
 };
+
+// src/helpers/server-version.ts
+var THREAD_ARTIFACTS_MIN_SERVER_VERSION = "0.17.1";
+function parseSemverParts(version) {
+  const core = version.trim().split("-")[0]?.split("+")[0] ?? "";
+  const [maj, min, pat] = core.split(".");
+  return [Number(maj) || 0, Number(min) || 0, Number(pat) || 0];
+}
+function compareSemver(a, b) {
+  const [aMaj, aMin, aPat] = parseSemverParts(a);
+  const [bMaj, bMin, bPat] = parseSemverParts(b);
+  if (aMaj !== bMaj) return aMaj < bMaj ? -1 : 1;
+  if (aMin !== bMin) return aMin < bMin ? -1 : 1;
+  if (aPat !== bPat) return aPat < bPat ? -1 : 1;
+  return 0;
+}
+function isServerAtLeast(version, minimum) {
+  if (!version?.trim()) return false;
+  return compareSemver(version, minimum) >= 0;
+}
+function supportsThreadArtifactsList(serverVersion) {
+  return isServerAtLeast(serverVersion, THREAD_ARTIFACTS_MIN_SERVER_VERSION);
+}
 function mergeDisplayContentParts(prev, next) {
   if (!next?.length) return prev;
   if (!prev?.length) return next;
@@ -1164,6 +1278,7 @@ function createAgentStore() {
     connection: {
       status: "idle",
       error: null,
+      serverVersion: null,
       sendError: null,
       reconnectAttempts: 0,
       reconnectFailed: false
@@ -1197,9 +1312,13 @@ function createAgentStore() {
           ...s.connection,
           status,
           error: error ?? null,
-          ...status === "connected" ? { sendError: null } : {}
+          ...status === "connected" ? { sendError: null } : {},
+          ...status === "connecting" ? { serverVersion: null } : {}
         }
       })),
+      setServerVersion: (version) => set((s) => ({
+        connection: { ...s.connection, serverVersion: version }
+      })),
       setSendError: (message) => set((s) => ({
         connection: { ...s.connection, sendError: message }
       })),
@@ -1756,13 +1875,22 @@ function useConnection() {
   const { client } = useAgentContext();
   const status = useStore((s) => s.connection.status);
   const error = useStore((s) => s.connection.error);
+  const serverVersion = useStore((s) => s.connection.serverVersion);
   const sendError = useStore((s) => s.connection.sendError);
   const reconnectFailed = useStore((s) => s.connection.reconnectFailed);
   const reconnect = react.useCallback(() => client.retry(), [client]);
   const dismissSendError = react.useCallback(() => {
     client.clearSendError();
   }, [client]);
-  return { status, error, sendError, dismissSendError, reconnectFailed, reconnect };
+  return {
+    status,
+    error,
+    serverVersion,
+    sendError,
+    dismissSendError,
+    reconnectFailed,
+    reconnect
+  };
 }
 function useFeedback(targetId, targetType = "event") {
   const { client } = useAgentContext();
@@ -2025,6 +2153,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);
@@ -2071,8 +2253,12 @@ function useUpload() {
 exports.AgentProvider = AgentProvider;
 exports.AgentServerClient = AgentServerClient;
 exports.PACKAGE_VERSION = PACKAGE_VERSION;
+exports.THREAD_ARTIFACTS_MIN_SERVER_VERSION = THREAD_ARTIFACTS_MIN_SERVER_VERSION;
 exports.apiMessagesUrlToWebSocketUrl = apiMessagesUrlToWebSocketUrl;
+exports.compareSemver = compareSemver;
+exports.isServerAtLeast = isServerAtLeast;
 exports.isSettingsFieldGroup = isSettingsFieldGroup;
+exports.supportsThreadArtifactsList = supportsThreadArtifactsList;
 exports.toChartEventData = toChartEventData;
 exports.toFormElement = toFormElement;
 exports.toFormEventData = toFormEventData;
@@ -2087,6 +2273,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;