@anuma/sdk 6.24.0 → 6.24.1

package/dist/expo/index.cjs

@@ -19459,6 +19459,7 @@ function createDurableAutoExtractor(options) {
   }
   async function extractBatch(messages, conversationId, ids, jobScope, jobFolderId) {
     let watchdog;
+    const model = options.modelForScope?.(jobScope) ?? options.extract.model;
     try {
       return await Promise.race([
         new Promise((resolve, reject) => {
@@ -19471,6 +19472,8 @@ function createDurableAutoExtractor(options) {
                 canWrite: async () => !disposed && await storage.conversationsCollection.query(import_watermelondb12.Q.where("conversation_id", conversationId), import_watermelondb12.Q.where("is_deleted", false)).fetchCount() > 0 && await storage.messagesCollection.query(import_watermelondb12.Q.where("conversation_id", conversationId), import_watermelondb12.Q.where("id", import_watermelondb12.Q.oneOf(ids))).fetchCount() === ids.length && (!vault.canWrite || await vault.canWrite()) && !disposed
               }
             },
+            // The model follows the job's scope, not the mode alive at drain time.
+            extract: { ...options.extract, ...model !== void 0 && { model } },
             // Never publish a private queued observation after a mode flip.
             scope: jobScope,
             folderId: jobFolderId,

package/dist/expo/index.d.mts

@@ -9459,6 +9459,16 @@ interface DurableAutoExtractorOptions extends Omit<CreateAutoExtractorOptions, "
      * as `"private"` — the direction that cannot publish.
      */
     scope?: string | (() => string);
+    /**
+     * Extraction model for a batch, chosen from the scope that batch will be
+     * retained under. A queued job keeps its scope across a privacy-mode flip but
+     * `extract.model` is whatever this instance was built with, so without this a
+     * turn queued in private mode is drained by a public-mode extractor on that
+     * extractor's model. Returning `undefined` keeps `extract.model`. A resolver
+     * that throws fails the batch, which stays queued for retry: guessing a model
+     * is exactly the mistake this exists to prevent.
+     */
+    modelForScope?: (scope: string) => string | undefined;
     /** Coalesce arrivals after durably recording them. Defaults to 20 seconds. */
     debounceMs?: number;
     /** Retry delay for a failed batch. Defaults to 30 seconds; max three attempts

package/dist/expo/index.d.ts

@@ -9459,6 +9459,16 @@ interface DurableAutoExtractorOptions extends Omit<CreateAutoExtractorOptions, "
      * as `"private"` — the direction that cannot publish.
      */
     scope?: string | (() => string);
+    /**
+     * Extraction model for a batch, chosen from the scope that batch will be
+     * retained under. A queued job keeps its scope across a privacy-mode flip but
+     * `extract.model` is whatever this instance was built with, so without this a
+     * turn queued in private mode is drained by a public-mode extractor on that
+     * extractor's model. Returning `undefined` keeps `extract.model`. A resolver
+     * that throws fails the batch, which stays queued for retry: guessing a model
+     * is exactly the mistake this exists to prevent.
+     */
+    modelForScope?: (scope: string) => string | undefined;
     /** Coalesce arrivals after durably recording them. Defaults to 20 seconds. */
     debounceMs?: number;
     /** Retry delay for a failed batch. Defaults to 30 seconds; max three attempts

package/dist/expo/index.mjs

@@ -9529,6 +9529,7 @@ function createDurableAutoExtractor(options) {
   }
   async function extractBatch(messages, conversationId, ids, jobScope, jobFolderId) {
     let watchdog;
+    const model = options.modelForScope?.(jobScope) ?? options.extract.model;
     try {
       return await Promise.race([
         new Promise((resolve, reject) => {
@@ -9541,6 +9542,8 @@ function createDurableAutoExtractor(options) {
                 canWrite: async () => !disposed && await storage.conversationsCollection.query(Q4.where("conversation_id", conversationId), Q4.where("is_deleted", false)).fetchCount() > 0 && await storage.messagesCollection.query(Q4.where("conversation_id", conversationId), Q4.where("id", Q4.oneOf(ids))).fetchCount() === ids.length && (!vault.canWrite || await vault.canWrite()) && !disposed
               }
             },
+            // The model follows the job's scope, not the mode alive at drain time.
+            extract: { ...options.extract, ...model !== void 0 && { model } },
             // Never publish a private queued observation after a mode flip.
             scope: jobScope,
             folderId: jobFolderId,

package/dist/react/index.cjs

@@ -20763,6 +20763,7 @@ function createDurableAutoExtractor(options) {
   }
   async function extractBatch(messages, conversationId, ids, jobScope, jobFolderId) {
     let watchdog;
+    const model = options.modelForScope?.(jobScope) ?? options.extract.model;
     try {
       return await Promise.race([
         new Promise((resolve, reject) => {
@@ -20775,6 +20776,8 @@ function createDurableAutoExtractor(options) {
                 canWrite: async () => !disposed && await storage.conversationsCollection.query(import_watermelondb13.Q.where("conversation_id", conversationId), import_watermelondb13.Q.where("is_deleted", false)).fetchCount() > 0 && await storage.messagesCollection.query(import_watermelondb13.Q.where("conversation_id", conversationId), import_watermelondb13.Q.where("id", import_watermelondb13.Q.oneOf(ids))).fetchCount() === ids.length && (!vault.canWrite || await vault.canWrite()) && !disposed
               }
             },
+            // The model follows the job's scope, not the mode alive at drain time.
+            extract: { ...options.extract, ...model !== void 0 && { model } },
             // Never publish a private queued observation after a mode flip.
             scope: jobScope,
             folderId: jobFolderId,

package/dist/react/index.d.mts

@@ -10694,6 +10694,16 @@ interface DurableAutoExtractorOptions extends Omit<CreateAutoExtractorOptions, "
      * as `"private"` — the direction that cannot publish.
      */
     scope?: string | (() => string);
+    /**
+     * Extraction model for a batch, chosen from the scope that batch will be
+     * retained under. A queued job keeps its scope across a privacy-mode flip but
+     * `extract.model` is whatever this instance was built with, so without this a
+     * turn queued in private mode is drained by a public-mode extractor on that
+     * extractor's model. Returning `undefined` keeps `extract.model`. A resolver
+     * that throws fails the batch, which stays queued for retry: guessing a model
+     * is exactly the mistake this exists to prevent.
+     */
+    modelForScope?: (scope: string) => string | undefined;
     /** Coalesce arrivals after durably recording them. Defaults to 20 seconds. */
     debounceMs?: number;
     /** Retry delay for a failed batch. Defaults to 30 seconds; max three attempts

package/dist/react/index.d.ts

@@ -10694,6 +10694,16 @@ interface DurableAutoExtractorOptions extends Omit<CreateAutoExtractorOptions, "
      * as `"private"` — the direction that cannot publish.
      */
     scope?: string | (() => string);
+    /**
+     * Extraction model for a batch, chosen from the scope that batch will be
+     * retained under. A queued job keeps its scope across a privacy-mode flip but
+     * `extract.model` is whatever this instance was built with, so without this a
+     * turn queued in private mode is drained by a public-mode extractor on that
+     * extractor's model. Returning `undefined` keeps `extract.model`. A resolver
+     * that throws fails the batch, which stays queued for retry: guessing a model
+     * is exactly the mistake this exists to prevent.
+     */
+    modelForScope?: (scope: string) => string | undefined;
     /** Coalesce arrivals after durably recording them. Defaults to 20 seconds. */
     debounceMs?: number;
     /** Retry delay for a failed batch. Defaults to 30 seconds; max three attempts

package/dist/react/index.mjs

@@ -10347,6 +10347,7 @@ function createDurableAutoExtractor(options) {
   }
   async function extractBatch(messages, conversationId, ids, jobScope, jobFolderId) {
     let watchdog;
+    const model = options.modelForScope?.(jobScope) ?? options.extract.model;
     try {
       return await Promise.race([
         new Promise((resolve, reject) => {
@@ -10359,6 +10360,8 @@ function createDurableAutoExtractor(options) {
                 canWrite: async () => !disposed && await storage.conversationsCollection.query(Q5.where("conversation_id", conversationId), Q5.where("is_deleted", false)).fetchCount() > 0 && await storage.messagesCollection.query(Q5.where("conversation_id", conversationId), Q5.where("id", Q5.oneOf(ids))).fetchCount() === ids.length && (!vault.canWrite || await vault.canWrite()) && !disposed
               }
             },
+            // The model follows the job's scope, not the mode alive at drain time.
+            extract: { ...options.extract, ...model !== void 0 && { model } },
             // Never publish a private queued observation after a mode flip.
             scope: jobScope,
             folderId: jobFolderId,

package/dist/server/index.cjs

@@ -32401,6 +32401,7 @@ function createDurableAutoExtractor(options) {
   }
   async function extractBatch(messages, conversationId, ids, jobScope, jobFolderId) {
     let watchdog;
+    const model = options.modelForScope?.(jobScope) ?? options.extract.model;
     try {
       return await Promise.race([
         new Promise((resolve, reject) => {
@@ -32413,6 +32414,8 @@ function createDurableAutoExtractor(options) {
                 canWrite: async () => !disposed && await storage.conversationsCollection.query(import_watermelondb24.Q.where("conversation_id", conversationId), import_watermelondb24.Q.where("is_deleted", false)).fetchCount() > 0 && await storage.messagesCollection.query(import_watermelondb24.Q.where("conversation_id", conversationId), import_watermelondb24.Q.where("id", import_watermelondb24.Q.oneOf(ids))).fetchCount() === ids.length && (!vault.canWrite || await vault.canWrite()) && !disposed
               }
             },
+            // The model follows the job's scope, not the mode alive at drain time.
+            extract: { ...options.extract, ...model !== void 0 && { model } },
             // Never publish a private queued observation after a mode flip.
             scope: jobScope,
             folderId: jobFolderId,

package/dist/server/index.d.mts

@@ -10031,6 +10031,16 @@ interface DurableAutoExtractorOptions extends Omit<CreateAutoExtractorOptions, "
      * as `"private"` — the direction that cannot publish.
      */
     scope?: string | (() => string);
+    /**
+     * Extraction model for a batch, chosen from the scope that batch will be
+     * retained under. A queued job keeps its scope across a privacy-mode flip but
+     * `extract.model` is whatever this instance was built with, so without this a
+     * turn queued in private mode is drained by a public-mode extractor on that
+     * extractor's model. Returning `undefined` keeps `extract.model`. A resolver
+     * that throws fails the batch, which stays queued for retry: guessing a model
+     * is exactly the mistake this exists to prevent.
+     */
+    modelForScope?: (scope: string) => string | undefined;
     /** Coalesce arrivals after durably recording them. Defaults to 20 seconds. */
     debounceMs?: number;
     /** Retry delay for a failed batch. Defaults to 30 seconds; max three attempts

package/dist/server/index.d.ts

@@ -10031,6 +10031,16 @@ interface DurableAutoExtractorOptions extends Omit<CreateAutoExtractorOptions, "
      * as `"private"` — the direction that cannot publish.
      */
     scope?: string | (() => string);
+    /**
+     * Extraction model for a batch, chosen from the scope that batch will be
+     * retained under. A queued job keeps its scope across a privacy-mode flip but
+     * `extract.model` is whatever this instance was built with, so without this a
+     * turn queued in private mode is drained by a public-mode extractor on that
+     * extractor's model. Returning `undefined` keeps `extract.model`. A resolver
+     * that throws fails the batch, which stays queued for retry: guessing a model
+     * is exactly the mistake this exists to prevent.
+     */
+    modelForScope?: (scope: string) => string | undefined;
     /** Coalesce arrivals after durably recording them. Defaults to 20 seconds. */
     debounceMs?: number;
     /** Retry delay for a failed batch. Defaults to 30 seconds; max three attempts

package/dist/server/index.mjs

@@ -8412,6 +8412,7 @@ function createDurableAutoExtractor(options) {
   }
   async function extractBatch(messages, conversationId, ids, jobScope, jobFolderId) {
     let watchdog;
+    const model = options.modelForScope?.(jobScope) ?? options.extract.model;
     try {
       return await Promise.race([
         new Promise((resolve, reject) => {
@@ -8424,6 +8425,8 @@ function createDurableAutoExtractor(options) {
                 canWrite: async () => !disposed && await storage.conversationsCollection.query(import_watermelondb20.Q.where("conversation_id", conversationId), import_watermelondb20.Q.where("is_deleted", false)).fetchCount() > 0 && await storage.messagesCollection.query(import_watermelondb20.Q.where("conversation_id", conversationId), import_watermelondb20.Q.where("id", import_watermelondb20.Q.oneOf(ids))).fetchCount() === ids.length && (!vault.canWrite || await vault.canWrite()) && !disposed
               }
             },
+            // The model follows the job's scope, not the mode alive at drain time.
+            extract: { ...options.extract, ...model !== void 0 && { model } },
             // Never publish a private queued observation after a mode flip.
             scope: jobScope,
             folderId: jobFolderId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anuma/sdk",
-  "version": "6.24.0",
+  "version": "6.24.1",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",