@codemation/core 0.7.0 → 0.8.0

package/src/contracts/runtimeTypes.ts

@@ -2,6 +2,7 @@ import type { ReadableStream as BinaryReadableStream } from "node:stream/web";
 import type { TypeToken } from "../di";
 import type { RunEventBus } from "../events/runEvents";
 import type { CredentialSessionService } from "./credentialTypes";
+import type { ExecutionTelemetry, ExecutionTelemetryFactory, NodeExecutionTelemetry } from "./telemetryTypes";
 import type {
   ConnectionInvocationAppendArgs,
   NodeInputsByPort,
@@ -28,6 +29,7 @@ import type {
   RunnableNodeConfig,
   OutputPortKey,
   ParentExecutionRef,
+  PersistedRunPolicySnapshot,
   RunDataFactory,
   RunDataSnapshot,
   RunId,
@@ -149,6 +151,7 @@ export interface ExecutionContext {
   now: () => Date;
   data: RunDataSnapshot;
   nodeState?: NodeExecutionStatePublisher;
+  telemetry: ExecutionTelemetry;
   binary: ExecutionBinaryService;
   getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
 }
@@ -158,11 +161,13 @@ export interface ExecutionContextFactory {
     runId: RunId;
     workflowId: WorkflowId;
     parent?: ParentExecutionRef;
+    policySnapshot?: PersistedRunPolicySnapshot;
     subworkflowDepth: number;
     engineMaxNodeActivations: number;
     engineMaxSubworkflowDepth: number;
     data: RunDataSnapshot;
     nodeState?: NodeExecutionStatePublisher;
+    telemetry?: ExecutionTelemetry;
     getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
   }): ExecutionContext;
 }
@@ -171,6 +176,7 @@ export interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfi
   nodeId: NodeId;
   activationId: NodeActivationId;
   config: TConfig;
+  telemetry: NodeExecutionTelemetry;
   binary: NodeBinaryAttachmentService;
 }
 
