@codemation/core 0.11.0 → 0.12.0

package/dist/contracts-CK0x6w_G.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts-CK0x6w_G.cjs","names":[],"sources":["../src/contracts/AgentBindError.ts","../src/contracts/NoOpAgentMcpIntegration.ts","../src/contracts/assertionTypes.ts"],"sourcesContent":["/**\n * Thrown at agent bind time when mcpServers declarations cannot be resolved.\n * Causes include: unknown server id, missing credential instance, insufficient scopes,\n * and ambiguous shorthand binding (multiple credential instances match).\n */\nexport class AgentBindError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"AgentBindError\";\n  }\n}\n","import type { AgentMcpIntegration, AgentMcpToolMap } from \"./agentMcpTypes\";\n\n/**\n * No-op implementation of AgentMcpIntegration.\n * Registered by the core engine runtime as a fallback when the host does not\n * supply a real implementation (e.g. in unit tests or headless engine setups).\n * Always returns an empty tool map so the agent runs with node-backed tools only.\n */\nexport class NoOpAgentMcpIntegration implements AgentMcpIntegration {\n  async prepareMcpTools(): Promise<AgentMcpToolMap> {\n    return new Map();\n  }\n}\n","import type { JsonValue, NodeId } from \"./workflowTypes\";\n\n/**\n * One assertion emitted by an assertion-emitting node (a node whose config sets\n * `emitsAssertions: true`). Each emitted item on `main` carries one of these as `item.json`.\n *\n * Pass/fail is derived from `score >= (passThreshold ?? 0.5)` — see {@link deriveAssertionPassed}.\n * The `errored` marker is for cases where the assertion code itself threw (distinct from\n * \"the assertion was evaluated and the score was low\") and is treated as a hard fail in rollups\n * regardless of `score`.\n */\nexport interface AssertionResult {\n  readonly name: string;\n  /** 0..1 score. Source of truth for pass/fail (compared against `passThreshold`). */\n  readonly score: number;\n  /** 0..1 threshold for \"passed\". When omitted, consumers default to 0.5. */\n  readonly passThreshold?: number;\n  /** True when evaluating the assertion threw — treated as fail regardless of `score`. */\n  readonly errored?: true;\n  /** What the assertion expected. Free-form JSON; UIs render with a JSON viewer. */\n  readonly expected?: JsonValue;\n  /** What the workflow actually produced. */\n  readonly actual?: JsonValue;\n  /** Short human-readable explanation, especially for fails / errors. */\n  readonly message?: string;\n  /** Bag of supplemental fields (e.g. judge prompt, judge raw response, comparison method). */\n  readonly details?: Readonly<Record<string, JsonValue>>;\n}\n\n/**\n * Default {@link AssertionResult.passThreshold} when authors omit it. Boolean-style assertions\n * (assertEqual / contains / etc.) emit `score: 1` or `score: 0` so this default works for them;\n * AI-judge assertions are expected to set their own threshold.\n */\nexport const DEFAULT_ASSERTION_PASS_THRESHOLD = 0.5;\n\n/**\n * Derive whether an assertion result is considered \"passing\" using the score-based contract:\n * `errored` always fails, otherwise `score >= (passThreshold ?? 0.5)`. This is the canonical\n * derivation — UI and rollup code should call it rather than inlining the comparison so future\n * tweaks (e.g. NaN handling) land in one place.\n */\nexport function deriveAssertionPassed(result: {\n  readonly score: number;\n  readonly passThreshold?: number;\n  readonly errored?: true;\n}): boolean {\n  if (result.errored === true) return false;\n  const threshold = result.passThreshold ?? DEFAULT_ASSERTION_PASS_THRESHOLD;\n  return result.score >= threshold;\n}\n\n/**\n * Provenance for a persisted {@link AssertionResult}: which node produced it and where in the\n * per-item iteration tree it landed. Filled in by the host-side persister, not the node itself.\n */\nexport interface AssertionResultProvenance {\n  readonly nodeId: NodeId;\n  /** Per-item iteration id when the emitting node ran inside a per-item loop. */\n  readonly iterationId?: string;\n  /** Item index (0-based) within the activation that produced this assertion. */\n  readonly itemIndex?: number;\n}\n"],"mappings":";;;;;;;AAKA,IAAa,iBAAb,cAAoC,MAAM;CACxC,YAAY,SAAiB;AAC3B,QAAM,QAAQ;AACd,OAAK,OAAO;;;;;;;;;;;;ACAhB,IAAa,0BAAb,MAAoE;CAClE,MAAM,kBAA4C;AAChD,yBAAO,IAAI,KAAK;;;;;;;;;;;ACwBpB,MAAa,mCAAmC;;;;;;;AAQhD,SAAgB,sBAAsB,QAI1B;AACV,KAAI,OAAO,YAAY,KAAM,QAAO;CACpC,MAAM,YAAY,OAAO,iBAAiB;AAC1C,QAAO,OAAO,SAAS"}

package/dist/contracts-DXdfTdpW.js

@@ -0,0 +1,50 @@
+//#region src/contracts/AgentBindError.ts
+/**
+* Thrown at agent bind time when mcpServers declarations cannot be resolved.
+* Causes include: unknown server id, missing credential instance, insufficient scopes,
+* and ambiguous shorthand binding (multiple credential instances match).
+*/
+var AgentBindError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AgentBindError";
+	}
+};
+
+//#endregion
+//#region src/contracts/NoOpAgentMcpIntegration.ts
+/**
+* No-op implementation of AgentMcpIntegration.
+* Registered by the core engine runtime as a fallback when the host does not
+* supply a real implementation (e.g. in unit tests or headless engine setups).
+* Always returns an empty tool map so the agent runs with node-backed tools only.
+*/
+var NoOpAgentMcpIntegration = class {
+	async prepareMcpTools() {
+		return /* @__PURE__ */ new Map();
+	}
+};
+
+//#endregion
+//#region src/contracts/assertionTypes.ts
+/**
+* Default {@link AssertionResult.passThreshold} when authors omit it. Boolean-style assertions
+* (assertEqual / contains / etc.) emit `score: 1` or `score: 0` so this default works for them;
+* AI-judge assertions are expected to set their own threshold.
+*/
+const DEFAULT_ASSERTION_PASS_THRESHOLD = .5;
+/**
+* Derive whether an assertion result is considered "passing" using the score-based contract:
+* `errored` always fails, otherwise `score >= (passThreshold ?? 0.5)`. This is the canonical
+* derivation — UI and rollup code should call it rather than inlining the comparison so future
+* tweaks (e.g. NaN handling) land in one place.
+*/
+function deriveAssertionPassed(result) {
+	if (result.errored === true) return false;
+	const threshold = result.passThreshold ?? DEFAULT_ASSERTION_PASS_THRESHOLD;
+	return result.score >= threshold;
+}
+
+//#endregion
+export { AgentBindError as i, deriveAssertionPassed as n, NoOpAgentMcpIntegration as r, DEFAULT_ASSERTION_PASS_THRESHOLD as t };
+//# sourceMappingURL=contracts-DXdfTdpW.js.map

