@utaba/deep-memory-storage-cosmosdb 0.12.0 → 0.14.0

package/dist/index.d.cts

@@ -147,7 +147,7 @@ declare class CosmosDbProvider implements StorageProvider, GraphTraversalProvide
      * For agent-facing graph queries use {@link traverse}, which enforces the
      * repositoryId partition predicate.
      */
-    executeNativeQuery(_repositoryId: string, query: string, params?: Record<string, unknown>): Promise<TraversalResult>;
+    executeNativeQuery(_repositoryId: string, query: string, params?: Record<string, unknown>): Promise<unknown[]>;
     private executeNativeQueryImpl;
 }
 

package/dist/index.d.ts

@@ -147,7 +147,7 @@ declare class CosmosDbProvider implements StorageProvider, GraphTraversalProvide
      * For agent-facing graph queries use {@link traverse}, which enforces the
      * repositoryId partition predicate.
      */
-    executeNativeQuery(_repositoryId: string, query: string, params?: Record<string, unknown>): Promise<TraversalResult>;
+    executeNativeQuery(_repositoryId: string, query: string, params?: Record<string, unknown>): Promise<unknown[]>;
     private executeNativeQueryImpl;
 }
 

package/dist/index.js

@@ -1090,41 +1090,71 @@ function isInTimeRange(timestamp, timeRange) {
 
 // src/queries/adaptive-import.ts
 import { ImportThrottleAbortError } from "@utaba/deep-memory";
-var DEFAULT_MIN = 2;
+var DEFAULT_MIN = 1;
 var DEFAULT_START = 5;
 var DEFAULT_MAX = 32;
 var DEFAULT_INCREASE_AFTER = 50;
 var DEFAULT_COOLDOWN_MS = 1e3;
+var DEFAULT_RAMP_UP_COOLDOWN_MS = 5e3;
 var DEFAULT_MAX_CONSECUTIVE_THROTTLES_AT_MIN = 10;
+var DEFAULT_THROTTLE_CEILING_MULTIPLIER = 3;
+var NO_SOFT_CEILING = Number.POSITIVE_INFINITY;
 function resolveOptions(opts) {
   const min = Math.max(1, opts?.min ?? DEFAULT_MIN);
   const max = Math.max(min, opts?.max ?? DEFAULT_MAX);
   const start = Math.min(max, Math.max(min, opts?.start ?? DEFAULT_START));
   const increaseAfter = Math.max(1, opts?.increaseAfter ?? DEFAULT_INCREASE_AFTER);
   const cooldownMs = Math.max(0, opts?.cooldownMs ?? DEFAULT_COOLDOWN_MS);
+  const rampUpCooldownMs = Math.max(0, opts?.rampUpCooldownMs ?? DEFAULT_RAMP_UP_COOLDOWN_MS);
   const maxConsecutiveThrottlesAtMin = Math.max(
     1,
     opts?.maxConsecutiveThrottlesAtMin ?? DEFAULT_MAX_CONSECUTIVE_THROTTLES_AT_MIN
   );
+  const throttleCeilingMultiplier = Math.max(
+    1,
+    opts?.throttleCeilingMultiplier ?? DEFAULT_THROTTLE_CEILING_MULTIPLIER
+  );
   return {
     min,
     start,
     max,
     increaseAfter,
     cooldownMs,
+    rampUpCooldownMs,
     maxConsecutiveThrottlesAtMin,
+    throttleCeilingMultiplier,
     onAdjust: opts?.onAdjust
   };
 }
+function resolveController(options, handle) {
+  if (!handle) {
+    return new AdaptiveConcurrencyController(options);
+  }
+  const cosmosHandle = handle;
+  if (!cosmosHandle.controller) {
+    cosmosHandle.controller = new AdaptiveConcurrencyController(options);
+  }
+  return cosmosHandle.controller;
+}
 var AdaptiveConcurrencyController = class {
   opts;
   current;
   streak = 0;
   cooldownUntil = 0;
+  rampFrozenUntil = 0;
   completed = 0;
   throttled = 0;
   startEmitted = false;
   consecutiveThrottlesAtMin = 0;
+  /**
+   * Highest concurrency at which a throttle has been observed and the
+   * controller actually halved (i.e. concrete evidence the cluster could not
+   * sustain that level). Re-approaching this level on subsequent ramp-ups
+   * requires `increaseAfter * throttleCeilingMultiplier` consecutive successes
+   * instead of just `increaseAfter`. Cleared once we've successfully held the
+   * level without further throttling — see noteSuccess.
+   */
+  softCeiling = NO_SOFT_CEILING;
   constructor(opts) {
     this.opts = resolveOptions(opts);
     this.current = this.opts.start;
@@ -1162,14 +1192,21 @@ var AdaptiveConcurrencyController = class {
     this.notify("start", this.current);
   }
   /** Record a throttle-free task completion. May trigger ramp-up. */
-  noteSuccess() {
+  noteSuccess(now = Date.now()) {
     this.completed++;
-    this.streak++;
     this.consecutiveThrottlesAtMin = 0;
-    if (this.streak >= this.opts.increaseAfter && this.current < this.opts.max) {
+    if (now < this.rampFrozenUntil) return;
+    this.streak++;
+    if (this.current >= this.opts.max) return;
+    const target = this.current + 1;
+    const needed = target >= this.softCeiling ? this.opts.increaseAfter * this.opts.throttleCeilingMultiplier : this.opts.increaseAfter;
+    if (this.streak >= needed) {
       const previous = this.current;
-      this.current = Math.min(this.opts.max, this.current + 1);
+      this.current = Math.min(this.opts.max, target);
       this.streak = 0;
+      if (this.current >= this.softCeiling) {
+        this.softCeiling = NO_SOFT_CEILING;
+      }
       this.notify("ramp-up", previous);
     }
   }
@@ -1181,8 +1218,10 @@ var AdaptiveConcurrencyController = class {
     const previous = this.current;
     const next = Math.max(this.opts.min, Math.floor(this.current / 2));
     this.cooldownUntil = now + this.opts.cooldownMs;
+    this.rampFrozenUntil = now + this.opts.rampUpCooldownMs;
     if (next !== previous) {
       this.current = next;
+      this.softCeiling = previous;
       this.notify("throttle", previous);
     }
     if (this.current === this.opts.min) {
@@ -1191,6 +1230,15 @@ var AdaptiveConcurrencyController = class {
       this.consecutiveThrottlesAtMin = 0;
     }
   }
+  /**
+   * Current soft ceiling — the highest concurrency at which a throttle was
+   * observed and the controller halved. {@link Number.POSITIVE_INFINITY} when
+   * no ceiling is in effect. Re-approaching this level requires
+   * `increaseAfter * throttleCeilingMultiplier` consecutive successes.
+   */
+  getSoftCeiling() {
+    return this.softCeiling;
+  }
   /** Configured circuit-breaker threshold. */
   getMaxConsecutiveThrottlesAtMin() {
     return this.opts.maxConsecutiveThrottlesAtMin;
@@ -1371,7 +1419,7 @@ async function importBulk(conn, repositoryId, data, options) {
   let relationshipsImported = 0;
   const errors = [];
   const skipCheck = options?.skipExistenceCheck ?? false;
-  const controller = new AdaptiveConcurrencyController(options?.adaptiveConcurrency);
+  const controller = resolveController(options?.adaptiveConcurrency, options?.adaptiveConcurrencyHandle);
   for (const chunk of data) {
     if (chunk.entities && chunk.entities.length > 0) {
       const results = await runAdaptive(
@@ -2136,35 +2184,9 @@ var CosmosDbProvider = class {
     return this.track("executeNativeQuery", void 0, () => this.executeNativeQueryImpl(query, params));
   }
   async executeNativeQueryImpl(query, params) {
-    const startTime = Date.now();
     try {
       const result = await this.conn.submit(query, params);
-      const executionTimeMs = Date.now() - startTime;
-      const entities = [];
-      for (const item of result.items) {
-        try {
-          const entity = entityFromGremlin(item);
-          if (entity.id) {
-            entities.push(entity);
-          }
-        } catch {
-        }
-      }
-      const queryMetadata = {
-        executionTimeMs,
-        resourceCost: result.requestCharge != null ? { units: "RU", value: result.requestCharge } : void 0,
-        compiledQuery: query,
-        compiledQueryLanguage: "gremlin",
-        appliedLimits: { maxResults: entities.length },
-        truncated: false
-      };
-      return {
-        entities,
-        total: entities.length,
-        returned: entities.length,
-        hasMore: false,
-        queryMetadata
-      };
+      return result.items;
     } catch (err) {
       throw new ProviderError(
         `Native Gremlin query failed: ${err instanceof Error ? err.message : String(err)}`,