@granular-software/sdk 0.4.23 → 0.4.25

package/dist/agent-evals.mjs

@@ -4547,6 +4547,7 @@ var Session = class {
   client;
   clientId;
   jobsMap = /* @__PURE__ */ new Map();
+  pendingAgentMessagesByJobId = /* @__PURE__ */ new Map();
   eventListeners = /* @__PURE__ */ new Map();
   toolHandlers = /* @__PURE__ */ new Map();
   /** Tracks which tools are instance methods (className set, not static) */
@@ -4704,6 +4705,15 @@ var Session = class {
       createdAt: Date.now()
     });
     this.jobsMap.set(result.jobId, job);
+    const pendingAgentMessages = this.pendingAgentMessagesByJobId.get(
+      result.jobId
+    );
+    if (pendingAgentMessages && pendingAgentMessages.length > 0) {
+      this.pendingAgentMessagesByJobId.delete(result.jobId);
+      for (const message of pendingAgentMessages) {
+        job.replayAgentMessage(message);
+      }
+    }
     return job;
   }
   /**
@@ -5105,6 +5115,22 @@ import { ${allImports} } from "./sandbox-tools";
     this.client.on("job.status", (data) => {
       this.emit("job:status", data);
     });
+    this.client.on("job.agent_message", (data) => {
+      const normalized = normalizeJobAgentMessageEnvelope(data);
+      if (!normalized) return;
+      if (this.jobsMap.has(normalized.jobId)) return;
+      const pending = this.pendingAgentMessagesByJobId.get(normalized.jobId) || [];
+      if (normalized.message.messageId && pending.some(
+        (message) => message.messageId === normalized.message.messageId
+      )) {
+        return;
+      }
+      pending.push(normalized.message);
+      this.pendingAgentMessagesByJobId.set(
+        normalized.jobId,
+        pending.slice(-25)
+      );
+    });
     this.client.on("exec.completed", (data) => {
       this.emit("exec:completed", data);
     });
@@ -5229,6 +5255,22 @@ function sanitizeFeedbackValue(value, depth = 0, seen = /* @__PURE__ */ new Weak
   }
   return truncateFeedbackString(String(value));
 }
+function normalizeJobAgentMessageEnvelope(data) {
+  const d = data;
+  if (typeof d?.jobId !== "string" || !d.jobId) {
+    return null;
+  }
+  return {
+    jobId: d.jobId,
+    message: {
+      messageId: d.messageId,
+      kind: d.kind === "artifacts" ? "artifacts" : "text",
+      reply: typeof d.reply === "string" ? d.reply : "",
+      show: d.show,
+      timestamp: d.timestamp || Date.now()
+    }
+  };
+}
 var JobImplementation = class {
   id;
   client;
@@ -5237,6 +5279,8 @@ var JobImplementation = class {
   _resolveResult;
   _rejectResult;
   eventListeners = /* @__PURE__ */ new Map();
+  bufferedAgentMessages = [];
+  bufferedAgentMessageIds = /* @__PURE__ */ new Set();
   metadata;
   constructor(id, client, initialState) {
     this.id = id;
@@ -5395,14 +5439,9 @@ var JobImplementation = class {
       }
     });
     this.client.on("job.agent_message", (data) => {
-      const d = data;
-      if (d.jobId === id) {
-        this.emit("agentMessage", {
-          messageId: d.messageId,
-          reply: typeof d.reply === "string" ? d.reply : "",
-          show: d.show,
-          timestamp: d.timestamp || Date.now()
-        });
+      const normalized = normalizeJobAgentMessageEnvelope(data);
+      if (normalized?.jobId === id) {
+        this.captureAgentMessage(normalized.message);
       }
     });
   }
@@ -5429,6 +5468,14 @@ var JobImplementation = class {
       this.eventListeners.set(event, []);
     }
     this.eventListeners.get(event).push(handler);
+    if (event === "agentMessage" && this.bufferedAgentMessages.length > 0) {
+      for (const message of this.bufferedAgentMessages) {
+        handler(message);
+      }
+    }
+  }
+  replayAgentMessage(message) {
+    this.captureAgentMessage(message);
   }
   buildFeedbackMetadata() {
     const startedAt = this.metadata.startedAt;
@@ -5498,6 +5545,18 @@ var JobImplementation = class {
       handlers.forEach((h) => h(data));
     }
   }
