@codemation/core 0.0.1

package/dist/index-gIcH60sp.d.ts

@@ -0,0 +1,674 @@
+import { $t as BinaryStorage, An as TriggerSetupStateStore, Ar as RunEventSubscription, B as CredentialTypeRegistry, Bt as WorkflowPolicyRuntimeDefaults, Cr as RunStateStore, Ct as RunId, Dr as WebhookRunResult, Er as RunSummary, F as CredentialSessionService, Fn as WorkflowRunnerResolver, Ft as WorkflowErrorHandlerSpec, Hn as WebhookInvocationMatch, Ht as WorkflowStoragePolicyDecisionArgs, In as WorkflowRunnerService, Lr as TypeToken, M as CredentialRequirement, Mn as WorkflowCatalog, Mt as WorkflowDefinition, Or as RunEvent, Pn as WorkflowRepository, Pt as WorkflowErrorHandler, Qn as EngineRunCounters, Qt as BinaryBody, Rn as WorkflowSnapshotResolver, Rt as WorkflowId, Sn as NodeResolver, St as RunDataSnapshot, Tr as RunStopCondition, Tt as RunnableNodeConfig, U as ActivationIdFactory, Un as WebhookTriggerMatcher, W as BinaryAttachment, Wn as WebhookTriggerResolution, Y as Item, Z as Items, Zn as CurrentStateExecutionRequest, _n as NodeBinaryAttachmentService, _r as RunListingStore, bn as NodeExecutionScheduler, cn as ExecutionContext, cr as PersistedRunState, dr as PersistedWorkflowTokenRegistryLike, ei as RetryPolicySpec, en as BinaryStorageReadResult, fn as NodeActivationContinuation, ft as NodeOffloadPolicy, gn as NodeActivationScheduler, gr as RunExecutionOptions, ht as NodeSchedulerDecision, in as EngineDeps, it as NodeConfigBase, jr as Container, kr as RunEventBus, ln as ExecutionContextFactory, lt as NodeErrorHandlerSpec, mn as NodeActivationRequest, mr as RunCurrentState, nt as MutableRunData, ot as NodeDefinition, pn as NodeActivationReceipt, pt as NodeOutputs, q as ExecutionMode, qn as WorkflowActivationPolicy, rn as BinaryStorageWriteResult, rr as NodeInputsByPort, rt as NodeActivationId, sn as ExecutionBinaryService, st as NodeErrorHandler, tn as BinaryStorageStatResult, tr as NodeExecutionSnapshot, ur as PersistedWorkflowSnapshotNode, ut as NodeId, vn as NodeExecutionContext, vr as RunPruneCandidate, vt as ParentExecutionRef, wt as RunIdFactory, xn as NodeExecutionStatePublisher, xr as RunResult, xt as RunDataFactory, yn as NodeExecutionRequest, yr as RunPruneListingStore, yt as PersistedRunPolicySnapshot, zn as HttpMethod } from "./InMemoryWorkflowCatalog-D5nCp2yZ.js";
+import { ZodType, input, output } from "zod";
+
+//#region src/runtime/Engine.d.ts
+interface EngineTriggerRuntime {
+  startTriggers(): Promise<void>;
+  stop(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+}
+interface EngineWorkflowRunStarter {
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+}
+interface EngineCurrentStateRunStarter {
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+}
+interface EngineRunContinuationService {
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+}
+interface EngineFacadeDeps {
+  workflowCatalog: WorkflowCatalog;
+  tokenRegistry: PersistedWorkflowTokenRegistryLike;
+  webhookTriggerMatcher: WebhookTriggerMatcher;
+  workflowSnapshotResolver: WorkflowSnapshotResolver;
+  triggerRuntime: EngineTriggerRuntime;
+  workflowRunStarter: EngineWorkflowRunStarter;
+  currentStateRunStarter: EngineCurrentStateRunStarter;
+  runContinuationService: EngineRunContinuationService;
+}
+/**
+ * Runtime facade for orchestration, continuation, triggers, and webhook routing.
+ * Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
+ * The class token is exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
+ */
+declare class Engine implements NodeActivationContinuation {
+  private readonly deps;
+  constructor(deps: EngineFacadeDeps);
+  loadWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+  getTokenRegistry(): EngineFacadeDeps["tokenRegistry"];
+  resolveWorkflowSnapshot(args: {
+    workflowId: WorkflowId;
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+  }): WorkflowDefinition | undefined;
+  startTriggers(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  start(workflows: WorkflowDefinition[]): Promise<void>;
+  stop(): Promise<void>;
+  resolveWebhookTrigger(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookTriggerResolution;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+}
+//#endregion
+//#region src/persistedWorkflow/MissingRuntimeNodeDefinitionFactory.d.ts
+declare class MissingRuntimeNodeDefinitionFactory {
+  create(snapshotNode: PersistedWorkflowSnapshotNode): NodeDefinition;
+}
+//#endregion
+//#region src/persistedWorkflow/PersistedWorkflowConfigHydrator.d.ts
+declare class PersistedWorkflowConfigHydrator {
+  private readonly tokenRegistry;
+  constructor(tokenRegistry: PersistedWorkflowTokenRegistryLike);
+  hydrate(snapshotNode: PersistedWorkflowSnapshotNode, liveConfig: NodeConfigBase): NodeConfigBase;
+  private mergeValue;
+  private mergeNestedValue;
+  private restoreNonSerializableProperties;
+  private restoreTypeProperty;
+  private asRecord;
+}
+//#endregion
+//#region src/policies/EngineExecutionLimitsPolicy.d.ts
+interface EngineExecutionLimitsPolicyConfig {
+  readonly defaultMaxNodeActivations: number;
+  readonly hardMaxNodeActivations: number;
+  readonly defaultMaxSubworkflowDepth: number;
+  readonly hardMaxSubworkflowDepth: number;
+}
+/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
+declare const ENGINE_EXECUTION_LIMITS_DEFAULTS: EngineExecutionLimitsPolicyConfig;
+/**
+ * Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
+ */
+declare class EngineExecutionLimitsPolicy {
+  private readonly config;
+  constructor(config?: EngineExecutionLimitsPolicyConfig);
+  /**
+   * Effective options for a new root run (depth 0): defaults merged with engine ceilings.
+   * Replaces a separate one-method factory for root-run bootstrap.
+   */
+  createRootExecutionOptions(): RunExecutionOptions;
+  mergeExecutionOptionsForNewRun(parent: ParentExecutionRef | undefined, user: RunExecutionOptions | undefined): RunExecutionOptions;
+  private capNumber;
+}
+//#endregion
+//#region src/runtime/EngineFactory.d.ts
+/**
+ * {@link EngineDeps} plus optional overrides for persisted-workflow materialization (`persistedWorkflow`).
+ * Overrides keep default construction in this factory while allowing tests or advanced wiring to inject instances.
+ */
+type EngineCompositionDeps = EngineDeps & {
+  persistedWorkflowConfigHydrator?: PersistedWorkflowConfigHydrator;
+  missingRuntimeNodeDefinitionFactory?: MissingRuntimeNodeDefinitionFactory;
+  /** When set, used for {@link WorkflowRunStarter}, {@link CurrentStateRunStarter}, and trigger/continuation fallbacks. */
+  executionLimitsPolicy?: EngineExecutionLimitsPolicy;
+};
+/**
+ * Composes the {@link Engine} graph from {@link EngineCompositionDeps}. Production wiring usually goes through
+ * {@link import("../bootstrap/runtime/EngineRuntimeRegistrar").EngineRuntimeRegistrar}; this factory remains for tests and custom composition.
+ * Exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
+ */
+declare class EngineFactory {
+  create(deps: EngineCompositionDeps): Engine;
+}
+//#endregion
+//#region src/policies/EngineExecutionLimitsPolicyFactory.d.ts
+/**
+ * Builds {@link EngineExecutionLimitsPolicy} by merging {@link ENGINE_EXECUTION_LIMITS_DEFAULTS} with optional `overrides` (e.g. host `runtime.engineExecutionLimits`).
+ */
+declare class EngineExecutionLimitsPolicyFactory {
+  create(overrides?: Partial<EngineExecutionLimitsPolicyConfig>): EngineExecutionLimitsPolicy;
+}
+//#endregion
+//#region src/events/NodeEventPublisher.d.ts
+/** Publishes node lifecycle snapshots onto the run {@link RunEventBus}. */
+declare class NodeEventPublisher {
+  private readonly eventBus;
+  constructor(eventBus: RunEventBus | undefined);
+  publish(kind: "nodeQueued" | "nodeStarted" | "nodeCompleted" | "nodeFailed", snapshot: NodeExecutionSnapshot): Promise<void>;
+}
+//#endregion
+//#region src/executionContext/CredentialResolverFactory.d.ts
+declare class CredentialResolverFactory {
+  private readonly credentialSessions;
+  constructor(credentialSessions: CredentialSessionService);
+  create(workflowId: WorkflowId, nodeId: NodeId, config?: NodeExecutionContext["config"]): NodeExecutionContext["getCredential"];
+}
+//#endregion
+//#region src/contracts/Clock.d.ts
+/** Port for time; inject `SystemClock` in production and a fake/test clock in tests. */
+interface Clock {
+  now(): Date;
+}
+declare class SystemClock implements Clock {
+  now(): Date;
+}
+//#endregion
+//#region src/ai/AiHost.d.ts
+interface AgentCanvasPresentation<TIcon extends string = string> {
+  readonly label?: string;
+  readonly icon?: TIcon;
+}
+type ZodSchemaAny = ZodType<any, any, any>;
+interface ToolConfig {
+  readonly type: TypeToken<Tool<ToolConfig, ZodSchemaAny, ZodSchemaAny>>;
+  readonly name: string;
+  readonly description?: string;
+  readonly presentation?: AgentCanvasPresentation;
+  getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
+}
+type ToolExecuteArgs<TConfig extends ToolConfig = ToolConfig, TInput = unknown> = Readonly<{
+  config: TConfig;
+  input: TInput;
+  ctx: NodeExecutionContext<any>;
+  item: Item;
+  itemIndex: number;
+  items: Items;
+}>;
+interface Tool<TConfig extends ToolConfig = ToolConfig, TInputSchema extends ZodSchemaAny = ZodSchemaAny, TOutputSchema extends ZodSchemaAny = ZodSchemaAny> {
+  readonly defaultDescription: string;
+  readonly inputSchema: TInputSchema;
+  readonly outputSchema: TOutputSchema;
+  execute(args: ToolExecuteArgs<TConfig, input<TInputSchema>>): Promise<output<TOutputSchema>> | output<TOutputSchema>;
+}
+type AgentTool<TInputSchema extends ZodSchemaAny = ZodSchemaAny, TOutputSchema extends ZodSchemaAny = ZodSchemaAny> = Tool<ToolConfig, TInputSchema, TOutputSchema>;
+type AgentToolExecuteArgs<TInput = unknown> = ToolExecuteArgs<ToolConfig, TInput>;
+type AgentToolToken = TypeToken<Tool<ToolConfig, ZodSchemaAny, ZodSchemaAny>>;
+interface AgentToolDefinition {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: ZodSchemaAny;
+}
+type AgentToolCall = Readonly<{
+  id?: string;
+  name: string;
+  input: unknown;
+}>;
+type AgentToolCallPlanner<_TNodeConfig = unknown> = (item: Item, index: number, items: Items, ctx: NodeExecutionContext<any>) => ReadonlyArray<AgentToolCall>;
+interface ChatModelConfig {
+  readonly type: TypeToken<ChatModelFactory<ChatModelConfig>>;
+  readonly name: string;
+  readonly presentation?: AgentCanvasPresentation;
+  getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
+}
+interface LangChainChatModelLike {
+  invoke(input: unknown, options?: unknown): Promise<unknown>;
+  bindTools?(tools: ReadonlyArray<unknown>): LangChainChatModelLike;
+}
+interface ChatModelFactory<TConfig extends ChatModelConfig = ChatModelConfig> {
+  create(args: Readonly<{
+    config: TConfig;
+    ctx: NodeExecutionContext<any>;
+  }>): Promise<LangChainChatModelLike> | LangChainChatModelLike;
+}
+interface AgentNodeConfig<TInputJson = unknown, TOutputJson = unknown> extends RunnableNodeConfig<TInputJson, TOutputJson> {
+  readonly systemMessage: string;
+  readonly userMessageFormatter: (item: Item<TInputJson>, index: number, items: Items<TInputJson>, ctx: NodeExecutionContext<any>) => string;
+  readonly chatModel: ChatModelConfig;
+  readonly tools?: ReadonlyArray<ToolConfig>;
+}
+declare class AgentConfigInspector {
+  static isAgentNodeConfig(config: NodeConfigBase | undefined): config is AgentNodeConfig<any, any>;
+}
+type AgentAttachmentRole = "languageModel" | "tool";
+//#endregion
+//#region src/diTokens/index.d.ts
+declare const CoreTokens: {
+  readonly PersistedWorkflowTokenRegistry: TypeToken<PersistedWorkflowTokenRegistryLike>;
+  readonly CredentialSessionService: TypeToken<CredentialSessionService>;
+  readonly CredentialTypeRegistry: TypeToken<CredentialTypeRegistry>;
+  readonly WorkflowRunnerService: TypeToken<WorkflowRunnerService>;
+  readonly WorkflowRunnerResolver: TypeToken<WorkflowRunnerResolver>;
+  readonly WorkflowCatalog: TypeToken<WorkflowCatalog>;
+  readonly WorkflowRepository: TypeToken<WorkflowRepository>;
+  readonly ServiceContainer: TypeToken<Container>;
+  readonly NodeResolver: TypeToken<NodeResolver>;
+  readonly RunIdFactory: TypeToken<RunIdFactory>;
+  readonly ActivationIdFactory: TypeToken<ActivationIdFactory>;
+  readonly RunStateStore: TypeToken<RunStateStore>;
+  readonly TriggerSetupStateStore: TypeToken<TriggerSetupStateStore>;
+  readonly NodeActivationScheduler: TypeToken<NodeActivationScheduler>;
+  readonly RunDataFactory: TypeToken<RunDataFactory>;
+  readonly ExecutionContextFactory: TypeToken<ExecutionContextFactory>;
+  readonly RunEventBus: TypeToken<RunEventBus>;
+  readonly BinaryStorage: TypeToken<BinaryStorage>;
+  readonly WebhookBasePath: TypeToken<string>;
+  /** Engine execution limits (defaults + optional host overrides). Consumers may bind a custom instance to override. */
+  readonly EngineExecutionLimitsPolicy: TypeToken<EngineExecutionLimitsPolicy>;
+  readonly WorkflowActivationPolicy: TypeToken<WorkflowActivationPolicy>;
+};
+//#endregion
+//#region src/events/InMemoryRunEventBusRegistry.d.ts
+declare class InMemoryRunEventBus implements RunEventBus {
+  private readonly globalListeners;
+  private readonly listenersByWorkflowId;
+  publish(event: RunEvent): Promise<void>;
+  subscribe(onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
+  subscribeToWorkflow(workflowId: WorkflowId, onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
+}
+//#endregion
+//#region src/events/PublishingRunStateStore.d.ts
+declare class PublishingRunStateStore implements RunStateStore, RunListingStore, RunPruneListingStore {
+  private readonly inner;
+  private readonly eventBus;
+  private readonly now;
+  constructor(inner: RunStateStore, eventBus: RunEventBus, now?: () => Date);
+  createRun(args: Parameters<RunStateStore["createRun"]>[0]): Promise<void>;
+  load(runId: RunId): Promise<PersistedRunState | undefined>;
+  save(state: PersistedRunState): Promise<void>;
+  deleteRun(runId: RunId): Promise<void>;
+  listRuns(args?: Readonly<{
+    workflowId?: WorkflowId;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunSummary>>;
+  listRunsOlderThan(args: Readonly<{
+    beforeIso: string;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+}
+//#endregion
+//#region src/items/ItemsInputNormalizer.d.ts
+declare class ItemsInputNormalizer {
+  normalize(raw: unknown): Items;
+  private normalizeItem;
+  private isItem;
+}
+//#endregion
+//#region src/runtime-types/persistedRuntimeTypeModelRegistry.d.ts
+type DecoratedRuntimeType = Readonly<{
+  name?: string;
+}> & object;
+type PersistedRuntimeTypeKind = "node" | "tool" | "chatModel";
+interface PersistedRuntimeTypeDecoratorOptions {
+  readonly name?: string;
+  readonly packageName?: string;
+  readonly moduleUrl?: string;
+}
+interface PersistedRuntimeTypeMetadata {
+  readonly persistedName: string;
+  readonly kind: PersistedRuntimeTypeKind;
+  readonly packageName: string;
+  readonly sourceHint?: string;
+}
+//#endregion
+//#region src/runtime-types/InjectableRuntimeDecoratorComposerRegistry.d.ts
+declare class InjectableRuntimeDecoratorComposer {
+  static compose(kind: PersistedRuntimeTypeKind, options: PersistedRuntimeTypeDecoratorOptions, decoratorFileUrl: string): ClassDecorator;
+}
+//#endregion
+//#region src/runtime-types/PersistedRuntimeTypeMetadataStoreRegistry.d.ts
+declare class PersistedRuntimeTypeMetadataStore {
+  static define(target: DecoratedRuntimeType, kind: PersistedRuntimeTypeKind, options: PersistedRuntimeTypeDecoratorOptions, decoratorFileUrl: string): void;
+  static get(target: unknown): PersistedRuntimeTypeMetadata | undefined;
+}
+//#endregion
+//#region src/runtime-types/PersistedRuntimeTypeNameResolver.d.ts
+declare class PersistedRuntimeTypeNameResolver {
+  static resolve(target: DecoratedRuntimeType, override: string | undefined): string;
+}
+//#endregion
+//#region src/runtime-types/StackTraceCallSitePathResolver.d.ts
+declare class StackTraceCallSitePathResolver {
+  static resolve(decoratorFileUrl: string): string | undefined;
+  private static extractPath;
+}
+//#endregion
+//#region src/runtime-types/runtimeTypeDecorators.types.d.ts
+declare function getPersistedRuntimeTypeMetadata(target: unknown): PersistedRuntimeTypeMetadata | undefined;
+declare function node(options?: PersistedRuntimeTypeDecoratorOptions): ClassDecorator;
+declare function tool(options?: PersistedRuntimeTypeDecoratorOptions): ClassDecorator;
+declare function chatModel(options?: PersistedRuntimeTypeDecoratorOptions): ClassDecorator;
+//#endregion
+//#region src/binaries/UnavailableBinaryStorage.d.ts
+declare class UnavailableBinaryStorage implements BinaryStorage {
+  readonly driverName = "unavailable";
+  write(): Promise<never>;
+  openReadStream(): Promise<undefined>;
+  stat(): Promise<{
+    exists: false;
+  }>;
+  delete(): Promise<void>;
+}
+//#endregion
+//#region src/binaries/DefaultExecutionBinaryServiceFactory.d.ts
+declare class DefaultExecutionBinaryService implements ExecutionBinaryService {
+  private readonly storage;
+  private readonly workflowId;
+  private readonly runId;
+  private readonly now;
+  constructor(storage: BinaryStorage, workflowId: WorkflowId, runId: RunId, now: () => Date);
+  forNode(args: {
+    nodeId: NodeId;
+    activationId: NodeActivationId;
+  }): NodeBinaryAttachmentService;
+  openReadStream(attachment: BinaryAttachment): Promise<BinaryStorageReadResult | undefined>;
+}
+//#endregion
+//#region src/executionContext/DefaultExecutionContextFactory.d.ts
+declare class DefaultExecutionContextFactory implements ExecutionContextFactory {
+  private readonly binaryStorage;
+  private readonly currentDate;
+  constructor(binaryStorage?: BinaryStorage, currentDate?: () => Date);
+  create(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    parent?: ParentExecutionRef;
+    subworkflowDepth: number;
+    engineMaxNodeActivations: number;
+    engineMaxSubworkflowDepth: number;
+    data: RunDataSnapshot;
+    nodeState?: NodeExecutionStatePublisher;
+    getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+  }): ExecutionContext;
+}
+//#endregion
+//#region src/policies/RunPolicySnapshotFactory.d.ts
+declare class RunPolicySnapshotFactory {
+  static create(workflow: WorkflowDefinition, defaults?: WorkflowPolicyRuntimeDefaults): PersistedRunPolicySnapshot;
+}
+//#endregion
+//#region src/policies/WorkflowStoragePolicyEvaluator.d.ts
+declare class WorkflowStoragePolicyEvaluator {
+  private readonly nodeResolver;
+  constructor(nodeResolver: NodeResolver);
+  shouldPersist(workflow: WorkflowDefinition, snapshot: PersistedRunPolicySnapshot | undefined, args: WorkflowStoragePolicyDecisionArgs): Promise<boolean>;
+  private modeMatches;
+}
+//#endregion
+//#region src/policies/RunTerminalPersistenceCoordinator.d.ts
+declare class RunTerminalPersistenceCoordinator {
+  private readonly runStore;
+  private readonly storageEvaluator;
+  constructor(runStore: RunStateStore, storageEvaluator: WorkflowStoragePolicyEvaluator);
+  maybeDeleteAfterTerminalState(args: {
+    workflow: WorkflowDefinition;
+    state: PersistedRunState;
+    finalStatus: "completed" | "failed";
+    finishedAt: string;
+  }): Promise<void>;
+}
+//#endregion
+//#region src/policies/WorkflowPolicyErrorServices.d.ts
+declare class WorkflowPolicyErrorServices {
+  private readonly nodeResolver;
+  constructor(nodeResolver: NodeResolver);
+  resolveNodeErrorHandler(spec: NodeErrorHandlerSpec | undefined): NodeErrorHandler | undefined;
+  resolveWorkflowErrorHandler(spec: WorkflowErrorHandlerSpec | undefined): WorkflowErrorHandler | undefined;
+}
+//#endregion
+//#region src/runStorage/InMemoryBinaryStorageRegistry.d.ts
+declare class InMemoryBinaryStorage implements BinaryStorage {
+  readonly driverName = "memory";
+  private readonly values;
+  write(args: {
+    storageKey: string;
+    body: BinaryBody;
+  }): Promise<BinaryStorageWriteResult>;
+  openReadStream(storageKey: string): Promise<BinaryStorageReadResult | undefined>;
+  stat(storageKey: string): Promise<BinaryStorageStatResult>;
+  delete(storageKey: string): Promise<void>;
+}
+//#endregion
+//#region src/runStorage/InMemoryRunDataFactory.d.ts
+declare class InMemoryRunDataFactory implements RunDataFactory {
+  create(initial?: Record<NodeId, NodeOutputs>): MutableRunData;
+}
+//#endregion
+//#region src/runStorage/InMemoryRunStateStore.d.ts
+declare class InMemoryRunStateStore implements RunStateStore, RunListingStore, RunPruneListingStore {
+  private readonly runs;
+  createRun(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    startedAt: string;
+    parent?: ParentExecutionRef;
+    executionOptions?: PersistedRunState["executionOptions"];
+    control?: PersistedRunState["control"];
+    workflowSnapshot?: PersistedRunState["workflowSnapshot"];
+    mutableState?: PersistedRunState["mutableState"];
+    policySnapshot?: PersistedRunState["policySnapshot"];
+    engineCounters?: EngineRunCounters;
+  }): Promise<void>;
+  load(runId: RunId): Promise<PersistedRunState | undefined>;
+  save(state: PersistedRunState): Promise<void>;
+  deleteRun(runId: RunId): Promise<void>;
+  listRuns(args?: Readonly<{
+    workflowId?: WorkflowId;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunSummary>>;
+  listRunsOlderThan(args: Readonly<{
+    beforeIso: string;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+}
+//#endregion
+//#region src/runStorage/RunSummaryMapper.d.ts
+/** Maps persisted run state to API run summaries for listings. */
+declare class RunSummaryMapper {
+  static fromPersistedState(state: PersistedRunState): RunSummary;
+}
+//#endregion
+//#region src/runtime/EngineWorkflowRunnerService.d.ts
+declare class EngineWorkflowRunnerService {
+  private readonly engine;
+  private readonly workflowRepository;
+  constructor(engine: Engine, workflowRepository: WorkflowRepository);
+  runById(args: {
+    workflowId: WorkflowId;
+    startAt?: NodeId;
+    items: Items;
+    parent?: ParentExecutionRef;
+  }): Promise<RunResult>;
+  private findDefaultStartNodeId;
+}
+//#endregion
+//#region src/runtime/RunIntentService.d.ts
+declare class RunIntentService {
+  private readonly engine;
+  private readonly workflowRepository;
+  constructor(engine: Engine, workflowRepository: WorkflowRepository);
+  startWorkflow(args: {
+    workflow: WorkflowDefinition;
+    startAt?: string;
+    items: Items;
+    parent?: CurrentStateExecutionRequest["parent"];
+    executionOptions?: RunExecutionOptions;
+    workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
+    mutableState?: CurrentStateExecutionRequest["mutableState"];
+    currentState?: RunCurrentState;
+    stopCondition?: RunStopCondition;
+    reset?: CurrentStateExecutionRequest["reset"];
+  }): Promise<RunResult>;
+  rerunFromNode(args: {
+    workflow: WorkflowDefinition;
+    nodeId: string;
+    currentState: RunCurrentState;
+    items?: Items;
+    parent?: CurrentStateExecutionRequest["parent"];
+    executionOptions?: RunExecutionOptions;
+    workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
+    mutableState?: CurrentStateExecutionRequest["mutableState"];
+  }): Promise<RunResult>;
+  resolveWebhookTrigger(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookTriggerResolution;
+  runMatchedWebhook(args: {
+    endpointPath: string;
+    method: HttpMethod;
+    requestItem: Items[number];
+  }): Promise<WebhookRunResult>;
+  runWebhookMatch(args: {
+    match: WebhookInvocationMatch;
+    requestItem: Items[number];
+  }): Promise<WebhookRunResult>;
+}
+//#endregion
+//#region src/execution/asyncSleeper.types.d.ts
+interface AsyncSleeper {
+  sleep(ms: number): Promise<void>;
+}
+//#endregion
+//#region src/execution/DefaultAsyncSleeper.d.ts
+declare class DefaultAsyncSleeper implements AsyncSleeper {
+  sleep(ms: number): Promise<void>;
+}
+//#endregion
+//#region src/execution/InProcessRetryRunner.d.ts
+declare class InProcessRetryRunner {
+  private readonly sleeper;
+  constructor(sleeper: AsyncSleeper);
+  run<T>(policy: RetryPolicySpec | undefined, work: () => Promise<T>): Promise<T>;
+  private static delayAfterFailureMs;
+  private static normalizePolicy;
+  private static assertPositiveInt;
+  private static assertNonNegativeFinite;
+  private static assertMultiplier;
+}
+//#endregion
+//#region src/execution/scheduling/ConfigDrivenOffloadPolicy.d.ts
+declare class ConfigDrivenOffloadPolicy implements NodeOffloadPolicy {
+  private readonly defaultMode;
+  constructor(defaultMode?: ExecutionMode);
+  decide(args: {
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    config: NodeConfigBase;
+  }): NodeSchedulerDecision;
+}
+//#endregion
+//#region src/execution/scheduling/InlineDrivingScheduler.d.ts
+declare class InlineDrivingScheduler implements NodeActivationScheduler {
+  private readonly nodeResolver;
+  private readonly retryRunner;
+  private continuation;
+  private readonly drainingRuns;
+  private readonly queuesByRunId;
+  private readonly scheduledRuns;
+  private seq;
+  constructor(nodeResolver: NodeResolver, retryRunner?: InProcessRetryRunner);
+  setContinuation(continuation: NodeActivationContinuation): void;
+  enqueue(request: NodeActivationRequest): Promise<NodeActivationReceipt>;
+  notifyPendingStatePersisted(runId: RunId): void;
+  private drainRun;
+  private scheduleDrain;
+  private executeRequest;
+  private resumeAfterExecutionResult;
+  private resumeAfterExecutionError;
+  private asError;
+  private rethrowUnlessIgnorableContinuationError;
+  private isIgnorableContinuationError;
+  private resolveNodeInstance;
+}
+//#endregion
+//#region src/execution/scheduling/DefaultDrivingScheduler.d.ts
+declare class DefaultDrivingScheduler implements NodeActivationScheduler {
+  private readonly offloadPolicy;
+  private readonly workerScheduler;
+  private readonly inline;
+  constructor(offloadPolicy: NodeOffloadPolicy, workerScheduler: NodeExecutionScheduler, inline: InlineDrivingScheduler);
+  setContinuation(continuation: NodeActivationContinuation): void;
+  enqueue(request: NodeActivationRequest): Promise<NodeActivationReceipt>;
+  notifyPendingStatePersisted(runId: string): void;
+}
+//#endregion
+//#region src/execution/scheduling/HintOnlyOffloadPolicy.d.ts
+declare class HintOnlyOffloadPolicy implements NodeOffloadPolicy {
+  decide(args: {
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    config: NodeConfigBase;
+  }): NodeSchedulerDecision;
+}
+//#endregion
+//#region src/execution/scheduling/LocalOnlyScheduler.d.ts
+declare class LocalOnlyScheduler implements NodeExecutionScheduler {
+  enqueue(_request: NodeExecutionRequest): Promise<{
+    receiptId: string;
+  }>;
+}
+//#endregion
+export { ZodSchemaAny as $, PersistedRuntimeTypeDecoratorOptions as A, AgentNodeConfig as B, getPersistedRuntimeTypeMetadata as C, PersistedRuntimeTypeNameResolver as D, StackTraceCallSitePathResolver as E, InMemoryRunEventBus as F, AgentToolExecuteArgs as G, AgentToolCall as H, CoreTokens as I, ChatModelFactory as J, AgentToolToken as K, AgentAttachmentRole as L, PersistedRuntimeTypeMetadata as M, ItemsInputNormalizer as N, PersistedRuntimeTypeMetadataStore as O, PublishingRunStateStore as P, ToolExecuteArgs as Q, AgentCanvasPresentation as R, chatModel as S, tool as T, AgentToolCallPlanner as U, AgentTool as V, AgentToolDefinition as W, Tool as X, LangChainChatModelLike as Y, ToolConfig as Z, WorkflowStoragePolicyEvaluator as _, ConfigDrivenOffloadPolicy as a, EngineCompositionDeps as at, DefaultExecutionBinaryService as b, AsyncSleeper as c, EngineExecutionLimitsPolicy as ct, RunSummaryMapper as d, Clock as et, InMemoryRunStateStore as f, RunTerminalPersistenceCoordinator as g, WorkflowPolicyErrorServices as h, InlineDrivingScheduler as i, EngineExecutionLimitsPolicyFactory as it, PersistedRuntimeTypeKind as j, InjectableRuntimeDecoratorComposer as k, RunIntentService as l, EngineExecutionLimitsPolicyConfig as lt, InMemoryBinaryStorage as m, HintOnlyOffloadPolicy as n, CredentialResolverFactory as nt, InProcessRetryRunner as o, EngineFactory as ot, InMemoryRunDataFactory as p, ChatModelConfig as q, DefaultDrivingScheduler as r, NodeEventPublisher as rt, DefaultAsyncSleeper as s, ENGINE_EXECUTION_LIMITS_DEFAULTS as st, LocalOnlyScheduler as t, SystemClock as tt, EngineWorkflowRunnerService as u, Engine as ut, RunPolicySnapshotFactory as v, node as w, UnavailableBinaryStorage as x, DefaultExecutionContextFactory as y, AgentConfigInspector as z };
+//# sourceMappingURL=index-gIcH60sp.d.ts.map