@codemation/core 0.14.0 → 0.15.0

package/dist/{agentMcpTypes-B11B3Hd-.d.cts → agentMcpTypes-BHX4RQCC.d.cts}

@@ -3,11 +3,6 @@ import { ZodType } from "zod";
 import { DependencyContainer as Container, DependencyContainer as DependencyContainer$1, Disposable, InjectionToken as InjectionToken$1, InjectionToken as TypeToken, Lifecycle, RegistrationOptions, container, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
 
 //#region src/contracts/baseTypes.d.ts
-/**
- * Minimal base types that have no dependencies on other contracts.
- * Used by credentialTypes, workflowTypes, and other contract layers
- * to avoid circular dependencies.
- */
 type WorkflowId = string;
 type NodeId = string;
 type OutputPortKey = string;
@@ -16,21 +11,12 @@ type PersistedTokenId = string;
 type NodeConnectionName = string;
 //#endregion
 //#region src/triggers/polling/PollingTriggerDedupWindow.d.ts
-/**
- * Merges processed-ID windows for polling triggers, capping the total to avoid unbounded growth.
- * Plugin code receives an instance of this class via {@link PollingTriggerHandle.dedup}.
- */
 declare class PollingTriggerDedupWindow {
   static readonly defaultCapN = 2000;
   merge(previous: ReadonlyArray<string>, incoming: ReadonlyArray<string>, capN?: number): ReadonlyArray<string>;
 }
 //#endregion
 //#region src/triggers/polling/PollingTriggerLogger.d.ts
-/**
- * Minimal logger surface for the polling-trigger runtime.
- * Hosts supply this via {@link EngineDeps.pollingTriggerLogger};
- * when absent the runtime is silent.
- */
 interface PollingTriggerLogger {
   info(message: string): void;
   warn(message: string): void;
@@ -56,22 +42,11 @@ type CredentialFieldSchema = Readonly<{
   type: "string" | "password" | "textarea" | "json" | "boolean";
   required?: true;
   order?: number;
-  /**
-   * Where this field appears in the credential dialog. Use `"advanced"` for optional or
-   * power-user fields; they render inside a collapsible section (see `CredentialTypeDefinition.advancedSection`).
-   * Defaults to `"default"` when omitted.
-   */
   visibility?: "default" | "advanced";
   placeholder?: string;
   helpText?: string;
-  /** When set, host resolves this field from process.env at runtime; env wins over stored values. */
   envVarName?: string;
-  /**
-   * When set, the dialog shows a copy action for this exact string (e.g. a static OAuth redirect URI
-   * pattern or documentation URL). Do not use for secret values.
-   */
   copyValue?: string;
-  /** Accessible label for the copy control (default: Copy). */
   copyButtonLabel?: string;
 }>;
 type CredentialRequirement = Readonly<{
@@ -126,20 +101,9 @@ type CredentialOAuth2AuthDefinition = Readonly<{
   clientSecretFieldKey?: string;
 } | {
   kind: "oauth2";
-  /**
-   * Free-form provider identifier for telemetry, DB rows, and Better Auth provider naming.
-   * Not used for any registry lookup — URLs come from {@link authorizeUrl} / {@link tokenUrl}.
-   */
   providerId: string;
-  /**
-   * Authorization endpoint. May contain `{publicFieldKey}` placeholders that the runtime
-   * substitutes from the credential's resolved public config (URL-encoded).
-   * Example: `https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/authorize`
-   */
   authorizeUrl: string;
-  /** Token endpoint. Same templating rules as {@link authorizeUrl}. */
   tokenUrl: string;
-  /** Optional userinfo endpoint. Same templating rules as {@link authorizeUrl}. */
   userInfoUrl?: string;
   scopes: ReadonlyArray<string>;
   scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
@@ -148,11 +112,8 @@ type CredentialOAuth2AuthDefinition = Readonly<{
 }>;
 type CredentialAuthDefinition = CredentialOAuth2AuthDefinition;
 type CredentialAdvancedSectionPresentation = Readonly<{
-  /** Collapsible section title (default: "Advanced"). */
   title?: string;
-  /** Optional short helper text shown inside the section (above the fields). */
   description?: string;
-  /** When true, the advanced section starts expanded. Default: false (collapsed). */
   defaultOpen?: boolean;
 }>;
 type CredentialTypeDefinition = Readonly<{
@@ -161,23 +122,11 @@ type CredentialTypeDefinition = Readonly<{
   description?: string;
   publicFields?: ReadonlyArray<CredentialFieldSchema>;
   secretFields?: ReadonlyArray<CredentialFieldSchema>;
-  /**
-   * Optional labels for the collapsible block that contains every field with `visibility: "advanced"`.
-   * If omitted, the UI still shows that block with defaults (title "Advanced", collapsed).
-   */
   advancedSection?: CredentialAdvancedSectionPresentation;
   supportedSourceKinds?: ReadonlyArray<CredentialMaterialSourceKind>;
   auth?: CredentialAuthDefinition;
 }>;
-/**
- * JSON-shaped credential field bag (public config, resolved secret material, etc.).
- */
 type CredentialJsonRecord = Readonly<Record<string, unknown>>;
-/**
- * Persisted credential instance with typed `publicConfig`.
- * Hosts may specialize `secretRef` with a stricter union while remaining
- * assignable here for session/test callbacks.
- */
 type CredentialInstanceRecord<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
   instanceId: CredentialInstanceId;
   typeId: CredentialTypeId;
@@ -189,46 +138,30 @@ type CredentialInstanceRecord<TPublicConfig extends CredentialJsonRecord = Crede
   setupStatus: CredentialSetupStatus;
   createdAt: string;
   updatedAt: string;
-  /**
-   * Pointer to where the credential material bytes live. For OSS / standalone
-   * rows this is `{source: "local", ref: instanceId}` and the bytes co-locate
-   * with the row in the workspace DB. For managed-mode rows this is
-   * `{source: "control-plane", ref: <cp_id>}` and the bytes live at CP.
-   *
-   * The seam is read through `CredentialMaterialProvider`. See
-   * `docs/design/credentials-oauth-unification.md` ("Material provider seam").
-   */
   material: Readonly<{
     source: "local" | "control-plane";
     ref: string;
   }>;
 }>;
-/**
- * Arguments passed to `CredentialType.createSession` and `CredentialType.test`.
- * Declare `TPublicConfig` / `TMaterial` on `CredentialType` so implementations are checked
- * against your credential shapes (similar to `NodeExecutionContext.config` for nodes).
- */
 type CredentialSessionFactoryArgs<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
   instance: CredentialInstanceRecord<TPublicConfig>;
   material: TMaterial;
   publicConfig: TPublicConfig;
 }>;
 type CredentialSessionFactory<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<TSession>;
+type CredentialAccessTokenSessionArgs<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
+  accessToken: string;
+  grantedScopes: ReadonlyArray<string>;
+  publicConfig: TPublicConfig;
+}>;
+type CredentialAccessTokenSessionFactory<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = (args: CredentialAccessTokenSessionArgs<TPublicConfig>) => Promise<TSession>;
 type CredentialHealthTester<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<CredentialHealth>;
-/**
- * Full credential type implementation: `definition` (UI/schema), `createSession`, and `test`.
- * Use this at registration and config boundaries; `CredentialTypeDefinition` is only the schema slice.
- */
 type CredentialType<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = Readonly<{
   definition: CredentialTypeDefinition;
   createSession: CredentialSessionFactory<TPublicConfig, TMaterial, TSession>;
+  createSessionFromAccessToken?: CredentialAccessTokenSessionFactory<TPublicConfig, TSession>;
   test: CredentialHealthTester<TPublicConfig, TMaterial>;
 }>;
-/**
- * Credential type with unspecified generics — used for `CodemationConfig.credentialTypes`, the host registry,
- * and anywhere a concrete `CredentialType<YourPublic, YourMaterial, YourSession>` is placed in a heterogeneous list.
- * Using `any` here avoids unsafe `as` casts while keeping typed `satisfies CredentialType<…>` definitions.
- */
 type AnyCredentialType = CredentialType<any, any, unknown>;
 interface CredentialSessionService {
   getSession<TSession = unknown>(args: Readonly<{
@@ -249,38 +182,22 @@ declare class CredentialUnboundError extends Error {
 }
 //#endregion
 //#region src/contracts/collectionTypes.d.ts
-/**
- * Represents a typed store for a single collection.
- * All rows include auto-managed id, created_at, and updated_at fields.
- */
 interface CollectionStore<TRow extends Record<string, unknown> = Record<string, unknown>> {
-  /**
-   * Insert a new row. id, created_at, and updated_at are auto-populated.
-   */
   insert(row: TRow): Promise<TRow & {
     id: string;
     created_at: Date;
     updated_at: Date;
   }>;
-  /**
-   * Get a single row by id.
-   */
   get(id: string): Promise<(TRow & {
     id: string;
     created_at: Date;
     updated_at: Date;
   }) | null>;
-  /**
-   * Find a single row matching the provided filter.
-   */
   findOne(filter: Partial<TRow>): Promise<(TRow & {
     id: string;
     created_at: Date;
     updated_at: Date;
   }) | null>;
-  /**
-   * List rows with optional pagination and filtering.
-   */
   list(opts?: {
     limit?: number;
     offset?: number;
@@ -293,24 +210,15 @@ interface CollectionStore<TRow extends Record<string, unknown> = Record<string,
     }>;
     total: number;
   }>;
-  /**
-   * Update a row by id with partial data.
-   */
   update(id: string, patch: Partial<TRow>): Promise<TRow & {
     id: string;
     created_at: Date;
     updated_at: Date;
   }>;
-  /**
-   * Delete a row by id. Hard delete only (no soft delete).
-   */
   delete(id: string): Promise<{
     deleted: boolean;
   }>;
 }
-/**
- * Runtime collections context: keyed by collection name.
- */
 type CollectionsContext = Readonly<Record<string, CollectionStore>>;
 //#endregion
 //#region src/contracts/CostTrackingTelemetryContract.d.ts
@@ -363,7 +271,6 @@ declare class NoOpTelemetryArtifactReference {
 //#region src/contracts/NoOpTelemetrySpanScope.d.ts
 declare class NoOpTelemetrySpanScope {
   static readonly value: TelemetrySpanScope;
-  /** Internal: the shared no-op {@link NodeExecutionTelemetry} that {@link NoOpNodeExecutionTelemetry} re-exposes. */
   static readonly nodeExecutionTelemetryValue: NodeExecutionTelemetry;
 }
 //#endregion
@@ -399,25 +306,15 @@ declare class CodemationTelemetryAttributeNames {
   static readonly connectionInvocationId = "codemation.connection.invocation_id";
   static readonly toolName = "codemation.tool.name";
   static readonly traceParentRunId = "codemation.parent.run.id";
-  /** Per-item iteration that emitted this span/metric. Set on spans recorded inside a runnable per-item loop. */
   static readonly iterationId = "codemation.iteration.id";
-  /** Item index (0-based) of the iteration. */
   static readonly iterationIndex = "codemation.iteration.index";
-  /** Set when this span/metric was recorded under a sub-agent triggered by an outer LLM/tool call. */
   static readonly parentInvocationId = "codemation.parent.invocation_id";
-  /** MCP server id on spans created for callTool invocations. */
   static readonly mcpServerId = "mcp.server_id";
-  /** MCP tool name on spans created for callTool invocations. */
   static readonly mcpToolName = "mcp.tool_name";
-  /** Terminal node-execution status (e.g. `"hitl-approved"`, `"hitl-rejected"`) on HITL outcome spans. */
   static readonly nodeExecutionStatus = "codemation.node.execution_status";
-  /** Populated on run-halted spans; discriminates the halt reason (e.g. `"hitl-rejected"`). */
   static readonly runHaltReason = "codemation.run.halt_reason";
-  /** Human task ID on `hitl.task.*` span events. */
   static readonly hitlTaskId = "codemation.hitl.task_id";
-  /** HITL channel name (e.g. `"inbox"`, `"control-plane-inbox"`) on `hitl.task.*` span events. */
   static readonly hitlChannel = "codemation.hitl.channel";
-  /** Decision outcome (e.g. `"approved"`, `"rejected"`) on `hitl.task.decided` span events. */
   static readonly hitlDecisionStatus = "codemation.hitl.decision_status";
 }
 //#endregion
@@ -498,13 +395,6 @@ interface TelemetrySpanScope extends TelemetryScope {
   readonly traceId: string;
   readonly spanId: string;
   end(args?: TelemetrySpanEnd): Promise<void> | void;
-  /**
-   * Lift this span into a {@link NodeExecutionTelemetry} scoped to a different (nodeId, activationId).
-   * Children created via the returned telemetry's `startChildSpan` get this span as their parent.
-   *
-   * Used at the sub-agent boundary so that nested runtime telemetry parents under the agent.tool.call
-   * span instead of the orchestrator's node-level span.
-   */
   asNodeTelemetry(args: Readonly<{
     nodeId: NodeId;
     activationId: NodeActivationId;
@@ -531,14 +421,9 @@ interface ExecutionTelemetryFactory {
 }
 //#endregion
 //#region src/contracts/workflowActivationPolicy.d.ts
-/**
- * Host-controlled policy: when false, trigger {@link TriggerNode} setup is skipped and webhook routes
- * for that workflow are not registered (see engine trigger runtime + webhook matcher).
- */
 interface WorkflowActivationPolicy {
   isActive(workflowId: WorkflowId): boolean;
 }
-/** Default for tests and harnesses: every workflow is treated as active (legacy behavior). */
 declare class AllWorkflowsActiveWorkflowActivationPolicy implements WorkflowActivationPolicy {
   isActive(_workflowId: WorkflowId): boolean;
 }
@@ -553,23 +438,19 @@ interface WebhookControlSignal {
 }
 interface WebhookTriggerRoutingDiagnostics {
   warn(message: string): void;
-  /** Inactive workflows omitted from the webhook route index (optional; host should wire for clarity at boot/reload). */
   info?(message: string): void;
 }
 interface TriggerInstanceId {
   workflowId: WorkflowId;
   nodeId: NodeId;
 }
-/** Match for an incoming HTTP request: user-defined URL segment + workflow trigger node. */
 interface WebhookInvocationMatch {
-  /** Same value as the webhook trigger's configured endpoint key (URL segment under the webhook base path). */
   endpointPath: string;
   workflowId: WorkflowId;
   nodeId: NodeId;
   methods: ReadonlyArray<HttpMethod>;
   parseJsonBody?: (body: unknown) => unknown;
 }
-/** Result of resolving an HTTP method + endpoint path against the catalog webhook index (404 vs 405 vs match). */
 type WebhookTriggerResolution = {
   status: "notFound";
 } | {
@@ -579,9 +460,6 @@ type WebhookTriggerResolution = {
   status: "ok";
   match: WebhookInvocationMatch;
 };
-/**
- * Resolves webhook routes from workflow definitions (catalog-backed index, no registration at trigger setup).
- */
 interface WebhookTriggerMatcher {
   match(args: {
     endpointPath: string;
@@ -590,52 +468,29 @@ interface WebhookTriggerMatcher {
   lookup(endpointPath: string): WebhookInvocationMatch | undefined;
   onEngineWorkflowsLoaded?(): void;
   onEngineStopped?(): void;
-  /** Rebuild route index after activation changes without stopping the engine. */
   reloadWebhookRoutes?(): void;
 }
 //#endregion
 //#region src/contracts/runtimeTypes.d.ts
-/** Opaque unique identifier for a single HumanTask instance. */
 type HumanTaskId = string;
-/**
- * Duration string — ISO 8601 duration ("PT24H") or shorthand ("24h").
- * Parsed by the timeout job; stored as-is in the suspension record.
- */
 type Duration = string;
-/**
- * Minimal handle handed to the `deliver` callback so it can route to the correct
- * inbox channel.
- */
 interface HumanTaskHandle {
   readonly taskId: HumanTaskId;
   readonly runId: string;
   readonly nodeId: string;
   readonly expiresAt: Date;
-  /** TODO: real signed URL; placeholder empty string for now. */
   readonly resumeUrl: string;
-  /**
-   * Arbitrary JSON metadata copied from `SuspensionRequest.request.metadata` at suspension time.
-   * Used by the agent runtime to round-trip the `agentCheckpoint` back to the
-   * resumed node via `ctx.resumeContext.task.metadata`.
-   */
   readonly metadata?: Readonly<Record<string, JsonValue>>;
 }
-/** Human-readable description surface shown to the reviewer. */
 interface HumanTaskSubject {
   readonly title: string;
   readonly summary: string;
   readonly attributes?: JsonValue;
 }
-/** Identity of the person who made a decision on the task. */
 interface HumanTaskActor {
   readonly actorId: string;
   readonly displayName?: string;
 }
-/**
- * Resume context injected into `NodeExecutionContext` when the engine re-activates
- * a previously suspended node. `defineHumanApprovalNode` wraps this with parsed
- * `TDecision`; at the engine layer `decision.value` is `unknown`.
- */
 interface ResumeContext {
   readonly decision: Readonly<{
     kind: "decided";
@@ -652,25 +507,6 @@ interface ResumeContext {
   readonly delivery: JsonValue;
   readonly task: HumanTaskHandle;
 }
-/**
- * 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: "..." };
- *   },
- * });
- * ```
- */
 declare class SuspensionRequest<TDecision = unknown, TDelivery extends JsonValue = JsonValue> extends Error {
   readonly request: Readonly<{
     decisionSchema: ZodType<TDecision>;
@@ -734,11 +570,6 @@ interface NodeExecutionStatePublisher {
     error: Error;
   }): Promise<void>;
   appendConnectionInvocation(args: ConnectionInvocationAppendArgs): Promise<void>;
-  /**
-   * Annotates the current snapshot for `nodeId` with the id of the child run spawned by a
-   * SubWorkflow invocation. Called from `SubWorkflowNode.execute` after `runById` resolves.
-   * The engine's subsequent `markCompleted` call preserves the value via `previous.childRunId`.
-   */
   setChildRunId?(args: {
     nodeId: NodeId;
     childRunId: RunId;
@@ -768,9 +599,7 @@ interface BinaryStorage {
   openReadStream(storageKey: string): Promise<BinaryStorageReadResult | undefined>;
   stat(storageKey: string): Promise<BinaryStorageStatResult>;
   delete(storageKey: string): Promise<void>;
-  /** Deletes multiple objects in bulk. Keys are batched internally. */
   deleteMany(storageKeys: ReadonlyArray<string>): Promise<void>;
-  /** Lists all keys sharing a common prefix. Returns keys in arbitrary order. */
   listByPrefix(prefix: string): Promise<ReadonlyArray<string>>;
 }
 interface BinaryAttachmentCreateRequest {
@@ -784,7 +613,6 @@ interface NodeBinaryAttachmentService extends ExecutionBinaryService {
   attach(args: BinaryAttachmentCreateRequest): Promise<BinaryAttachment>;
   withAttachment<TJson>(item: Item<TJson>, name: string, attachment: BinaryAttachment): Item<TJson>;
 }
-/** Default maximum bytes read into memory by the bounded helpers (50 MiB). */
 declare const BINARY_DEFAULT_MAX_BYTES: number;
 interface ExecutionBinaryService {
   forNode(args: {
@@ -792,32 +620,16 @@ interface ExecutionBinaryService {
     activationId: NodeActivationId;
   }): NodeBinaryAttachmentService;
   openReadStream(attachment: BinaryAttachment): Promise<BinaryStorageReadResult | undefined>;
-  /**
-   * Reads all bytes from the attachment into a contiguous `Uint8Array`.
-   * Checks `attachment.size` against `maxBytes` *before* any allocation; throws a bounded-read
-   * error when exceeded (no OOM). Throws if the stream is unavailable or the byte count mismatches.
-   */
   getBytes(attachment: BinaryAttachment, maxBytes?: number): Promise<Uint8Array>;
-  /**
-   * Reads the attachment and decodes the bytes as UTF-8 text.
-   * Subject to the same bounded-read safety as `getBytes`.
-   */
   getText(attachment: BinaryAttachment, maxBytes?: number): Promise<string>;
-  /**
-   * Reads the attachment, decodes as UTF-8 text, and parses as JSON.
-   * Throws a clear error on invalid JSON. Subject to the same bounded-read safety.
-   */
   getJson<T = unknown>(attachment: BinaryAttachment, maxBytes?: number): Promise<T>;
 }
 interface ExecutionContext {
   runId: RunId;
   workflowId: WorkflowId;
   parent?: ParentExecutionRef;
-  /** This run's subworkflow depth (0 = root). */
   subworkflowDepth: number;
-  /** Effective activation budget cap for this run (after policy merge). */
   engineMaxNodeActivations: number;
-  /** Effective subworkflow nesting cap for this run (after policy merge). */
   engineMaxSubworkflowDepth: number;
   now: () => Date;
   data: RunDataSnapshot;
@@ -825,28 +637,11 @@ interface ExecutionContext {
   telemetry: ExecutionTelemetry;
   binary: ExecutionBinaryService;
   getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
-  /** Per-item iteration id, set by {@link NodeExecutor} on the ctx passed into runnable `execute`. */
   iterationId?: NodeIterationId;
-  /** Item index (0-based) within the current activation's batch; set alongside {@link iterationId}. */
   itemIndex?: number;
-  /** When set, this ctx is executing inside a sub-agent triggered by the named parent invocation. */
   parentInvocationId?: ConnectionInvocationId;
-  /**
-   * Present iff the run was started by a TestSuiteOrchestrator. The {@link IsTestRunNode}
-   * branches on this; assertion-emitting nodes use it to decide whether to record results.
-   */
   testContext?: RunTestContext;
-  /**
-   * Collections registered in the codemation config, keyed by collection name.
-   */
   readonly collections?: CollectionsContext;
-  /**
-   * Resolve a DI token from the host container.
-   * Allows nodes to reach host-side services (e.g. `InboxChannelResolverToken`)
-   * without importing host code. Wired by `DefaultExecutionContextFactory`; throws
-   * a clear error when no resolver is configured (e.g. in unit tests that don't
-   * set up the full container).
-   */
   resolve<T>(token: TypeToken<T>): T;
 }
 interface ExecutionContextFactory {
@@ -871,18 +666,9 @@ interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfigBase>
   config: TConfig;
   telemetry: NodeExecutionTelemetry;
   binary: NodeBinaryAttachmentService;
-  /**
-   * Present when this node activation is a HITL resume.
-   * The node checks `ctx.resumeContext !== undefined` and takes the resume branch.
-   */
   resumeContext?: ResumeContext;
 }
-interface PollingTriggerHandle {
-  /**
-   * Start the polling loop. The runtime registers its own cleanup handle so callers do not need to
-   * call {@link TriggerSetupContext.registerCleanup} for the loop.
-   * @returns The state returned by the first cycle (or `undefined` when the overlap guard fired).
-   */
+interface TriggerPollingPort {
   start<TState, TItem>(args: {
     intervalMs: number;
     seedState?: TState;
@@ -894,7 +680,8 @@ interface PollingTriggerHandle {
       nextState: TState;
     }>;
   }): Promise<TState | undefined>;
-  /** Convenience dedup-window helper. */
+}
+interface PollingTriggerHandle extends TriggerPollingPort {
   readonly dedup: PollingTriggerDedupWindow;
 }
 interface TriggerSetupContext<TConfig extends TriggerNodeConfig<any, any> = TriggerNodeConfig<any, any>, TSetupState$1 extends JsonValue | undefined = TriggerNodeSetupState<TConfig>> extends ExecutionContext {
@@ -903,7 +690,6 @@ interface TriggerSetupContext<TConfig extends TriggerNodeConfig<any, any> = Trig
   previousState: TSetupState$1;
   registerCleanup(cleanup: TriggerCleanupHandle): void;
   emit(items: Items): Promise<void>;
-  /** Generic polling-trigger surface. Pre-binds trigger id, emit, and registerCleanup. */
   readonly polling: PollingTriggerHandle;
 }
 interface TriggerTestItemsContext<TConfig extends TriggerNodeConfig<any, any> = TriggerNodeConfig<any, any>, TSetupState$1 extends JsonValue | undefined = TriggerNodeSetupState<TConfig>> extends ExecutionContext {
@@ -912,11 +698,6 @@ interface TriggerTestItemsContext<TConfig extends TriggerNodeConfig<any, any> =
   config: TConfig;
   previousState: TSetupState$1;
 }
-/**
- * Trigger setup state is intentionally engine-owned so future ownership and
- * leader-election metadata can be coordinated centrally rather than pushed into
- * package-level setup code.
- */
 interface PersistedTriggerSetupState<TState extends JsonValue | undefined = JsonValue | undefined> {
   trigger: TriggerInstanceId;
   updatedAt: string;
@@ -934,12 +715,6 @@ interface EngineHost {
   credentialSessions: CredentialSessionService;
   workflows?: WorkflowRunnerService;
 }
-/**
- * Per-item runnable node: return JSON, an array to fan-out on `main`, an explicit `Item`, or {@link emitPorts}
- * for multi-port emission. Engine applies `inputSchema.parse(item.json)` and passes the result as `args.input`
- * (wire `item.json` is unchanged). Transform helpers may opt into binary preservation, while routers and
- * pass-through nodes should return explicit items when they need to preserve full item state.
- */
 interface RunnableNodeExecuteArgs<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown> {
   readonly input: TInputJson$1;
   readonly item: Item;
@@ -949,27 +724,13 @@ interface RunnableNodeExecuteArgs<TConfig extends RunnableNodeConfig<any, any> =
 }
 interface RunnableNode<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown, _TOutputJson = unknown> {
   readonly kind: "node";
-  /**
-   * Declared output ports (e.g. `["main"]`).
-   *
-   * Prefer describing dynamic router ports (Switch) and fixed multi-ports (If true/false)
-   * via {@link NodeConfigBase.declaredOutputPorts}. Engine defaults to `["main"]` when omitted.
-   */
   readonly outputPorts?: ReadonlyArray<OutputPortKey>;
-  /** When omitted, engine uses {@link RunnableNodeConfig.inputSchema} or `z.unknown()`. */
   readonly inputSchema?: ZodType<TInputJson$1>;
   execute(args: RunnableNodeExecuteArgs<TConfig, TInputJson$1>): Promise<unknown> | unknown;
 }
-/** @deprecated Use {@link RunnableNode} */
 type ItemNode<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown, TOutputJson$1 = unknown> = RunnableNode<TConfig, TInputJson$1, TOutputJson$1>;
 interface MultiInputNode<TConfig extends NodeConfigBase = NodeConfigBase> {
   kind: "node";
-  /**
-   * Declared output ports (typically `["main"]`).
-   *
-   * Prefer describing ports for authoring/canvas via {@link NodeConfigBase.declaredOutputPorts}.
-   * Engine defaults to `["main"]` when omitted.
-   */
   outputPorts?: ReadonlyArray<OutputPortKey>;
   executeMulti(inputsByPort: NodeInputsByPort, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
 }
@@ -1070,7 +831,6 @@ interface WorkflowSnapshotResolver {
     workflowSnapshot?: PersistedWorkflowSnapshot;
   }): WorkflowDefinition | undefined;
 }
-/** Optional host wiring for trigger lifecycle logs (boot skip + activation sync). */
 interface TriggerRuntimeDiagnostics {
   info(message: string): void;
   warn(message: string): void;
@@ -1079,7 +839,6 @@ interface EngineDeps {
   credentialSessions: CredentialSessionService;
   liveWorkflowRepository: LiveWorkflowRepository;
   workflowRepository: WorkflowRepository;
-  /** When {@link AllWorkflowsActiveWorkflowActivationPolicy}, all workflows behave as active (tests). */
   workflowActivationPolicy: WorkflowActivationPolicy;
   nodeResolver: NodeResolver;
   triggerSetupStateRepository: TriggerSetupStateRepository;
@@ -1095,39 +854,27 @@ interface EngineDeps {
   eventBus?: RunEventBus;
   tokenRegistry: PersistedWorkflowTokenRegistryLike;
   workflowNodeInstanceFactory: WorkflowNodeInstanceFactory;
-  /** Defaults for prune/storage snapshot when workflow omits explicit policy fields. */
   workflowPolicyRuntimeDefaults?: WorkflowPolicyRuntimeDefaults;
-  /** When set, logs inactive-workflow skips at boot and trigger start/stop on activation changes. */
   triggerRuntimeDiagnostics?: TriggerRuntimeDiagnostics;
-  /** When set, the polling-trigger runtime uses this logger for cycle info/debug/error. */
   pollingTriggerLogger?: PollingTriggerLogger;
 }
 //#endregion
 //#region src/contracts/retryPolicySpec.types.d.ts
-/**
- * In-process retry policy for runnable nodes. Serialized configs use the same
- * `kind` discriminator (`JSON.stringify` / persisted workflows).
- *
- * `maxAttempts` is the total number of tries including the first (e.g. 3 means up to 2 delays after failures).
- */
 type RetryPolicySpec = NoneRetryPolicySpec | FixedRetryPolicySpec | ExponentialRetryPolicySpec;
 interface NoneRetryPolicySpec {
   readonly kind: "none";
 }
 interface FixedRetryPolicySpec {
   readonly kind: "fixed";
-  /** Total attempts including the first execution. Must be >= 1. */
   readonly maxAttempts: number;
   readonly delayMs: number;
 }
 interface ExponentialRetryPolicySpec {
   readonly kind: "exponential";
-  /** Total attempts including the first execution. Must be >= 1. */
   readonly maxAttempts: number;
   readonly initialDelayMs: number;
   readonly multiplier: number;
   readonly maxDelayMs?: number;
-  /** When true, each delay is multiplied by a random factor in [1, 1.2). */
   readonly jitter?: boolean;
 }
 //#endregion
@@ -1142,7 +889,6 @@ interface JsonObject {
 }
 type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 type JsonArray = ReadonlyArray<JsonValue>;
-/** JSON value that is not a top-level array (nested arrays inside objects are allowed). */
 type JsonNonArray = JsonPrimitive | JsonObject;
 interface Edge {
   from: {
@@ -1154,11 +900,6 @@ interface Edge {
     input: InputPortKey;
   };
 }
-/**
- * Named connection from a parent node to child nodes that exist in {@link WorkflowDefinition.nodes}
- * but are not traversed by the main execution graph. Parents are commonly executable nodes, but may
- * also be connection-owned nodes for recursive agent attachments.
- */
 interface WorkflowNodeConnection {
   readonly parentNodeId: NodeId;
   readonly connectionName: NodeConnectionName;
@@ -1169,18 +910,10 @@ interface WorkflowDefinition {
   name: string;
   nodes: NodeDefinition[];
   edges: Edge[];
-  /**
-   * Optional metadata: which nodes are connection-owned children (e.g. AI agent `llm` / `tools` slots).
-   * When omitted, all nodes in {@link nodes} are treated as executable for topology.
-   */
   readonly connections?: ReadonlyArray<WorkflowNodeConnection>;
-  /** Directory + file-stem path under a workflow discovery root (for UI grouping only). */
   discoveryPathSegments?: readonly string[];
-  /** Retention for run JSON and binaries (seconds). Host/env may supply defaults when omitted. */
   readonly prunePolicy?: WorkflowPrunePolicySpec;
-  /** Whether to keep run data after completion. Host/env may supply defaults when omitted. */
   readonly storagePolicy?: WorkflowStoragePolicySpec;
-  /** Invoked after a node fails permanently (retries exhausted) and node error handler did not recover. */
   readonly workflowErrorHandler?: WorkflowErrorHandlerSpec;
 }
 interface WorkflowGraph {
@@ -1198,59 +931,26 @@ interface NodeConfigBase {
   readonly name?: string;
   readonly id?: NodeId;
   readonly icon?: string;
-  /**
-   * Plain-language, non-technical explanation of what this node does, surfaced in the workflow
-   * inspector / node properties sidebar. A first-class config option every authorable node accepts
-   * directly (alongside `id`), so it flows into the persisted config the mappers read. Distinct from
-   * {@link inspectorSummary} (config-derived label/value rows).
-   */
   readonly description?: string;
   readonly execution?: Readonly<{
     hint?: "local" | "worker";
     queue?: string;
   }>;
-  /** In-process execute retries (runnable nodes). Triggers typically omit this. */
   readonly retryPolicy?: RetryPolicySpec;
-  /** Recover from execute failures; return outputs to continue, or rethrow to fail the node. */
   readonly nodeErrorHandler?: NodeErrorHandlerSpec;
-  /**
-   * When true, edges carrying zero items on an output port still schedule single-input downstream nodes.
-   * Decided from the **source** node that produced the (empty) output. Default (false/undefined): empty
-   * main batches skip downstream execution and propagate the empty path.
-   */
   readonly continueWhenEmptyOutput?: boolean;
-  /**
-   * Declared I/O port names for canvas authoring (unioned with ports inferred from edges).
-   * Use for dynamic routers (Switch) and future error ports.
-   */
   readonly declaredOutputPorts?: ReadonlyArray<OutputPortKey>;
   readonly declaredInputPorts?: ReadonlyArray<InputPortKey>;
   getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
-  /**
-   * Marker: this node emits {@link import("./assertionTypes").AssertionResult}-shaped items on its
-   * `main` port. The TestSuiteOrchestrator (and host-side TestAssertionPersister) listen for
-   * `nodeCompleted` events from nodes with this flag set, and persist their output items as
-   * TestAssertion records (only when the run carries a `testContext`). Set on assertion node
-   * configs (e.g. `AssertionNodeConfig`, `StringEqualsAssertionNodeConfig`).
-   */
   readonly emitsAssertions?: true;
-  /**
-   * Static configuration summary surfaced in the workflow inspector — the design-time
-   * "what does this node do" panel that renders before any run telemetry exists.
-   *
-   * Return 2–6 short label/value pairs derived from this config (method + url for an HTTP
-   * call, model + tool list for an agent, schedule + timezone for a cron trigger, etc.).
-   * Values are truncated by the UI; aim for one line each. Return `undefined` to opt out
-   * — the inspector hides the section when no rows are produced.
-   *
-   * Implement on the config class instance so the function can read sibling config fields.
-   * `defineNode({ inspectorSummary })` plumbs through to this.
-   */
   inspectorSummary?(): ReadonlyArray<NodeInspectorSummaryRow> | undefined;
 }
-/**
- * One row of a node's static configuration summary. See {@link NodeConfigBase.inspectorSummary}.
- */
+interface PollingTriggerConfig {
+  getTriggerPollConfig(): Readonly<{
+    config: JsonObject;
+    pollIntervalMs?: number;
+  }>;
+}
 interface NodeInspectorSummaryRow {
   readonly label: string;
   readonly value: string;
@@ -1258,24 +958,11 @@ interface NodeInspectorSummaryRow {
 declare const runnableNodeInputType: unique symbol;
 declare const runnableNodeOutputType: unique symbol;
 declare const triggerNodeOutputType: unique symbol;
-/**
- * Runnable node: **`TInputJson`** is what **`inputSchema`** validates on **`item.json`** (the wire payload).
- * **`TOutputJson`** is emitted `item.json` on outputs.
- */
 interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends NodeConfigBase {
   readonly kind: "node";
   readonly [runnableNodeInputType]?: TInputJson$1;
   readonly [runnableNodeOutputType]?: TOutputJson$1;
-  /**
-   * Optional Zod input contract for {@link RunnableNode} when not set on the node class.
-   * Resolution order: node instance `inputSchema`, then config `inputSchema`, then `z.unknown()`.
-   */
   readonly inputSchema?: ZodType<TInputJson$1>;
-  /**
-   * When an activation receives **zero** input items, the engine normally runs `execute` zero times.
-   * Set to **`runOnce`** to run `execute` once with an empty `items` batch (and a synthetic wire item for schema parsing).
-   * Used by batch-style callback nodes (built-in `Callback`) so `callback([], ctx)` still runs.
-   */
   readonly emptyBatchExecution?: "skip" | "runOnce";
 }
 declare const triggerNodeSetupStateType: unique symbol;
@@ -1283,11 +970,6 @@ interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonV
   readonly kind: "trigger";
   readonly [triggerNodeOutputType]?: TOutputJson$1;
   readonly [triggerNodeSetupStateType]?: TSetupState$1;
-  /**
-   * Distinguishes triggers driven by the live activation policy (webhooks, cron, polling) from
-   * triggers driven only by the {@link TestSuiteOrchestrator}. `WorkflowActivation` skips
-   * `"test"` triggers; the orchestrator skips `"live"` triggers. Defaults to `"live"` when omitted.
-   */
   readonly triggerKind?: "live" | "test";
 }
 type RunnableNodeInputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<infer TInputJson, any> ? TInputJson : never;
@@ -1339,27 +1021,14 @@ type Items<TJson = unknown> = ReadonlyArray<Item<TJson>>;
 type NodeOutputs = Partial<Record<OutputPortKey, Items>>;
 type RunId = string;
 type NodeActivationId = string;
-/**
- * One per-item iteration of a runnable node's execute loop. Refines `NodeActivationId` for
- * per-item connection invocations and telemetry. Undefined when the executing node is a batch
- * node or trigger that does not iterate items.
- */
 type NodeIterationId = string;
 interface ParentExecutionRef {
   runId: RunId;
   workflowId: WorkflowId;
   nodeId: NodeId;
-  /** Subworkflow depth of the **spawning** run (0 = root). Passed when starting a child run. */
   subworkflowDepth?: number;
-  /** Effective max node activations from the parent run (propagated to child policy merge). */
   engineMaxNodeActivations?: number;
-  /** Effective max subworkflow depth from the parent run (propagated to child policy merge). */
   engineMaxSubworkflowDepth?: number;
-  /**
-   * Test-suite linkage inherited by the child subworkflow run. Set by whichever node
-   * spawns the subworkflow when its own `ctx.testContext` is present, so assertions
-   * emitted inside a subworkflow land under the correct parent test case.
-   */
   testContext?: RunTestContext;
 }
 interface RunDataSnapshot {
@@ -1394,7 +1063,6 @@ interface NodeOffloadPolicy {
     config: NodeConfigBase;
   }): NodeSchedulerDecision;
 }
-/** Whether to persist run execution data after the workflow finishes. */
 type WorkflowStoragePolicyMode = "ALL" | "SUCCESS" | "ERROR" | "NEVER";
 type WorkflowStoragePolicySpec = WorkflowStoragePolicyMode | TypeToken<WorkflowStoragePolicyResolver>;
 interface WorkflowStoragePolicyResolver {
@@ -1447,7 +1115,6 @@ interface NodeErrorHandler {
   handle<TConfig extends NodeConfigBase>(args: NodeErrorHandlerArgs<TConfig>): Promise<NodeOutputs>;
 }
 type NodeErrorHandlerSpec = TypeToken<NodeErrorHandler> | NodeErrorHandler;
-/** Runtime defaults when workflow omits prune/storage fields (typically from host env). */
 interface WorkflowPolicyRuntimeDefaults {
   readonly retentionSeconds?: number;
   readonly binaryRetentionSeconds?: number;
@@ -1458,76 +1125,25 @@ interface WorkflowPolicyRuntimeDefaults {
 }
 //#endregion
 //#region src/contracts/testTriggerTypes.d.ts
-/**
- * Identifier minted by the host (or in-memory test runner) for one execution of a test suite.
- * One TestSuiteRun produces N child workflow runs, one per item yielded by `generateItems`.
- */
 type TestSuiteRunId = string;
-/**
- * Setup context passed to a {@link TestTriggerNodeConfig.generateItems} callback. Distinct from
- * {@link import("./runtimeTypes").TriggerSetupContext} on purpose: test triggers are not
- * activated by the live trigger lifecycle (webhooks, cron, polling) and never call `emit` —
- * the orchestrator pulls from the iterable they return and dispatches one run per item.
- */
 interface TestTriggerSetupContext<TConfig extends TestTriggerNodeConfig<unknown> = TestTriggerNodeConfig<unknown>> {
   readonly workflowId: WorkflowId;
   readonly nodeId: NodeId;
   readonly config: TConfig;
   readonly testSuiteRunId: TestSuiteRunId;
-  /**
-   * Resolves a credential session for a slot declared on this trigger's
-   * {@link import("./workflowTypes").NodeConfigBase.getCredentialRequirements}. Same contract as
-   * {@link import("./runtimeTypes").ExecutionContext.getCredential}.
-   */
   getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
-  /** AbortSignal raised when the suite is cancelled — long-running pulls should bail out. */
   readonly signal: AbortSignal;
 }
-/**
- * A trigger config that emits **test cases**. Each item yielded by {@link generateItems}
- * becomes one workflow run (with `executionOptions.testContext` set), so 10 yielded items
- * → 10 runs marked under the same TestSuiteRun.
- *
- * The trigger is otherwise a normal {@link TriggerNodeConfig} (so the canvas treats it like
- * any other trigger), but its `triggerKind` is `"test"` so the live activation policy skips it.
- */
 interface TestTriggerNodeConfig<TOutputJson$1 = unknown> extends TriggerNodeConfig<TOutputJson$1, undefined> {
   readonly triggerKind: "test";
-  /**
-   * Author-supplied async iterable of items, evaluated lazily. Implementations may fetch from
-   * credentialed APIs, read fixture files, or yield hard-coded items. The orchestrator iterates
-   * and dispatches one run per item, with concurrency capped by {@link concurrency} (default 4).
-   */
   generateItems(ctx: TestTriggerSetupContext<TestTriggerNodeConfig<TOutputJson$1>>): AsyncIterable<Item<TOutputJson$1>>;
-  /** Per-suite-run cap on simultaneously-executing test cases. Default: 4. */
   readonly concurrency?: number;
-  /**
-   * Free-form description of where the test cases come from — surfaced in the node properties
-   * panel and the suite-detail header so authors revisiting the workflow six months later
-   * remember which mailbox / folder / fixture file the cases originate from.
-   *
-   * Example: `"All emails in the Gmail label \"test/triage-fixtures\" — 14 messages as of 2026-05-03."`
-   */
   readonly description?: string;
-  /**
-   * Resolves a human-readable label for one yielded test case (e.g. email subject). The
-   * orchestrator calls this once per yielded item, persists the result on the run, and the
-   * Tests-tab UI uses it to render the case row instead of the opaque runId. Return
-   * `undefined` to fall back to "Case #N".
-   */
   caseLabel?(item: Item<TOutputJson$1>): string | undefined;
 }
 //#endregion
 //#region src/events/runEvents.d.ts
-/**
- * Outcome of a single test case (one workflow run dispatched by the test-suite orchestrator).
- * - `running`: workflow still in flight
- * - `succeeded`: workflow completed AND all assertions passed (or no assertions)
- * - `failed`: workflow failed OR (workflow completed but ≥1 assertion failed)
- * - `errored` / `cancelled`: workflow itself errored or was cancelled
- */
 type TestCaseRunStatus = "running" | "succeeded" | "failed" | "errored" | "cancelled";
-/** Aggregate outcome of a TestSuiteRun. */
 type TestSuiteRunStatus = "succeeded" | "failed" | "partial" | "errored" | "cancelled";
 type RunEvent = Readonly<{
   kind: "runCreated";
@@ -1641,23 +1257,20 @@ interface EngineExecutionLimitsPolicyConfig {
   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/contracts/triggerInvokerTypes.d.ts
+interface TriggerInvoker {
+  invoke(trigger: TriggerInstanceId, config: TriggerNodeConfig, lastRanAt: string | undefined): Promise<Items>;
+}
+//#endregion
 //#region src/di/CoreTokens.d.ts
 declare const CoreTokens: {
   readonly PersistedWorkflowTokenRegistry: TypeToken<PersistedWorkflowTokenRegistryLike>;
@@ -1678,54 +1291,31 @@ declare const CoreTokens: {
   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>;
-  /**
-   * Optional. When registered, AIAgentNode uses it to resolve mcpServers bindings,
-   * validate scopes, open pool connections, and prepare the MCP ToolSet map.
-   * Not registered in the default core bootstrap — the host provides the implementation.
-   */
   readonly AgentMcpIntegration: TypeToken<AgentMcpIntegration>;
+  readonly TriggerInvoker: TypeToken<TriggerInvoker>;
 };
 //#endregion
 //#region src/contracts/runTypes.d.ts
-/**
- * Test-suite linkage for a run. When set, this run was started by a TestSuiteOrchestrator
- * as one test case inside a TestSuiteRun. The `IsTestRun` node and host-side persisters key
- * off the presence of this field. Subworkflow runs inherit it from their parent run.
- */
 interface RunTestContext {
   readonly testSuiteRunId: string;
   readonly testCaseIndex: number;
-  /**
-   * Optional human-friendly label for this test case (e.g. an email subject when fixtures
-   * are loaded from a mailbox). Resolved per item by `TestTrigger.caseLabel(item)` if set,
-   * persisted on `Run.test_case_label` so the Tests-tab tree-table can show "RFQ for batch 14"
-   * instead of "run_1777755971399_bbb86beac1396".
-   */
   readonly testCaseLabel?: string;
 }
 interface RunExecutionOptions {
-  /** Run-intent override: force the inline scheduler and bypass node-level offload decisions. */
   localOnly?: boolean;
-  /** Marks runs started from webhook handling so orchestration can apply webhook-specific continuation rules. */
   webhook?: boolean;
   mode?: "manual" | "debug";
   sourceWorkflowId?: WorkflowId;
   sourceRunId?: RunId;
   derivedFromRunId?: RunId;
   isMutable?: boolean;
-  /** Set by the engine for this run: 0 = root, 1 = first child subworkflow, … */
   subworkflowDepth?: number;
-  /** Effective cap after engine policy merge (successful node completions per run). */
   maxNodeActivations?: number;
-  /** Effective cap after engine policy merge (subworkflow nesting). */
   maxSubworkflowDepth?: number;
-  /** Present iff started by a TestSuiteOrchestrator; propagates to subworkflow runs via {@link ParentExecutionRef.testContext}. */
   testContext?: RunTestContext;
 }
-/** Engine-owned counters persisted with the run (worker-safe). */
 interface EngineRunCounters {
   completedNodeActivations: number;
 }
@@ -1750,7 +1340,6 @@ interface PersistedWorkflowSnapshotNode {
   tokenName?: string;
   configTokenName?: string;
   config: unknown;
-  /** Pre-computed static configuration summary; populated by WorkflowSnapshotCodec. */
   inspectorSummary?: ReadonlyArray<Readonly<{
     label: string;
     value: string;
@@ -1761,9 +1350,7 @@ interface PersistedWorkflowSnapshot {
   name: string;
   nodes: ReadonlyArray<PersistedWorkflowSnapshotNode>;
   edges: ReadonlyArray<Edge>;
-  /** When the snapshot was built from a live workflow definition that configured a workflow error handler. */
   workflowErrorHandlerConfigured?: boolean;
-  /** Connection metadata for child nodes not in the execution graph (e.g. AI agent attachments). */
   connections?: ReadonlyArray<WorkflowNodeConnection>;
 }
 type PinnedNodeOutputsByPort = Readonly<Record<OutputPortKey, Items>>;
@@ -1811,18 +1398,9 @@ interface NodeExecutionSnapshot {
   inputsByPort?: NodeInputsByPort;
   outputs?: NodeOutputs;
   error?: NodeExecutionError;
-  /**
-   * When the node is a SubWorkflow invocation, the run id of the child run it spawned.
-   * Populated after the child run completes so the UI can deep-link to that specific execution.
-   */
   childRunId?: RunId;
 }
-/** Stable id for a single connection invocation row in {@link ConnectionInvocationRecord}. */
 type ConnectionInvocationId = string;
-/**
- * One logical LLM or tool call under an owning workflow node (e.g. AI agent).
- * The owning node defines what {@link managedInput} and {@link managedOutput} contain.
- */
 interface ConnectionInvocationRecord {
   readonly invocationId: ConnectionInvocationId;
   readonly runId: RunId;
@@ -1833,23 +1411,17 @@ interface ConnectionInvocationRecord {
   readonly status: NodeExecutionStatus;
   readonly managedInput?: JsonValue;
   readonly managedOutput?: JsonValue;
-  /** Short human-readable description of what this invocation is doing right now (e.g. `"calling search_messages"`). Rendered as a sub-line on the canvas node card. */
   readonly statusLabel?: string;
-  /** Stable identifier for the thing this invocation acts on (e.g. an MCP tool name like `"search_messages"`). Persists across status transitions so the inspector can show it on completed/failed entries too. Connection nodes that ARE the tool (e.g. node-backed agent tools) leave this unset — the parent node id already identifies the subject. */
   readonly subjectName?: string;
   readonly error?: NodeExecutionError;
   readonly queuedAt?: string;
   readonly startedAt?: string;
   readonly finishedAt?: string;
   readonly updatedAt: string;
-  /** Per-item iteration id minted by the engine when this invocation occurred inside a runnable node's per-item loop. */
   readonly iterationId?: NodeIterationId;
-  /** Item index (0-based) of the iteration that produced this invocation. */
   readonly itemIndex?: number;
-  /** When set, this invocation was produced inside a sub-agent triggered by the named parent invocation. */
   readonly parentInvocationId?: ConnectionInvocationId;
 }
-/** Arguments for appending a {@link ConnectionInvocationRecord} (engine fills run/workflow ids and timestamps). */
 type ConnectionInvocationAppendArgs = Readonly<{
   invocationId: ConnectionInvocationId;
   connectionNodeId: NodeId;
@@ -1871,7 +1443,6 @@ type ConnectionInvocationAppendArgs = Readonly<{
 interface RunCurrentState {
   outputsByNode: Record<NodeId, NodeOutputs>;
   nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
-  /** Append-only history of connection-scoped invocations (LLM/tool) for inspector and canvas. */
   connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
   mutableState?: PersistedMutableRunState;
 }
@@ -1898,21 +1469,13 @@ interface ExecutionFrontierPlan {
   preservedPinnedNodeIds: ReadonlyArray<NodeId>;
 }
 type RunStatus = "running" | "pending" | "completed" | "failed" | "suspended" | "halted";
-/** Reason a run transitioned to {@link RunStatus} `"halted"`. */
 type RunHaltReason = "hitl-rejected" | "hitl-timeout" | "hitl-cancelled";
 interface RunSummary {
   runId: RunId;
   workflowId: WorkflowId;
   startedAt: string;
   status: RunStatus;
-  /**
-   * Test-case status for runs dispatched as part of a TestSuiteRun. Carries the
-   * assertion-rollup-corrected outcome the test orchestrator persists onto the row, so the
-   * executions list can show "failed" for a run whose workflow completed cleanly but whose
-   * assertions caught regressions. Absent for non-test runs and legacy rows.
-   */
   testCaseStatus?: TestCaseRunStatus;
-  /** ISO timestamp when the run finished (derived from node snapshots or store `updatedAt`); omit while running/pending. */
   finishedAt?: string;
   parent?: ParentExecutionRef;
   executionOptions?: RunExecutionOptions;
@@ -1933,70 +1496,42 @@ interface PersistedRunSchedulingState {
   pending?: PendingNodeExecution;
   queue: RunQueueEntry[];
 }
-/** One persisted suspension entry per suspended item. */
 interface PersistedSuspensionEntry {
-  /** Opaque task identifier (UUID v4). */
   readonly taskId: string;
   readonly nodeId: NodeId;
   readonly activationId: NodeActivationId;
   readonly itemIndex: number;
-  /** SHA-256 hex digest of the decision schema JSON (for schema-drift detection). */
   readonly decisionSchemaHash: string;
-  /** Serialized return value from `SuspensionRequest.deliver` (stored on the HumanTask row). */
   readonly deliveryRef: JsonValue;
-  /** ISO timestamp when the task expires. */
   readonly timeoutAt: string;
   readonly onTimeout: "halt" | "auto-accept";
 }
-/**
- * When a node is re-activated after suspension, the engine writes the resume context here
- * so `NodeExecutionRequestHandlerService` can splice `resumeContext` into ctx.
- * Cleared once the re-activation is consumed.
- */
 interface PendingResumeEntry {
   readonly activationId: NodeActivationId;
   readonly nodeId: NodeId;
-  /**
-   * Typed as `unknown` here to avoid a circular import between runTypes ↔ runtimeTypes.
-   * `NodeExecutionRequestHandlerService` casts this to `ResumeContext` from runtimeTypes.
-   */
   readonly resumeContext: unknown;
 }
 interface PersistedRunState {
   runId: RunId;
   workflowId: WorkflowId;
   startedAt: string;
-  /** Canonical terminal time for listings and retention when persisted on the run root. */
   finishedAt?: string;
-  /** Optimistic concurrency / CAS on the run aggregate (repository may increment on save). */
   revision?: number;
   parent?: ParentExecutionRef;
   executionOptions?: RunExecutionOptions;
   control?: PersistedRunControlState;
   workflowSnapshot?: PersistedWorkflowSnapshot;
   mutableState?: PersistedMutableRunState;
-  /** Frozen at createRun from workflow + runtime defaults for prune/storage decisions. */
   policySnapshot?: PersistedRunPolicySnapshot;
-  /** Successful node completions so far (for activation budget). */
   engineCounters?: EngineRunCounters;
   status: RunStatus;
-  /** Populated when `status === "halted"` to discriminate why the run was halted. */
   reason?: RunHaltReason;
   pending?: PendingNodeExecution;
   queue: RunQueueEntry[];
   outputsByNode: Record<NodeId, NodeOutputs>;
   nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
-  /** Append-only history of connection invocations (LLM/tool) nested under owning nodes. */
   connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
-  /**
-   * One entry per outstanding HITL suspension (per-item).
-   * Present and non-empty iff `status === "suspended"`.
-   */
   suspension?: ReadonlyArray<PersistedSuspensionEntry>;
-  /**
-   * Written by `resumeRun()` so `NodeExecutionRequestHandlerService` can splice `resumeContext`
-   * into the ctx when re-executing the suspended node. Cleared once consumed.
-   */
   pendingResume?: PendingResumeEntry;
 }
 interface WorkflowExecutionRepository {
@@ -2023,7 +1558,6 @@ interface WorkflowExecutionListingRepository {
     limit?: number;
   }>): Promise<ReadonlyArray<RunSummary>>;
 }
-/** Runs eligible for retention-based pruning (completed or failed, older than cutoff). */
 interface RunPruneCandidate {
   readonly runId: RunId;
   readonly workflowId: WorkflowId;
@@ -2086,42 +1620,13 @@ interface RunEventPublisherDeps {
 }
 //#endregion
 //#region src/contracts/agentMcpTypes.d.ts
-/**
- * Emitted as a span event when a credential is missing required scopes
- * (bind-time) or when callTool returns a permission error (runtime).
- * The credential type id can be looked up from the credential instance when needed.
- */
 interface NeedsReconsentEvent {
   readonly serverId: string;
   readonly credentialInstanceId: string;
   readonly missingScopesHint?: readonly string[];
 }
-/**
- * An opaque MCP tool map: keyed by serverId → (toolName → tool definition).
- * Typed as unknown so core does not depend on the AI SDK's ToolSet type.
- * AIAgentNode (in core-nodes, which does depend on ai) casts this to
- * ReadonlyMap<string, ToolSet> before passing to DeferredMetaToolStrategyFactory.
- */
 type AgentMcpToolMap = ReadonlyMap<string, Readonly<Record<string, unknown>>>;
-/**
- * Contract implemented by the host. Resolves MCP server bindings for an agent run
- * via the standard credential-binding table (one slot per declared server, keyed
- * by `(workflowId, mcpConnectionNodeId, "credential")`), and returns a ready-to-use
- * tool map with wrapped execute callbacks for telemetry and 403 detection.
- * Core-nodes imports this interface so AIAgentNode can inject it without
- * depending on the host.
- */
 interface AgentMcpIntegration {
-  /**
-   * Look up the credential binding per server, validate scopes, open pool
-   * connections, and return a tool map keyed by serverId. Each tool's
-   * execute callback includes:
-   * - Telemetry child span (mcp.server_id, mcp.tool_name attributes)
-   * - 403/permission error detection → emits a NeedsReconsentEvent span event
-   *
-   * Throws `AgentBindError` on validation failures (missing server, unbound
-   * credential slot, missing credential instance, insufficient scopes).
-   */
   prepareMcpTools(args: {
     readonly workflowId: WorkflowId;
     readonly agentNodeId: NodeId;
@@ -2137,18 +1642,13 @@ interface AgentMcpIntegration {
         statusMessage?: string;
       }) => void;
     };
-    /** Per-MCP-tool-call invocation appender. Optional; when omitted the wrapper emits only telemetry spans. */
     readonly appendMcpInvocation?: (args: ConnectionInvocationAppendArgs) => Promise<void>;
-    /** Agent activation id to attach to each invocation record (used by canvas + inspector grouping). */
     readonly parentAgentActivationId?: NodeActivationId;
-    /** Per-item iteration id when the agent runs inside a per-item loop. */
     readonly iterationId?: NodeIterationId;
-    /** Item index (0-based) of the iteration that owns these tool calls. */
     readonly itemIndex?: number;
-    /** Parent invocation id when this agent is itself executing as a sub-agent. */
     readonly parentInvocationId?: ConnectionInvocationId;
   }): Promise<AgentMcpToolMap>;
 }
 //#endregion
-export { injectAll as $, NodeActivationRequest as $n, CodemationTelemetryMetricNames as $r, RunnableNodeConfig as $t, RunHaltReason as A, CredentialOAuth2ScopesFromPublicConfig as Ai, BinaryAttachmentCreateRequest as An, WorkflowSnapshotResolver as Ar, JsonValue as At, WorkflowExecutionListingRepository as B, CredentialUnboundError as Bi, ExecutableTriggerNode as Bn, ExecutionTelemetry as Br, NodeIterationId as Bt, PersistedWorkflowSnapshotNode as C, CredentialHealthStatus as Ci, triggerNodeOutputType as Cn, TriggerSetupStateRepository as Cr, Item as Ct, RunCurrentState as D, CredentialJsonRecord as Di, NoneRetryPolicySpec as Dn, WorkflowRunnerResolver as Dr, JsonNonArray as Dt, RunCompletionNotifier as E, CredentialInstanceRecord as Ei, FixedRetryPolicySpec as En, WorkflowRepository as Er, JsonArray as Et, RunStatus as F, CredentialSetupStatus as Fi, BinaryStorageWriteRequest as Fn, WebhookTriggerMatcher as Fr, NodeErrorHandler as Ft, Disposable as G, InputPortKey as Gi, HumanTaskHandle as Gn, TelemetryAttributePrimitive as Gr, NodeSchedulerDecision as Gt, WorkflowExecutionRepository as H, NoOpPollingTriggerLogger as Hi, ExecutionContext as Hn, NodeExecutionTelemetry as Hr, NodeOffloadPolicy as Ht, RunStopCondition as I, CredentialType as Ii, BinaryStorageWriteResult as In, WebhookTriggerResolution as Ir, NodeErrorHandlerArgs as It, RegistrationOptions as J, OutputPortKey as Ji, ItemNode as Jn, TelemetryMetricRecord as Jr, PersistedRunPolicySnapshot as Jt, InjectionToken$1 as K, NodeConnectionName as Ki, HumanTaskId as Kn, TelemetryAttributes as Kr, PairedItemRef as Kt, RunSummary as L, CredentialTypeDefinition as Li, Duration as Ln, WebhookTriggerRoutingDiagnostics as Lr, NodeErrorHandlerSpec as Lt, RunQueueEntry as M, CredentialSessionFactory as Mi, BinaryStorage as Mn, TriggerInstanceId as Mr, NodeActivationId as Mt, RunResult as N, CredentialSessionFactoryArgs as Ni, BinaryStorageReadResult as Nn, WebhookControlSignal as Nr, NodeConfigBase as Nt, RunEventPublisherDeps as O, CredentialMaterialSourceKind as Oi, RetryPolicySpec as On, WorkflowRunnerService as Or, JsonObject as Ot, RunStateResetRequest as P, CredentialSessionService as Pi, BinaryStorageStatResult as Pn, WebhookInvocationMatch as Pr, NodeDefinition as Pt, inject as Q, NodeActivationReceipt as Qn, TelemetrySpanScope as Qr, RunIdFactory as Qt, RunTestContext as R, CredentialTypeId as Ri, EngineDeps as Rn, AllWorkflowsActiveWorkflowActivationPolicy as Rr, NodeIdRef as Rt, PersistedWorkflowSnapshot as S, CredentialHealth as Si, runnableNodeOutputType as Sn, TriggerSetupStateFor as Sr, ExecutionMode as St, PinnedNodeOutputsByPort as T, CredentialInstanceId as Ti, ExponentialRetryPolicySpec as Tn, WorkflowNodeInstanceFactory as Tr, Items as Tt, Container as U, PollingTriggerLogger as Ui, ExecutionContextFactory as Un, TelemetryArtifactAttachment as Ur, NodeOutputs as Ut, WorkflowExecutionPruneRepository as V, OAuth2ProviderFromPublicConfig as Vi, ExecutionBinaryService as Vn, ExecutionTelemetryFactory as Vr, NodeKind as Vt, DependencyContainer$1 as W, PollingTriggerDedupWindow as Wi, HumanTaskActor as Wn, TelemetryArtifactReference as Wr, NodeRef as Wt, container as X, WorkflowId as Xi, MultiInputNode as Xn, TelemetrySpanEnd as Xr, RunDataSnapshot as Xt, TypeToken as Y, PersistedTokenId as Yi, LiveWorkflowRepository as Yn, TelemetryScope as Yr, RunDataFactory as Yt, delay as Z, NodeActivationContinuation as Zn, TelemetrySpanEventRecord as Zr, RunId as Zt, PersistedMutableRunState as _, CredentialAdvancedSectionPresentation as _i, WorkflowStoragePolicyResolver as _n, TestableTriggerNode as _r, TestTriggerSetupContext as _t, ConnectionInvocationId as a, NoOpTelemetrySpanScope as ai, UpstreamRefPlaceholder as an, NodeExecutionRequestHandler as ar, singleton as at, PersistedRunState as b, CredentialBindingKey as bi, nodeRef as bn, TriggerRuntimeDiagnostics as br, BinaryPreviewKind as bt, EngineRunCounters as c, CostTrackingPriceQuote as ci, WorkflowErrorHandler as cn, NodeExecutor as cr, EngineExecutionLimitsPolicy as ct, NodeExecutionSnapshot as d, CostTrackingTelemetryFactory as di, WorkflowGraphFactory as dn, PollingTriggerHandle as dr, RunEventBus as dt, GenAiTelemetryAttributeNames as ei, RunnableNodeInputJson as en, NodeActivationRequestBase as er, injectable as et, NodeExecutionStatus as f, CostTrackingTelemetryMetricNames as fi, WorkflowNodeConnection as fn, PreparedNodeActivationDispatch as fr, RunEventSubscription as ft, PersistedMutableNodeState as g, AnyCredentialType as gi, WorkflowStoragePolicyMode as gn, SuspensionRequest as gr, TestTriggerNodeConfig as gt, PendingResumeEntry as h, CollectionsContext as hi, WorkflowStoragePolicyDecisionArgs as hn, RunnableNodeExecuteArgs as hr, TestSuiteRunId as ht, ConnectionInvocationAppendArgs as i, NoOpNodeExecutionTelemetry as ii, TriggerNodeSetupState as in, NodeExecutionRequest as ir, registry as it, RunPruneCandidate as j, CredentialRequirement as ji, BinaryBody as jn, HttpMethod as jr, MutableRunData as jt, RunExecutionOptions as k, CredentialOAuth2AuthDefinition as ki, BINARY_DEFAULT_MAX_BYTES as kn, WorkflowSnapshotFactory as kr, JsonPrimitive as kt, ExecutionFrontierPlan as l, CostTrackingTelemetry as li, WorkflowErrorHandlerSpec as ln, NodeResolver as lr, EngineExecutionLimitsPolicyConfig as lt, PendingNodeExecution as m, CollectionStore as mi, WorkflowPrunePolicySpec as mn, RunnableNode as mr, TestSuiteRunStatus as mt, AgentMcpToolMap as n, NoOpExecutionTelemetryFactory as ni, TriggerNodeConfig as nn, NodeBinaryAttachmentService as nr, instancePerContainerCachingFactory as nt, ConnectionInvocationRecord as o, NoOpTelemetryArtifactReference as oi, WorkflowDefinition as on, NodeExecutionScheduler as or, CoreTokens as ot, NodeInputsByPort as p, CostTrackingUsageRecord as pi, WorkflowPolicyRuntimeDefaults as pn, ResumeContext as pr, TestCaseRunStatus as pt, Lifecycle as q, NodeId as qi, HumanTaskSubject as qn, TelemetryChildSpanStart as qr, ParentExecutionRef as qt, NeedsReconsentEvent as r, NoOpExecutionTelemetry as ri, TriggerNodeOutputJson as rn, NodeExecutionContext as rr, predicateAwareClassFactory as rt, CurrentStateExecutionRequest as s, CostTrackingComponent as si, WorkflowErrorContext as sn, NodeExecutionStatePublisher as sr, ENGINE_EXECUTION_LIMITS_DEFAULTS as st, AgentMcpIntegration as t, CodemationTelemetryAttributeNames as ti, RunnableNodeOutputJson as tn, NodeActivationScheduler as tr, instanceCachingFactory as tt, NodeExecutionError as u, CostTrackingTelemetryAttributeNames as ui, WorkflowGraph as un, PersistedTriggerSetupState as ur, RunEvent as ut, PersistedRunControlState as v, CredentialAuthDefinition as vi, WorkflowStoragePolicySpec as vn, TriggerCleanupHandle as vr, ActivationIdFactory as vt, PersistedWorkflowTokenRegistryLike as w, CredentialHealthTester as wi, triggerNodeSetupStateType as wn, TriggerTestItemsContext as wr, ItemBinary as wt, PersistedSuspensionEntry as x, CredentialFieldSchema as xi, runnableNodeInputType as xn, TriggerSetupContext as xr, Edge as xt, PersistedRunSchedulingState as y, CredentialBinding as yi, branchRef as yn, TriggerNode as yr, BinaryAttachment as yt, WebhookRunResult as z, CredentialTypeRegistry as zi, EngineHost as zn, WorkflowActivationPolicy as zr, NodeInspectorSummaryRow as zt };
-//# sourceMappingURL=agentMcpTypes-B11B3Hd-.d.cts.map
+export { injectAll as $, OutputPortKey as $i, NodeActivationContinuation as $n, TelemetrySpanEnd as $r, RunId as $t, RunHaltReason as A, CredentialInstanceId as Ai, RetryPolicySpec as An, WorkflowRunnerResolver as Ar, JsonPrimitive as At, WorkflowExecutionListingRepository as B, CredentialSetupStatus as Bi, EngineDeps as Bn, WebhookTriggerRoutingDiagnostics as Br, NodeInspectorSummaryRow as Bt, PersistedWorkflowSnapshotNode as C, CredentialAuthDefinition as Ci, runnableNodeInputType as Cn, TriggerRuntimeDiagnostics as Cr, ExecutionMode as Ct, RunCurrentState as D, CredentialHealth as Di, ExponentialRetryPolicySpec as Dn, TriggerTestItemsContext as Dr, JsonArray as Dt, RunCompletionNotifier as E, CredentialFieldSchema as Ei, triggerNodeSetupStateType as En, TriggerSetupStateRepository as Er, Items as Et, RunStatus as F, CredentialOAuth2ScopesFromPublicConfig as Fi, BinaryStorageReadResult as Fn, TriggerInstanceId as Fr, NodeDefinition as Ft, Disposable as G, CredentialUnboundError as Gi, ExecutionContextFactory as Gn, NodeExecutionTelemetry as Gr, NodeRef as Gt, WorkflowExecutionRepository as H, CredentialTypeDefinition as Hi, ExecutableTriggerNode as Hn, WorkflowActivationPolicy as Hr, NodeKind as Ht, RunStopCondition as I, CredentialRequirement as Ii, BinaryStorageStatResult as In, WebhookControlSignal as Ir, NodeErrorHandler as It, RegistrationOptions as J, PollingTriggerLogger as Ji, HumanTaskId as Jn, TelemetryAttributePrimitive as Jr, ParentExecutionRef as Jt, InjectionToken$1 as K, OAuth2ProviderFromPublicConfig as Ki, HumanTaskActor as Kn, TelemetryArtifactAttachment as Kr, NodeSchedulerDecision as Kt, RunSummary as L, CredentialSessionFactory as Li, BinaryStorageWriteRequest as Ln, WebhookInvocationMatch as Lr, NodeErrorHandlerArgs as Lt, RunQueueEntry as M, CredentialJsonRecord as Mi, BinaryAttachmentCreateRequest as Mn, WorkflowSnapshotFactory as Mr, MutableRunData as Mt, RunResult as N, CredentialMaterialSourceKind as Ni, BinaryBody as Nn, WorkflowSnapshotResolver as Nr, NodeActivationId as Nt, RunEventPublisherDeps as O, CredentialHealthStatus as Oi, FixedRetryPolicySpec as On, WorkflowNodeInstanceFactory as Or, JsonNonArray as Ot, RunStateResetRequest as P, CredentialOAuth2AuthDefinition as Pi, BinaryStorage as Pn, HttpMethod as Pr, NodeConfigBase as Pt, inject as Q, NodeId as Qi, MultiInputNode as Qn, TelemetryScope as Qr, RunDataSnapshot as Qt, RunTestContext as R, CredentialSessionFactoryArgs as Ri, BinaryStorageWriteResult as Rn, WebhookTriggerMatcher as Rr, NodeErrorHandlerSpec as Rt, PersistedWorkflowSnapshot as S, CredentialAdvancedSectionPresentation as Si, nodeRef as Sn, TriggerPollingPort as Sr, Edge as St, PinnedNodeOutputsByPort as T, CredentialBindingKey as Ti, triggerNodeOutputType as Tn, TriggerSetupStateFor as Tr, ItemBinary as Tt, Container as U, CredentialTypeId as Ui, ExecutionBinaryService as Un, ExecutionTelemetry as Ur, NodeOffloadPolicy as Ut, WorkflowExecutionPruneRepository as V, CredentialType as Vi, EngineHost as Vn, AllWorkflowsActiveWorkflowActivationPolicy as Vr, NodeIterationId as Vt, DependencyContainer$1 as W, CredentialTypeRegistry as Wi, ExecutionContext as Wn, ExecutionTelemetryFactory as Wr, NodeOutputs as Wt, container as X, InputPortKey as Xi, ItemNode as Xn, TelemetryChildSpanStart as Xr, PollingTriggerConfig as Xt, TypeToken as Y, PollingTriggerDedupWindow as Yi, HumanTaskSubject as Yn, TelemetryAttributes as Yr, PersistedRunPolicySnapshot as Yt, delay as Z, NodeConnectionName as Zi, LiveWorkflowRepository as Zn, TelemetryMetricRecord as Zr, RunDataFactory as Zt, PersistedMutableRunState as _, CollectionStore as _i, WorkflowStoragePolicyDecisionArgs as _n, RunnableNodeExecuteArgs as _r, TestTriggerNodeConfig as _t, ConnectionInvocationId as a, NoOpExecutionTelemetryFactory as ai, TriggerNodeOutputJson as an, NodeExecutionContext as ar, singleton as at, PersistedRunState as b, CredentialAccessTokenSessionArgs as bi, WorkflowStoragePolicySpec as bn, TriggerCleanupHandle as br, BinaryAttachment as bt, EngineRunCounters as c, NoOpTelemetrySpanScope as ci, WorkflowDefinition as cn, NodeExecutionScheduler as cr, ENGINE_EXECUTION_LIMITS_DEFAULTS as ct, NodeExecutionSnapshot as d, CostTrackingPriceQuote as di, WorkflowErrorHandlerSpec as dn, NodeResolver as dr, RunEvent as dt, PersistedTokenId as ea, TelemetrySpanEventRecord as ei, RunIdFactory as en, NodeActivationReceipt as er, injectable as et, NodeExecutionStatus as f, CostTrackingTelemetry as fi, WorkflowGraph as fn, PersistedTriggerSetupState as fr, RunEventBus as ft, PersistedMutableNodeState as g, CostTrackingUsageRecord as gi, WorkflowPrunePolicySpec as gn, RunnableNode as gr, TestSuiteRunId as gt, PendingResumeEntry as h, CostTrackingTelemetryMetricNames as hi, WorkflowPolicyRuntimeDefaults as hn, ResumeContext as hr, TestSuiteRunStatus as ht, ConnectionInvocationAppendArgs as i, CodemationTelemetryAttributeNames as ii, TriggerNodeConfig as in, NodeBinaryAttachmentService as ir, registry as it, RunPruneCandidate as j, CredentialInstanceRecord as ji, BINARY_DEFAULT_MAX_BYTES as jn, WorkflowRunnerService as jr, JsonValue as jt, RunExecutionOptions as k, CredentialHealthTester as ki, NoneRetryPolicySpec as kn, WorkflowRepository as kr, JsonObject as kt, ExecutionFrontierPlan as l, NoOpTelemetryArtifactReference as li, WorkflowErrorContext as ln, NodeExecutionStatePublisher as lr, EngineExecutionLimitsPolicy as lt, PendingNodeExecution as m, CostTrackingTelemetryFactory as mi, WorkflowNodeConnection as mn, PreparedNodeActivationDispatch as mr, TestCaseRunStatus as mt, AgentMcpToolMap as n, CodemationTelemetryMetricNames as ni, RunnableNodeInputJson as nn, NodeActivationRequestBase as nr, instancePerContainerCachingFactory as nt, ConnectionInvocationRecord as o, NoOpExecutionTelemetry as oi, TriggerNodeSetupState as on, NodeExecutionRequest as or, CoreTokens as ot, NodeInputsByPort as p, CostTrackingTelemetryAttributeNames as pi, WorkflowGraphFactory as pn, PollingTriggerHandle as pr, RunEventSubscription as pt, Lifecycle as q, NoOpPollingTriggerLogger as qi, HumanTaskHandle as qn, TelemetryArtifactReference as qr, PairedItemRef as qt, NeedsReconsentEvent as r, GenAiTelemetryAttributeNames as ri, RunnableNodeOutputJson as rn, NodeActivationScheduler as rr, predicateAwareClassFactory as rt, CurrentStateExecutionRequest as s, NoOpNodeExecutionTelemetry as si, UpstreamRefPlaceholder as sn, NodeExecutionRequestHandler as sr, TriggerInvoker as st, AgentMcpIntegration as t, WorkflowId as ta, TelemetrySpanScope as ti, RunnableNodeConfig as tn, NodeActivationRequest as tr, instanceCachingFactory as tt, NodeExecutionError as u, CostTrackingComponent as ui, WorkflowErrorHandler as un, NodeExecutor as ur, EngineExecutionLimitsPolicyConfig as ut, PersistedRunControlState as v, CollectionsContext as vi, WorkflowStoragePolicyMode as vn, SuspensionRequest as vr, TestTriggerSetupContext as vt, PersistedWorkflowTokenRegistryLike as w, CredentialBinding as wi, runnableNodeOutputType as wn, TriggerSetupContext as wr, Item as wt, PersistedSuspensionEntry as x, CredentialAccessTokenSessionFactory as xi, branchRef as xn, TriggerNode as xr, BinaryPreviewKind as xt, PersistedRunSchedulingState as y, AnyCredentialType as yi, WorkflowStoragePolicyResolver as yn, TestableTriggerNode as yr, ActivationIdFactory as yt, WebhookRunResult as z, CredentialSessionService as zi, Duration as zn, WebhookTriggerResolution as zr, NodeIdRef as zt };
+//# sourceMappingURL=agentMcpTypes-BHX4RQCC.d.cts.map