@@ -416,6 +422,7 @@ export interface EngineDeps {
   activationScheduler: NodeActivationScheduler;
   runDataFactory: RunDataFactory;
   executionContextFactory: ExecutionContextFactory;
+  executionTelemetryFactory?: ExecutionTelemetryFactory;
   nodeExecutor: NodeExecutor;
   eventBus?: RunEventBus;
   tokenRegistry: PersistedWorkflowTokenRegistryLike;

package/src/contracts/telemetryTypes.ts

@@ -0,0 +1,105 @@
+import type {
+  JsonValue,
+  NodeActivationId,
+  NodeId,
+  ParentExecutionRef,
+  PersistedRunPolicySnapshot,
+  RunId,
+  WorkflowId,
+} from "./workflowTypes";
+import type { CostTrackingTelemetry } from "./CostTrackingTelemetryContract";
+
+export type TelemetryAttributePrimitive = string | number | boolean | null;
+
+export interface TelemetryAttributes {
+  readonly [key: string]: TelemetryAttributePrimitive | undefined;
+}
+
+export interface TelemetryMetricRecord {
+  readonly name: string;
+  readonly value: number;
+  readonly unit?: string;
+  readonly attributes?: TelemetryAttributes;
+}
+
+export interface TelemetrySpanEventRecord {
+  readonly name: string;
+  readonly occurredAt?: Date;
+  readonly attributes?: TelemetryAttributes;
+}
+
+export interface TelemetryArtifactAttachment {
+  readonly kind: string;
+  readonly contentType: string;
+  readonly previewText?: string;
+  readonly previewJson?: JsonValue;
+  readonly payloadText?: string;
+  readonly payloadJson?: JsonValue;
+  readonly bytes?: number;
+  readonly truncated?: boolean;
+  readonly expiresAt?: Date;
+}
+
+export interface TelemetryArtifactReference {
+  readonly artifactId: string;
+  readonly traceId?: string;
+  readonly spanId?: string;
+}
+
+export interface TelemetrySpanEnd {
+  readonly status?: "ok" | "error";
+  readonly statusMessage?: string;
+  readonly endedAt?: Date;
+  readonly attributes?: TelemetryAttributes;
+}
+
+export interface TelemetryChildSpanStart {
+  readonly name: string;
+  readonly kind?: "internal" | "client";
+  readonly startedAt?: Date;
+  readonly attributes?: TelemetryAttributes;
+}
+
+export interface TelemetryScope {
+  readonly traceId?: string;
+  readonly spanId?: string;
+  readonly costTracking?: CostTrackingTelemetry;
+  addSpanEvent(args: TelemetrySpanEventRecord): Promise<void> | void;
+  recordMetric(args: TelemetryMetricRecord): Promise<void> | void;
+  attachArtifact(args: TelemetryArtifactAttachment): Promise<TelemetryArtifactReference> | TelemetryArtifactReference;
+}
+
+export interface TelemetrySpanScope extends TelemetryScope {
+  readonly traceId: string;
+  readonly spanId: string;
+  end(args?: TelemetrySpanEnd): Promise<void> | void;
+}
+
+export interface NodeExecutionTelemetry extends ExecutionTelemetry, TelemetrySpanScope {
+  startChildSpan(args: TelemetryChildSpanStart): TelemetrySpanScope;
+}
+
+export interface ExecutionTelemetry extends TelemetryScope {
+  readonly traceId: string;
+  readonly spanId: string;
+  forNode(args: Readonly<{ nodeId: NodeId; activationId: NodeActivationId }>): NodeExecutionTelemetry;
+}
+
+export interface ExecutionTelemetryFactory {
+  create(
+    args: Readonly<{
+      runId: RunId;
+      workflowId: WorkflowId;
+      parent?: ParentExecutionRef;
+      policySnapshot?: PersistedRunPolicySnapshot;
+    }>,
+  ): ExecutionTelemetry;
+}
+export { NoOpTelemetryArtifactReference } from "./NoOpTelemetryArtifactReference";
+export { NoOpTelemetrySpanScope } from "./NoOpTelemetrySpanScope";
+export { NoOpNodeExecutionTelemetry } from "./NoOpNodeExecutionTelemetry";
+export { NoOpExecutionTelemetry } from "./NoOpExecutionTelemetry";
+export { NoOpExecutionTelemetryFactory } from "./NoOpExecutionTelemetryFactory";
+export { CodemationTelemetryAttributeNames } from "./CodemationTelemetryAttributeNames";
+export { GenAiTelemetryAttributeNames } from "./GenAiTelemetryAttributeNames";
+export { CodemationTelemetryMetricNames } from "./CodemationTelemetryMetricNames";

package/src/contracts/workflowTypes.ts

@@ -269,11 +269,17 @@ export interface WorkflowStoragePolicyDecisionArgs {
 export interface WorkflowPrunePolicySpec {
   readonly runDataRetentionSeconds?: number;
   readonly binaryRetentionSeconds?: number;
+  readonly telemetrySpanRetentionSeconds?: number;
+  readonly telemetryArtifactRetentionSeconds?: number;
+  readonly telemetryMetricRetentionSeconds?: number;
 }
 
 export interface PersistedRunPolicySnapshot {
   readonly retentionSeconds?: number;
   readonly binaryRetentionSeconds?: number;
+  readonly telemetrySpanRetentionSeconds?: number;
+  readonly telemetryArtifactRetentionSeconds?: number;
+  readonly telemetryMetricRetentionSeconds?: number;
   readonly storagePolicy: WorkflowStoragePolicyMode;
 }
 
@@ -311,5 +317,8 @@ export type NodeErrorHandlerSpec = TypeToken<NodeErrorHandler> | NodeErrorHandle
 export interface WorkflowPolicyRuntimeDefaults {
   readonly retentionSeconds?: number;
   readonly binaryRetentionSeconds?: number;
+  readonly telemetrySpanRetentionSeconds?: number;
+  readonly telemetryArtifactRetentionSeconds?: number;
+  readonly telemetryMetricRetentionSeconds?: number;
   readonly storagePolicy?: WorkflowStoragePolicyMode;
 }

package/src/events/EventPublishingWorkflowExecutionRepository.ts

@@ -63,7 +63,7 @@ export class EventPublishingWorkflowExecutionRepository
   }
 
   async listRunsOlderThan(
-    args: Readonly<{ beforeIso: string; limit?: number }>,
+    args: Readonly<{ nowIso: string; defaultRetentionSeconds: number; limit?: number }>,
   ): Promise<ReadonlyArray<RunPruneCandidate>> {
     const pruneRepository = this.inner as unknown as Partial<WorkflowExecutionPruneRepository>;
     if (!pruneRepository.listRunsOlderThan) return [];

package/src/execution/CatalogBackedCostTrackingTelemetry.ts

@@ -0,0 +1,81 @@
+import type { CostCatalog } from "../contracts/CostCatalogContract";
+import {
+  CostTrackingTelemetryAttributeNames,
+  CostTrackingTelemetryMetricNames,
+  type CostTrackingPriceQuote,
+  type CostTrackingTelemetry,
+  type CostTrackingUsageRecord,
+} from "../contracts/CostTrackingTelemetryContract";
+import type { TelemetryAttributes, TelemetryScope } from "../types";
+
+export class CatalogBackedCostTrackingTelemetry implements CostTrackingTelemetry {
+  constructor(
+    private readonly currentScope: TelemetryScope,
+    private readonly costCatalog: CostCatalog,
+  ) {}
+
+  async captureUsage(args: CostTrackingUsageRecord): Promise<CostTrackingPriceQuote | undefined> {
+    const usageAttributes = this.createUsageAttributes(args);
+    await this.currentScope.recordMetric({
+      name: CostTrackingTelemetryMetricNames.usage,
+      value: args.quantity,
+      unit: args.usageUnit,
+      attributes: usageAttributes,
+    });
+
+    const catalogEntry = this.costCatalog.findEntry(args);
+    if (!catalogEntry) {
+      return undefined;
+    }
+
+    const estimatedAmountMinor = Math.round(args.quantity * catalogEntry.pricePerUnitMinor);
+    const costAttributes = this.createCostAttributes(args, catalogEntry.currency, catalogEntry.currencyScale);
+    await this.currentScope.recordMetric({
+      name: CostTrackingTelemetryMetricNames.estimatedCost,
+      value: estimatedAmountMinor,
+      unit: catalogEntry.currency,
+      attributes: costAttributes,
+    });
+
+    return {
+      currency: catalogEntry.currency,
+      currencyScale: catalogEntry.currencyScale,
+      estimatedAmountMinor,
+      estimateKind: "catalog",
+    };
+  }
+
+  forScope(scope: TelemetryScope): CostTrackingTelemetry {
+    // eslint-disable-next-line codemation/no-manual-di-new
+    return new CatalogBackedCostTrackingTelemetry(scope, this.costCatalog);
+  }
+
+  private createUsageAttributes(args: CostTrackingUsageRecord): TelemetryAttributes {
+    return {
+      ...args.attributes,
+      [CostTrackingTelemetryAttributeNames.component]: args.component,
+      [CostTrackingTelemetryAttributeNames.provider]: args.provider,
+      [CostTrackingTelemetryAttributeNames.operation]: args.operation,
+      [CostTrackingTelemetryAttributeNames.pricingKey]: args.pricingKey,
+      [CostTrackingTelemetryAttributeNames.usageUnit]: args.usageUnit,
+    };
+  }
+
+  private createCostAttributes(
+    args: CostTrackingUsageRecord,
+    currency: string,
+    currencyScale: number,
+  ): TelemetryAttributes {
+    return {
+      ...args.attributes,
+      [CostTrackingTelemetryAttributeNames.component]: args.component,
+      [CostTrackingTelemetryAttributeNames.provider]: args.provider,
+      [CostTrackingTelemetryAttributeNames.operation]: args.operation,
+      [CostTrackingTelemetryAttributeNames.pricingKey]: args.pricingKey,
+      [CostTrackingTelemetryAttributeNames.usageUnit]: args.usageUnit,
+      [CostTrackingTelemetryAttributeNames.currency]: currency,
+      [CostTrackingTelemetryAttributeNames.currencyScale]: currencyScale,
+      [CostTrackingTelemetryAttributeNames.estimateKind]: "catalog",
+    };
+  }
+}

package/src/execution/CatalogBackedCostTrackingTelemetryFactory.ts

@@ -0,0 +1,12 @@
+import type { CostCatalog } from "../contracts/CostCatalogContract";
+import type { CostTrackingTelemetry, CostTrackingTelemetryFactory } from "../contracts/CostTrackingTelemetryContract";
+import type { ExecutionTelemetry } from "../contracts/telemetryTypes";
+import { CatalogBackedCostTrackingTelemetry } from "./CatalogBackedCostTrackingTelemetry";
+
+export class CatalogBackedCostTrackingTelemetryFactory implements CostTrackingTelemetryFactory {
+  constructor(private readonly costCatalog: CostCatalog) {}
+
+  create(args: Readonly<{ telemetry: ExecutionTelemetry }>): CostTrackingTelemetry {
+    return new CatalogBackedCostTrackingTelemetry(args.telemetry, this.costCatalog);
+  }
+}

package/src/execution/DefaultExecutionContextFactory.ts

@@ -1,22 +1,30 @@
 import type {
   BinaryStorage,
+  CostTrackingTelemetryFactory,
   ExecutionContext,
   ExecutionContextFactory,
+  ExecutionTelemetryFactory,
   NodeExecutionStatePublisher,
   ParentExecutionRef,
   RunDataSnapshot,
   RunId,
   WorkflowId,
 } from "../types";
+import { NoOpCostTrackingTelemetryFactory, NoOpExecutionTelemetryFactory } from "../types";
 
 import {
   DefaultExecutionBinaryService,
   UnavailableBinaryStorage,
 } from "../binaries/DefaultExecutionBinaryServiceFactory";
+import { ExecutionTelemetryCostTrackingDecoratorFactory } from "./ExecutionTelemetryCostTrackingDecoratorFactory";
 
 export class DefaultExecutionContextFactory implements ExecutionContextFactory {
+  private readonly telemetryDecoratorFactory = new ExecutionTelemetryCostTrackingDecoratorFactory();
+
   constructor(
     private readonly binaryStorage: BinaryStorage = new UnavailableBinaryStorage(),
+    private readonly telemetryFactory: ExecutionTelemetryFactory = new NoOpExecutionTelemetryFactory(),
+    private readonly costTrackingFactory: CostTrackingTelemetryFactory = new NoOpCostTrackingTelemetryFactory(),
     private readonly currentDate: () => Date = () => new Date(),
   ) {}
 
@@ -24,13 +32,27 @@ export class DefaultExecutionContextFactory implements ExecutionContextFactory {
     runId: RunId;
     workflowId: WorkflowId;
     parent?: ParentExecutionRef;
+    policySnapshot?: import("../types").PersistedRunPolicySnapshot;
     subworkflowDepth: number;
     engineMaxNodeActivations: number;
     engineMaxSubworkflowDepth: number;
     data: RunDataSnapshot;
     nodeState?: NodeExecutionStatePublisher;
+    telemetry?: ExecutionContext["telemetry"];
     getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
   }): ExecutionContext {
+    const baseTelemetry =
+      args.telemetry ??
+      this.telemetryFactory.create({
+        runId: args.runId,
+        workflowId: args.workflowId,
+        parent: args.parent,
+        policySnapshot: args.policySnapshot,
+      });
+    const telemetry = this.telemetryDecoratorFactory.decorateExecutionTelemetry({
+      telemetry: baseTelemetry,
+      costTracking: baseTelemetry.costTracking ?? this.costTrackingFactory.create({ telemetry: baseTelemetry }),
+    });
     return {
       runId: args.runId,
       workflowId: args.workflowId,
@@ -41,6 +63,7 @@ export class DefaultExecutionContextFactory implements ExecutionContextFactory {
       now: this.currentDate,
       data: args.data,
       nodeState: args.nodeState,
+      telemetry,
       binary: new DefaultExecutionBinaryService(this.binaryStorage, args.workflowId, args.runId, this.currentDate),
       getCredential: args.getCredential,
     };

package/src/execution/ExecutionTelemetryCostTrackingDecoratorFactory.ts

@@ -0,0 +1,84 @@
+import type { CostTrackingTelemetry } from "../contracts/CostTrackingTelemetryContract";
+import type {
+  ExecutionTelemetry,
+  NodeExecutionTelemetry,
+  TelemetryArtifactAttachment,
+  TelemetryArtifactReference,
+  TelemetryChildSpanStart,
+  TelemetryMetricRecord,
+  TelemetrySpanEnd,
+  TelemetrySpanEventRecord,
+  TelemetrySpanScope,
+} from "../contracts/telemetryTypes";
+import type { NodeActivationId, NodeId } from "../contracts/workflowTypes";
+
+export class ExecutionTelemetryCostTrackingDecoratorFactory {
+  decorateExecutionTelemetry(args: {
+    telemetry: ExecutionTelemetry;
+    costTracking: CostTrackingTelemetry;
+  }): ExecutionTelemetry {
+    return {
+      traceId: args.telemetry.traceId,
+      spanId: args.telemetry.spanId,
+      costTracking: args.costTracking,
+      addSpanEvent: (event: TelemetrySpanEventRecord) => args.telemetry.addSpanEvent(event),
+      recordMetric: (metric: TelemetryMetricRecord) => args.telemetry.recordMetric(metric),
+      attachArtifact: (
+        artifact: TelemetryArtifactAttachment,
+      ): Promise<TelemetryArtifactReference> | TelemetryArtifactReference => args.telemetry.attachArtifact(artifact),
+      forNode: (nodeArgs: Readonly<{ nodeId: NodeId; activationId: NodeActivationId }>): NodeExecutionTelemetry => {
+        const nodeTelemetry = args.telemetry.forNode(nodeArgs);
+        return this.decorateNodeExecutionTelemetry({
+          telemetry: nodeTelemetry,
+          costTracking: args.costTracking.forScope(nodeTelemetry),
+        });
+      },
+    };
+  }
+
+  private decorateNodeExecutionTelemetry(args: {
+    telemetry: NodeExecutionTelemetry;
+    costTracking: CostTrackingTelemetry;
+  }): NodeExecutionTelemetry {
+    return {
+      traceId: args.telemetry.traceId,
+      spanId: args.telemetry.spanId,
+      costTracking: args.costTracking,
+      addSpanEvent: (event: TelemetrySpanEventRecord) => args.telemetry.addSpanEvent(event),
+      recordMetric: (metric: TelemetryMetricRecord) => args.telemetry.recordMetric(metric),
+      attachArtifact: (
+        artifact: TelemetryArtifactAttachment,
+      ): Promise<TelemetryArtifactReference> | TelemetryArtifactReference => args.telemetry.attachArtifact(artifact),
+      end: (endArgs?: TelemetrySpanEnd) => args.telemetry.end(endArgs),
+      startChildSpan: (spanArgs: TelemetryChildSpanStart): TelemetrySpanScope =>
+        this.decorateTelemetrySpanScope({
+          scope: args.telemetry.startChildSpan(spanArgs),
+          costTracking: args.costTracking,
+        }),
+      forNode: (nodeArgs: Readonly<{ nodeId: NodeId; activationId: NodeActivationId }>): NodeExecutionTelemetry => {
+        const nodeTelemetry = args.telemetry.forNode(nodeArgs);
+        return this.decorateNodeExecutionTelemetry({
+          telemetry: nodeTelemetry,
+          costTracking: args.costTracking.forScope(nodeTelemetry),
+        });
+      },
+    };
+  }
+
+  private decorateTelemetrySpanScope(args: {
+    scope: TelemetrySpanScope;
+    costTracking: CostTrackingTelemetry;
+  }): TelemetrySpanScope {
+    return {
+      traceId: args.scope.traceId,
+      spanId: args.scope.spanId,
+      costTracking: args.costTracking.forScope(args.scope),
+      addSpanEvent: (event: TelemetrySpanEventRecord) => args.scope.addSpanEvent(event),
+      recordMetric: (metric: TelemetryMetricRecord) => args.scope.recordMetric(metric),
+      attachArtifact: (
+        artifact: TelemetryArtifactAttachment,
+      ): Promise<TelemetryArtifactReference> | TelemetryArtifactReference => args.scope.attachArtifact(artifact),
+      end: (endArgs?: TelemetrySpanEnd) => args.scope.end(endArgs),
+    };
+  }
+}

package/src/execution/NodeActivationRequestComposer.ts

@@ -142,6 +142,7 @@ export class NodeActivationRequestComposer {
       nodeId: definition.id,
       activationId,
       config: definition.config,
+      telemetry: args.base.telemetry.forNode({ nodeId: definition.id, activationId }),
       binary: args.base.binary.forNode({ nodeId: definition.id, activationId }),
       getCredential: this.credentialResolverFactory.create(args.workflowId, definition.id, definition.config),
     };

package/src/execution/NodeExecutionSnapshotFactory.ts

@@ -1,4 +1,5 @@
 import type {
+  JsonValue,
   NodeActivationId,
   NodeExecutionSnapshot,
   NodeId,
@@ -146,6 +147,7 @@ export class NodeExecutionSnapshotFactory {
         message: args.error.message,
         name: args.error.name,
         stack: args.error.stack,
+        details: (args.error as Error & { details?: JsonValue }).details,
       },
     };
   }

package/src/execution/StaticCostCatalog.ts

@@ -0,0 +1,22 @@
+import type { CostCatalog, CostCatalogEntry } from "../contracts/CostCatalogContract";
+import type { CostTrackingUsageRecord } from "../contracts/CostTrackingTelemetryContract";
+
+export class StaticCostCatalog implements CostCatalog {
+  private readonly entriesByKey: ReadonlyMap<string, CostCatalogEntry>;
+
+  constructor(entries: ReadonlyArray<CostCatalogEntry>) {
+    this.entriesByKey = new Map(entries.map((entry) => [this.createKeyFromEntry(entry), entry]));
+  }
+
+  findEntry(args: CostTrackingUsageRecord): CostCatalogEntry | undefined {
+    return this.entriesByKey.get(this.createKeyFromUsage(args));
+  }
+
+  private createKeyFromEntry(entry: CostCatalogEntry): string {
+    return `${entry.component}::${entry.provider}::${entry.operation}::${entry.pricingKey}::${entry.usageUnit}`;
+  }
+
+  private createKeyFromUsage(args: CostTrackingUsageRecord): string {
+    return `${args.component}::${args.provider}::${args.operation}::${args.pricingKey}::${args.usageUnit}`;
+  }
+}

package/src/execution/WorkflowRunExecutionContextFactory.ts

@@ -24,6 +24,7 @@ export class WorkflowRunExecutionContextFactory {
     workflowId: WorkflowId;
     nodeId: NodeId;
     parent?: ParentExecutionRef;
+    policySnapshot?: import("../types").PersistedRunPolicySnapshot;
     subworkflowDepth: number;
     engineMaxNodeActivations: number;
     engineMaxSubworkflowDepth: number;
@@ -34,6 +35,7 @@ export class WorkflowRunExecutionContextFactory {
       runId: args.runId,
       workflowId: args.workflowId,
       parent: args.parent,
+      policySnapshot: args.policySnapshot,
       subworkflowDepth: args.subworkflowDepth,
       engineMaxNodeActivations: args.engineMaxNodeActivations,
       engineMaxSubworkflowDepth: args.engineMaxSubworkflowDepth,

package/src/execution/index.ts

@@ -4,6 +4,9 @@ export { NodeInputContractError } from "./NodeInputContractError";
 export { CredentialResolverFactory } from "./CredentialResolverFactory";
 export { DefaultAsyncSleeper } from "./DefaultAsyncSleeper";
 export { DefaultExecutionContextFactory } from "./DefaultExecutionContextFactory";
+export { CatalogBackedCostTrackingTelemetry } from "./CatalogBackedCostTrackingTelemetry";
+export { CatalogBackedCostTrackingTelemetryFactory } from "./CatalogBackedCostTrackingTelemetryFactory";
+export { ExecutionTelemetryCostTrackingDecoratorFactory } from "./ExecutionTelemetryCostTrackingDecoratorFactory";
 export { InProcessRetryRunner } from "./InProcessRetryRunner";
 export { ItemExprResolver } from "./ItemExprResolver";
 export { NodeOutputNormalizer } from "./NodeOutputNormalizer";
@@ -21,6 +24,7 @@ export { NodeRunStateWriterFactory } from "./NodeRunStateWriterFactory";
 export { PersistedRunStateTerminalBuilder } from "./PersistedRunStateTerminalBuilder";
 export { RunStateSemantics } from "./RunStateSemantics";
 export { WorkflowRunExecutionContextFactory } from "./WorkflowRunExecutionContextFactory";
+export { StaticCostCatalog } from "./StaticCostCatalog";
 export type { AsyncSleeper } from "./asyncSleeper.types";
 export { RunContinuationService } from "../orchestration/RunContinuationService";
 export { RunStartService } from "../orchestration/RunStartService";

package/src/orchestration/NodeExecutionRequestHandlerService.ts

@@ -71,6 +71,7 @@ export class NodeExecutionRequestHandlerService implements NodeExecutionRequestH
       workflowId: state.workflowId,
       nodeId: request.nodeId,
       parent: resolvedParent,
+      policySnapshot: state.policySnapshot,
       subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
       engineMaxNodeActivations: limits.engineMaxNodeActivations,
       engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,

package/src/orchestration/RunContinuationService.ts

@@ -135,6 +135,7 @@ export class RunContinuationService {
       workflowId: state.workflowId,
       nodeId: args.nodeId,
       parent: state.parent,
+      policySnapshot: state.policySnapshot,
       subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
       engineMaxNodeActivations: limits.engineMaxNodeActivations,
       engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
@@ -748,6 +749,7 @@ export class RunContinuationService {
       workflowId: args.state.workflowId,
       nodeId: nextDefinition.id,
       parent: args.state.parent,
+      policySnapshot: args.state.policySnapshot,
       subworkflowDepth: args.state.executionOptions?.subworkflowDepth ?? 0,
       engineMaxNodeActivations: webhookLimits.engineMaxNodeActivations,
       engineMaxSubworkflowDepth: webhookLimits.engineMaxSubworkflowDepth,
@@ -851,6 +853,7 @@ export class RunContinuationService {
       workflowId: state.workflowId,
       nodeId,
       parent: state.parent,
+      policySnapshot: state.policySnapshot,
       subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
       engineMaxNodeActivations: limits.engineMaxNodeActivations,
       engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
@@ -864,6 +867,7 @@ export class RunContinuationService {
       nodeId,
       activationId,
       config: def.config,
+      telemetry: base.telemetry.forNode({ nodeId, activationId }),
       binary: base.binary.forNode({ nodeId, activationId }),
       getCredential: this.credentialResolverFactory.create(wf.id, nodeId, def.config),
     };

package/src/orchestration/RunStartService.ts

@@ -90,6 +90,7 @@ export class RunStartService {
       workflowId: workflow.id,
       nodeId: startAt,
       parent,
+      policySnapshot,
       subworkflowDepth: mergedExecutionOptions.subworkflowDepth ?? 0,
       engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations!,
       engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth!,
@@ -199,6 +200,7 @@ export class RunStartService {
           request.workflow,
         ) ?? "unknown_node",
       parent: request.parent,
+      policySnapshot,
       subworkflowDepth: mergedExecutionOptions.subworkflowDepth ?? 0,
       engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations!,
       engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth!,

package/src/policies/storage/RunPolicySnapshotFactory.ts

@@ -10,6 +10,12 @@ export class RunPolicySnapshotFactory {
     const prune = workflow.prunePolicy;
     const retentionSeconds = prune?.runDataRetentionSeconds ?? defaults?.retentionSeconds;
     const binaryRetentionSeconds = prune?.binaryRetentionSeconds ?? defaults?.binaryRetentionSeconds;
+    const telemetrySpanRetentionSeconds =
+      prune?.telemetrySpanRetentionSeconds ?? defaults?.telemetrySpanRetentionSeconds;
+    const telemetryArtifactRetentionSeconds =
+      prune?.telemetryArtifactRetentionSeconds ?? defaults?.telemetryArtifactRetentionSeconds;
+    const telemetryMetricRetentionSeconds =
+      prune?.telemetryMetricRetentionSeconds ?? defaults?.telemetryMetricRetentionSeconds;
     const storagePolicy: WorkflowStoragePolicyMode =
       typeof workflow.storagePolicy === "string"
         ? (workflow.storagePolicy as WorkflowStoragePolicyMode)
@@ -17,6 +23,9 @@ export class RunPolicySnapshotFactory {
     return {
       retentionSeconds,
       binaryRetentionSeconds,
+      telemetrySpanRetentionSeconds,
+      telemetryArtifactRetentionSeconds,
+      telemetryMetricRetentionSeconds,
       storagePolicy,
     };
   }

package/src/runStorage/InMemoryWorkflowExecutionRepository.ts

@@ -87,14 +87,16 @@ export class InMemoryWorkflowExecutionRepository
   }
 
   async listRunsOlderThan(
-    args: Readonly<{ beforeIso: string; limit?: number }>,
+    args: Readonly<{ nowIso: string; defaultRetentionSeconds: number; limit?: number }>,
   ): Promise<ReadonlyArray<RunPruneCandidate>> {
     const limit = args.limit ?? 100;
     const out: RunPruneCandidate[] = [];
     for (const s of this.runs.values()) {
       if (s.status !== "completed" && s.status !== "failed") continue;
       const finishedAt = RunFinishedAtFactory.resolveIso(s);
-      if (!finishedAt || finishedAt >= args.beforeIso) continue;
+      const retentionSeconds = s.policySnapshot?.retentionSeconds ?? args.defaultRetentionSeconds;
+      const cutoffIso = new Date(new Date(args.nowIso).getTime() - retentionSeconds * 1000).toISOString();
+      if (!finishedAt || finishedAt >= cutoffIso) continue;
       out.push({
         runId: s.runId,
         workflowId: s.workflowId,

package/src/types/index.ts

@@ -7,8 +7,13 @@ export * from "../contracts/NoRetryPolicy";
 export * from "../contracts/RetryPolicy";
 export * from "../contracts/ExpRetryPolicy";
 export * from "../contracts/credentialTypes";
+export * from "../contracts/CostCatalogContract";
+export * from "../contracts/CostTrackingTelemetryContract";
+export * from "../contracts/NoOpCostTrackingTelemetry";
+export * from "../contracts/NoOpCostTrackingTelemetryFactory";
 export * from "../contracts/executionPersistenceContracts";
 export * from "../contracts/runtimeTypes";
+export * from "../contracts/telemetryTypes";
 export * from "../contracts/runFinishedAtFactory";
 export * from "../contracts/runTypes";
 export * from "../contracts/webhookTypes";