package/dist/contracts-DXdfTdpW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts-DXdfTdpW.js","names":[],"sources":["../src/contracts/AgentBindError.ts","../src/contracts/NoOpAgentMcpIntegration.ts","../src/contracts/assertionTypes.ts"],"sourcesContent":["/**\n * Thrown at agent bind time when mcpServers declarations cannot be resolved.\n * Causes include: unknown server id, missing credential instance, insufficient scopes,\n * and ambiguous shorthand binding (multiple credential instances match).\n */\nexport class AgentBindError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"AgentBindError\";\n  }\n}\n","import type { AgentMcpIntegration, AgentMcpToolMap } from \"./agentMcpTypes\";\n\n/**\n * No-op implementation of AgentMcpIntegration.\n * Registered by the core engine runtime as a fallback when the host does not\n * supply a real implementation (e.g. in unit tests or headless engine setups).\n * Always returns an empty tool map so the agent runs with node-backed tools only.\n */\nexport class NoOpAgentMcpIntegration implements AgentMcpIntegration {\n  async prepareMcpTools(): Promise<AgentMcpToolMap> {\n    return new Map();\n  }\n}\n","import type { JsonValue, NodeId } from \"./workflowTypes\";\n\n/**\n * One assertion emitted by an assertion-emitting node (a node whose config sets\n * `emitsAssertions: true`). Each emitted item on `main` carries one of these as `item.json`.\n *\n * Pass/fail is derived from `score >= (passThreshold ?? 0.5)` — see {@link deriveAssertionPassed}.\n * The `errored` marker is for cases where the assertion code itself threw (distinct from\n * \"the assertion was evaluated and the score was low\") and is treated as a hard fail in rollups\n * regardless of `score`.\n */\nexport interface AssertionResult {\n  readonly name: string;\n  /** 0..1 score. Source of truth for pass/fail (compared against `passThreshold`). */\n  readonly score: number;\n  /** 0..1 threshold for \"passed\". When omitted, consumers default to 0.5. */\n  readonly passThreshold?: number;\n  /** True when evaluating the assertion threw — treated as fail regardless of `score`. */\n  readonly errored?: true;\n  /** What the assertion expected. Free-form JSON; UIs render with a JSON viewer. */\n  readonly expected?: JsonValue;\n  /** What the workflow actually produced. */\n  readonly actual?: JsonValue;\n  /** Short human-readable explanation, especially for fails / errors. */\n  readonly message?: string;\n  /** Bag of supplemental fields (e.g. judge prompt, judge raw response, comparison method). */\n  readonly details?: Readonly<Record<string, JsonValue>>;\n}\n\n/**\n * Default {@link AssertionResult.passThreshold} when authors omit it. Boolean-style assertions\n * (assertEqual / contains / etc.) emit `score: 1` or `score: 0` so this default works for them;\n * AI-judge assertions are expected to set their own threshold.\n */\nexport const DEFAULT_ASSERTION_PASS_THRESHOLD = 0.5;\n\n/**\n * Derive whether an assertion result is considered \"passing\" using the score-based contract:\n * `errored` always fails, otherwise `score >= (passThreshold ?? 0.5)`. This is the canonical\n * derivation — UI and rollup code should call it rather than inlining the comparison so future\n * tweaks (e.g. NaN handling) land in one place.\n */\nexport function deriveAssertionPassed(result: {\n  readonly score: number;\n  readonly passThreshold?: number;\n  readonly errored?: true;\n}): boolean {\n  if (result.errored === true) return false;\n  const threshold = result.passThreshold ?? DEFAULT_ASSERTION_PASS_THRESHOLD;\n  return result.score >= threshold;\n}\n\n/**\n * Provenance for a persisted {@link AssertionResult}: which node produced it and where in the\n * per-item iteration tree it landed. Filled in by the host-side persister, not the node itself.\n */\nexport interface AssertionResultProvenance {\n  readonly nodeId: NodeId;\n  /** Per-item iteration id when the emitting node ran inside a per-item loop. */\n  readonly iterationId?: string;\n  /** Item index (0-based) within the activation that produced this assertion. */\n  readonly itemIndex?: number;\n}\n"],"mappings":";;;;;;AAKA,IAAa,iBAAb,cAAoC,MAAM;CACxC,YAAY,SAAiB;AAC3B,QAAM,QAAQ;AACd,OAAK,OAAO;;;;;;;;;;;;ACAhB,IAAa,0BAAb,MAAoE;CAClE,MAAM,kBAA4C;AAChD,yBAAO,IAAI,KAAK;;;;;;;;;;;ACwBpB,MAAa,mCAAmC;;;;;;;AAQhD,SAAgB,sBAAsB,QAI1B;AACV,KAAI,OAAO,YAAY,KAAM,QAAO;CACpC,MAAM,YAAY,OAAO,iBAAiB;AAC1C,QAAO,OAAO,SAAS"}

package/dist/contracts.cjs

@@ -0,0 +1,6 @@
+const require_contracts = require('./contracts-CK0x6w_G.cjs');
+
+exports.AgentBindError = require_contracts.AgentBindError;
+exports.DEFAULT_ASSERTION_PASS_THRESHOLD = require_contracts.DEFAULT_ASSERTION_PASS_THRESHOLD;
+exports.NoOpAgentMcpIntegration = require_contracts.NoOpAgentMcpIntegration;
+exports.deriveAssertionPassed = require_contracts.deriveAssertionPassed;

package/dist/contracts.d.cts

