@omnikit-ai/sdk 2.2.1 → 2.2.2

package/dist/index.mjs

@@ -1548,6 +1548,18 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
                     if (params?.model) {
                       params = { ...params, model: mapLLMModel(params.model) };
                     }
+                    if (params?.saveResult) {
+                      params = {
+                        ...params,
+                        save_result: {
+                          collection: params.saveResult.collection,
+                          document_id: params.saveResult.documentId,
+                          field: params.saveResult.field,
+                          additional_fields: params.saveResult.additionalFields
+                        }
+                      };
+                      delete params.saveResult;
+                    }
                   }
                   const integrationPackage = client._integrations[packageName];
                   if (!integrationPackage) {
@@ -1662,7 +1674,7 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
         );
         return response;
       },
-      // List all records with MongoDB/Mongoose-style filtering
+      // List all records with MongoDB/Mongoose-style filtering and cursor pagination
       async list(...args) {
         const queryParams = new URLSearchParams();
         let filter;
@@ -1707,11 +1719,25 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
             if (options.offset !== void 0) {
               queryParams.append("offset", String(options.offset));
             }
+            if (options.after !== void 0) {
+              queryParams.append("after", options.after);
+            }
           }
         }
         const url = queryParams.toString() ? `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}?${queryParams}` : `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}`;
         const response = await client.makeRequest(url, "GET");
-        return makeArrayForgiving(Array.isArray(response) ? response : []);
+        if (response && typeof response === "object" && "data" in response && "hasMore" in response) {
+          return {
+            data: makeArrayForgiving(response.data),
+            hasMore: response.hasMore,
+            nextCursor: response.nextCursor
+          };
+        }
+        return {
+          data: makeArrayForgiving(Array.isArray(response) ? response : []),
+          hasMore: false,
+          nextCursor: null
+        };
       },
       // Filter records by query (alias for list)
       async filter(...args) {
@@ -1720,21 +1746,21 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
       // Find single record matching query
       async findOne(...args) {
         if (args.length === 0) {
-          const results = await this.list({}, { limit: 1 });
-          return results[0] || null;
+          const result = await this.list({}, { limit: 1 });
+          return result.data[0] || null;
         } else if (args.length === 1) {
           const arg = args[0];
           if (arg && (arg.q !== void 0 || arg._count !== void 0)) {
-            const results = await this.list({ ...arg, limit: 1 });
-            return results[0] || null;
+            const result = await this.list({ ...arg, limit: 1 });
+            return result.data[0] || null;
           } else {
-            const results = await this.list(arg, { limit: 1 });
-            return results[0] || null;
+            const result = await this.list(arg, { limit: 1 });
+            return result.data[0] || null;
           }
         } else {
           const [filter, options] = args;
-          const results = await this.list(filter, { ...options, limit: 1 });
-          return results[0] || null;
+          const result = await this.list(filter, { ...options, limit: 1 });
+          return result.data[0] || null;
         }
       },
       // Create new record
@@ -2360,6 +2386,266 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
       config
     );
   }
