@elevasis/sdk 1.44.3 → 1.46.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 = {
@@ -3047,8 +3058,8 @@ function preview(text, n = 120) {
 // ../core/src/platform/utils/token-counter.ts
 var CHARS_PER_TOKEN = 3.5;
 function estimateTokens(text) {
-  const content = typeof text === "string" ? text : JSON.stringify(text);
-  const chars = content.length;
+  const content2 = typeof text === "string" ? text : JSON.stringify(text);
+  const chars = content2.length;
   return Math.ceil(chars / CHARS_PER_TOKEN);
 }
 function truncationCharBudget(maxTokens, noticeLength = 0) {
@@ -3088,7 +3099,7 @@ function buildUntrustedDataPolicy(securityLevel) {
 }
 function buildAgentMessages(systemPrompt, memory, currentInput, securityLevel, conversationHistory = []) {
   const policy = buildUntrustedDataPolicy(securityLevel);
-  const historyMessages = conversationHistory.map(({ role, content }) => ({ role, content }));
+  const historyMessages = conversationHistory.map(({ role, content: content2 }) => ({ role, content: content2 }));
   if (historyMessages.length > 0) {
     historyMessages[historyMessages.length - 1].cacheBreakpoint = true;
   }
@@ -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(),
@@ -3648,11 +3613,11 @@ function safeStructuralPrefix(raw, cutAt) {
   const base = stripDanglingTail(raw.slice(0, cutPoint), stack[stack.length - 1] === "}");
   return base + [...stack].reverse().join("");
 }
-function truncateContent(content, maxTokens) {
-  const estimated = estimateTokens(content);
-  if (estimated <= maxTokens) return { content };
+function truncateContent(content2, maxTokens) {
+  const estimated = estimateTokens(content2);
+  if (estimated <= maxTokens) return { content: content2 };
   const cutAt = truncationCharBudget(maxTokens, CLOSING_BRACKET_RESERVE);
-  const safeContent = safeStructuralPrefix(content, cutAt);
+  const safeContent = safeStructuralPrefix(content2, cutAt);
   const omittedTokens = estimated - maxTokens;
   return { content: safeContent, truncated: { omittedTokens } };
 }
@@ -3748,9 +3713,9 @@ async function executeToolCall(iterationContext, action) {
     const validatedResult = tool.outputSchema.parse(rawResult);
     let boundedResult = validatedResult;
     if (tool.maxOutputTokens !== void 0) {
-      const { content, truncated } = truncateContent(JSON.stringify(validatedResult), tool.maxOutputTokens);
+      const { content: content2, truncated } = truncateContent(JSON.stringify(validatedResult), tool.maxOutputTokens);
       if (truncated) {
-        boundedResult = content;
+        boundedResult = content2;
       }
     }
     const toolEndTime = 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()}`
     );
   }
 }
@@ -4069,15 +4024,17 @@ async function processMemory(memoryManager, response, logger, iteration) {
   if (!response.memoryOps) return;
   const { memoryOps } = response;
   if (memoryOps.set) {
-    for (const [key, content] of Object.entries(memoryOps.set)) {
+    for (const [key, content2] of Object.entries(memoryOps.set)) {
       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 content2 === "string" ? content2 : JSON.stringify(content2)),
+        () => `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}`
+      );
     }
   }
 }
@@ -4204,13 +4152,13 @@ var MAX_TOOL_RESULT_TOKENS = 4e3;
 
 // ../core/src/execution/engine/agent/memory/manager.ts
 var ENVELOPE_FULL_RESULT_WINDOW = 3;
-function parseIfJson(content) {
-  const trimmed = content.trim();
-  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return content;
+function parseIfJson(content2) {
+  const trimmed = content2.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return content2;
   try {
-    return JSON.parse(content);
+    return JSON.parse(content2);
   } catch {
-    return content;
+    return content2;
   }
 }
 function isInTurnScope(entry, currentTurn) {
@@ -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
@@ -4274,8 +4221,8 @@ var MemoryManager = class {
    * @param key - Session memory key
    * @param content - String content from agent
    */
-  set(key, content, source = "model") {
-    const entryTokens = estimateTokens(content);
+  set(key, content2, source = "model") {
+    const entryTokens = estimateTokens(content2);
     let truncated;
     if (entryTokens > MAX_SINGLE_ENTRY_TOKENS) {
       const truncateTime = Date.now();
@@ -4287,13 +4234,13 @@ var MemoryManager = class {
         truncateTime,
         0
       );
-      const result = truncateContent(content, MAX_SINGLE_ENTRY_TOKENS);
-      content = result.content;
+      const result = truncateContent(content2, MAX_SINGLE_ENTRY_TOKENS);
+      content2 = result.content;
       truncated = result.truncated;
     }
     this.memory.sessionMemory[key] = {
       type: "context",
-      content,
+      content: content2,
       timestamp: Date.now(),
       turnNumber: null,
       // Session memory entries are not turn-specific
@@ -4303,7 +4250,7 @@ var MemoryManager = class {
       ...truncated && { truncated },
       // Screened once, here, instead of by re-scanning the whole envelope on every iteration this
       // key gets re-sent for — see `MemoryEntry.warnings`.
-      warnings: sanitizeUserInput(content).warnings
+      warnings: sanitizeUserInput(content2).warnings
     };
   }
   /**
@@ -4341,14 +4288,14 @@ var MemoryManager = class {
         iterationNumber: entry.iterationNumber
       });
     }
-    let content = entry.content;
+    let content2 = entry.content;
     let truncated;
     if (entry.type === "tool-result" || entry.type === "error") {
-      const before = content;
-      const result = truncateContent(content, MAX_TOOL_RESULT_TOKENS);
-      content = result.content;
+      const before = content2;
+      const result = truncateContent(content2, MAX_TOOL_RESULT_TOKENS);
+      content2 = result.content;
       truncated = result.truncated;
-      if (content !== before) {
+      if (content2 !== before) {
         const truncateTime = Date.now();
         this.logger?.action(
           "memory-tool-result-truncate",
@@ -4362,12 +4309,12 @@ var MemoryManager = class {
     }
     this.memory.history.push({
       ...entry,
-      content,
+      content: content2,
       timestamp: Date.now(),
       ...truncated && { truncated },
       // Screened once, here, instead of by re-scanning the whole accumulated envelope on every
       // iteration this entry gets re-sent for — see `MemoryEntry.warnings`.
-      warnings: sanitizeUserInput(content).warnings
+      warnings: sanitizeUserInput(content2).warnings
     });
     this.autoCompact();
   }
@@ -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,
@@ -6184,28 +6123,42 @@ z.object({
   limit: z.number().int(),
   offset: z.number().int()
 });
-var AcqArtifactOwnerKindSchema = z.enum(["company", "contact", "deal", "list", "list_member"]);
+var AcqArtifactOwnerKindSchema = z.enum(["company", "contact", "deal", "list", "list_member", "organization"]);
 z.object({
   ownerKind: AcqArtifactOwnerKindSchema,
-  ownerId: UuidSchema
+  ownerId: UuidSchema.optional()
 }).strict();
+var PipelineIdSchema = z.string().trim().min(1).max(255);
 z.object({
   ownerKind: AcqArtifactOwnerKindSchema,
-  ownerId: UuidSchema,
+  // Nullable + optional: an org-owned artifact (ownerKind: 'organization') has no
+  // single owning entity row. See the comment on AcqArtifactOwnerKindSchema above.
+  ownerId: UuidSchema.nullable().optional(),
   kind: z.string().trim().min(1).max(255),
   content: z.record(z.string(), z.unknown()),
-  sourceExecutionId: UuidSchema.optional()
+  sourceExecutionId: UuidSchema.optional(),
+  // Nullable + optional: acquisition's own artifacts (audits, proposals, ICP docs) predate the
+  // pipeline concept and have none. `getActiveArtifact` filters on it, so any artifact meant to
+  // be resolvable as "the active document for pipeline X" MUST supply it -- artifacts-platform-tool
+  // .mdx Step 3 defect 1.
+  pipelineId: PipelineIdSchema.nullable().optional()
 }).strict();
 var AcqArtifactResponseSchema = z.object({
   id: z.string(),
   organizationId: z.string(),
   ownerKind: z.string(),
-  ownerId: z.string(),
+  // Nullable as of content-pipeline-foundation D14: an org-owned artifact has no owning entity row.
+  // CreateArtifactRequestSchema already accepted a null ownerId; this response schema not doing so
+  // was Step 3 defect 2 -- an org-owned artifact inserted fine and then failed serialization.
+  ownerId: z.string().nullable(),
   kind: z.string(),
+  pipelineId: z.string().nullable(),
   content: z.record(z.string(), z.unknown()),
   sourceExecutionId: z.string().nullable(),
   createdBy: z.string().nullable(),
   createdAt: z.string(),
+  updatedAt: z.string(),
+  isActive: z.boolean(),
   version: z.number().int()
 });
 z.object({
@@ -6854,6 +6807,25 @@ var list = createAdapter("list", [
   "listPendingContactIds"
 ]);
 
+// src/worker/adapters/artifacts.ts
+var artifacts = createAdapter("artifacts", [
+  "listArtifacts",
+  "createArtifact",
+  "getActive"
+]);
+
+// src/worker/adapters/content.ts
+var content = createAdapter("content", [
+  "createItem",
+  "getItem",
+  "listItems",
+  "updateItem",
+  "createAttempt",
+  "listAttempts",
+  "createDistribution",
+  "updateDistribution"
+]);
+
 // src/worker/adapters/pdf.ts
 var pdf = createAdapter("pdf", ["render", "renderToBuffer"]);
 
@@ -7413,4 +7385,4 @@ if (workerData != null && workerData.kind === "static") {
   })();
 }
 
-export { ListBuilderResultSchema, ListBuilderResultsSchema, PlatformToolError, acqDb, approval, classifyPlatformToolError, createAdapter, createAnymailfinderAdapter, createApifyAdapter, createAttioAdapter, createClickUpAdapter, createDropboxAdapter, createGmailAdapter, createGoogleSheetsAdapter, createInstantlyAdapter, createMillionVerifierAdapter, createResendAdapter, createSignatureApiAdapter, createStripeAdapter, createTombaAdapter, crm, email, executeWorkflow, execution, generateHmacToken, list, listBuilderWorkflow, llm, notifications, pdf, platform, projects, scheduler, startWorker, storage };
+export { ListBuilderResultSchema, ListBuilderResultsSchema, PlatformToolError, acqDb, approval, artifacts, classifyPlatformToolError, content, createAdapter, createAnymailfinderAdapter, createApifyAdapter, createAttioAdapter, createClickUpAdapter, createDropboxAdapter, createGmailAdapter, createGoogleSheetsAdapter, createInstantlyAdapter, createMillionVerifierAdapter, createResendAdapter, createSignatureApiAdapter, createStripeAdapter, createTombaAdapter, crm, email, executeWorkflow, execution, generateHmacToken, list, listBuilderWorkflow, llm, notifications, pdf, platform, projects, scheduler, startWorker, storage };