@granular-software/sdk 0.4.7 → 0.4.9

package/dist/index.js

@@ -3972,6 +3972,9 @@ var WSClient = class {
     this.sessionId = options.sessionId;
     this.token = options.token;
   }
+  get currentSessionId() {
+    return this.sessionId;
+  }
   clearTokenRefreshTimer() {
     if (this.tokenRefreshTimer) {
       clearTimeout(this.tokenRefreshTimer);
@@ -4496,6 +4499,18 @@ var Session = class {
     this.setupEventHandlers();
     this.setupToolInvokeHandler();
   }
+  extractDomainRevisionFromDoc(doc) {
+    const domain = doc?.domain;
+    const active = domain?.active;
+    if (typeof active === "string" && active.trim()) {
+      return active;
+    }
+    const nestedRevision = active?.domainRevision;
+    if (typeof nestedRevision === "string" && nestedRevision.trim()) {
+      return nestedRevision;
+    }
+    return null;
+  }
   buildLegacyEffectContext() {
     return {
       effectClientId: this.clientId,
@@ -4513,6 +4528,9 @@ var Session = class {
   get document() {
     return this.client.doc;
   }
+  get sessionId() {
+    return this.client.currentSessionId;
+  }
   get domainRevision() {
     return this.currentDomainRevision;
   }
@@ -4590,7 +4608,14 @@ var Session = class {
    * execute locally and return the result to the sandbox.
    */
   async submitJob(code, domainRevision) {
-    const revision = domainRevision || this.currentDomainRevision || this.client.doc?.domain?.active || void 0;
+    let revision = domainRevision || this.currentDomainRevision || this.extractDomainRevisionFromDoc(this.client.doc) || void 0;
+    if (!revision) {
+      try {
+        const summary = await this.getDomain();
+        revision = summary.activeDomainRevision || this.extractDomainRevisionFromDoc(this.client.doc) || void 0;
+      } catch {
+      }
+    }
     if (!revision) {
       throw new Error("No domain revision available. Register live effects or ensure the build schema is activated.");
     }
@@ -4601,7 +4626,11 @@ var Session = class {
     if (!result.jobId) {
       throw new Error("Failed to submit job: no jobId returned");
     }
-    const job = new JobImplementation(result.jobId, this.client);
+    const job = new JobImplementation(result.jobId, this.client, {
+      code,
+      domainRevision: revision,
+      createdAt: Date.now()
+    });
     this.jobsMap.set(result.jobId, job);
     return job;
   }
@@ -4715,7 +4744,13 @@ var Session = class {
    * Get the current domain state and available tools
    */
   async getDomain() {
-    return this.client.call("domain.getSummary", {});
+    const summary = await this.client.call("domain.getSummary", {});
+    if (summary.activeDomainRevision) {
+      this.currentDomainRevision = summary.activeDomainRevision;
+    } else {
+      this.currentDomainRevision = this.extractDomainRevisionFromDoc(this.client.doc);
+    }
+    return summary;
   }
   /**
    * Fetch a domain package part from the backend (no fallback).
@@ -4933,6 +4968,7 @@ import { ${allImports} } from "./sandbox-tools";
   }
   setupEventHandlers() {
     this.client.on("sync", (doc) => {
+      this.currentDomainRevision = this.extractDomainRevisionFromDoc(doc);
       this.emit("sync", doc);
       this.checkForToolChanges();
     });
@@ -4988,6 +5024,78 @@ import { ${allImports} } from "./sandbox-tools";
     }
   }
 };
+var MAX_FEEDBACK_STRING_LENGTH = 16e3;
+var MAX_FEEDBACK_TOOL_CALLS = 50;
+var MAX_FEEDBACK_ARRAY_ITEMS = 50;
+var MAX_FEEDBACK_OBJECT_KEYS = 50;
+var MAX_FEEDBACK_DEPTH = 6;
+function truncateFeedbackString(value, maxLength = MAX_FEEDBACK_STRING_LENGTH) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength)}...[truncated ${value.length - maxLength} chars]`;
+}
+function normalizeJobStatus(status) {
+  if (typeof status !== "string") {
+    return "queued";
+  }
+  switch (status) {
+    case "completed":
+      return "succeeded";
+    case "failed":
+    case "running":
+    case "queued":
+    case "succeeded":
+    case "timeout":
+    case "canceled":
+      return status;
+    default:
+      return "queued";
+  }
+}
+function sanitizeFeedbackValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (depth >= MAX_FEEDBACK_DEPTH) {
+    return "[Max depth reached]";
+  }
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return truncateFeedbackString(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return truncateFeedbackString(value.toString());
+  }
+  if (value instanceof Error) {
+    return {
+      name: truncateFeedbackString(value.name),
+      message: truncateFeedbackString(value.message),
+      stack: truncateFeedbackString(value.stack || "")
+    };
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, MAX_FEEDBACK_ARRAY_ITEMS).map((entry) => sanitizeFeedbackValue(entry, depth + 1, seen));
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const entries = Object.entries(value).slice(0, MAX_FEEDBACK_OBJECT_KEYS);
+    const sanitized = {};
+    for (const [key, entryValue] of entries) {
+      sanitized[key] = sanitizeFeedbackValue(entryValue, depth + 1, seen);
+    }
+    return sanitized;
+  }
+  return truncateFeedbackString(String(value));
+}
 var JobImplementation = class {
   id;
   client;
@@ -4996,9 +5104,20 @@ var JobImplementation = class {
   _resolveResult;
   _rejectResult;
   eventListeners = /* @__PURE__ */ new Map();
-  constructor(id, client) {
+  metadata;
+  constructor(id, client, initialState) {
     this.id = id;
     this.client = client;
+    this.metadata = {
+      source: "sdk",
+      status: "queued",
+      code: truncateFeedbackString(initialState.code),
+      domainRevision: initialState.domainRevision,
+      createdAt: initialState.createdAt,
+      stdout: [],
+      stderr: [],
+      toolCalls: []
+    };
     this._resultPromise = new Promise((resolve, reject) => {
       this._resolveResult = resolve;
       this._rejectResult = reject;
@@ -5006,69 +5125,98 @@ var JobImplementation = class {
     this.client.on("exec.completed", (data) => {
       const execData = data;
       if (execData.execId === id || execData.jobId === id) {
-        this.status = "succeeded";
-        this.emit("status", this.status);
         if (execData.error) {
-          this._rejectResult(execData.error);
+          this.finalize("failed", void 0, execData.error);
         } else {
-          this._resolveResult(execData.result);
+          this.finalize("succeeded", execData.result);
         }
+        this.emit("status", this.status);
       }
     });
     this.client.on("exec.progress", (data) => {
       const progressData = data;
       if (progressData.execId === id || progressData.jobId === id) {
         if (progressData.stdout) {
+          this.markStarted();
+          this.metadata.stdout = [...this.metadata.stdout, truncateFeedbackString(progressData.stdout)].slice(-100);
           this.emit("stdout", progressData.stdout);
         }
         if (progressData.stderr) {
+          this.markStarted();
+          this.metadata.stderr = [...this.metadata.stderr, truncateFeedbackString(progressData.stderr)].slice(-100);
           this.emit("stderr", progressData.stderr);
         }
       }
     });
     this.client.on(`job.${id}.status`, (status) => {
-      this.status = status;
-      this.emit("status", status);
+      const normalizedStatus = normalizeJobStatus(status);
+      this.status = normalizedStatus;
+      this.metadata.status = normalizedStatus;
+      if (normalizedStatus === "running") {
+        this.markStarted();
+      }
+      if (normalizedStatus === "failed" || normalizedStatus === "timeout" || normalizedStatus === "canceled") {
+        this.finalize(normalizedStatus);
+      }
+      if (normalizedStatus === "succeeded") {
+        this.finalize("succeeded");
+      }
+      this.emit("status", normalizedStatus);
     });
     this.client.on(`job.${id}.stdout`, (line) => {
+      this.markStarted();
+      this.metadata.stdout = [...this.metadata.stdout, truncateFeedbackString(String(line))].slice(-100);
       this.emit("stdout", line);
     });
     this.client.on(`job.${id}.stderr`, (line) => {
+      this.markStarted();
+      this.metadata.stderr = [...this.metadata.stderr, truncateFeedbackString(String(line))].slice(-100);
       this.emit("stderr", line);
     });
     this.client.on(`job.${id}.result`, (result) => {
-      this.status = "succeeded";
-      this._resolveResult(result);
+      this.finalize("succeeded", result);
     });
     this.client.on(`job.${id}.error`, (error) => {
-      this.status = "failed";
-      this._rejectResult(error);
+      this.finalize("failed", void 0, error);
     });
     this.client.on("job.completed", (data) => {
       const jobData = data;
       if (jobData.jobId === id) {
-        this.status = "succeeded";
+        this.finalize("succeeded", jobData.result);
         this.emit("status", this.status);
-        this._resolveResult(jobData.result);
       }
     });
     this.client.on("job.failed", (data) => {
       const jobData = data;
       if (jobData.jobId === id) {
-        this.status = "failed";
+        this.finalize("failed", void 0, jobData.error || new Error("Job failed"));
         this.emit("status", this.status);
-        this._rejectResult(jobData.error || new Error("Job failed"));
       }
     });
     this.client.on("tool.call.start", (data) => {
       const d = data;
       if (d.jobId === id) {
+        this.metadata.toolCalls = this.upsertToolCall({
+          callId: d.callId,
+          toolName: d.toolName,
+          input: sanitizeFeedbackValue(d.input),
+          startedAt: d.timestamp || Date.now()
+        });
         this.emit("toolCallStart", { callId: d.callId, toolName: d.toolName, input: d.input, timestamp: d.timestamp });
       }
     });
     this.client.on("tool.call.end", (data) => {
       const d = data;
       if (d.jobId === id) {
+        const completedAt = d.timestamp || Date.now();
+        this.metadata.toolCalls = this.upsertToolCall({
+          callId: d.callId,
+          toolName: d.toolName,
+          output: sanitizeFeedbackValue(d.result),
+          error: d.error ? truncateFeedbackString(d.error) : void 0,
+          completedAt,
+          durationMs: typeof d.durationMs === "number" ? d.durationMs : void 0
+        });
         this.emit("toolCallEnd", { callId: d.callId, toolName: d.toolName, result: d.result, error: d.error, durationMs: d.durationMs, timestamp: d.timestamp });
       }
     });
@@ -5076,12 +5224,87 @@ var JobImplementation = class {
   get result() {
     return this._resultPromise;
   }
+  async leaveFeedback(input) {
+    const sentiment = input.sentiment;
+    if (sentiment !== "good" && sentiment !== "bad") {
+      throw new Error('Job feedback sentiment must be "good" or "bad".');
+    }
+    const comment = typeof input.comment === "string" ? input.comment.trim() : "";
+    const response = await this.client.call("job.feedback", {
+      jobId: this.id,
+      sentiment,
+      comment: comment || void 0,
+      metadata: this.buildFeedbackMetadata()
+    });
+    this.emit("feedback", response);
+    return response;
+  }
   on(event, handler) {
     if (!this.eventListeners.has(event)) {
       this.eventListeners.set(event, []);
     }
     this.eventListeners.get(event).push(handler);
   }
+  buildFeedbackMetadata() {
+    const startedAt = this.metadata.startedAt;
+    const completedAt = this.metadata.completedAt;
+    return {
+      ...this.metadata,
+      durationMs: typeof startedAt === "number" && typeof completedAt === "number" ? completedAt - startedAt : this.metadata.durationMs ?? null,
+      stdout: [...this.metadata.stdout],
+      stderr: [...this.metadata.stderr],
+      toolCalls: this.metadata.toolCalls.slice(0, MAX_FEEDBACK_TOOL_CALLS).map((call) => ({ ...call }))
+    };
+  }
+  markStarted(timestamp = Date.now()) {
+    if (!this.metadata.startedAt) {
+      this.metadata.startedAt = timestamp;
+    }
+    if (this.status === "queued") {
+      this.status = "running";
+    }
+    if (this.metadata.status === "queued") {
+      this.metadata.status = "running";
+    }
+  }
+  finalize(status, result, error) {
+    if (!this.metadata.startedAt) {
+      this.metadata.startedAt = Date.now();
+    }
+    this.status = status;
+    this.metadata.status = status;
+    this.metadata.completedAt = this.metadata.completedAt || Date.now();
+    this.metadata.durationMs = this.metadata.completedAt - this.metadata.startedAt;
+    if (result !== void 0) {
+      this.metadata.result = sanitizeFeedbackValue(result);
+      this._resolveResult(result);
+    }
+    if (error !== void 0) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.metadata.error = truncateFeedbackString(message);
+      this._rejectResult(error);
+    }
+  }
+  upsertToolCall(next) {
+    const callId = next.callId || `tool-call-${Date.now()}`;
+    const existingIndex = this.metadata.toolCalls.findIndex((entry) => entry.callId === callId);
+    const existing = existingIndex >= 0 ? this.metadata.toolCalls[existingIndex] : void 0;
+    const merged = {
+      ...existing,
+      ...next,
+      callId,
+      toolName: next.toolName || existing?.toolName
+    };
+    if (merged.durationMs === void 0 && typeof merged.startedAt === "number" && typeof merged.completedAt === "number") {
+      merged.durationMs = merged.completedAt - merged.startedAt;
+    }
+    if (existingIndex >= 0) {
+      const updated = [...this.metadata.toolCalls];
+      updated[existingIndex] = merged;
+      return updated.slice(-MAX_FEEDBACK_TOOL_CALLS);
+    }
+    return [...this.metadata.toolCalls, merged].slice(-MAX_FEEDBACK_TOOL_CALLS);
+  }
   emit(event, data) {
     const handlers = this.eventListeners.get(event);
     if (handlers) {
@@ -5222,7 +5445,7 @@ function normalizeUser(user) {
     permissions: Array.isArray(user.permissions) ? user.permissions : []
   };
 }
-var Environment = class _Environment extends Session {
+var Environment = class extends Session {
   envData;
   _apiKey;
   _apiEndpoint;
@@ -5282,6 +5505,22 @@ var Environment = class _Environment extends Session {
       return this._apiEndpoint.replace(/\/orchestrator\/graphql$/, "").replace(/\/$/, "");
     }
   }
+  async controlPlaneRequest(path, options = {}) {
+    const runtimeBase = this.getRuntimeBaseUrl();
+    const url = `${runtimeBase}${path}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Authorization": `Bearer ${this._apiKey}`,
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Control Plane API Error (${response.status}): ${await response.text()}`);
+    }
+    return response.json();
+  }
   /**
    * Close the session and disconnect from the sandbox.
    *
@@ -5878,105 +6117,84 @@ var Environment = class _Environment extends Session {
    * ```
    */
   async recordObject(options) {
-    const { className, id, label, fields, relationships } = options;
-    const graphPath = _Environment.toGraphPath(className, id);
-    const existsResult = await this.graphql(
-      `query { model(path: "${graphPath}") { path } }`
+    const results = await this.recordObjects([options]);
+    return results[0];
+  }
+  /**
+   * 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.
+   */
+  async recordObjects(records) {
+    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 alreadyExists = !!existsResult.data?.model;
-    const instResult = await this.graphql(
-      `mutation {
-                at(path: "${className}") {
-                    instantiate(path: "${graphPath}"${label ? `, label: "${label}"` : ""}) {
-                        model { path }
-                    }
-                }
-            }`
+    return Array.isArray(response.items) ? response.items : [];
+  }
+  /**
+   * Queue a background record import for this environment.
+   */
+  async enqueueRecordImport(records, options = {}) {
+    return this.controlPlaneRequest(
+      `/control/environments/${this.environmentId}/record-imports`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          records,
+          batchSize: options.batchSize
+        })
+      }
     );
-    if (instResult.errors?.length) {
-      throw new Error(`recordObject instantiate failed: ${instResult.errors[0].message}`);
-    }
-    const instancePath = instResult.data?.at?.instantiate?.model?.path ?? graphPath;
-    await this.graphql(
-      `mutation {
-                at(path: "${instancePath}") {
-                    create_submodel(subpath: "_realId", label: "_realId") {
-                        model { path }
-                    }
-                }
-            }`
+  }
+  /**
+   * List queued or completed record imports for this environment.
+   */
+  async listRecordImports(status) {
+    const suffix = status ? `?status=${encodeURIComponent(status)}` : "";
+    const response = await this.controlPlaneRequest(
+      `/control/environments/${this.environmentId}/record-imports${suffix}`
     );
-    await this.graphql(
-      `mutation {
-                at(path: "${instancePath}") {
-                    at(submodel: "_realId") {
-                        set_string_value(value: "${id.replace(/"/g, '\\"')}") { done }
-                    }
-                }
-            }`
+    return Array.isArray(response.items) ? response.items : [];
+  }
+  /**
+   * Fetch the latest aggregate import counters for this environment.
+   */
+  async getRecordImportSummary() {
+    return this.controlPlaneRequest(
+      `/control/environments/${this.environmentId}/record-imports/summary`
     );
-    if (fields) {
-      for (const [fieldName, value] of Object.entries(fields)) {
-        if (value === null) continue;
-        await this.graphql(
-          `mutation {
-                        at(path: "${instancePath}") {
-                            create_submodel(subpath: "${fieldName}", label: "${fieldName}") {
-                                model { path }
-                            }
-                        }
-                    }`
-        );
-        if (typeof value === "string") {
-          await this.graphql(
-            `mutation {
-                            at(path: "${instancePath}") {
-                                at(submodel: "${fieldName}") {
-                                    set_string_value(value: "${value.replace(/"/g, '\\"')}") { done }
-                                }
-                            }
-                        }`
-          );
-        } else if (typeof value === "number") {
-          await this.graphql(
-            `mutation {
-                            at(path: "${instancePath}") {
-                                at(submodel: "${fieldName}") {
-                                    set_number_value(value: ${value}) { done }
-                                }
-                            }
-                        }`
-          );
-        } else if (typeof value === "boolean") {
-          await this.graphql(
-            `mutation {
-                            at(path: "${instancePath}") {
-                                at(submodel: "${fieldName}") {
-                                    set_boolean_value(value: ${value}) { done }
-                                }
-                            }
-                        }`
-          );
-        }
-      }
-    }
-    if (relationships) {
-      const rels = await this.getRelationships(className);
-      const relMap = {};
-      for (const rel of rels) {
-        const submodelLeaf = rel.local_submodel.path.includes(":") ? rel.local_submodel.path.split(":").pop() : rel.local_submodel.path;
-        relMap[submodelLeaf] = rel.foreign_model.path;
-      }
-      for (const [submodelName, targets] of Object.entries(relationships)) {
-        const foreignClass = relMap[submodelName];
-        const targetList = Array.isArray(targets) ? targets : [targets];
-        for (const target of targetList) {
-          const targetGraphPath = foreignClass ? _Environment.toGraphPath(foreignClass, target) : target;
-          await this.attach(instancePath, submodelName, targetGraphPath);
-        }
+  }
+  /**
+   * Convenience helper returning queued + processing records for this environment.
+   */
+  async getAwaitingRecordCount() {
+    const summary = await this.getRecordImportSummary();
+    return summary.awaitingRecords;
+  }
+  /**
+   * Fetch a single record import by id.
+   */
+  async getRecordImport(importId) {
+    return this.controlPlaneRequest(`/control/record-imports/${importId}`);
+  }
+  /**
+   * Cancel a queued/background record import.
+   */
+  async cancelRecordImport(importId) {
+    return this.controlPlaneRequest(
+      `/control/record-imports/${importId}/cancel`,
+      {
+        method: "POST"
       }
-    }
-    return { path: instancePath, id, created: !alreadyExists };
+    );
   }
   // ==================== PUBLISH TOOLS ====================
   /**