@mindstudio-ai/agent 0.1.119 → 0.1.121

package/dist/index.d.ts

@@ -2521,6 +2521,12 @@ interface DataSourceDocument {
     createdAt: string;
     ingestedAt: string | null;
 }
+/** One page of a corpus. See {@link DataSource.documentsPage}. */
+interface DataSourceDocumentPage {
+    documents: DataSourceDocument[];
+    /** Pass to the next call; null when this was the last page. */
+    nextCursor: string | null;
+}
 /** One chunk exactly as it was indexed. See {@link DataSource.chunks}. */
 interface DataSourceChunk {
     index: number;
@@ -2749,6 +2755,13 @@ declare class DataSource {
      * corpora reload inside the search and never raise it. Sources on dedicated
      * capacity are never evicted, so they never raise it either; they raise
      * `capacity_hibernated` and friends instead when their capacity is parked.
+     *
+     * **Throws `index_building`** (HTTP 503) on dedicated capacity while a bulk
+     * load runs and after one finishes: the index is not built behind every
+     * write during a load, it is built once at the end, and until then a search
+     * would scan the corpus unindexed. The message carries "N of M vectors
+     * indexed". Handle it like `index_warming`: the knowledge base is being
+     * built, never empty; say so and retry later.
      */
     search(query: string, options?: SearchOptions): Promise<{
         results: SearchHit[];
@@ -2821,16 +2834,41 @@ declare class DataSource {
     /**
      * Documents in the corpus, with ingest status.
      *
-     * Without options this is the first thousand, newest first: enough to show
-     * a small corpus, not a way to walk a large one (a corpus of any size is
-     * loaded and inspected from the CLI). To follow what {@link add} just
-     * queued, pass the ids it returned: `documents({ ids })` answers only those,
-     * at most two hundred per call.
+     * Without options this is the first page only: the oldest thousand, enough
+     * to show a small corpus. To walk a corpus of any size use
+     * {@link allDocuments} (or {@link documentsPage} for one page at a time). To
+     * follow what {@link add} just queued, pass the ids it returned:
+     * `documents({ ids })` answers only those, at most two hundred per call.
      */
     documents(options?: {
         /** Only these documents (at most 200). */
         ids?: string[];
     }): Promise<DataSourceDocument[]>;
+    /**
+     * One page of the corpus, oldest first, with the cursor for the next page.
+     * `limit` is at most 1,000 (the default).
+     */
+    documentsPage(options?: {
+        cursor?: string | null;
+        limit?: number;
+    }): Promise<DataSourceDocumentPage>;
+    /**
+     * Every document in the corpus, oldest first, a page at a time behind the
+     * scenes. This is how an app builds its own view of a large corpus (a
+     * timeline, counts by year, a table of ids) after an ingest: walk it once,
+     * then keep up with what each sync adds. Millions of documents is thousands
+     * of pages, so run it in a background task, not a request.
+     *
+     * ```ts
+     * for await (const doc of Archive.allDocuments()) {
+     *   await index.upsert({ id: doc.id, year: doc.metadata?.year });
+     * }
+     * ```
+     */
+    allDocuments(options?: {
+        /** Documents per page, at most 1,000 (the default). */
+        pageSize?: number;
+    }): AsyncGenerator<DataSourceDocument, void, undefined>;
     /** Remove a document and its vectors. */
     remove(documentId: string): Promise<void>;
     /**
@@ -2886,6 +2924,12 @@ declare class DataSource {
     sync(options?: {
         /** Override the connector's per-sync budget for this run, in dollars. */
         budgetDollars?: number;
+        /**
+         * Embed at the provider's priority tier for this run: calls are admitted
+         * ahead of the provider's queue at 1.5x the embedding price. For the sync
+         * where the clock matters more than the price; off by default.
+         */
+        priority?: boolean;
     }): Promise<{
         job: DataSourceJob;
     }>;
@@ -11817,6 +11861,13 @@ interface MapRunObject {
     metadata: DocumentMetadata | null;
     /** Short-lived read URL for the object's bytes. */
     url: string;
+    /**
+     * The object's bytes, base64, when the platform already held them (it
+     * hashes and lands every object before mapping, and small objects ride
+     * along). Present, it is the bytes; `url` is the fallback for large objects
+     * and for frames from a platform that predates it.
+     */
+    content?: string;
 }
 interface MapRunParams {
     v: 1;

package/dist/index.js

@@ -2874,6 +2874,13 @@ var DataSource = class {
    * corpora reload inside the search and never raise it. Sources on dedicated
    * capacity are never evicted, so they never raise it either; they raise
    * `capacity_hibernated` and friends instead when their capacity is parked.
+   *
+   * **Throws `index_building`** (HTTP 503) on dedicated capacity while a bulk
+   * load runs and after one finishes: the index is not built behind every
+   * write during a load, it is built once at the end, and until then a search
+   * would scan the corpus unindexed. The message carries "N of M vectors
+   * indexed". Handle it like `index_warming`: the knowledge base is being
+   * built, never empty; say so and retry later.
    */
   async search(query, options) {
     const { results, mode, latencyMs } = await this._call("search", {
@@ -2979,11 +2986,11 @@ var DataSource = class {
   /**
    * Documents in the corpus, with ingest status.
    *
-   * Without options this is the first thousand, newest first: enough to show
-   * a small corpus, not a way to walk a large one (a corpus of any size is
-   * loaded and inspected from the CLI). To follow what {@link add} just
-   * queued, pass the ids it returned: `documents({ ids })` answers only those,
-   * at most two hundred per call.
+   * Without options this is the first page only: the oldest thousand, enough
+   * to show a small corpus. To walk a corpus of any size use
+   * {@link allDocuments} (or {@link documentsPage} for one page at a time). To
+   * follow what {@link add} just queued, pass the ids it returned:
+   * `documents({ ids })` answers only those, at most two hundred per call.
    */
   async documents(options) {
     const { documents: documents2 } = await this._call("documents", {
@@ -2992,6 +2999,47 @@ var DataSource = class {
     });
     return documents2 ?? [];
   }
+  /**
+   * One page of the corpus, oldest first, with the cursor for the next page.
+   * `limit` is at most 1,000 (the default).
+   */
+  async documentsPage(options) {
+    const { documents: documents2, nextCursor } = await this._call("documents", {
+      slug: this._slug,
+      ...options?.cursor ? { cursor: options.cursor } : {},
+      ...options?.limit ? { limit: options.limit } : {}
+    });
+    return { documents: documents2 ?? [], nextCursor: nextCursor ?? null };
+  }
+  /**
+   * Every document in the corpus, oldest first, a page at a time behind the
+   * scenes. This is how an app builds its own view of a large corpus (a
+   * timeline, counts by year, a table of ids) after an ingest: walk it once,
+   * then keep up with what each sync adds. Millions of documents is thousands
+   * of pages, so run it in a background task, not a request.
+   *
+   * ```ts
+   * for await (const doc of Archive.allDocuments()) {
+   *   await index.upsert({ id: doc.id, year: doc.metadata?.year });
+   * }
+   * ```
+   */
+  async *allDocuments(options) {
+    let cursor = null;
+    while (true) {
+      const page = await this.documentsPage({
+        cursor,
+        ...options?.pageSize ? { limit: options.pageSize } : {}
+      });
+      for (const doc of page.documents) {
+        yield doc;
+      }
+      if (!page.nextCursor || page.documents.length === 0) {
+        return;
+      }
+      cursor = page.nextCursor;
+    }
+  }
   /** Remove a document and its vectors. */
   async remove(documentId) {
     await this._call("remove", { slug: this._slug, documentId });
@@ -3061,7 +3109,8 @@ var DataSource = class {
   async sync(options) {
     return this._call("sync", {
       slug: this._slug,
-      ...options?.budgetDollars !== void 0 ? { budgetDollars: options.budgetDollars } : {}
+      ...options?.budgetDollars !== void 0 ? { budgetDollars: options.budgetDollars } : {},
+      ...options?.priority ? { priority: true } : {}
     });
   }
   /** Recent ingestion jobs on this source (syncs and CLI loads), newest first. */
@@ -7914,7 +7963,9 @@ function objectFor(input) {
   let cached = null;
   const bytes = () => {
     if (!cached) {
-      cached = (async () => {
+      cached = input.content !== void 0 ? Promise.resolve(
+        new Uint8Array(Buffer.from(input.content, "base64"))
+      ) : (async () => {
         const response = await fetch(input.url);
         if (!response.ok) {
           throw new Error(