@mindstudio-ai/agent 0.1.120 → 0.1.122

package/dist/index.d.ts

@@ -2755,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[];
@@ -2784,6 +2791,32 @@ declare class DataSource {
      * someone migrates it.
      */
     stats(): Promise<DataSourceStats>;
+    /**
+     * How many passages (chunks) match a filter — exact, over the whole corpus.
+     *
+     * The honest number to show beside a search's hits: `count({ contains:
+     * query })` is how many passages contain **all** the query's words, so a UI
+     * can say "8 of 3,891 passages mention these words" and mean it. Same
+     * grammar as {@link SearchOptions.filter}, so it also answers "how many
+     * passages are tagged `department: 'legal'`" or contain an exact `phrase`.
+     * No filter counts the whole corpus.
+     *
+     * What it is not: a relevance count. Similarity is a continuous score over
+     * every chunk and no such total exists, so do not label this "relevant
+     * results" or "matches for your query". It is also not the set `search`
+     * returns: the semantic branch surfaces passages without the words, and the
+     * lexical branch scores partial overlap. Chunks, not documents — a long
+     * document contributes several.
+     *
+     * Counts share the search rate limit (300/minute per app); a count paired
+     * with every search spends two. Cheap otherwise: one index lookup, no model
+     * call. Shows the same `index_warming` / `index_building` as search while a
+     * corpus is loading or building, never a false `0`.
+     */
+    count(filter?: SearchFilter): Promise<{
+        chunks: number;
+        latencyMs: number;
+    }>;
     /**
      * Every chunk of one document, exactly as it was indexed.
      *
@@ -2838,12 +2871,14 @@ declare class DataSource {
         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).
+     * One page of the corpus with the cursor for the next page. Oldest first
+     * unless `order: 'newest'` — the page an app shows as "what just arrived"
+     * without walking anything. `limit` is at most 1,000 (the default).
      */
     documentsPage(options?: {
         cursor?: string | null;
         limit?: number;
+        order?: 'oldest' | 'newest';
     }): Promise<DataSourceDocumentPage>;
     /**
      * Every document in the corpus, oldest first, a page at a time behind the
@@ -2917,6 +2952,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;
     }>;
@@ -11848,6 +11889,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", {
@@ -2922,6 +2929,35 @@ var DataSource = class {
   async stats() {
     return this._call("stats", { slug: this._slug });
   }
+  /**
+   * How many passages (chunks) match a filter — exact, over the whole corpus.
+   *
+   * The honest number to show beside a search's hits: `count({ contains:
+   * query })` is how many passages contain **all** the query's words, so a UI
+   * can say "8 of 3,891 passages mention these words" and mean it. Same
+   * grammar as {@link SearchOptions.filter}, so it also answers "how many
+   * passages are tagged `department: 'legal'`" or contain an exact `phrase`.
+   * No filter counts the whole corpus.
+   *
+   * What it is not: a relevance count. Similarity is a continuous score over
+   * every chunk and no such total exists, so do not label this "relevant
+   * results" or "matches for your query". It is also not the set `search`
+   * returns: the semantic branch surfaces passages without the words, and the
+   * lexical branch scores partial overlap. Chunks, not documents — a long
+   * document contributes several.
+   *
+   * Counts share the search rate limit (300/minute per app); a count paired
+   * with every search spends two. Cheap otherwise: one index lookup, no model
+   * call. Shows the same `index_warming` / `index_building` as search while a
+   * corpus is loading or building, never a false `0`.
+   */
+  async count(filter) {
+    const { chunks, latencyMs } = await this._call("count", {
+      slug: this._slug,
+      ...filter !== void 0 ? { filter } : {}
+    });
+    return { chunks: chunks ?? 0, latencyMs: latencyMs ?? 0 };
+  }
   /**
    * Every chunk of one document, exactly as it was indexed.
    *
@@ -2993,14 +3029,16 @@ 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).
+   * One page of the corpus with the cursor for the next page. Oldest first
+   * unless `order: 'newest'` — the page an app shows as "what just arrived"
+   * without walking anything. `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 } : {}
+      ...options?.limit ? { limit: options.limit } : {},
+      ...options?.order ? { order: options.order } : {}
     });
     return { documents: documents2 ?? [], nextCursor: nextCursor ?? null };
   }
@@ -3102,7 +3140,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. */
@@ -7955,7 +7994,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(