@codemation/core 0.6.0 → 0.8.0

package/src/contracts/NoOpCostTrackingTelemetry.ts

@@ -0,0 +1,16 @@
+import type {
+  CostTrackingPriceQuote,
+  CostTrackingTelemetry,
+  CostTrackingUsageRecord,
+} from "./CostTrackingTelemetryContract";
+import type { TelemetryScope } from "./telemetryTypes";
+
+export class NoOpCostTrackingTelemetry implements CostTrackingTelemetry {
+  async captureUsage(_: CostTrackingUsageRecord): Promise<CostTrackingPriceQuote | undefined> {
+    return undefined;
+  }
+
+  forScope(_: TelemetryScope): CostTrackingTelemetry {
+    return this;
+  }
+}

package/src/contracts/NoOpCostTrackingTelemetryFactory.ts

@@ -0,0 +1,9 @@
+import type { CostTrackingTelemetry, CostTrackingTelemetryFactory } from "./CostTrackingTelemetryContract";
+import type { ExecutionTelemetry } from "./telemetryTypes";
+import { NoOpCostTrackingTelemetry } from "./NoOpCostTrackingTelemetry";
+
+export class NoOpCostTrackingTelemetryFactory implements CostTrackingTelemetryFactory {
+  create(_: Readonly<{ telemetry: ExecutionTelemetry }>): CostTrackingTelemetry {
+    return new NoOpCostTrackingTelemetry();
+  }
+}

package/src/contracts/NoOpExecutionTelemetry.ts

@@ -0,0 +1,26 @@
+import type {
+  ExecutionTelemetry,
+  NodeExecutionTelemetry,
+  TelemetryArtifactAttachment,
+  TelemetryArtifactReference,
+  TelemetryMetricRecord,
+  TelemetrySpanEventRecord,
+} from "./telemetryTypes";
+import type { NodeActivationId, NodeId } from "./workflowTypes";
+import { NoOpNodeExecutionTelemetry } from "./NoOpNodeExecutionTelemetry";
+import { NoOpTelemetryArtifactReference } from "./NoOpTelemetryArtifactReference";
+
+export class NoOpExecutionTelemetry {
+  static readonly value: ExecutionTelemetry = {
+    traceId: "00000000000000000000000000000000",
+    spanId: "0000000000000000",
+    addSpanEvent(_: TelemetrySpanEventRecord): void {},
+    recordMetric(_: TelemetryMetricRecord): void {},
+    attachArtifact(_: TelemetryArtifactAttachment): TelemetryArtifactReference {
+      return NoOpTelemetryArtifactReference.value;
+    },
+    forNode(_: Readonly<{ nodeId: NodeId; activationId: NodeActivationId }>): NodeExecutionTelemetry {
+      return NoOpNodeExecutionTelemetry.value;
+    },
+  };
+}

package/src/contracts/NoOpExecutionTelemetryFactory.ts

@@ -0,0 +1,16 @@
+import type { ParentExecutionRef, PersistedRunPolicySnapshot, RunId, WorkflowId } from "./workflowTypes";
+import type { ExecutionTelemetry, ExecutionTelemetryFactory } from "./telemetryTypes";
+import { NoOpExecutionTelemetry } from "./NoOpExecutionTelemetry";
+
+export class NoOpExecutionTelemetryFactory implements ExecutionTelemetryFactory {
+  create(
+    _: Readonly<{
+      runId: RunId;
+      workflowId: WorkflowId;
+      parent?: ParentExecutionRef;
+      policySnapshot?: PersistedRunPolicySnapshot;
+    }>,
+  ): ExecutionTelemetry {
+    return NoOpExecutionTelemetry.value;
+  }
+}

package/src/contracts/NoOpNodeExecutionTelemetry.ts

@@ -0,0 +1,15 @@
+import type { NodeActivationId, NodeId } from "./workflowTypes";
+import type { NodeExecutionTelemetry, TelemetryChildSpanStart, TelemetrySpanScope } from "./telemetryTypes";
+import { NoOpTelemetrySpanScope } from "./NoOpTelemetrySpanScope";
+
+export class NoOpNodeExecutionTelemetry {
+  static readonly value: NodeExecutionTelemetry = {
+    ...NoOpTelemetrySpanScope.value,
+    forNode(_: Readonly<{ nodeId: NodeId; activationId: NodeActivationId }>): NodeExecutionTelemetry {
+      return NoOpNodeExecutionTelemetry.value;
+    },
+    startChildSpan(_: TelemetryChildSpanStart): TelemetrySpanScope {
+      return NoOpTelemetrySpanScope.value;
+    },
+  };
+}