@@ -0,0 +1,5 @@
+import { $n as NodeActivationRequestBase, $r as GenAiTelemetryAttributeNames, $t as RunnableNodeConfig, A as RunHaltReason, Ai as CredentialRequirement, An as BinaryBody, Ar as HttpMethod, At as JsonValue, B as WorkflowExecutionListingRepository, Bi as OAuth2ProviderFromPublicConfig, Bn as ExecutionBinaryService, Br as ExecutionTelemetryFactory, Bt as NodeIterationId, C as PersistedWorkflowSnapshotNode, Ci as CredentialHealthTester, Cn as triggerNodeOutputType, Cr as TriggerTestItemsContext, Ct as Item, D as RunCurrentState, Di as CredentialMaterialSourceKind, Dn as NoneRetryPolicySpec, Dr as WorkflowRunnerService, Dt as JsonNonArray, E as RunCompletionNotifier, Ei as CredentialJsonRecord, En as FixedRetryPolicySpec, Er as WorkflowRunnerResolver, Et as JsonArray, F as RunStatus, Fi as CredentialType, Fn as BinaryStorageWriteResult, Fr as WebhookTriggerResolution, Ft as NodeErrorHandler, Gi as NodeConnectionName, Gn as HumanTaskId, Gr as TelemetryAttributes, Gt as NodeSchedulerDecision, H as WorkflowExecutionRepository, Hn as ExecutionContextFactory, Hr as TelemetryArtifactAttachment, Ht as NodeOffloadPolicy, I as RunStopCondition, Ii as CredentialTypeDefinition, In as Duration, Ir as WebhookTriggerRoutingDiagnostics, It as NodeErrorHandlerArgs, Ji as PersistedTokenId, Jn as LiveWorkflowRepository, Jr as TelemetryScope, Jt as PersistedRunPolicySnapshot, Ki as NodeId, Kn as HumanTaskSubject, Kr as TelemetryChildSpanStart, Kt as PairedItemRef, L as RunSummary, Li as CredentialTypeId, Ln as EngineDeps, Lt as NodeErrorHandlerSpec, M as RunQueueEntry, Mi as CredentialSessionFactoryArgs, Mn as BinaryStorageReadResult, Mr as WebhookControlSignal, Mt as NodeActivationId, N as RunResult, Ni as CredentialSessionService, Nn as BinaryStorageStatResult, Nr as WebhookInvocationMatch, Nt as NodeConfigBase, O as RunEventPublisherDeps, Oi as CredentialOAuth2AuthDefinition, On as RetryPolicySpec, Or as WorkflowSnapshotFactory, Ot as JsonObject, P as RunStateResetRequest, Pi as CredentialSetupStatus, Pn as BinaryStorageWriteRequest, Pr as WebhookTriggerMatcher, Pt as NodeDefinition, Qn as NodeActivationRequest, Qr as CodemationTelemetryMetricNames, Qt as RunIdFactory, R as RunTestContext, Ri as CredentialTypeRegistry, Rn as EngineHost, Rt as NodeIdRef, S as PersistedWorkflowSnapshot, Si as CredentialHealthStatus, Sn as runnableNodeOutputType, Sr as TriggerSetupStateRepository, St as ExecutionMode, T as PinnedNodeOutputsByPort, Ti as CredentialInstanceRecord, Tn as ExponentialRetryPolicySpec, Tr as WorkflowRepository, Tt as Items, Un as HumanTaskActor, Ur as TelemetryArtifactReference, Ut as NodeOutputs, V as WorkflowExecutionPruneRepository, Vn as ExecutionContext, Vr as NodeExecutionTelemetry, Vt as NodeKind, Wi as InputPortKey, Wn as HumanTaskHandle, Wr as TelemetryAttributePrimitive, Wt as NodeRef, Xn as NodeActivationContinuation, Xr as TelemetrySpanEventRecord, Xt as RunDataSnapshot, Yi as WorkflowId, Yn as MultiInputNode, Yr as TelemetrySpanEnd, Yt as RunDataFactory, Zn as NodeActivationReceipt, Zr as TelemetrySpanScope, Zt as RunId, _ as PersistedMutableRunState, _i as CredentialAuthDefinition, _n as WorkflowStoragePolicyResolver, _r as TriggerCleanupHandle, _t as TestTriggerSetupContext, a as ConnectionInvocationId, ai as NoOpTelemetryArtifactReference, an as UpstreamRefPlaceholder, ar as NodeExecutionScheduler, b as PersistedRunState, bi as CredentialFieldSchema, bn as nodeRef, br as TriggerSetupContext, bt as BinaryPreviewKind, c as EngineRunCounters, ci as CostTrackingTelemetry, cn as WorkflowErrorHandler, cr as NodeResolver, d as NodeExecutionSnapshot, dn as WorkflowGraphFactory, dr as PreparedNodeActivationDispatch, ei as CodemationTelemetryAttributeNames, en as RunnableNodeInputJson, er as NodeActivationScheduler, f as NodeExecutionStatus, fi as CostTrackingUsageRecord, fn as WorkflowNodeConnection, fr as ResumeContext, g as PersistedMutableNodeState, gi as CredentialAdvancedSectionPresentation, gn as WorkflowStoragePolicyMode, gr as TestableTriggerNode, gt as TestTriggerNodeConfig, h as PendingResumeEntry, hi as AnyCredentialType, hn as WorkflowStoragePolicyDecisionArgs, hr as SuspensionRequest, ht as TestSuiteRunId, i as ConnectionInvocationAppendArgs, ii as NoOpTelemetrySpanScope, in as TriggerNodeSetupState, ir as NodeExecutionRequestHandler, j as RunPruneCandidate, ji as CredentialSessionFactory, jn as BinaryStorage, jr as TriggerInstanceId, jt as MutableRunData, k as RunExecutionOptions, ki as CredentialOAuth2ScopesFromPublicConfig, kn as BinaryAttachmentCreateRequest, kr as WorkflowSnapshotResolver, kt as JsonPrimitive, l as ExecutionFrontierPlan, ln as WorkflowErrorHandlerSpec, lr as PersistedTriggerSetupState, m as PendingNodeExecution, mn as WorkflowPrunePolicySpec, mr as RunnableNodeExecuteArgs, n as AgentMcpToolMap, ni as NoOpExecutionTelemetry, nn as TriggerNodeConfig, nr as NodeExecutionContext, o as ConnectionInvocationRecord, oi as CostTrackingComponent, on as WorkflowDefinition, or as NodeExecutionStatePublisher, p as NodeInputsByPort, pn as WorkflowPolicyRuntimeDefaults, pr as RunnableNode, qi as OutputPortKey, qn as ItemNode, qr as TelemetryMetricRecord, qt as ParentExecutionRef, r as NeedsReconsentEvent, ri as NoOpNodeExecutionTelemetry, rn as TriggerNodeOutputJson, rr as NodeExecutionRequest, s as CurrentStateExecutionRequest, si as CostTrackingPriceQuote, sn as WorkflowErrorContext, sr as NodeExecutor, t as AgentMcpIntegration, ti as NoOpExecutionTelemetryFactory, tn as RunnableNodeOutputJson, tr as NodeBinaryAttachmentService, u as NodeExecutionError, ui as CostTrackingTelemetryFactory, un as WorkflowGraph, ur as PollingTriggerHandle, v as PersistedRunControlState, vi as CredentialBinding, vn as WorkflowStoragePolicySpec, vr as TriggerNode, vt as ActivationIdFactory, w as PersistedWorkflowTokenRegistryLike, wi as CredentialInstanceId, wn as triggerNodeSetupStateType, wr as WorkflowNodeInstanceFactory, wt as ItemBinary, x as PersistedSuspensionEntry, xi as CredentialHealth, xn as runnableNodeInputType, xr as TriggerSetupStateFor, xt as Edge, y as PersistedRunSchedulingState, yi as CredentialBindingKey, yn as branchRef, yr as TriggerRuntimeDiagnostics, yt as BinaryAttachment, z as WebhookRunResult, zn as ExecutableTriggerNode, zr as ExecutionTelemetry, zt as NodeInspectorSummaryRow } from "./agentMcpTypes-DUmniLOY.cjs";
+import { C as deriveAssertionPassed, S as DEFAULT_ASSERTION_PASS_THRESHOLD, T as AgentBindError, _ as WorkItemStatus, a as ExecutionPayloadPolicyFields, b as AssertionResult, c as PersistedExecutionInstanceRecord, d as PersistedRunWorkItemRecord, f as RunIterationDto, g as WorkItemId, h as SlotExecutionStateDto, i as ExecutionInstanceId, l as PersistedRunSlotProjectionRecord, m as RunSlotProjectionState, n as ConnectionInvocationKind, o as PayloadStorageKind, p as RunRevision, r as ExecutionInstanceDto, s as PersistedExecutionInstanceKind, t as BatchId, u as PersistedRunWorkItemKind, v as WorkflowDetailSelectionState, w as NoOpAgentMcpIntegration, x as AssertionResultProvenance, y as WorkflowRunDetailDto } from "./executionPersistenceContracts-DenJJK2T.cjs";
+import { n as Param, r as ParamDeep, t as Expr } from "./params-DqRvku2h.cjs";
+import { n as CostCatalogEntry, t as CostCatalog } from "./CostCatalogContract-DD7fQ4FF.cjs";
+export { ActivationIdFactory, AgentBindError, AgentMcpIntegration, AgentMcpToolMap, type AnyCredentialType, AssertionResult, AssertionResultProvenance, BatchId, BinaryAttachment, BinaryAttachmentCreateRequest, BinaryBody, BinaryPreviewKind, BinaryStorage, BinaryStorageReadResult, BinaryStorageStatResult, BinaryStorageWriteRequest, BinaryStorageWriteResult, CodemationTelemetryAttributeNames, CodemationTelemetryMetricNames, ConnectionInvocationAppendArgs, ConnectionInvocationId, ConnectionInvocationKind, ConnectionInvocationRecord, CostCatalog, CostCatalogEntry, type CostTrackingComponent, type CostTrackingPriceQuote, type CostTrackingTelemetry, type CostTrackingTelemetryFactory, type CostTrackingUsageRecord, type CredentialAdvancedSectionPresentation, type CredentialAuthDefinition, type CredentialBinding, type CredentialBindingKey, type CredentialFieldSchema, type CredentialHealth, type CredentialHealthStatus, type CredentialHealthTester, type CredentialInstanceId, type CredentialInstanceRecord, type CredentialJsonRecord, type CredentialMaterialSourceKind, type CredentialOAuth2AuthDefinition, type CredentialOAuth2ScopesFromPublicConfig, type CredentialRequirement, type CredentialSessionFactory, type CredentialSessionFactoryArgs, type CredentialSessionService, type CredentialSetupStatus, type CredentialType, type CredentialTypeDefinition, type CredentialTypeId, type CredentialTypeRegistry, CurrentStateExecutionRequest, DEFAULT_ASSERTION_PASS_THRESHOLD, Duration, Edge, EngineDeps, EngineHost, EngineRunCounters, ExecutableTriggerNode, ExecutionBinaryService, ExecutionContext, ExecutionContextFactory, ExecutionFrontierPlan, ExecutionInstanceDto, ExecutionInstanceId, ExecutionMode, ExecutionPayloadPolicyFields, ExecutionTelemetry, ExecutionTelemetryFactory, ExponentialRetryPolicySpec, Expr, FixedRetryPolicySpec, GenAiTelemetryAttributeNames, HttpMethod, HumanTaskActor, HumanTaskHandle, HumanTaskId, HumanTaskSubject, InputPortKey, Item, ItemBinary, ItemNode, Items, JsonArray, JsonNonArray, JsonObject, JsonPrimitive, JsonValue, LiveWorkflowRepository, MultiInputNode, MutableRunData, NeedsReconsentEvent, NoOpAgentMcpIntegration, NoOpExecutionTelemetry, NoOpExecutionTelemetryFactory, NoOpNodeExecutionTelemetry, NoOpTelemetryArtifactReference, NoOpTelemetrySpanScope, NodeActivationContinuation, NodeActivationId, NodeActivationReceipt, NodeActivationRequest, NodeActivationRequestBase, NodeActivationScheduler, NodeBinaryAttachmentService, NodeConfigBase, NodeConnectionName, NodeDefinition, NodeErrorHandler, NodeErrorHandlerArgs, NodeErrorHandlerSpec, NodeExecutionContext, NodeExecutionError, NodeExecutionRequest, NodeExecutionRequestHandler, NodeExecutionScheduler, NodeExecutionSnapshot, NodeExecutionStatePublisher, NodeExecutionStatus, NodeExecutionTelemetry, NodeExecutor, NodeId, NodeIdRef, NodeInputsByPort, NodeInspectorSummaryRow, NodeIterationId, NodeKind, NodeOffloadPolicy, NodeOutputs, NodeRef, NodeResolver, NodeSchedulerDecision, NoneRetryPolicySpec, type OAuth2ProviderFromPublicConfig, OutputPortKey, PairedItemRef, Param, ParamDeep, ParentExecutionRef, PayloadStorageKind, PendingNodeExecution, PendingResumeEntry, PersistedExecutionInstanceKind, PersistedExecutionInstanceRecord, PersistedMutableNodeState, PersistedMutableRunState, PersistedRunControlState, PersistedRunPolicySnapshot, PersistedRunSchedulingState, PersistedRunSlotProjectionRecord, PersistedRunState, PersistedRunWorkItemKind, PersistedRunWorkItemRecord, PersistedSuspensionEntry, PersistedTokenId, PersistedTriggerSetupState, PersistedWorkflowSnapshot, PersistedWorkflowSnapshotNode, PersistedWorkflowTokenRegistryLike, PinnedNodeOutputsByPort, PollingTriggerHandle, PreparedNodeActivationDispatch, ResumeContext, RetryPolicySpec, RunCompletionNotifier, RunCurrentState, RunDataFactory, RunDataSnapshot, RunEventPublisherDeps, RunExecutionOptions, RunHaltReason, RunId, RunIdFactory, RunIterationDto, RunPruneCandidate, RunQueueEntry, RunResult, RunRevision, RunSlotProjectionState, RunStateResetRequest, RunStatus, RunStopCondition, RunSummary, RunTestContext, RunnableNode, RunnableNodeConfig, RunnableNodeExecuteArgs, RunnableNodeInputJson, RunnableNodeOutputJson, SlotExecutionStateDto, SuspensionRequest, TelemetryArtifactAttachment, TelemetryArtifactReference, TelemetryAttributePrimitive, TelemetryAttributes, TelemetryChildSpanStart, TelemetryMetricRecord, TelemetryScope, TelemetrySpanEnd, TelemetrySpanEventRecord, TelemetrySpanScope, TestSuiteRunId, TestTriggerNodeConfig, TestTriggerSetupContext, TestableTriggerNode, TriggerCleanupHandle, TriggerInstanceId, TriggerNode, TriggerNodeConfig, TriggerNodeOutputJson, TriggerNodeSetupState, TriggerRuntimeDiagnostics, TriggerSetupContext, TriggerSetupStateFor, TriggerSetupStateRepository, TriggerTestItemsContext, UpstreamRefPlaceholder, WebhookControlSignal, WebhookInvocationMatch, WebhookRunResult, WebhookTriggerMatcher, WebhookTriggerResolution, WebhookTriggerRoutingDiagnostics, WorkItemId, WorkItemStatus, WorkflowDefinition, WorkflowDetailSelectionState, WorkflowErrorContext, WorkflowErrorHandler, WorkflowErrorHandlerSpec, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository, WorkflowExecutionRepository, WorkflowGraph, WorkflowGraphFactory, WorkflowId, WorkflowNodeConnection, WorkflowNodeInstanceFactory, WorkflowPolicyRuntimeDefaults, WorkflowPrunePolicySpec, WorkflowRepository, WorkflowRunDetailDto, WorkflowRunnerResolver, WorkflowRunnerService, WorkflowSnapshotFactory, WorkflowSnapshotResolver, WorkflowStoragePolicyDecisionArgs, WorkflowStoragePolicyMode, WorkflowStoragePolicyResolver, WorkflowStoragePolicySpec, branchRef, deriveAssertionPassed, nodeRef, runnableNodeInputType, runnableNodeOutputType, triggerNodeOutputType, triggerNodeSetupStateType };