+  captureAgentMessage(message) {
+    if (message.messageId && this.bufferedAgentMessageIds.has(message.messageId)) {
+      return;
+    }
+    if (message.messageId) {
+      this.bufferedAgentMessageIds.add(message.messageId);
+    }
+    this.bufferedAgentMessages = [...this.bufferedAgentMessages, message].slice(
+      -25
+    );
+    this.emit("agentMessage", message);
+  }
 };
 
 // src/endpoints.ts
@@ -13552,14 +13611,22 @@ function reviewGeneratedJobCode(code) {
       }
     }
   }
-  const hasConversationalReturn = /return\s+[`'"]/.test(normalized) || /\breply\s*:/.test(normalized) || /\bagent_message\s*\(/.test(normalized);
+  const hasConversationalReturn = /return\s+[`'"]/.test(normalized) || /\breply\s*:/.test(normalized) || /\bagent_message\s*\(/.test(normalized) || /\bagent_text_message\s*\(/.test(normalized);
   const returnsObjectLiteral = /return\s+\{[\s\S]*?\}/.test(normalized);
+  const returnsShowPayload = /return\s+\{[\s\S]*?\bshow\s*:/.test(normalized);
   const closesLoop = /loop\.close_loop\s*\(/.test(normalized);
   if (!hasConversationalReturn && returnsObjectLiteral && !closesLoop) {
     issues.push({
       code: "missing_user_reply",
       severity: "error",
-      message: "User-facing jobs must end with a natural-language answer. Return a short string, an object with a top-level `reply` string, or use agent_message({ reply, show }). Do not end with bare structured JSON."
+      message: "User-facing jobs must end with a natural-language answer. Return a short string, an object with a top-level `reply` string, or post text with agent_text_message(...). Do not end with bare structured JSON."
+    });
+  }
+  if (returnsShowPayload) {
+    issues.push({
+      code: "return_show_not_for_ui",
+      severity: "error",
+      message: "Do not use the final return value to send UI record refs through `show`. Use agent_heap_objects(...) for heap-backed UI, then return plain text if you still want a final textual answer."
     });
   }
   return issues;
@@ -14404,7 +14471,7 @@ ${loopBlock}
 
 \u2500\u2500\u2500 CODE RULES \u2500\u2500\u2500
 - Import from \`./sandbox-tools\`.
-- If you use \`heap\`, \`loop\`, or \`agent_message\`, import them explicitly from \`./sandbox-tools\`.
+- If you use \`heap\`, \`loop\`, \`agent_text_message\`, \`agent_heap_objects\`, or legacy \`agent_message\`, import them explicitly from \`./sandbox-tools\`.
 - Write top-level executable code with \`await\` at top level.
 - The generated job body must be plain runnable JavaScript. The DOMAIN TYPES block is only a reference for shapes and available methods.
 - Do not write TypeScript-only syntax in executable code: no type annotations, no interfaces, no enums, no \`as Type\` casts, no \`satisfies\`, and no generic type parameters in code.
@@ -14413,9 +14480,9 @@ ${loopBlock}
 - Never invent helper methods such as \`find(...)\` or unsupported parameters such as \`id\` when the typedefs require \`path\`.
 - Use \`ClassName.get({ path })\` only when you already know an object's graph path.
 - Use \`ClassName.count()\` when you only need a total.
-- Use \`ClassName.page({ page, perPage, saveAs })\` when you need both records and pagination metadata like \`totalCount\` or \`hasMore\`.
-- Use \`ClassName.list({ page, perPage, saveAs })\` to load one typed page of records. \`limit\` is only a legacy alias for \`perPage\`.
-- Use \`for await (const item of ClassName.iterate({ perPage, maxItems }))\` for large batch jobs so you do not materialize the whole result set at once.
+- Use \`ClassName.page({ page, perPage, saveAs })\` when you need both records and pagination metadata like \`totalCount\` or \`hasMore\`. \`perPage\` defaults to \`100\` and larger values are clamped to \`100\`.
+- Use \`ClassName.list({ page, perPage, saveAs })\` to load one typed page of records. \`limit\` is only a legacy alias for \`perPage\`, \`perPage\` defaults to \`100\`, and larger values are clamped to \`100\`.
+- Use \`for await (const item of ClassName.iterate({ perPage, maxItems }))\` for large batch jobs so you do not materialize the whole result set at once. \`perPage\` defaults to \`100\` and larger values are clamped to \`100\`.
 - Instance methods: \`await instance.method_name(params)\`.
 - Static methods: \`await ClassName.static_method(params)\`.
 - Global effects: \`await effect_name(params)\`.
@@ -14446,21 +14513,31 @@ ${loopBlock}
   - \`loop.close_loop(...)\`: record the current workflow outcome with a short summary before stopping. Do not call it in the same job that opens a new user prompt unless the workflow is explicitly blocked. This does not end the session forever.
 - Avoid \`as any\` and other broad casts when the DOMAIN TYPES block already tells you the correct class or list type.
 - Prefer manipulating heap-backed instances and typed lists instead of returning raw JSON blobs or object IDs unless the user explicitly asks for them.
-- If the user expects an answer after the job runs, the final \`return\` value must be either a short natural-language string or an object with a top-level \`reply\` string.
-- You may call \`agent_message(...)\` multiple times in one job to post several assistant messages while the job is still running.
-- Prefer \`agent_message({ reply, show })\` when you want to leave a user-facing answer and optionally show heap-backed records in the UI.
-- \`agent_message(...)\` also accepts \`content\`, \`message\`, or \`text\` instead of \`reply\`.
-- \`agent_message({ show })\` may receive explicit refs or sandbox instances and arrays of sandbox instances. The runtime will convert those into UI references.
-- When it helps the UI show specific heap-backed results, you may instead return:
-  \`{ reply: string, show: { entryPaths?: string[], listNames?: string[], variableNames?: string[] } }\`
-- If you create or load objects the user should see, save them in the heap and return references to them through \`show\` instead of serializing full objects.
+- Every job that intends to answer the user must emit at least one explicit UI message with \`agent_text_message(...)\` and/or \`agent_heap_objects(...)\`.
+- Use \`agent_text_message("...")\` for all user-visible text shown in the UI.
+- Use \`agent_heap_objects(...)\` only when you want the UI to render heap-backed records or lists.
+- If you want to show both text and records, call \`agent_text_message(...)\` and \`agent_heap_objects(...)\` separately in whatever order fits the interaction.
+- \`agent_text_message(...)\` should be used with a plain text string in normal generated code.
+- \`agent_heap_objects(...)\` should point at heap-backed values: explicit \`entryPaths\` / \`listNames\` / \`variableNames\`, a named list saved with \`saveAs\`, or values read back from \`heap.getVar(...)\`.
+- If you just fetched records and want to show them in the UI, save or reference them through the heap first, then call \`agent_heap_objects(...)\`. Do not try to hand-build UI payloads in job code.
+- Do not assume heap changes will be displayed automatically. If records should appear in the UI, you must call \`agent_heap_objects(...)\`.
+- Never write \`return { reply, show }\` or \`return { show: ... }\` for UI. If you want the UI to render records or lists, call \`agent_heap_objects(...)\` instead.
+- Do not rely on the final return value for user-visible output. A plain return value is not considered a displayed UI answer.
+- \`agent_message(...)\` remains available as a legacy compatibility alias, but prefer \`agent_text_message(...)\` and \`agent_heap_objects(...)\` in new code.
 - Do not return bare structured JSON, low-level diagnostics, or database-shaped payloads as the final answer unless the user explicitly asks for them.
 - Prefer simple executable JavaScript over clever interpolation. Avoid nested template literals or unusually dense inline expressions when a small temporary variable or string concatenation would be clearer and safer.
 - Use \`console.log()\` only for intermediate diagnostics, not for the final user-facing answer.`;
 }
 
 // src/job-presentation.ts
-var RESPONSE_KEYS = ["reply", "response", "text", "message", "summary", "answer"];
+var RESPONSE_KEYS = [
+  "reply",
+  "response",
+  "text",
+  "message",
+  "summary",
+  "answer"
+];
 var ENTRY_KEY_CANDIDATES = ["entryPath", "path"];
 var ENTRY_ARRAY_KEY_CANDIDATES = ["entryPaths", "paths"];
 var LIST_KEY_CANDIDATES = ["listName"];
@@ -14502,15 +14579,22 @@ function pushStringArray(target, value) {
   }
 }
 function collectReferencesFromRecord(record, refs) {
-  for (const key of ENTRY_KEY_CANDIDATES) pushString(refs.entryPaths, record[key]);
-  for (const key of ENTRY_ARRAY_KEY_CANDIDATES) pushStringArray(refs.entryPaths, record[key]);
-  for (const key of LIST_KEY_CANDIDATES) pushString(refs.listNames, record[key]);
-  for (const key of LIST_ARRAY_KEY_CANDIDATES) pushStringArray(refs.listNames, record[key]);
-  for (const key of VARIABLE_KEY_CANDIDATES) pushString(refs.variableNames, record[key]);
-  for (const key of VARIABLE_ARRAY_KEY_CANDIDATES) pushStringArray(refs.variableNames, record[key]);
+  for (const key of ENTRY_KEY_CANDIDATES)
+    pushString(refs.entryPaths, record[key]);
+  for (const key of ENTRY_ARRAY_KEY_CANDIDATES)
+    pushStringArray(refs.entryPaths, record[key]);
+  for (const key of LIST_KEY_CANDIDATES)
+    pushString(refs.listNames, record[key]);
+  for (const key of LIST_ARRAY_KEY_CANDIDATES)
+    pushStringArray(refs.listNames, record[key]);
+  for (const key of VARIABLE_KEY_CANDIDATES)
+    pushString(refs.variableNames, record[key]);
+  for (const key of VARIABLE_ARRAY_KEY_CANDIDATES)
+    pushStringArray(refs.variableNames, record[key]);
 }
 function scanForHeapReferences(value, heap, refs, depth = 0, seen = /* @__PURE__ */ new Set()) {
-  if (value === null || value === void 0 || depth > 4 || seen.has(value)) return;
+  if (value === null || value === void 0 || depth > 4 || seen.has(value))
+    return;
   if (typeof value === "string") {
     const trimmed = value.trim();
     if (heap.entriesByPath?.[trimmed]) refs.entryPaths.add(trimmed);
@@ -14606,12 +14690,16 @@ function fallbackResponseText(entries, lists) {
 }
 function getJobRelatedEntries(heap, jobId) {
   return sortEntries(
-    Object.values(heap.entriesByPath || {}).filter((entry) => entry.relatedJobIds?.includes(jobId))
+    Object.values(heap.entriesByPath || {}).filter(
+      (entry) => entry.relatedJobIds?.includes(jobId)
+    )
   );
 }
 function getJobRelatedLists(heap, jobId) {
   return sortLists(
-    Object.values(heap.listsByName || {}).filter((list) => list.relatedJobIds?.includes(jobId))
+    Object.values(heap.listsByName || {}).filter(
+      (list) => list.relatedJobIds?.includes(jobId)
+    )
   );
 }
 function entriesFromLists(lists, heap) {
@@ -14628,15 +14716,18 @@ function resolveJobPresentation({
   jobId,
   result,
   stdout = [],
-  sessionHeap
+  sessionHeap,
+  allowExplicitArtifacts = true
 }) {
   const refs = {
     entryPaths: /* @__PURE__ */ new Set(),
     listNames: /* @__PURE__ */ new Set(),
     variableNames: /* @__PURE__ */ new Set()
   };
-  scanForHeapReferences(result, sessionHeap, refs);
-  resolveVariablesToReferences(refs.variableNames, sessionHeap, refs);
+  if (allowExplicitArtifacts) {
+    scanForHeapReferences(result, sessionHeap, refs);
+    resolveVariablesToReferences(refs.variableNames, sessionHeap, refs);
+  }
   const referencedLists = sortLists(
     [...refs.listNames].map((name) => sessionHeap.listsByName?.[name]).filter((list) => Boolean(list))
   );
@@ -14649,20 +14740,22 @@ function resolveJobPresentation({
     ...jobEntries,
     ...entriesFromLists(jobLists, sessionHeap)
   ]);
-  const lists = dedupeLists([...referencedLists, ...jobLists]);
-  const entries = dedupeEntries([
+  const explicitLists = dedupeLists(referencedLists);
+  const explicitEntries = dedupeEntries([
     ...referencedEntries,
-    ...entriesFromLists(referencedLists, sessionHeap),
-    ...jobEntries,
-    ...entriesFromLists(jobLists, sessionHeap)
+    ...entriesFromLists(referencedLists, sessionHeap)
   ]);
+  const hasExplicitArtifacts = allowExplicitArtifacts && (explicitEntries.length > 0 || explicitLists.length > 0);
+  const lists = hasExplicitArtifacts ? explicitLists : jobLists;
+  const entries = hasExplicitArtifacts ? explicitEntries : changedEntries;
   const responseText = extractResponseText(result, stdout) || fallbackResponseText(entries, lists);
   return {
     responseText,
     entries,
     lists,
     changedEntries,
-    changedLists: jobLists
+    changedLists: jobLists,
+    hasExplicitArtifacts
   };
 }