package/src/contracts/NoOpTelemetryArtifactReference.ts

@@ -0,0 +1,9 @@
+import type { TelemetryArtifactReference } from "./telemetryTypes";
+
+export class NoOpTelemetryArtifactReference {
+  static readonly value: TelemetryArtifactReference = {
+    artifactId: "telemetry-artifact-noop",
+    traceId: undefined,
+    spanId: undefined,
+  };
+}

package/src/contracts/NoOpTelemetrySpanScope.ts

@@ -0,0 +1,22 @@
+import type {
+  TelemetryArtifactAttachment,
+  TelemetryArtifactReference,
+  TelemetryMetricRecord,
+  TelemetrySpanEnd,
+  TelemetrySpanEventRecord,
+  TelemetrySpanScope,
+} from "./telemetryTypes";
+import { NoOpTelemetryArtifactReference } from "./NoOpTelemetryArtifactReference";
+
+export class NoOpTelemetrySpanScope {
+  static readonly value: TelemetrySpanScope = {
+    traceId: "00000000000000000000000000000000",
+    spanId: "0000000000000000",
+    addSpanEvent(_: TelemetrySpanEventRecord): void {},
+    recordMetric(_: TelemetryMetricRecord): void {},
+    attachArtifact(_: TelemetryArtifactAttachment): TelemetryArtifactReference {
+      return NoOpTelemetryArtifactReference.value;
+    },
+    end(_: TelemetrySpanEnd = {}): void {},
+  };
+}

package/src/contracts/index.ts

@@ -2,8 +2,10 @@ export * from "./credentialTypes";
 export * from "./emitPorts";
 export * from "./executionPersistenceContracts";
 export * from "./itemMeta";
-export * from "./itemValue";
+export * from "./params";
+export * from "./itemExpr";
 export * from "./runtimeTypes";
+export * from "./telemetryTypes";
 export * from "./runFinishedAtFactory";
 export * from "./runTypes";
 export * from "./webhookTypes";

package/src/contracts/{itemValue.ts → itemExpr.ts}

@@ -1,9 +1,9 @@
 import type { NodeExecutionContext } from "./runtimeTypes";
 import type { Item, Items, NodeActivationId, NodeId, RunDataSnapshot, RunId, WorkflowId } from "./workflowTypes";
 
-const ITEM_VALUE_BRAND = Symbol.for("codemation.itemValue");
+const ITEM_EXPR_BRAND = Symbol.for("codemation.itemExpr");
 