+  /**
+   * Run an assistant with streaming response.
+   *
+   * Assistants are server-side AI agents with custom instructions and built-in actions.
+   * They can create/update/delete records, send emails, make HTTP requests, etc.
+   *
+   * @example
+   * ```typescript
+   * const result = await omnikit.runAssistant('customer_support', {
+   *   messages: [{ role: 'user', content: 'Help me track my order #12345' }],
+   *   onToken: (token) => setResponse(prev => prev + token),
+   *   onActionStart: (action) => console.log(`Starting: ${action.name}`),
+   *   onActionComplete: (action) => console.log(`Completed: ${action.name}`),
+   * });
+   *
+   * // Continue the conversation
+   * await omnikit.runAssistant('customer_support', {
+   *   messages: [{ role: 'user', content: 'When will it arrive?' }],
+   *   threadId: result.threadId,
+   *   onToken: (token) => setResponse(prev => prev + token),
+   * });
+   * ```
+   *
+   * @param assistantName - Name of the assistant to run
+   * @param params - Run parameters including messages and callbacks
+   * @returns Promise resolving to the run result with threadId
+   */
+  async runAssistant(assistantName, params) {
+    await this.ensureInitialized();
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const token = this.getAuthToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    if (this._serviceToken) {
+      headers["X-Service-Token"] = this._serviceToken;
+    }
+    if (this._apiKey) {
+      headers["X-API-Key"] = this._apiKey;
+    }
+    const requestBody = {
+      messages: params.messages,
+      thread_id: params.threadId,
+      stream: true
+    };
+    const response = await fetch(
+      `${this.baseUrl}/apps/${this.appId}/assistants/${assistantName}/runs`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody)
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = `Assistant run failed: ${response.statusText}`;
+      try {
+        const errorJson = JSON.parse(errorText);
+        errorMessage = errorJson.detail || errorJson.message || errorMessage;
+      } catch {
+        errorMessage = errorText || errorMessage;
+      }
+      const err = new OmnikitError(errorMessage, response.status, "ASSISTANT_ERROR");
+      params.onError?.(err);
+      throw err;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      const err = new OmnikitError("No response body", 500, "NO_BODY");
+      params.onError?.(err);
+      throw err;
+    }
+    const decoder = new TextDecoder();
+    let fullResponse = "";
+    let buffer = "";
+    let threadId = params.threadId || "";
+    let messageCount = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            try {
+              const event = JSON.parse(line.slice(6));
+              if (event.type === "token" && event.content) {
+                fullResponse += event.content;
+                params.onToken?.(event.content);
+              } else if (event.type === "action_start") {
+                params.onActionStart?.({
+                  id: event.id || "",
+                  name: event.name || "",
+                  arguments: event.arguments || {}
+                });
+              } else if (event.type === "action_complete") {
+                params.onActionComplete?.({
+                  id: event.id || "",
+                  name: event.name || "",
+                  output: event.output
+                });
+              } else if (event.type === "action_failed") {
+                params.onActionFailed?.({
+                  id: event.id || "",
+                  name: event.name || "",
+                  error: event.error || "Action failed"
+                });
+              } else if (event.type === "done") {
+                threadId = event.thread_id || threadId;
+                messageCount = event.message_count || 0;
+                const result = {
+                  threadId,
+                  messageCount,
+                  response: fullResponse
+                };
+                params.onComplete?.(result);
+              } else if (event.type === "error") {
+                const err = new OmnikitError(
+                  event.message || "Assistant error",
+                  500,
+                  "ASSISTANT_ERROR"
+                );
+                params.onError?.(err);
+                throw err;
+              }
+            } catch (parseError) {
+              if (parseError instanceof OmnikitError) {
+                throw parseError;
+              }
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return {
+      threadId,
+      messageCount,
+      response: fullResponse
+    };
+  }
+  /**
+   * Subscribe to a thread via WebSocket for real-time updates.
+   *
+   * Use this to watch a thread without triggering a run. Useful for:
+   * - Showing live updates when another client runs the assistant
+   * - Reconnecting after page navigation
+   * - Observing thread activity in real-time
+   *
+   * @example
+   * ```typescript
+   * // Subscribe to a thread
+   * const unsubscribe = omnikit.subscribeToThread(threadId, {
+   *   onConnected: (info) => console.log(`Connected to ${info.assistantName}`),
+   *   onToken: (token) => setResponse(prev => prev + token),
+   *   onActionStart: (action) => console.log(`Action: ${action.name}`),
+   *   onActionComplete: (action) => console.log(`Result: ${JSON.stringify(action.output)}`),
+   *   onRunComplete: (result) => console.log(`Run complete, ${result.messageCount} messages`),
+   *   onError: (error) => console.error(error),
+   * });
+   *
+   * // Later: disconnect
+   * unsubscribe();
+   * ```
+   *
+   * @param threadId - Thread ID to subscribe to
+   * @param callbacks - Event callbacks for real-time updates
+   * @returns Unsubscribe function to close the WebSocket
+   */
+  subscribeToThread(threadId, callbacks) {
+    const wsProtocol = this.baseUrl.startsWith("https") ? "wss" : "ws";
+    const wsBaseUrl = this.baseUrl.replace(/^https?:\/\//, "");
+    let wsUrl = `${wsProtocol}://${wsBaseUrl}/apps/${this.appId}/threads/${threadId}/subscribe`;
+    const token = this.getAuthToken();
+    if (token) {
+      wsUrl += `?token=${encodeURIComponent(token)}`;
+    }
+    const ws = new WebSocket(wsUrl);
+    let pingInterval = null;
+    ws.onopen = () => {
+      pingInterval = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "ping" }));
+        }
+      }, 3e4);
+    };
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        switch (data.type) {
+          case "connected":
+            callbacks.onConnected?.({
+              threadId: data.thread_id,
+              assistantName: data.assistant_name,
+              messageCount: data.message_count
+            });
+            break;
+          case "token":
+            callbacks.onToken?.(data.content || "");
+            break;
+          case "action_start":
+            callbacks.onActionStart?.({
+              id: data.id || "",
+              name: data.name || "",
+              arguments: data.arguments || {}
+            });
+            break;
+          case "action_complete":
+            callbacks.onActionComplete?.({
+              id: data.id || "",
+              name: data.name || "",
+              output: data.output
+            });
+            break;
+          case "action_failed":
+            callbacks.onActionFailed?.({
+              id: data.id || "",
+              name: data.name || "",
+              error: data.error || "Action failed"
+            });
+            break;
+          case "run_complete":
+          case "done":
+            callbacks.onRunComplete?.({
+              threadId: data.thread_id || threadId,
+              messageCount: data.message_count || 0
+            });
+            break;
+          case "error":
+            callbacks.onError?.(new Error(data.message || "WebSocket error"));
+            break;
+          case "pong":
+            break;
+        }
+      } catch (parseError) {
+      }
+    };
+    ws.onerror = (event) => {
+      callbacks.onError?.(new Error("WebSocket connection error"));
+    };
+    ws.onclose = () => {
+      if (pingInterval) {
+        clearInterval(pingInterval);
+      }
+      callbacks.onDisconnect?.();
+    };
+    return () => {
+      if (pingInterval) {
+        clearInterval(pingInterval);
+      }
+      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+        ws.close();
+      }
+    };
+  }
   /**
    * Invoke a backend function by name.
    *