package/dist/contracts.d.ts

@@ -0,0 +1,2 @@
+import { $ as ExecutionPayloadPolicyFields, $a as CredentialFieldSchema, $i as TriggerSetupContext, $n as BinaryPreviewKind, $r as nodeRef, $t as PersistedRunState, Aa as TelemetrySpanScope, Ai as NodeActivationReceipt, Ar as RunId, At as DEFAULT_ASSERTION_PASS_THRESHOLD, Ba as CostTrackingPriceQuote, Bi as NodeExecutor, Br as WorkflowErrorContext, Bt as CurrentStateExecutionRequest, Ca as TelemetryAttributePrimitive, Ci as HumanTaskHandle, Co as InputPortKey, Cr as NodeRef, Da as TelemetryScope, Di as LiveWorkflowRepository, Do as PersistedTokenId, Dr as PersistedRunPolicySnapshot, Ea as TelemetryMetricRecord, Ei as ItemNode, Eo as OutputPortKey, Er as ParentExecutionRef, Fa as NoOpExecutionTelemetry, Fi as NodeExecutionContext, Fr as TriggerNodeConfig, Ft as AgentMcpToolMap, Ga as CostTrackingUsageRecord, Gi as ResumeContext, Gr as WorkflowNodeConnection, Gt as NodeExecutionStatus, Hi as PersistedTriggerSetupState, Hr as WorkflowErrorHandlerSpec, Ht as ExecutionFrontierPlan, Ia as NoOpNodeExecutionTelemetry, Ii as NodeExecutionRequest, Ir as TriggerNodeOutputJson, It as NeedsReconsentEvent, Ja as AnyCredentialType, Ji as SuspensionRequest, Jn as TestSuiteRunId, Jr as WorkflowStoragePolicyDecisionArgs, Jt as PendingResumeEntry, Ki as RunnableNode, Kr as WorkflowPolicyRuntimeDefaults, Kt as NodeInputsByPort, La as NoOpTelemetrySpanScope, Li as NodeExecutionRequestHandler, Lr as TriggerNodeSetupState, Lt as ConnectionInvocationAppendArgs, Ma as GenAiTelemetryAttributeNames, Mi as NodeActivationRequestBase, Mr as RunnableNodeConfig, Mt as NoOpAgentMcpIntegration, Na as CodemationTelemetryAttributeNames, Ni as NodeActivationScheduler, Nr as RunnableNodeInputJson, Nt as AgentBindError, Oa as TelemetrySpanEnd, Oi as MultiInputNode, Oo as WorkflowId, Or as RunDataFactory, Ot as AssertionResult, Pa as NoOpExecutionTelemetryFactory, Pi as NodeBinaryAttachmentService, Pr as RunnableNodeOutputJson, Pt as AgentMcpIntegration, Q as ExecutionInstanceId, Qa as CredentialBindingKey, Qi as TriggerRuntimeDiagnostics, Qn as BinaryAttachment, Qr as branchRef, Qt as PersistedRunSchedulingState, Ra as NoOpTelemetryArtifactReference, Ri as NodeExecutionScheduler, Rr as UpstreamRefPlaceholder, Rt as ConnectionInvocationId, Sa as TelemetryArtifactReference, Si as HumanTaskActor, Sr as NodeOutputs, Ta as TelemetryChildSpanStart, Ti as HumanTaskSubject, To as NodeId, Tr as PairedItemRef, Ua as CostTrackingTelemetryFactory, Ui as PollingTriggerHandle, Ur as WorkflowGraph, Ut as NodeExecutionError, Va as CostTrackingTelemetry, Vi as NodeResolver, Vr as WorkflowErrorHandler, Vt as EngineRunCounters, Wi as PreparedNodeActivationDispatch, Wr as WorkflowGraphFactory, Wt as NodeExecutionSnapshot, X as ConnectionInvocationKind, Xa as CredentialAuthDefinition, Xi as TriggerCleanupHandle, Xn as TestTriggerSetupContext, Xr as WorkflowStoragePolicyResolver, Xt as PersistedMutableRunState, Y as BatchId, Ya as CredentialAdvancedSectionPresentation, Yi as TestableTriggerNode, Yn as TestTriggerNodeConfig, Yr as WorkflowStoragePolicyMode, Yt as PersistedMutableNodeState, Z as ExecutionInstanceDto, Za as CredentialBinding, Zi as TriggerNode, Zn as ActivationIdFactory, Zr as WorkflowStoragePolicySpec, Zt as PersistedRunControlState, _i as EngineHost, _n as RunTestContext, _o as CredentialTypeRegistry, _r as NodeIdRef, _t as Param, aa as WorkflowRunnerResolver, ai as FixedRetryPolicySpec, an as RunCompletionNotifier, ao as CredentialJsonRecord, ar as JsonArray, at as PersistedRunWorkItemRecord, ba as NodeExecutionTelemetry, bi as ExecutionContext, bn as WorkflowExecutionPruneRepository, br as NodeKind, ca as WorkflowSnapshotResolver, ci as BinaryAttachmentCreateRequest, cn as RunExecutionOptions, co as CredentialOAuth2ScopesFromPublicConfig, cr as JsonPrimitive, ct as RunSlotProjectionState, da as WebhookControlSignal, di as BinaryStorageReadResult, dn as RunQueueEntry, do as CredentialSessionFactoryArgs, dr as NodeActivationId, dt as WorkItemStatus, ea as TriggerSetupStateFor, ei as runnableNodeInputType, en as PersistedSuspensionEntry, eo as CredentialHealth, er as Edge, et as PayloadStorageKind, fa as WebhookInvocationMatch, fi as BinaryStorageStatResult, fn as RunResult, fo as CredentialSessionService, fr as NodeConfigBase, ft as WorkflowDetailSelectionState, gi as EngineDeps, gn as RunSummary, go as CredentialTypeId, gr as NodeErrorHandlerSpec, gt as Expr, ha as WebhookTriggerRoutingDiagnostics, hi as Duration, hn as RunStopCondition, ho as CredentialTypeDefinition, hr as NodeErrorHandlerArgs, ht as CostCatalogEntry, ia as WorkflowRepository, ii as ExponentialRetryPolicySpec, in as PinnedNodeOutputsByPort, io as CredentialInstanceRecord, ir as Items, it as PersistedRunWorkItemKind, ja as CodemationTelemetryMetricNames, ji as NodeActivationRequest, jr as RunIdFactory, jt as deriveAssertionPassed, ka as TelemetrySpanEventRecord, ki as NodeActivationContinuation, kr as RunDataSnapshot, kt as AssertionResultProvenance, la as HttpMethod, li as BinaryBody, ln as RunHaltReason, lo as CredentialRequirement, lr as JsonValue, lt as SlotExecutionStateDto, ma as WebhookTriggerResolution, mi as BinaryStorageWriteResult, mn as RunStatus, mo as CredentialType, mr as NodeErrorHandler, mt as CostCatalog, na as TriggerTestItemsContext, ni as triggerNodeOutputType, nn as PersistedWorkflowSnapshotNode, no as CredentialHealthTester, nr as Item, nt as PersistedExecutionInstanceRecord, oa as WorkflowRunnerService, oi as NoneRetryPolicySpec, on as RunCurrentState, oo as CredentialMaterialSourceKind, or as JsonNonArray, ot as RunIterationDto, pa as WebhookTriggerMatcher, pi as BinaryStorageWriteRequest, pn as RunStateResetRequest, po as CredentialSetupStatus, pr as NodeDefinition, pt as WorkflowRunDetailDto, qi as RunnableNodeExecuteArgs, qr as WorkflowPrunePolicySpec, qt as PendingNodeExecution, ra as WorkflowNodeInstanceFactory, ri as triggerNodeSetupStateType, rn as PersistedWorkflowTokenRegistryLike, ro as CredentialInstanceId, rr as ItemBinary, rt as PersistedRunSlotProjectionRecord, sa as WorkflowSnapshotFactory, si as RetryPolicySpec, sn as RunEventPublisherDeps, so as CredentialOAuth2AuthDefinition, sr as JsonObject, st as RunRevision, ta as TriggerSetupStateRepository, ti as runnableNodeOutputType, tn as PersistedWorkflowSnapshot, to as CredentialHealthStatus, tr as ExecutionMode, tt as PersistedExecutionInstanceKind, ua as TriggerInstanceId, ui as BinaryStorage, un as RunPruneCandidate, uo as CredentialSessionFactory, ur as MutableRunData, ut as WorkItemId, va as ExecutionTelemetry, vi as ExecutableTriggerNode, vn as WebhookRunResult, vr as NodeInspectorSummaryRow, vt as ParamDeep, wa as TelemetryAttributes, wi as HumanTaskId, wo as NodeConnectionName, wr as NodeSchedulerDecision, xa as TelemetryArtifactAttachment, xi as ExecutionContextFactory, xn as WorkflowExecutionRepository, xr as NodeOffloadPolicy, ya as ExecutionTelemetryFactory, yi as ExecutionBinaryService, yn as WorkflowExecutionListingRepository, yo as OAuth2ProviderFromPublicConfig, yr as NodeIterationId, za as CostTrackingComponent, zi as NodeExecutionStatePublisher, zr as WorkflowDefinition, zt as ConnectionInvocationRecord } from "./index-CSKKuK60.js";
+export { ActivationIdFactory, AgentBindError, AgentMcpIntegration, AgentMcpToolMap, AnyCredentialType, AssertionResult, AssertionResultProvenance, BatchId, BinaryAttachment, BinaryAttachmentCreateRequest, BinaryBody, BinaryPreviewKind, BinaryStorage, BinaryStorageReadResult, BinaryStorageStatResult, BinaryStorageWriteRequest, BinaryStorageWriteResult, CodemationTelemetryAttributeNames, CodemationTelemetryMetricNames, ConnectionInvocationAppendArgs, ConnectionInvocationId, ConnectionInvocationKind, ConnectionInvocationRecord, CostCatalog, CostCatalogEntry, CostTrackingComponent, CostTrackingPriceQuote, CostTrackingTelemetry, CostTrackingTelemetryFactory, CostTrackingUsageRecord, CredentialAdvancedSectionPresentation, CredentialAuthDefinition, CredentialBinding, CredentialBindingKey, CredentialFieldSchema, CredentialHealth, CredentialHealthStatus, CredentialHealthTester, CredentialInstanceId, CredentialInstanceRecord, CredentialJsonRecord, CredentialMaterialSourceKind, CredentialOAuth2AuthDefinition, CredentialOAuth2ScopesFromPublicConfig, CredentialRequirement, CredentialSessionFactory, CredentialSessionFactoryArgs, CredentialSessionService, CredentialSetupStatus, CredentialType, CredentialTypeDefinition, CredentialTypeId, CredentialTypeRegistry, CurrentStateExecutionRequest, DEFAULT_ASSERTION_PASS_THRESHOLD, Duration, Edge, EngineDeps, EngineHost, EngineRunCounters, ExecutableTriggerNode, ExecutionBinaryService, ExecutionContext, ExecutionContextFactory, ExecutionFrontierPlan, ExecutionInstanceDto, ExecutionInstanceId, ExecutionMode, ExecutionPayloadPolicyFields, ExecutionTelemetry, ExecutionTelemetryFactory, ExponentialRetryPolicySpec, Expr, FixedRetryPolicySpec, GenAiTelemetryAttributeNames, HttpMethod, HumanTaskActor, HumanTaskHandle, HumanTaskId, HumanTaskSubject, InputPortKey, Item, ItemBinary, ItemNode, Items, JsonArray, JsonNonArray, JsonObject, JsonPrimitive, JsonValue, LiveWorkflowRepository, MultiInputNode, MutableRunData, NeedsReconsentEvent, NoOpAgentMcpIntegration, NoOpExecutionTelemetry, NoOpExecutionTelemetryFactory, NoOpNodeExecutionTelemetry, NoOpTelemetryArtifactReference, NoOpTelemetrySpanScope, NodeActivationContinuation, NodeActivationId, NodeActivationReceipt, NodeActivationRequest, NodeActivationRequestBase, NodeActivationScheduler, NodeBinaryAttachmentService, NodeConfigBase, NodeConnectionName, NodeDefinition, NodeErrorHandler, NodeErrorHandlerArgs, NodeErrorHandlerSpec, NodeExecutionContext, NodeExecutionError, NodeExecutionRequest, NodeExecutionRequestHandler, NodeExecutionScheduler, NodeExecutionSnapshot, NodeExecutionStatePublisher, NodeExecutionStatus, NodeExecutionTelemetry, NodeExecutor, NodeId, NodeIdRef, NodeInputsByPort, NodeInspectorSummaryRow, NodeIterationId, NodeKind, NodeOffloadPolicy, NodeOutputs, NodeRef, NodeResolver, NodeSchedulerDecision, NoneRetryPolicySpec, OAuth2ProviderFromPublicConfig, OutputPortKey, PairedItemRef, Param, ParamDeep, ParentExecutionRef, PayloadStorageKind, PendingNodeExecution, PendingResumeEntry, PersistedExecutionInstanceKind, PersistedExecutionInstanceRecord, PersistedMutableNodeState, PersistedMutableRunState, PersistedRunControlState, PersistedRunPolicySnapshot, PersistedRunSchedulingState, PersistedRunSlotProjectionRecord, PersistedRunState, PersistedRunWorkItemKind, PersistedRunWorkItemRecord, PersistedSuspensionEntry, PersistedTokenId, PersistedTriggerSetupState, PersistedWorkflowSnapshot, PersistedWorkflowSnapshotNode, PersistedWorkflowTokenRegistryLike, PinnedNodeOutputsByPort, PollingTriggerHandle, PreparedNodeActivationDispatch, ResumeContext, RetryPolicySpec, RunCompletionNotifier, RunCurrentState, RunDataFactory, RunDataSnapshot, RunEventPublisherDeps, RunExecutionOptions, RunHaltReason, RunId, RunIdFactory, RunIterationDto, RunPruneCandidate, RunQueueEntry, RunResult, RunRevision, RunSlotProjectionState, RunStateResetRequest, RunStatus, RunStopCondition, RunSummary, RunTestContext, RunnableNode, RunnableNodeConfig, RunnableNodeExecuteArgs, RunnableNodeInputJson, RunnableNodeOutputJson, SlotExecutionStateDto, SuspensionRequest, TelemetryArtifactAttachment, TelemetryArtifactReference, TelemetryAttributePrimitive, TelemetryAttributes, TelemetryChildSpanStart, TelemetryMetricRecord, TelemetryScope, TelemetrySpanEnd, TelemetrySpanEventRecord, TelemetrySpanScope, TestSuiteRunId, TestTriggerNodeConfig, TestTriggerSetupContext, TestableTriggerNode, TriggerCleanupHandle, TriggerInstanceId, TriggerNode, TriggerNodeConfig, TriggerNodeOutputJson, TriggerNodeSetupState, TriggerRuntimeDiagnostics, TriggerSetupContext, TriggerSetupStateFor, TriggerSetupStateRepository, TriggerTestItemsContext, UpstreamRefPlaceholder, WebhookControlSignal, WebhookInvocationMatch, WebhookRunResult, WebhookTriggerMatcher, WebhookTriggerResolution, WebhookTriggerRoutingDiagnostics, WorkItemId, WorkItemStatus, WorkflowDefinition, WorkflowDetailSelectionState, WorkflowErrorContext, WorkflowErrorHandler, WorkflowErrorHandlerSpec, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository, WorkflowExecutionRepository, WorkflowGraph, WorkflowGraphFactory, WorkflowId, WorkflowNodeConnection, WorkflowNodeInstanceFactory, WorkflowPolicyRuntimeDefaults, WorkflowPrunePolicySpec, WorkflowRepository, WorkflowRunDetailDto, WorkflowRunnerResolver, WorkflowRunnerService, WorkflowSnapshotFactory, WorkflowSnapshotResolver, WorkflowStoragePolicyDecisionArgs, WorkflowStoragePolicyMode, WorkflowStoragePolicyResolver, WorkflowStoragePolicySpec, branchRef, deriveAssertionPassed, nodeRef, runnableNodeInputType, runnableNodeOutputType, triggerNodeOutputType, triggerNodeSetupStateType };

