@elevasis/sdk 1.44.3 → 1.45.0

package/dist/worker/index.js

@@ -2465,6 +2465,23 @@ var Workflow = class {
 
 // ../core/src/execution/engine/agent/observability/logging.ts
 function createAgentLogger(logger, agentId, sessionId) {
+  function emitAction(actionType, message, iteration, startTime, endTime, duration) {
+    const event = {
+      type: "agent",
+      agentId,
+      lifecycle: "iteration",
+      eventType: "action",
+      iteration,
+      actionType,
+      startTime,
+      endTime,
+      duration,
+      data: { message },
+      ...sessionId && { sessionId }
+      // Include sessionId if present
+    };
+    logger.info("action", event);
+  }
   return {
     lifecycle(lifecycle, stage, data) {
       let event;
@@ -2531,21 +2548,15 @@ function createAgentLogger(logger, agentId, sessionId) {
       logger.info("reasoning", event);
     },
     action(actionType, message, iteration, startTime, endTime, duration) {
-      const event = {
-        type: "agent",
-        agentId,
-        lifecycle: "iteration",
-        eventType: "action",
-        iteration,
-        actionType,
-        startTime,
-        endTime,
-        duration,
-        data: { message },
-        ...sessionId && { sessionId }
-        // Include sessionId if present
-      };
-      logger.info("action", event);
+      emitAction(actionType, message, iteration, startTime, endTime, duration);
+    },
+    async timed(actionType, iteration, work, message) {
+      const startTime = Date.now();
+      const result = await work();
+      const endTime = Date.now();
+      const resolvedActionType = typeof actionType === "function" ? actionType(result) : actionType;
+      emitAction(resolvedActionType, message(result), iteration, startTime, endTime, endTime - startTime);
+      return result;
     },
     toolCall(toolName, iteration, startTime, endTime, duration, success, error, input, output) {
       const event = {
@@ -3443,66 +3454,21 @@ async function processReasoning(iterationContext) {
     reasoning: response.reasoning
   });
   iterationContext.logger.reasoning(response.reasoning, iterationContext.iteration, startTime, endTime, duration);
-  const memoryStartTime = Date.now();
-  iterationContext.memoryManager.addToHistory({
-    type: "reasoning",
-    content: response.reasoning,
-    turnNumber: iterationContext.executionContext.sessionTurnNumber ?? null,
-    iterationNumber: iterationContext.iteration,
-    source: "model"
-  });
-  const memoryEndTime = Date.now();
-  const memoryDuration = memoryEndTime - memoryStartTime;
-  iterationContext.logger.action(
+  await iterationContext.logger.timed(
     "memory-reasoning",
-    `Stored reasoning (${response.reasoning.length} chars), history size: ${iterationContext.memoryManager.getHistoryLength()}, actions: ${response.nextActions.map((a) => a.type).join(", ")}`,
     iterationContext.iteration,
-    memoryStartTime,
-    memoryEndTime,
-    memoryDuration
+    () => iterationContext.memoryManager.addToHistory({
+      type: "reasoning",
+      content: response.reasoning,
+      turnNumber: iterationContext.executionContext.sessionTurnNumber ?? null,
+      iterationNumber: iterationContext.iteration,
+      source: "model"
+    }),
+    () => `Stored reasoning (${response.reasoning.length} chars), history size: ${iterationContext.memoryManager.getHistoryLength()}, actions: ${response.nextActions.map((a) => a.type).join(", ")}`
   );
   return response;
 }
 
-// ../core/src/execution/engine/agent/memory/domains.ts
-var MEMORY_DOMAINS = {
-  /**
-   * Tool-owned keys
-   * Updated automatically by tools as side effects
-   * LLM cannot modify these via memoryOps
-   *
-   * Tools manage complex structured data (caches, indexes, etc.)
-   * that would be error-prone for LLM to update via JSON strings.
-   *
-   * No tool currently writes these three keys, so in practice the guard reserves the names
-   * against the LLM rather than arbitrating a live conflict. That is still enforcement --
-   * see `validateMemoryKeyOwnership` in `./utils` -- not dead code.
-   */
-  TOOL_OWNED: [
-    "notion-pages-cache",
-    // Notion tools manage page hierarchy
-    "github-repo-cache",
-    // GitHub tools manage repository structure
-    "slack-channel-cache"
-    // Slack tools manage channel data
-  ]
-  /**
-   * LLM-owned keys
-   * All keys NOT in TOOL_OWNED
-   * Managed via memoryOps by agent reasoning
-   *
-   * LLM manages semantic memory (business context, decisions, etc.)
-   * that requires understanding and judgment.
-   */
-};
-function isToolOwnedKey(key) {
-  return MEMORY_DOMAINS.TOOL_OWNED.includes(key);
-}
-function getKeyOwner(key) {
-  if (isToolOwnedKey(key)) return "tool";
-  return "llm";
-}
-
 // ../core/src/execution/engine/agent/memory/utils.ts
 function addToolError(memoryManager, action, errorMessage, iteration, turnNumber = null, metadata) {
   memoryManager.addToHistory({
@@ -3526,11 +3492,10 @@ function addToolError(memoryManager, action, errorMessage, iteration, turnNumber
   });
 }
 function validateMemoryKeyOwnership(key, logger, iteration) {
-  if (isToolOwnedKey(key)) {
-    const owner = getKeyOwner(key);
+  if (key.startsWith("_")) {
     logger.action(
       "memory-set-rejected",
-      `Rejected LLM update to ${owner}-managed key: ${key}`,
+      `Rejected LLM update to framework-reserved key: ${key}`,
       iteration,
       Date.now(),
       Date.now(),
@@ -3772,25 +3737,19 @@ async function executeToolCall(iterationContext, action) {
       action.input,
       boundedResult
     );
-    const memoryStartTime = Date.now();
     const memoryContent = typeof boundedResult === "string" ? boundedResult : JSON.stringify(boundedResult);
-    iterationContext.memoryManager.addToHistory({
-      type: "tool-result",
-      content: memoryContent,
-      toolName: action.name,
-      turnNumber: iterationContext.executionContext.sessionTurnNumber ?? null,
-      iterationNumber: iterationContext.iteration,
-      source: "tool"
-    });
-    const memoryEndTime = Date.now();
-    const memoryDuration = memoryEndTime - memoryStartTime;
-    iterationContext.logger.action(
+    await iterationContext.logger.timed(
       "memory-tool-result",
-      `Stored tool-result for ${action.name} (${memoryContent.length} chars), history size: ${iterationContext.memoryManager.getHistoryLength()}`,
       iterationContext.iteration,
-      memoryStartTime,
-      memoryEndTime,
-      memoryDuration
+      () => iterationContext.memoryManager.addToHistory({
+        type: "tool-result",
+        content: memoryContent,
+        toolName: action.name,
+        turnNumber: iterationContext.executionContext.sessionTurnNumber ?? null,
+        iterationNumber: iterationContext.iteration,
+        source: "tool"
+      }),
+      () => `Stored tool-result for ${action.name} (${memoryContent.length} chars), history size: ${iterationContext.memoryManager.getHistoryLength()}`
     );
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -3813,29 +3772,25 @@ async function executeToolCall(iterationContext, action) {
       action.input,
       void 0
     );
-    const memoryStartTime = Date.now();
-    const metadata = error instanceof ToolingError ? {
-      errorType: error.errorType,
-      severity: error.severity,
-      isRetryable: error.isRetryable()
-    } : void 0;
-    addToolError(
-      iterationContext.memoryManager,
-      action,
-      errorMessage,
-      iterationContext.iteration,
-      iterationContext.executionContext.sessionTurnNumber ?? null,
-      metadata
-    );
-    const memoryEndTime = Date.now();
-    const memoryDuration = memoryEndTime - memoryStartTime;
-    iterationContext.logger.action(
+    await iterationContext.logger.timed(
       "memory-tool-error",
-      `Stored error for ${action.name}: ${errorMessage}, history size: ${iterationContext.memoryManager.getHistoryLength()}`,
       iterationContext.iteration,
-      memoryStartTime,
-      memoryEndTime,
-      memoryDuration
+      () => {
+        const metadata = error instanceof ToolingError ? {
+          errorType: error.errorType,
+          severity: error.severity,
+          isRetryable: error.isRetryable()
+        } : void 0;
+        addToolError(
+          iterationContext.memoryManager,
+          action,
+          errorMessage,
+          iterationContext.iteration,
+          iterationContext.executionContext.sessionTurnNumber ?? null,
+          metadata
+        );
+      },
+      () => `Stored error for ${action.name}: ${errorMessage}, history size: ${iterationContext.memoryManager.getHistoryLength()}`
     );
   }
 }
@@ -4073,11 +4028,13 @@ async function processMemory(memoryManager, response, logger, iteration) {
       if (!validateMemoryKeyOwnership(key, logger, iteration)) {
         continue;
       }
-      const startTime = Date.now();
-      const stringValue = typeof content === "string" ? content : JSON.stringify(content);
-      memoryManager.set(key, stringValue);
-      const endTime = Date.now();
-      logger.action("memory-set", `Set: ${key}`, iteration, startTime, endTime, endTime - startTime);
+      await logger.timed(
+        "memory-set",
+        iteration,
+        // Auto-stringify non-string values (arrays, objects, etc.)
+        () => memoryManager.set(key, typeof content === "string" ? content : JSON.stringify(content)),
+        () => `Set: ${key}`
+      );
     }
   }
   if (memoryOps.delete) {
@@ -4085,21 +4042,12 @@ async function processMemory(memoryManager, response, logger, iteration) {
       if (!validateMemoryKeyOwnership(key, logger, iteration)) {
         continue;
       }
-      const startTime = Date.now();
-      const deleted = memoryManager.delete(key);
-      const endTime = Date.now();
-      if (deleted) {
-        logger.action("memory-delete", `Deleted: ${key}`, iteration, startTime, endTime, endTime - startTime);
-      } else {
-        logger.action(
-          "memory-delete-missing",
-          `Attempted to delete non-existent key: ${key}`,
-          iteration,
-          startTime,
-          endTime,
-          endTime - startTime
-        );
-      }
+      await logger.timed(
+        (deleted) => deleted ? "memory-delete" : "memory-delete-missing",
+        iteration,
+        () => memoryManager.delete(key),
+        (deleted) => deleted ? `Deleted: ${key}` : `Attempted to delete non-existent key: ${key}`
+      );
     }
   }
 }
@@ -4226,7 +4174,6 @@ var MemoryManager = class {
     this.constraints = constraints;
     this.logger = logger;
   }
-  cachedSnapshot;
   /**
    * Rolling correction for `estimateTokens`'s bias, learned from real provider usage.
    * `undefined` until the first `recordActualUsage` call -- the cold-start state, where
@@ -4515,21 +4462,15 @@ var MemoryManager = class {
     };
   }
   /**
-   * Create memory snapshot for persistence
-   * Caches snapshot internally for later retrieval
+   * Create a memory snapshot for persistence.
+   *
+   * Stateless: every call returns a fresh `structuredClone` of the current memory, so the caller
+   * owns caching if it needs to hold onto the result across calls (see `Agent.memorySnapshot`).
+   *
    * @returns Deep copy of current memory state
    */
-  toSnapshot() {
-    this.cachedSnapshot = structuredClone(this.memory);
-    return this.cachedSnapshot;
-  }
-  /**
-   * Get cached memory snapshot
-   * Returns snapshot created by toSnapshot()
-   * @returns Cached snapshot (undefined if toSnapshot() not called yet)
-   */
-  getSnapshot() {
-    return this.cachedSnapshot;
+  snapshot() {
+    return structuredClone(this.memory);
   }
   /**
    * Build the framework framing and the untrusted data envelope for an LLM call.
@@ -4661,6 +4602,12 @@ var Agent = class {
    * reading memory history after the fact, because the emit is the user-visible event and memory
    * can be compacted or restructured without changing whether the turn spoke. */
   spokeThisTurn = false;
+  /** Cached result of `memoryManager.snapshot()` -- `MemoryManager.snapshot()` itself is stateless
+   * (a fresh `structuredClone` every call), so caching the LAST one taken is this class's job. Set
+   * once, in the `finally` around `iterate()` and again in `complete()` -- see `getMemorySnapshot()`
+   * for why `undefined`-before-first-iteration is a contract other callers (`session.ts`, the SDK
+   * worker) depend on. */
+  memorySnapshot;
   /**
    * Create a new agent instance from definition
    * Memory will be initialized during execution
@@ -4701,7 +4648,7 @@ var Agent = class {
         try {
           await this.iterate(this.executionContext);
         } finally {
-          this.memoryManager.toSnapshot();
+          this.memorySnapshot = this.memoryManager.snapshot();
         }
       }
       const output = await this.complete();
@@ -4814,22 +4761,21 @@ var Agent = class {
   async initializeMemoryManager(context) {
     const memory = await this.resolveInitialMemory(context);
     const memoryManager = new MemoryManager(memory, this.config.constraints, this.logger);
-    const inputStartTime = Date.now();
-    memoryManager.addToHistory({
-      type: "input",
-      content: this.currentInput,
-      turnNumber: context.sessionTurnNumber ?? null,
-      iterationNumber: 0,
-      source: "user"
-    });
-    const inputEndTime = Date.now();
-    this.logger.action(
+    await this.logger.timed(
       "memory-input",
-      `Added input entry to history`,
       0,
-      inputStartTime,
-      inputEndTime,
-      inputEndTime - inputStartTime
+      // Kept in history even though the input also travels as its own message: history is what
+      // later iterations and later turns read, and `autoCompact` anchors on `history[0]` as the
+      // original input. `toContextParts` excludes this entry from the current turn's envelope so
+      // the model does not see the same text twice.
+      () => memoryManager.addToHistory({
+        type: "input",
+        content: this.currentInput,
+        turnNumber: context.sessionTurnNumber ?? null,
+        iterationNumber: 0,
+        source: "user"
+      }),
+      () => `Added input entry to history`
     );
     flowLog("agent.initialize", {
       resourceId: this.config.resourceId,
@@ -4851,32 +4797,20 @@ var Agent = class {
    */
   async resolveInitialMemory(context) {
     if (this.initialMemory) {
-      const restoreStartTime = Date.now();
-      const memory = structuredClone(this.initialMemory);
-      const restoreEndTime = Date.now();
-      this.logger.action(
+      return this.logger.timed(
         "memory-restore",
-        `Restored ${Object.keys(memory.sessionMemory).length} session memory entries`,
         0,
-        restoreStartTime,
-        restoreEndTime,
-        restoreEndTime - restoreStartTime
+        () => structuredClone(this.initialMemory),
+        (memory) => `Restored ${Object.keys(memory.sessionMemory).length} session memory entries`
       );
-      return memory;
     }
     if (this.definition.preloadMemory) {
-      const preloadStartTime = Date.now();
-      const memory = await this.definition.preloadMemory(context);
-      const preloadEndTime = Date.now();
-      this.logger.action(
+      return this.logger.timed(
         "memory-preload",
-        `Preloaded ${Object.keys(memory.sessionMemory).length} session memory entries`,
         0,
-        preloadStartTime,
-        preloadEndTime,
-        preloadEndTime - preloadStartTime
+        () => this.definition.preloadMemory(context),
+        (memory) => `Preloaded ${Object.keys(memory.sessionMemory).length} session memory entries`
       );
-      return memory;
     }
     return { sessionMemory: {}, history: [] };
   }
@@ -5010,8 +4944,8 @@ var Agent = class {
           0
         );
       }
-      this.memoryManager.toSnapshot();
-      const snapshot = this.memoryManager.getSnapshot();
+      const snapshot = this.memoryManager.snapshot();
+      this.memorySnapshot = snapshot;
       const completionEndTime = Date.now();
       this.logger.lifecycle("completion", "completed", {
         startTime: completionStartTime,
@@ -5227,12 +5161,17 @@ Fix the errors and generate a valid output.
 `.trim();
   }
   /**
-   * Get memory snapshot after execution
-   * Delegates to MemoryManager.getSnapshot()
-   * @returns Memory snapshot (only available after execute() completes)
+   * Get memory snapshot after execution.
+   *
+   * `undefined` until the `finally` around `iterate()` (or `complete()`) takes the first snapshot --
+   * `session.ts` and the SDK worker both rely on this to distinguish "no memory produced yet" (a
+   * throw during `initialize()`, before any iteration ran) from "memory exists".
+   *
+   * @returns Memory snapshot (only available after execute() completes, or after a mid-turn throw
+   *   past the point `iterate()` began)
    */
   getMemorySnapshot() {
-    return this.memoryManager.getSnapshot();
+    return this.memorySnapshot;
   }
   /**
    * How the just-finished turn ended -- see `AgentStopReason`. Set once `iterate()` returns,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/sdk",
-  "version": "1.44.3",
+  "version": "1.45.0",
   "description": "SDK for building Elevasis organization resources",
   "type": "module",
   "bin": {
@@ -12,7 +12,7 @@
       "import": "./dist/index.js"
     },
     "./worker": {
-      "types": "./dist/types/worker/index.d.ts",
+      "types": "./dist/worker/index.d.ts",
       "import": "./dist/worker/index.js"
     },
     "./test-utils": {
@@ -28,10 +28,7 @@
     "dist/index.js",
     "dist/index.d.ts",
     "dist/worker/index.js",
-    "dist/types/worker/index.d.ts",
-    "dist/types/worker/platform.d.ts",
-    "dist/types/worker/utils.d.ts",
-    "dist/types/worker/adapters/",
+    "dist/worker/index.d.ts",
     "dist/test-utils/index.js",
     "dist/test-utils/index.d.ts",
     "dist/node/",
@@ -58,9 +55,9 @@
     "tsup": "^8.0.0",
     "typescript": "5.9.2",
     "zod": "^4.1.0",
-    "@repo/core": "0.59.0",
-    "@repo/typescript-config": "0.0.0",
-    "@repo/eslint-config": "0.0.0"
+    "@repo/core": "0.60.0",
+    "@repo/eslint-config": "0.0.0",
+    "@repo/typescript-config": "0.0.0"
   },
   "scripts": {
     "lint": "eslint src --max-warnings 0",