-export type ItemValueResolvedContext = Readonly<{
+export type ItemExprResolvedContext = Readonly<{
   runId: RunId;
   workflowId: WorkflowId;
   nodeId: NodeId;
@@ -14,52 +14,51 @@ export type ItemValueResolvedContext = Readonly<{
 /**
  * Context aligned with former {@link ItemInputMapperContext} — use **`data`** to read any completed upstream node.
  */
-export type ItemValueContext = ItemValueResolvedContext;
+export type ItemExprContext = ItemExprResolvedContext;
 
-export type ItemValueArgs<TItemJson = unknown> = Readonly<{
+export type ItemExprArgs<TItemJson = unknown> = Readonly<{
   item: Item<TItemJson>;
   itemIndex: number;
   items: Items<TItemJson>;
-  ctx: ItemValueContext;
+  ctx: ItemExprContext;
 }>;
 
-export type ItemValueCallback<T, TItemJson = unknown> = (args: ItemValueArgs<TItemJson>) => T | Promise<T>;
+export type ItemExprCallback<T, TItemJson = unknown> = (args: ItemExprArgs<TItemJson>) => T | Promise<T>;
 
-export type ItemValue<T, TItemJson = unknown> = Readonly<{
-  readonly [ITEM_VALUE_BRAND]: true;
-  readonly fn: ItemValueCallback<T, TItemJson>;
+export type ItemExpr<T, TItemJson = unknown> = Readonly<{
+  readonly [ITEM_EXPR_BRAND]: true;
+  readonly fn: ItemExprCallback<T, TItemJson>;
 }>;
 
-export function itemValue<T, TItemJson = unknown>(fn: ItemValueCallback<T, TItemJson>): ItemValue<T, TItemJson> {
-  return { [ITEM_VALUE_BRAND]: true, fn };
+export function itemExpr<T, TItemJson = unknown>(fn: ItemExprCallback<T, TItemJson>): ItemExpr<T, TItemJson> {
+  return { [ITEM_EXPR_BRAND]: true, fn };
 }
 
-export function isItemValue<T, TItemJson = unknown>(value: unknown): value is ItemValue<T, TItemJson> {
+export function isItemExpr<T, TItemJson = unknown>(value: unknown): value is ItemExpr<T, TItemJson> {
   if (typeof value !== "object" || value === null) {
     return false;
   }
   const v = value as Record<PropertyKey, unknown>;
-  if (v[ITEM_VALUE_BRAND] === true) {
+  if (v[ITEM_EXPR_BRAND] === true) {
     return true;
   }
-  // Support snapshot-hydrated itemValue wrappers where the symbol brand was lost but the callback survived.
+  // Support snapshot-hydrated itemExpr wrappers where the symbol brand was lost but the callback survived.
   // Workflow snapshot hydration currently restores function-valued fields (like `fn`) but may drop symbol-keyed brands.
-  // We treat the minimal `{ fn: Function }` shape as an itemValue wrapper to keep runnable configs working.
+  // We treat the minimal `{ fn: Function }` shape as an itemExpr wrapper to keep runnable configs working.
   const keys = Object.keys(v);
   if (keys.length === 1 && keys[0] === "fn" && typeof (v as { fn?: unknown }).fn === "function") {
     return true;
   }
-  // Support legacy module-local Symbol("codemation.itemValue") brands (e.g. duplicate module graphs).
   for (const sym of Object.getOwnPropertySymbols(v)) {
-    if (sym.description === "codemation.itemValue" && v[sym] === true) {
+    if (sym.description === "codemation.itemExpr" && v[sym] === true) {
       return true;
     }
   }
   return false;
 }
 
-function containsItemValueInUnknown(value: unknown, seen: WeakSet<object> = new WeakSet()): boolean {
-  if (isItemValue(value)) {
+function containsItemExprInUnknown(value: unknown, seen: WeakSet<object> = new WeakSet()): boolean {
+  if (isItemExpr(value)) {
     return true;
   }
   if (value === null || typeof value !== "object") {
@@ -70,10 +69,10 @@ function containsItemValueInUnknown(value: unknown, seen: WeakSet<object> = new
   }
   seen.add(value as object);
   if (Array.isArray(value)) {
-    return value.some((entry) => containsItemValueInUnknown(entry, seen));
+    return value.some((entry) => containsItemExprInUnknown(entry, seen));
   }
   for (const entry of Object.values(value as Record<string, unknown>)) {
-    if (containsItemValueInUnknown(entry, seen)) {
+    if (containsItemExprInUnknown(entry, seen)) {
       return true;
     }
   }
@@ -81,14 +80,14 @@ function containsItemValueInUnknown(value: unknown, seen: WeakSet<object> = new
 }
 
 /**
- * Deep-resolves {@link itemValue} leaves. Returns a new graph (does not mutate the original config object).
+ * Deep-resolves {@link itemExpr} leaves. Returns a new graph (does not mutate the original config object).
  */
-export async function resolveItemValuesInUnknown(
+export async function resolveItemExprsInUnknown(
   value: unknown,
-  args: ItemValueArgs,
+  args: ItemExprArgs,
   seen: WeakSet<object> = new WeakSet(),
 ): Promise<unknown> {
-  if (isItemValue(value)) {
+  if (isItemExpr(value)) {
     return await Promise.resolve(value.fn(args));
   }
   if (value === null || typeof value !== "object") {
@@ -101,7 +100,7 @@ export async function resolveItemValuesInUnknown(
   if (Array.isArray(value)) {
     const out: unknown[] = [];
     for (let i = 0; i < value.length; i++) {
-      out.push(await resolveItemValuesInUnknown(value[i], args, seen));
+      out.push(await resolveItemExprsInUnknown(value[i], args, seen));
     }
     return out;
   }
@@ -113,22 +112,22 @@ export async function resolveItemValuesInUnknown(
   }
   const out = Object.create(proto) as Record<string, unknown>;
   for (const [k, v] of entries) {
-    out[k] = await resolveItemValuesInUnknown(v, args, seen);
+    out[k] = await resolveItemExprsInUnknown(v, args, seen);
   }
   return out;
 }
 
 /**
- * Clones runnable config (best-effort) so per-item {@link itemValue} resolution never mutates shared instances.
+ * Clones runnable config (best-effort) so per-item {@link itemExpr} resolution never mutates shared instances.
  */
-export async function resolveItemValuesForExecution(
+export async function resolveItemExprsForExecution(
   config: unknown,
   nodeCtx: NodeExecutionContext,
   item: Item,
   itemIndex: number,
   items: Items,
 ): Promise<unknown | undefined> {
-  const ivArgs: ItemValueArgs = {
+  const exprArgs: ItemExprArgs = {
     item,
     itemIndex,
     items,
@@ -140,8 +139,8 @@ export async function resolveItemValuesForExecution(
       data: nodeCtx.data,
     },
   };
-  if (!containsItemValueInUnknown(config)) {
+  if (!containsItemExprInUnknown(config)) {
     return undefined;
   }
-  return await resolveItemValuesInUnknown(config, ivArgs);
+  return await resolveItemExprsInUnknown(config, exprArgs);
 }

package/src/contracts/params.ts

@@ -0,0 +1,10 @@
+import type { ItemExpr } from "./itemExpr";
+
+export type Expr<T, TItemJson = unknown> = ItemExpr<T, TItemJson>;
+
+export type Param<T, TItemJson = unknown> = T | Expr<T, TItemJson>;
+
+export type ParamDeep<T, TItemJson = unknown> =
+  | Expr<T, TItemJson>
+  | (T extends readonly (infer U)[] ? ReadonlyArray<ParamDeep<U, TItemJson>> : never)
+  | (T extends object ? { [K in keyof T]: ParamDeep<T[K], TItemJson> } : T);

package/src/contracts/runTypes.ts

@@ -112,6 +112,7 @@ export interface NodeExecutionError {
   message: string;
   name?: string;
   stack?: string;
+  details?: JsonValue;
 }
 
 export interface NodeExecutionSnapshot {
@@ -291,7 +292,9 @@ export interface RunPruneCandidate {
 }
 
 export interface WorkflowExecutionPruneRepository {
-  listRunsOlderThan(args: Readonly<{ beforeIso: string; limit?: number }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+  listRunsOlderThan(
+    args: Readonly<{ nowIso: string; defaultRetentionSeconds: number; limit?: number }>,
+  ): Promise<ReadonlyArray<RunPruneCandidate>>;
 }
 
 export type RunResult =

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

@@ -6,6 +6,7 @@ import type { RetryPolicySpec } from "./retryPolicySpec.types";
 
 export type WorkflowId = string;
 export type NodeId = string;
+export type NodeIdRef<TJson = unknown> = NodeId & Readonly<{ __codemationNodeJson?: TJson }>;
 export type OutputPortKey = string;
 export type InputPortKey = string;
 export type PersistedTokenId = string;
@@ -154,6 +155,10 @@ export interface NodeRef {
   name?: string;
 }
 
+export function nodeRef<TJson>(nodeId: NodeId): NodeIdRef<TJson> {
+  return nodeId as NodeIdRef<TJson>;
+}
+
 export type PairedItemRef = Readonly<{ nodeId: NodeId; output: OutputPortKey; itemIndex: number }>;
 
 export type BinaryPreviewKind = "image" | "audio" | "video" | "download";
@@ -204,8 +209,12 @@ export interface ParentExecutionRef {
 
 export interface RunDataSnapshot {
   getOutputs(nodeId: NodeId): NodeOutputs | undefined;
-  getOutputItems(nodeId: NodeId, output?: OutputPortKey): Items;
-  getOutputItem(nodeId: NodeId, itemIndex: number, output?: OutputPortKey): Item | undefined;
+  getOutputItems<TJson = unknown>(nodeId: NodeId | NodeIdRef<TJson>, output?: OutputPortKey): Items<TJson>;
+  getOutputItem<TJson = unknown>(
+    nodeId: NodeId | NodeIdRef<TJson>,
+    itemIndex: number,
+    output?: OutputPortKey,
+  ): Item<TJson> | undefined;
 }
 
 export interface MutableRunData extends RunDataSnapshot {
@@ -260,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;
 }
 
@@ -302,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);
+  }
+}