package/dist/contracts.js

@@ -0,0 +1,3 @@
+import { i as AgentBindError, n as deriveAssertionPassed, r as NoOpAgentMcpIntegration, t as DEFAULT_ASSERTION_PASS_THRESHOLD } from "./contracts-DXdfTdpW.js";
+
+export { AgentBindError, DEFAULT_ASSERTION_PASS_THRESHOLD, NoOpAgentMcpIntegration, deriveAssertionPassed };

package/dist/di-DdsgWfVy.js

@@ -0,0 +1,405 @@
+import "reflect-metadata";
+import { container as container$1, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
+
+//#region src/workflow/definition/ConnectionNodeIdFactory.ts
+/**
+* Deterministic ids for workflow connection-owned child nodes (LLM slot, tools, etc.).
+* These are stable across loads.
+*/
+var ConnectionNodeIdFactory = class {
+	static connectionSegment = "__conn__";
+	static languageModelConnectionNodeId(parentNodeId) {
+		return `${parentNodeId}${this.connectionSegment}llm`;
+	}
+	static toolConnectionNodeId(parentNodeId, toolName) {
+		const normalized = this.normalizeToolName(toolName);
+		return `${parentNodeId}${this.connectionSegment}tool${this.connectionSegment}${normalized}`;
+	}
+	static mcpConnectionNodeId(parentNodeId, serverId) {
+		return `${parentNodeId}${this.connectionSegment}mcp${this.connectionSegment}${serverId}`;
+	}
+	static isMcpConnectionNodeId(nodeId) {
+		return nodeId.includes(`${this.connectionSegment}mcp${this.connectionSegment}`);
+	}
+	static parseMcpConnectionNodeId(nodeId) {
+		if (!this.isMcpConnectionNodeId(nodeId)) return;
+		const marker = `${this.connectionSegment}mcp${this.connectionSegment}`;
+		const idx = nodeId.lastIndexOf(marker);
+		if (idx < 0) return;
+		const parentNodeId = nodeId.slice(0, idx);
+		const serverId = nodeId.slice(idx + marker.length);
+		if (!parentNodeId || !serverId) return;
+		return {
+			parentNodeId,
+			serverId
+		};
+	}
+	static isLanguageModelConnectionNodeId(nodeId) {
+		return nodeId.endsWith(`${this.connectionSegment}llm`);
+	}
+	static isToolConnectionNodeId(nodeId) {
+		return nodeId.includes(`${this.connectionSegment}tool${this.connectionSegment}`);
+	}
+	static parseLanguageModelConnectionNodeId(nodeId) {
+		if (!this.isLanguageModelConnectionNodeId(nodeId)) return;
+		const suffix = `${this.connectionSegment}llm`;
+		const parentNodeId = nodeId.slice(0, -suffix.length);
+		return parentNodeId ? { parentNodeId } : void 0;
+	}
+	static parseToolConnectionNodeId(nodeId) {
+		if (!this.isToolConnectionNodeId(nodeId)) return;
+		const marker = `${this.connectionSegment}tool${this.connectionSegment}`;
+		const idx = nodeId.lastIndexOf(marker);
+		if (idx < 0) return;
+		const parentNodeId = nodeId.slice(0, idx);
+		const normalizedToolName = nodeId.slice(idx + marker.length);
+		if (!parentNodeId || !normalizedToolName) return;
+		return {
+			parentNodeId,
+			normalizedToolName
+		};
+	}
+	/** True when `nodeId` is a connection-owned child of `parentNodeId` (LLM or tool slot). */
+	static isConnectionOwnedDescendantOf(parentNodeId, nodeId) {
+		return nodeId.startsWith(`${parentNodeId}${this.connectionSegment}`);
+	}
+	/** Normalizes a tool display name to a stable id segment. */
+	static normalizeToolName(toolName) {
+		return toolName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "tool";
+	}
+};
+
+//#endregion
+//#region src/contracts/itemExpr.ts
+const ITEM_EXPR_BRAND = Symbol.for("codemation.itemExpr");
+function itemExpr(fn) {
+	return {
+		[ITEM_EXPR_BRAND]: true,
+		fn
+	};
+}
+function isItemExpr(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const v = value;
+	if (v[ITEM_EXPR_BRAND] === true) return true;
+	const keys = Object.keys(v);
+	if (keys.length === 1 && keys[0] === "fn" && typeof v.fn === "function") return true;
+	for (const sym of Object.getOwnPropertySymbols(v)) if (sym.description === "codemation.itemExpr" && v[sym] === true) return true;
+	return false;
+}
+function containsItemExprInUnknown(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isItemExpr(value)) return true;
+	if (value === null || typeof value !== "object") return false;
+	if (seen.has(value)) return false;
+	seen.add(value);
+	if (Array.isArray(value)) return value.some((entry) => containsItemExprInUnknown(entry, seen));
+	for (const entry of Object.values(value)) if (containsItemExprInUnknown(entry, seen)) return true;
+	return false;
+}
+/**
+* Deep-resolves {@link itemExpr} leaves. Returns a new graph (does not mutate the original config object).
+*/
+async function resolveItemExprsInUnknown(value, args, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isItemExpr(value)) return await Promise.resolve(value.fn(args));
+	if (value === null || typeof value !== "object") return value;
+	if (seen.has(value)) return value;
+	seen.add(value);
+	if (Array.isArray(value)) {
+		const out$1 = [];
+		for (let i = 0; i < value.length; i++) out$1.push(await resolveItemExprsInUnknown(value[i], args, seen));
+		return out$1;
+	}
+	const rec = value;
+	const entries = Object.entries(rec);
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null && entries.length === 0) return value;
+	const out = Object.create(proto);
+	for (const [k, v] of entries) out[k] = await resolveItemExprsInUnknown(v, args, seen);
+	return out;
+}
+/**
+* Clones runnable config (best-effort) so per-item {@link itemExpr} resolution never mutates shared instances.
+*/
+async function resolveItemExprsForExecution(config, nodeCtx, item, itemIndex, items) {
+	const exprArgs = {
+		item,
+		itemIndex,
+		items,
+		ctx: {
+			runId: nodeCtx.runId,
+			workflowId: nodeCtx.workflowId,
+			nodeId: nodeCtx.nodeId,
+			activationId: nodeCtx.activationId,
+			data: nodeCtx.data
+		}
+	};
+	if (!containsItemExprInUnknown(config)) return;
+	return await resolveItemExprsInUnknown(config, exprArgs);
+}
+
+//#endregion
+//#region src/ai/AgentConfigInspectorFactory.ts
+var AgentConfigInspector = class {
+	static isAgentNodeConfig(config) {
+		if (!config) return false;
+		const candidate = config;
+		return !!candidate.chatModel && this.hasCompatibleMessageConfiguration(candidate);
+	}
+	static hasCompatibleMessageConfiguration(candidate) {
+		const messages = candidate.messages;
+		if (messages === void 0 || messages === null) return false;
+		if (Array.isArray(messages)) return messages.length > 0;
+		if (typeof messages === "object") {
+			if (isItemExpr(messages)) return true;
+			const o = messages;
+			return Array.isArray(o.prompt) && o.prompt.length > 0 || typeof o.buildMessages === "function";
+		}
+		return false;
+	}
+};
+
+//#endregion
+//#region src/ai/NodeBackedToolConfig.ts
+var NodeBackedToolConfig = class {
+	type;
+	toolKind = "nodeBacked";
+	description;
+	presentation;
+	inputSchemaValue;
+	outputSchemaValue;
+	mapInputValue;
+	mapOutputValue;
+	constructor(name, node, options) {
+		this.name = name;
+		this.node = node;
+		this.type = node.type;
+		this.description = options.description;
+		this.presentation = options.presentation;
+		this.inputSchemaValue = options.inputSchema;
+		this.outputSchemaValue = options.outputSchema;
+		this.mapInputValue = options.mapInput;
+		this.mapOutputValue = options.mapOutput;
+	}
+	getCredentialRequirements() {
+		return this.node.getCredentialRequirements?.() ?? [];
+	}
+	getInputSchema() {
+		return this.inputSchemaValue;
+	}
+	getOutputSchema() {
+		return this.outputSchemaValue;
+	}
+	toNodeItem(args) {
+		const mapped = this.mapInputValue?.(args) ?? args.input;
+		if (this.isItem(mapped)) return mapped;
+		return { json: mapped };
+	}
+	toToolOutput(args) {
+		const raw = this.mapOutputValue?.(args) ?? this.readDefaultToolOutput(args.outputs);
+		return this.outputSchemaValue.parse(raw);
+	}
+	readDefaultToolOutput(outputs) {
+		const firstMainItem = outputs.main?.[0];
+		if (!firstMainItem) throw new Error(`Node-backed tool "${this.name}" did not produce a main output item.`);
+		return firstMainItem.json;
+	}
+	isItem(value) {
+		return typeof value === "object" && value !== null && "json" in value;
+	}
+};
+
+//#endregion
+//#region src/ai/AgentConnectionNodeCollector.ts
+const AgentConnectionNodeCollector = new class {
+	collect(parentNodeId, agentConfig, mcpServerResolver) {
+		const collected = [];
+		this.collectInto(parentNodeId, agentConfig, collected, mcpServerResolver);
+		return collected;
+	}
+	collectInto(parentNodeId, agentConfig, collected, mcpServerResolver) {
+		collected.push({
+			nodeId: ConnectionNodeIdFactory.languageModelConnectionNodeId(parentNodeId),
+			parentNodeId,
+			connectionName: "llm",
+			role: "languageModel",
+			name: agentConfig.chatModel.presentation?.label ?? agentConfig.chatModel.name,
+			typeName: agentConfig.chatModel.name,
+			icon: agentConfig.chatModel.presentation?.icon,
+			credentialSource: agentConfig.chatModel
+		});
+		for (const tool of agentConfig.tools ?? []) {
+			const toolNodeId = ConnectionNodeIdFactory.toolConnectionNodeId(parentNodeId, tool.name);
+			const isNestedAgent = this.isNodeBackedAgentTool(tool);
+			collected.push({
+				nodeId: toolNodeId,
+				parentNodeId,
+				connectionName: "tools",
+				role: isNestedAgent ? "nestedAgent" : "tool",
+				name: tool.presentation?.label ?? tool.name,
+				typeName: tool.name,
+				icon: tool.presentation?.icon,
+				credentialSource: tool
+			});
+			this.collectNestedAgentTools(toolNodeId, tool, collected, mcpServerResolver);
+		}
+		if (mcpServerResolver) {
+			const mcpServers = agentConfig.mcpServers;
+			for (const serverId of mcpServers ?? []) {
+				const decl = mcpServerResolver(serverId);
+				if (!decl) continue;
+				const acceptedTypes = decl.acceptedCredentialTypes ?? [];
+				collected.push({
+					nodeId: ConnectionNodeIdFactory.mcpConnectionNodeId(parentNodeId, serverId),
+					parentNodeId,
+					connectionName: "tools",
+					role: "tool",
+					name: decl.displayName,
+					typeName: "MCP server",
+					icon: "lucide:plug",
+					credentialSource: { getCredentialRequirements: () => [{
+						slotKey: "credential",
+						label: decl.displayName,
+						acceptedTypes
+					}] }
+				});
+			}
+		}
+	}
+	collectNestedAgentTools(toolNodeId, tool, collected, mcpServerResolver) {
+		if (!this.isNodeBackedAgentTool(tool)) return;
+		const innerAgent = tool instanceof NodeBackedToolConfig ? tool.node : tool.node;
+		this.collectInto(toolNodeId, innerAgent, collected, mcpServerResolver);
+	}
+	/**
+	* After JSON round-trip (persisted snapshots), tools are plain objects — `instanceof NodeBackedToolConfig` fails.
+	* Detect node-backed tools structurally via {@link NodeBackedToolConfig#toolKind}.
+	*/
+	isNodeBackedAgentTool(tool) {
+		if (tool instanceof NodeBackedToolConfig) return AgentConfigInspector.isAgentNodeConfig(tool.node);
+		if (!tool || typeof tool !== "object") return false;
+		const t = tool;
+		if (t.toolKind !== "nodeBacked") return false;
+		return AgentConfigInspector.isAgentNodeConfig(t.node);
+	}
+}();
+
+//#endregion
+//#region src/workflow/definition/NodeIterationIdFactory.ts
+/**
+* Unique ids for one per-item iteration of a runnable node's execute loop.
+*
+* Activations are per-batch (one scheduled execution of a node, possibly with N items).
+* Iterations refine that to one identifier per item-index inside the batch loop, so per-item
+* connection invocations and telemetry can be grouped without time-window heuristics.
+*
+* Uses Web Crypto's `randomUUID` (Node 19+ and all modern browsers) so this module is safe
+* to include in the browser entry. Importing `node:crypto` here previously leaked into the
+* canvas client bundle through `browser.ts` and OOM'd consumers' Turbopack builds.
+*/
+var NodeIterationIdFactory = class {
+	static create() {
+		return `iter_${globalThis.crypto.randomUUID()}`;
+	}
+	/** Deterministic id for tests when a stable sequence is needed. */
+	static createForTest(seed, sequence) {
+		return `iter_${seed}_${sequence}`;
+	}
+	/** Deterministic id derived from a connection node id (for sub-agent / tool-call scopes). */
+	static createForConnection(connectionNodeId, sequence) {
+		return `iter_${connectionNodeId}_${sequence}`;
+	}
+};
+
+//#endregion
+//#region src/contracts/credentialTypes.ts
+var CredentialUnboundError = class CredentialUnboundError extends Error {
+	constructor(bindingKey, acceptedTypes = []) {
+		super(CredentialUnboundError.createMessage(bindingKey, acceptedTypes));
+		this.bindingKey = bindingKey;
+		this.acceptedTypes = acceptedTypes;
+		this.name = "CredentialUnboundError";
+	}
+	static createMessage(bindingKey, acceptedTypes) {
+		const acceptedTypesSuffix = acceptedTypes.length > 0 ? ` Accepted credential types: ${acceptedTypes.join(", ")}.` : "";
+		return `Credential slot "${bindingKey.slotKey}" is not bound for workflow ${bindingKey.workflowId} node ${bindingKey.nodeId}.${acceptedTypesSuffix}`;
+	}
+};
+
+//#endregion
+//#region src/contracts/runtimeTypes.ts
+/**
+* Thrown by a node's `execute()` to request durable suspension of the current item.
+* The engine catches this, persists the suspension entry, calls `deliver`, and
+* continues to the next item (per-item semantics).
+*
+* @example
+* ```ts
+* throw new SuspensionRequest({
+*   decisionSchema: z.object({ approved: z.boolean() }),
+*   timeout: "PT24H",
+*   onTimeout: "halt",
+*   subject: { title: "Approve invoice", summary: "Invoice #1234 needs approval" },
+*   deliver: async (handle) => {
+*     await notifySlack(handle);
+*     return { channel: "slack", ts: "..." };
+*   },
+* });
+* ```
+*/
+var SuspensionRequest = class extends Error {
+	constructor(request) {
+		super(`SuspensionRequest(${request.subject?.title ?? "untitled"})`);
+		this.request = request;
+		this.name = "SuspensionRequest";
+	}
+};
+
+//#endregion
+//#region src/contracts/runFinishedAtFactory.ts
+/** Derives workflow end time from persisted run root or node snapshots for run listings. */
+var RunFinishedAtFactory = class {
+	static resolveIso(state) {
+		if (state.finishedAt && state.status !== "running" && state.status !== "pending") return state.finishedAt;
+		if (state.status === "running" || state.status === "pending") return;
+		let max;
+		for (const snap of Object.values(state.nodeSnapshotsByNodeId)) if (snap?.finishedAt && (!max || snap.finishedAt > max)) max = snap.finishedAt;
+		return max;
+	}
+};
+
+//#endregion
+//#region src/contracts/workflowTypes.ts
+function nodeRef(nodeId) {
+	return nodeId;
+}
+const branchRef = (index) => `$${index}`;
+
+//#endregion
+//#region src/di/CoreTokens.ts
+const CoreTokens = {
+	PersistedWorkflowTokenRegistry: Symbol.for("codemation.core.PersistedWorkflowTokenRegistry"),
+	CredentialSessionService: Symbol.for("codemation.core.CredentialSessionService"),
+	CredentialTypeRegistry: Symbol.for("codemation.core.CredentialTypeRegistry"),
+	WorkflowRunnerService: Symbol.for("codemation.core.WorkflowRunnerService"),
+	LiveWorkflowRepository: Symbol.for("codemation.core.LiveWorkflowRepository"),
+	WorkflowRepository: Symbol.for("codemation.core.WorkflowRepository"),
+	NodeResolver: Symbol.for("codemation.core.NodeResolver"),
+	WorkflowNodeInstanceFactory: Symbol.for("codemation.core.WorkflowNodeInstanceFactory"),
+	RunIdFactory: Symbol.for("codemation.core.RunIdFactory"),
+	ActivationIdFactory: Symbol.for("codemation.core.ActivationIdFactory"),
+	WorkflowExecutionRepository: Symbol.for("codemation.core.WorkflowExecutionRepository"),
+	TriggerSetupStateRepository: Symbol.for("codemation.core.TriggerSetupStateRepository"),
+	NodeActivationScheduler: Symbol.for("codemation.core.NodeActivationScheduler"),
+	RunDataFactory: Symbol.for("codemation.core.RunDataFactory"),
+	ExecutionContextFactory: Symbol.for("codemation.core.ExecutionContextFactory"),
+	RunEventBus: Symbol.for("codemation.core.RunEventBus"),
+	BinaryStorage: Symbol.for("codemation.core.BinaryStorage"),
+	WebhookBasePath: Symbol.for("codemation.core.WebhookBasePath"),
+	EngineExecutionLimitsPolicy: Symbol.for("codemation.core.EngineExecutionLimitsPolicy"),
+	WorkflowActivationPolicy: Symbol.for("codemation.core.WorkflowActivationPolicy"),
+	AgentMcpIntegration: Symbol.for("codemation.core.AgentMcpIntegration")
+};
+
+//#endregion
+export { resolveItemExprsForExecution as C, itemExpr as S, ConnectionNodeIdFactory as T, NodeIterationIdFactory as _, injectable as a, AgentConfigInspector as b, predicateAwareClassFactory as c, CoreTokens as d, branchRef as f, CredentialUnboundError as g, SuspensionRequest as h, injectAll as i, registry as l, RunFinishedAtFactory as m, delay as n, instanceCachingFactory as o, nodeRef as p, inject as r, instancePerContainerCachingFactory as s, container$1 as t, singleton as u, AgentConnectionNodeCollector as v, resolveItemExprsInUnknown as w, isItemExpr as x, NodeBackedToolConfig as y };
+//# sourceMappingURL=di-DdsgWfVy.js.map