@granular-software/sdk 0.4.19 → 0.4.20

package/README.md

@@ -456,6 +456,16 @@ Defines domain ontology: classes (with typed properties), and relationships (wit
 ### `environment.recordObject(options)`
 Creates or updates a class instance with fields and relationships. Returns `{ path, id, created }`.
 
+### `environment.recordObjects(records, options?)`
+Batch upsert for many instances. The SDK sends **chunks** (default **100** rows per HTTP `POST` to `/records/batch`) with **retries** on transient failures, so large arrays do not time out as a single oversized request.
+
+Optional **`options`**:
+- **`batchSize`** — max rows per request (default 100).
+- **`concurrency`** — how many chunk requests may run in parallel (default 1, max 16); can reduce wall time when the server can overlap work.
+- **`onChunkComplete`** — async-friendly hook after each chunk for progress UIs; the returned array is always ordered like `records`.
+
+**Sync batch vs queued import:** use **`recordObjects`** when you need **synchronous** commits and/or per-chunk feedback. Use **`enqueueRecordImport`** + **`getRecordImport` / `getRecordImportSummary`** for **background** ingestion with aggregate counters when admission latency matters more than immediate row-by-row completion.
+
 ### `environment.getRelationships(modelPath)`
 Returns relationship definitions for a given class.
 

package/dist/agent-evals.d.mts

@@ -1,4 +1,4 @@
-import { P as Prompt, c as Environment, b as SessionHeapSnapshot, aZ as ManifestContent, ax as RecordObjectOptions, T as ToolWithHandler, G as Granular, C as ConnectOptions, y as CreateEnvironmentData, i as GranularOptions } from './client-BQw_gUK3.mjs';
+import { P as Prompt, c as Environment, b as SessionHeapSnapshot, a$ as ManifestContent, ax as RecordObjectOptions, T as ToolWithHandler, G as Granular, C as ConnectOptions, y as CreateEnvironmentData, i as GranularOptions } from './client-DWYdWpS-.mjs';
 import { GeneratedJobCodeIssue, HarnessControllerBudgets } from './agent-harness.mjs';
 import '@automerge/automerge';
 import '@automerge/automerge/slim';

package/dist/agent-evals.d.ts

@@ -1,4 +1,4 @@
-import { P as Prompt, c as Environment, b as SessionHeapSnapshot, aZ as ManifestContent, ax as RecordObjectOptions, T as ToolWithHandler, G as Granular, C as ConnectOptions, y as CreateEnvironmentData, i as GranularOptions } from './client-BQw_gUK3.js';
+import { P as Prompt, c as Environment, b as SessionHeapSnapshot, a$ as ManifestContent, ax as RecordObjectOptions, T as ToolWithHandler, G as Granular, C as ConnectOptions, y as CreateEnvironmentData, i as GranularOptions } from './client-DWYdWpS-.js';
 import { GeneratedJobCodeIssue, HarnessControllerBudgets } from './agent-harness.js';
 import '@automerge/automerge';
 import '@automerge/automerge/slim';

package/dist/agent-evals.js

@@ -11256,6 +11256,28 @@ var STANDARD_MODULES_OPERATIONS = [
 var BUILTIN_MODULES = {
   "standard_modules": STANDARD_MODULES_OPERATIONS
 };
+var DEFAULT_DIRECT_RECORD_OBJECTS_REQUEST_BATCH_SIZE = 100;
+var MAX_RECORD_OBJECTS_CONCURRENCY = 16;
+var DEFAULT_DIRECT_RECORD_OBJECTS_RETRY_COUNT = 3;
+var DEFAULT_DIRECT_RECORD_OBJECTS_RETRY_DELAY_MS = 1e3;
+function planRecordObjectsChunks(records, batchSize) {
+  const total = records.length;
+  const size = Math.max(1, Math.min(batchSize, total));
+  const chunkCount = Math.ceil(total / size);
+  const plans = [];
+  for (let offset = 0, chunkIndex = 0; offset < total; offset += size, chunkIndex += 1) {
+    const slice = records.slice(offset, offset + size);
+    plans.push({ chunkIndex, chunkCount, offset, slice });
+  }
+  return plans;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryableRecordObjectsError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /worker restarted mid-request|econnreset|network|socket connection was closed unexpectedly|timed out/i.test(message);
+}
 function computeEffectKey2(effect) {
   const attachedClass = effect.className?.trim();
   if (!attachedClass) {
@@ -12213,24 +12235,101 @@ var Environment = class extends Session {
   /**
    * Batch version of `recordObject()`.
    *
-   * Sends several upserts through the control-plane batch endpoint so the
-   * server can collapse the graph mutations into far fewer round trips.
+   * Sends rows through the control-plane **`/records/batch`** endpoint in **chunks** (default
+   * **100** records per HTTP request) so individual requests stay bounded and gateway timeouts are
+   * unlikely. Each chunk is retried on transient network / worker errors.
+   *
+   * Use the optional second argument to:
+   * - **`batchSize`** — rows per POST (smaller = more progress events; larger = fewer round trips).
+   * - **`concurrency`** — run up to N chunk POSTs in parallel (capped at 16) when you want lower wall time.
+   * - **`onChunkComplete`** — hook for UIs after each chunk succeeds (row order in the returned array
+   *   always matches `records`; chunk **completion** order may differ when `concurrency > 1`).
+   *
+   * For **asynchronous** ingestion with worker-side batching and aggregate counters (`queued`,
+   * `completed`, …), use **`enqueueRecordImport`** and poll **`getRecordImport`** /
+   * **`getRecordImportSummary`** — best for very large fire-and-forget loads when immediate
+   * synchronous commit of every row is not required.
    */
-  async recordObjects(records) {
+  async recordObjects(records, options) {
     if (!Array.isArray(records) || records.length === 0) {
       return [];
     }
-    const response = await this.controlPlaneRequest(
-      `/control/environments/${this.environmentId}/records/batch`,
-      {
-        method: "POST",
-        body: JSON.stringify({ records })
-      }
+    const batchSize = Math.max(
+      1,
+      Math.min(
+        records.length,
+        options?.batchSize ?? DEFAULT_DIRECT_RECORD_OBJECTS_REQUEST_BATCH_SIZE
+      )
     );
-    return Array.isArray(response.items) ? response.items : [];
+    const concurrency = Math.min(
+      MAX_RECORD_OBJECTS_CONCURRENCY,
+      Math.max(1, options?.concurrency ?? 1)
+    );
+    const plans = planRecordObjectsChunks(records, batchSize);
+    const total = records.length;
+    const results = new Array(total);
+    const onChunk = options?.onChunkComplete;
+    for (let waveStart = 0; waveStart < plans.length; waveStart += concurrency) {
+      const wave = plans.slice(waveStart, waveStart + concurrency);
+      await Promise.all(
+        wave.map(async (plan) => {
+          const { items, durationMs } = await this.executeRecordObjectsChunk(plan.slice);
+          if (items.length !== plan.slice.length) {
+            throw new Error(
+              `recordObjects: chunk ${plan.chunkIndex + 1} returned ${items.length} results, expected ${plan.slice.length}`
+            );
+          }
+          for (let index = 0; index < items.length; index += 1) {
+            results[plan.offset + index] = items[index];
+          }
+          if (onChunk) {
+            const info = {
+              chunkIndex: plan.chunkIndex,
+              totalChunks: plan.chunkCount,
+              offset: plan.offset,
+              recordCount: plan.slice.length,
+              durationMs,
+              results: items
+            };
+            await onChunk(info);
+          }
+        })
+      );
+    }
+    return results;
+  }
+  async executeRecordObjectsChunk(chunk) {
+    const wallStart = Date.now();
+    let lastError;
+    for (let attempt = 1; attempt <= DEFAULT_DIRECT_RECORD_OBJECTS_RETRY_COUNT; attempt += 1) {
+      try {
+        const response = await this.controlPlaneRequest(
+          `/control/environments/${this.environmentId}/records/batch`,
+          {
+            method: "POST",
+            body: JSON.stringify({ records: chunk })
+          }
+        );
+        const items = Array.isArray(response.items) ? response.items : [];
+        return { items, durationMs: Date.now() - wallStart };
+      } catch (error) {
+        lastError = error;
+        if (!isRetryableRecordObjectsError(error) || attempt === DEFAULT_DIRECT_RECORD_OBJECTS_RETRY_COUNT) {
+          throw error;
+        }
+        await sleep(DEFAULT_DIRECT_RECORD_OBJECTS_RETRY_DELAY_MS * attempt);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
   }
   /**
-   * Queue a background record import for this environment.
+   * Queue a background record import for this environment (async worker pipeline).
+   *
+   * **vs `recordObjects`:** this path accepts the full payload in one request, returns an
+   * **`importId`**, and processes rows in the background — use **`getRecordImport`** /
+   * **`getRecordImportSummary`** for progress. Choose it for large bulk loads where you do not
+   * need every row committed before the HTTP call returns. Use **`recordObjects`** when you need
+   * synchronous upserts and fine-grained chunk progress via **`onChunkComplete`**.
    */
   async enqueueRecordImport(records, options = {}) {
     return this.controlPlaneRequest(
@@ -14589,7 +14688,7 @@ ${modelOutputInstruction()}` },
         if (!response.ok) {
           const errorText = await response.text();
           if (attempt < 3 && (response.status >= 500 || response.status === 429)) {
-            await sleep(500 * attempt);
+            await sleep2(500 * attempt);
             continue;
           }
           throw new Error(`OpenAI chat generation failed: ${response.status} ${errorText}`);
@@ -14600,7 +14699,7 @@ ${modelOutputInstruction()}` },
         const parsed = extractJsonObject(text);
         if (!parsed) {
           if (attempt < 3) {
-            await sleep(300 * attempt);
+            await sleep2(300 * attempt);
             continue;
           }
           throw new Error(`Model output was not valid JSON:
@@ -14614,7 +14713,7 @@ ${text}`);
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
         if (attempt < 3 && /socket connection was closed unexpectedly|ECONNRESET|network|timed out/i.test(lastError.message)) {
-          await sleep(500 * attempt);
+          await sleep2(500 * attempt);
           continue;
         }
         throw lastError;
@@ -14626,7 +14725,7 @@ ${text}`);
 async function ensureDir(dir) {
   await promises.mkdir(dir, { recursive: true });
 }
-async function sleep(ms) {
+async function sleep2(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function withTimeout(promise, ms, label) {
@@ -15069,7 +15168,7 @@ function createAgentEvalHarness(options) {
         stderr: [...pending.stderr, ...resumed.stderr]
       };
     }
-    await sleep(350);
+    await sleep2(350);
     const liveDoc = cloneJson(pending.conversation.environment.document);
     const presentation = resolveJobPresentation({
       jobId: pending.job.id,
@@ -15238,7 +15337,7 @@ function createAgentEvalHarness(options) {
       if (outcome.kind !== "completed") {
         throw new Error("Unexpected non-completed outcome after prompt handling");
       }
-      await sleep(350);
+      await sleep2(350);
       const settledLiveDoc = cloneJson(conversation.environment.document);
       const sessionHeap = normalizeHeapSnapshot2(asRecord4(settledLiveDoc?.heap));
       const presentation = resolveJobPresentation({