@codemation/host 0.3.0 → 1.0.0

package/CHANGELOG.md

@@ -1,5 +1,80 @@
 # @codemation/host
 
+## 1.0.0
+
+### Major Changes
+
+- [#93](https://github.com/MadeRelevant/codemation/pull/93) [`640e303`](https://github.com/MadeRelevant/codemation/commit/640e3032b1386568df725980a27761b6e230302c) Thanks [@cblokland90](https://github.com/cblokland90)! - Replace LangChain with the Vercel AI SDK for all AIAgent flows.
+
+  Codemation no longer depends on `@langchain/core` or `@langchain/openai`. Chat model providers, the turn loop, structured output, and tool calls now run on top of the Vercel **AI SDK** (`ai`, `@ai-sdk/openai`, `@ai-sdk/provider`). Custom Codemation behaviors that LangChain did not cover — the **tool-args repair loop**, the **structured-output repair loop**, **connection-invocation tracking**, and our **telemetry / cost-tracking spans** — are preserved and built on top of the new primitives.
+
+  ### Dependency changes
+  - **Removed**: `@langchain/core`, `@langchain/openai` (from `@codemation/core-nodes`).
+  - **Added**: `ai` `^6.0.168`, `@ai-sdk/openai` `^3.0.53`, `@ai-sdk/provider` `^3.0.8` (to `@codemation/core-nodes`). `@codemation/host` picks up `ai` + `@ai-sdk/provider` for its test harness only.
+
+  ### Public API renames (`@codemation/core`)
+
+  | Before                                               | After                                                                                                             |
+  | ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
+  | `LangChainChatModelLike`                             | `ChatLanguageModel`                                                                                               |
+  | `LangChainStructuredOutputModelLike`                 | _(removed — replaced by `StructuredOutputOptions` + `generateText({ experimental_output: Output.object(...) })`)_ |
+  | `ChatModelFactory.create` → `LangChainChatModelLike` | `ChatModelFactory.create` → `ChatLanguageModel` (thin wrapper around an AI SDK `LanguageModelV2`)                 |
+
+  `ChatLanguageModel` exposes the underlying AI SDK `LanguageModel` via `languageModel` plus `modelName`, `provider`, and optional `defaultCallOptions` (`maxOutputTokens`, `temperature`, `providerOptions`). `StructuredOutputOptions` mirrors `generateText({ output: Output.object(...) })` and carries an optional `schemaName` plus `strict` flag.
+
+  ### Custom behavior preserved (not delegated to the AI SDK)
+  - **Tool dispatch + tool-args repair**: tools are passed to `generateText` **without `execute`** so tool calls surface back to Codemation; `AgentToolExecutionCoordinator` still drives parallel execution, per-tool Zod-input validation, repair prompts, and retry accounting via `repairAttemptsByToolName`.
+  - **Structured output repair**: `AgentStructuredOutputRunner` still runs the `OpenAiStrictJsonSchemaFactory` + `AgentStructuredOutputRepairPromptFactory` loop; AI SDK's `Output.object(...)` is used only for the **first** structured attempt when the provider supports it.
+  - **Connection-invocation tracking**: `ConnectionInvocationIdFactory` + synthetic `LanguageModelConnectionNode` / tool connection node states (`queued` / `running` / `completed` / `failed`) are still emitted per turn and per tool call.
+  - **Telemetry span names (intentional, short-term)**: LLM calls stay on `gen_ai.chat.completion`, tool calls on `agent.tool.call`, metrics on `codemation.ai.turns` / `codemation.ai.tool_calls` / `codemation.cost.estimated`. We disable AI SDK's built-in telemetry (`experimental_telemetry`) for this cut so host-side telemetry aggregations keep working unchanged. Migrating to AI SDK native span names is intentionally deferred.
+  - **Engine-level retry control**: every `generateText` call uses `maxRetries: 0` so Codemation's own retry / repair policy is the single source of truth.
+
+  ### New test utilities
+
+  Tests that previously scripted `LangChainChatModelLike` now script AI SDK `LanguageModelV3` via `MockLanguageModelV3` from `ai/test`. `@codemation/core-nodes` and `@codemation/host` test files ship small adapters (`ScriptedResponseConverter`, `ScriptedDoGenerateFactory`, `TelemetryResponseConverter`) that translate Codemation's legacy `{ content, tool_calls, usage_metadata }` fixtures into `LanguageModelV3GenerateResult`.
+
+  ### Migration notes for consumers
+  - If you implemented a **custom `ChatModelFactory`**, return a `ChatLanguageModel` (wrap an AI SDK `LanguageModelV2`) instead of a LangChain-shaped chat model. The `name` / `modelName` / `provider` on your config still drive cost tracking.
+  - If you imported the type `LangChainChatModelLike` (or `LangChainStructuredOutputModelLike`) from `@codemation/core`, switch to `ChatLanguageModel` (and drop structured-output-method imports — `generateText({ experimental_output })` covers it).
+  - `OpenAIChatModelFactory` now builds an AI SDK OpenAI provider under the hood; behavior for end users (model presets, credential resolution, token accounting, structured output against strict mode) is unchanged.
+  - Telemetry dashboards, trace views, and cost-tracking queries continue to work against the existing Codemation span / metric names.
+
+### Patch Changes
+
+- [#93](https://github.com/MadeRelevant/codemation/pull/93) [`640e303`](https://github.com/MadeRelevant/codemation/commit/640e3032b1386568df725980a27761b6e230302c) Thanks [@cblokland90](https://github.com/cblokland90)! - Fix `Unique constraint failed on the fields: (instance_id)` crash when rerunning a workflow that contains an AI agent.
+
+  Reproduction: build `Manual trigger → AI agent → node → node`, click play on the agent, then click play on the next node (sometimes twice). The second run would fail at `PrismaWorkflowRunRepository.saveOnce` with a Postgres PK violation on the `ExecutionInstance` table.
+
+  Root cause: `RunStartService.createRunCurrentState` was deep-copying the prior run's `connectionInvocations` verbatim into the new run's initial state. Each record kept its original globally-unique `invocationId`, which is the primary key in `ExecutionInstance`. `saveOnce`'s existing-row lookup is scoped to the current `runId`, so the collision against the prior run's rows was only detected by Postgres when the insert fired.
+
+  Beyond the crash, the old behavior was also a data-model lie for compliance / OTEL: a `ConnectionInvocationRecord` represents a single auditable LLM / tool call and must belong to exactly one run. Copying it into another run made the same event appear to have happened twice.
+
+  Fix (domain + defense-in-depth):
+  - `@codemation/core` — `RunStartService.createRunCurrentState` now starts new runs with an empty invocation ledger. The prior run's invocations remain queryable on that run's persisted state (their true owner).
+  - `@codemation/host` — `PrismaWorkflowRunRepository.buildExecutionInstances` skips any invocation whose `runId` differs from the run being saved, so a stray carry-over from any other code path self-heals instead of crashing the save.
+
+  UI impact: none for the historical-run view (it reads invocations directly from the selected run). The client-side debugger overlay continues to surface the prior run's invocations locally during a rerun, and inspector telemetry already fetches against each invocation's original `runId`.
+
+- Updated dependencies [[`640e303`](https://github.com/MadeRelevant/codemation/commit/640e3032b1386568df725980a27761b6e230302c), [`640e303`](https://github.com/MadeRelevant/codemation/commit/640e3032b1386568df725980a27761b6e230302c)]:
+  - @codemation/core-nodes@1.0.0
+  - @codemation/core@1.0.0
+  - @codemation/eventbus-redis@0.0.32
+
+## 0.3.1
+
+### Patch Changes
+
+- [`7eaa288`](https://github.com/MadeRelevant/codemation/commit/7eaa288737f2d126218dac84fa4fde2a4113b7f3) Thanks [@cblokland90](https://github.com/cblokland90)! - Default DI container registrations to singletons so framework services that own long-lived resources (timers, subscriptions, sockets) have deterministic lifecycles. Previously `container.register(Class, { useClass: Class })` produced a new instance per resolution, which caused the `WorkflowRunRetentionPruneScheduler` `setInterval` timer to leak across HMR reloads and blocked `pnpm dev` from shutting down on Ctrl+C.
+
+  Public registration DTOs still accept `useClass` as a shape hint, but the host applies every class-based registration as a singleton. Plugin authors using `plugin.register({ registerNode, registerClass })` and consumers using `containerRegistrations: [{ token, useClass }]` no longer need to reason about lifecycle. Redundant `@registry([{ useClass }])` decorators on Hono route registrars and domain event handlers have been removed.
+
+  A new ESLint rule (`codemation/no-transient-container-register`) prevents reintroducing `.register(token, { useClass: Class })` and `@registry([{ useClass: Class }])` patterns across `packages/**` and `apps/**`.
+
+- Updated dependencies [[`7eaa288`](https://github.com/MadeRelevant/codemation/commit/7eaa288737f2d126218dac84fa4fde2a4113b7f3)]:
+  - @codemation/core@0.8.1
+  - @codemation/core-nodes@0.4.3
+  - @codemation/eventbus-redis@0.0.31
+
 ## 0.3.0
 
 ### Minor Changes

package/dist/{AppConfigFactory-Dq7ttwQ_.d.ts → AppConfigFactory-PFmDg5Sg.d.ts}

@@ -1,5 +1,5 @@
-import { i as AppPersistenceConfig, r as AppConfig } from "./CodemationAppContext-P7P-xZhQ.js";
-import { t as NormalizedCodemationConfig } from "./CodemationConfigNormalizer-BCtBrJDe.js";
+import { i as AppPersistenceConfig, r as AppConfig } from "./CodemationAppContext-DP_-56c6.js";
+import { t as NormalizedCodemationConfig } from "./CodemationConfigNormalizer-B8RGUwAe.js";
 import { AnyNull, AnyNullClass, DbNull, DbNullClass, Decimal, JsonNull, JsonNullClass, NullTypes as NullTypes$1, ObjectEnumValue, PrismaClientInitializationError, PrismaClientKnownRequestError, PrismaClientRustPanicError, PrismaClientUnknownRequestError, PrismaClientValidationError, RawValue, Sql, Value, empty, isAnyNull, isDbNull, isJsonNull, isObjectEnumValue, join, raw, sql as sqltag } from "@prisma/client-runtime-utils";
 
 //#region src/infrastructure/persistence/generated/prisma-postgresql-client/runtime/client.d.ts
@@ -34760,4 +34760,4 @@ declare class AppConfigFactory {
 }
 //#endregion
 export { PrismaClient as i, PrismaMigrationDeployer as n, PrismaDatabaseClient as r, AppConfigFactory as t };
-//# sourceMappingURL=AppConfigFactory-Dq7ttwQ_.d.ts.map
+//# sourceMappingURL=AppConfigFactory-PFmDg5Sg.d.ts.map

package/dist/{AppContainerFactory-D9je1sSV.js → AppContainerFactory-Cr3JeVmg.js}

@@ -8,7 +8,7 @@ import { AIAgentConnectionWorkflowExpander, ConnectionCredentialNodeConfigFactor
 import { mkdir, rm, stat } from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { AgentConfigInspector, AgentConnectionNodeCollector, CoreTokens, CostTrackingTelemetryAttributeNames, CostTrackingTelemetryMetricNames, DefaultExecutionBinaryService, EventPublishingWorkflowExecutionRepository, GenAiTelemetryAttributeNames, InMemoryLiveWorkflowRepository, InMemoryRunEventBus, ItemsInputNormalizer, NoOpTelemetryArtifactReference, RunFinishedAtFactory, SystemClock, container, getPersistedRuntimeTypeMetadata, inject, injectAll, injectable, instanceCachingFactory, registry } from "@codemation/core";
+import { AgentConfigInspector, AgentConnectionNodeCollector, CoreTokens, CostTrackingTelemetryAttributeNames, CostTrackingTelemetryMetricNames, DefaultExecutionBinaryService, EventPublishingWorkflowExecutionRepository, GenAiTelemetryAttributeNames, InMemoryLiveWorkflowRepository, InMemoryRunEventBus, ItemsInputNormalizer, NoOpTelemetryArtifactReference, RunFinishedAtFactory, SystemClock, container, getPersistedRuntimeTypeMetadata, inject, injectAll, injectable, instanceCachingFactory } from "@codemation/core";
 import { createHash, randomBytes } from "node:crypto";
 import "reflect-metadata";
 import { CatalogBackedCostTrackingTelemetryFactory, ConfigDrivenOffloadPolicy, DefaultDrivingScheduler, DefaultExecutionContextFactory, Engine, EngineRuntimeRegistrar, InMemoryBinaryStorage, InMemoryRunDataFactory, InlineDrivingScheduler, MissingRuntimeTriggerToken, PersistedWorkflowTokenRegistry, RunIntentService, RunSummaryMapper, StaticCostCatalog, WorkflowRepositoryWebhookTriggerMatcher } from "@codemation/core/bootstrap";
@@ -2708,13 +2708,13 @@ var CodemationPluginRegistrar = class {
 				loggerFactory: args.loggerFactory,
 				registerCredentialType: (type) => args.registerCredentialType(type),
 				registerNode: (token, implementation) => {
-					args.container.register(token, { useClass: implementation ?? token });
+					args.container.registerSingleton(token, implementation ?? token);
 				},
 				registerValue: (token, value) => {
 					args.container.registerInstance(token, value);
 				},
 				registerClass: (token, implementation) => {
-					args.container.register(token, { useClass: implementation });
+					args.container.registerSingleton(token, implementation);
 				},
 				registerFactory: (token, factory) => {
 					args.container.register(token, { useFactory: (dependencyContainer) => factory(dependencyContainer) });
@@ -5356,10 +5356,6 @@ let AuthHonoApiRouteRegistrar = class AuthHonoApiRouteRegistrar$1 {
 };
 AuthHonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: AuthHonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(AuthHttpRouteHandler)),
 	__decorateParam(1, inject(CodemationBetterAuthRuntime)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$29 = typeof AuthHttpRouteHandler !== "undefined" && AuthHttpRouteHandler) === "function" ? _ref$29 : Object, typeof (_ref2$5 = typeof CodemationBetterAuthRuntime !== "undefined" && CodemationBetterAuthRuntime) === "function" ? _ref2$5 : Object])
@@ -5381,10 +5377,6 @@ let BinaryHonoApiRouteRegistrar = class BinaryHonoApiRouteRegistrar$1 {
 };
 BinaryHonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: BinaryHonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(BinaryHttpRouteHandler)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$28 = typeof BinaryHttpRouteHandler !== "undefined" && BinaryHttpRouteHandler) === "function" ? _ref$28 : Object])
 ], BinaryHonoApiRouteRegistrar);
@@ -5407,10 +5399,6 @@ let BootstrapHonoApiRouteRegistrar = class BootstrapHonoApiRouteRegistrar$1 {
 };
 BootstrapHonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: BootstrapHonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(PublicFrontendBootstrapHttpRouteHandler)),
 	__decorateParam(1, inject(InternalAuthBootstrapHttpRouteHandler)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$27 = typeof PublicFrontendBootstrapHttpRouteHandler !== "undefined" && PublicFrontendBootstrapHttpRouteHandler) === "function" ? _ref$27 : Object, typeof (_ref2$4 = typeof InternalAuthBootstrapHttpRouteHandler !== "undefined" && InternalAuthBootstrapHttpRouteHandler) === "function" ? _ref2$4 : Object])
@@ -5541,10 +5529,6 @@ let CredentialHonoApiRouteRegistrar = class CredentialHonoApiRouteRegistrar$1 {
 };
 CredentialHonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: CredentialHonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(CredentialHttpRouteHandler)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$26 = typeof CredentialHttpRouteHandler !== "undefined" && CredentialHttpRouteHandler) === "function" ? _ref$26 : Object])
 ], CredentialHonoApiRouteRegistrar);
@@ -5562,10 +5546,6 @@ let DevHonoApiRouteRegistrar = class DevHonoApiRouteRegistrar$1 {
 };
 DevHonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: DevHonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(DevBootstrapSummaryHttpRouteHandler)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$25 = typeof DevBootstrapSummaryHttpRouteHandler !== "undefined" && DevBootstrapSummaryHttpRouteHandler) === "function" ? _ref$25 : Object])
 ], DevHonoApiRouteRegistrar);
@@ -5691,10 +5671,6 @@ let OAuth2HonoApiRouteRegistrar = class OAuth2HonoApiRouteRegistrar$1 {
 };
 OAuth2HonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: OAuth2HonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(OAuth2HttpRouteHandler)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$23 = typeof OAuth2HttpRouteHandler !== "undefined" && OAuth2HttpRouteHandler) === "function" ? _ref$23 : Object])
 ], OAuth2HonoApiRouteRegistrar);
@@ -5788,10 +5764,6 @@ let RunHonoApiRouteRegistrar = class RunHonoApiRouteRegistrar$1 {
 };
 RunHonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: RunHonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(RunHttpRouteHandler)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$22 = typeof RunHttpRouteHandler !== "undefined" && RunHttpRouteHandler) === "function" ? _ref$22 : Object])
 ], RunHonoApiRouteRegistrar);
@@ -5931,10 +5903,6 @@ let TelemetryHonoApiRouteRegistrar = class TelemetryHonoApiRouteRegistrar$1 {
 };
 TelemetryHonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: TelemetryHonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(TelemetryHttpRouteHandler)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$21 = typeof TelemetryHttpRouteHandler !== "undefined" && TelemetryHttpRouteHandler) === "function" ? _ref$21 : Object])
 ], TelemetryHonoApiRouteRegistrar);
@@ -6036,10 +6004,6 @@ let UserHonoApiRouteRegistrar = class UserHonoApiRouteRegistrar$1 {
 };
 UserHonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: UserHonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(UserHttpRouteHandler)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$20 = typeof UserHttpRouteHandler !== "undefined" && UserHttpRouteHandler) === "function" ? _ref$20 : Object])
 ], UserHonoApiRouteRegistrar);
@@ -6197,10 +6161,6 @@ let WebhookHonoApiRouteRegistrar = class WebhookHonoApiRouteRegistrar$1 {
 };
 WebhookHonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: WebhookHonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(WebhookHttpRouteHandler)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$18 = typeof WebhookHttpRouteHandler !== "undefined" && WebhookHttpRouteHandler) === "function" ? _ref$18 : Object])
 ], WebhookHonoApiRouteRegistrar);
@@ -6218,10 +6178,6 @@ let WhitelabelHonoApiRouteRegistrar = class WhitelabelHonoApiRouteRegistrar$1 {
 };
 WhitelabelHonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: WhitelabelHonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(WhitelabelLogoHttpRouteHandler)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$17 = typeof WhitelabelLogoHttpRouteHandler !== "undefined" && WhitelabelLogoHttpRouteHandler) === "function" ? _ref$17 : Object])
 ], WhitelabelHonoApiRouteRegistrar);
@@ -6325,10 +6281,6 @@ let WorkflowHonoApiRouteRegistrar = class WorkflowHonoApiRouteRegistrar$1 {
 };
 WorkflowHonoApiRouteRegistrar = __decorate([
 	injectable(),
-	registry([{
-		token: ApplicationTokens.HonoApiRouteRegistrar,
-		useClass: WorkflowHonoApiRouteRegistrar
-	}]),
 	__decorateParam(0, inject(WorkflowHttpRouteHandler)),
 	__decorateMetadata("design:paramtypes", [typeof (_ref$15 = typeof WorkflowHttpRouteHandler !== "undefined" && WorkflowHttpRouteHandler) === "function" ? _ref$15 : Object])
 ], WorkflowHonoApiRouteRegistrar);
@@ -16619,6 +16571,7 @@ let PrismaWorkflowRunRepository = class PrismaWorkflowRunRepository$1 {
 		}
 		let cIdx = 0;
 		for (const inv of state.connectionInvocations ?? []) {
+			if (inv.runId !== state.runId) continue;
 			rows.push({
 				instanceId: inv.invocationId,
 				runId: state.runId,
@@ -16930,7 +16883,7 @@ var CodemationContainerRegistrationRegistrar = class {
 			return;
 		}
 		if (this.isClassRegistration(registration)) {
-			container$1.register(registration.token, { useClass: registration.useClass });
+			container$1.registerSingleton(registration.token, registration.useClass);
 			return;
 		}
 		container$1.register(registration.token, { useFactory: (dependencyContainer) => registration.useFactory(dependencyContainer) });
@@ -17528,8 +17481,8 @@ var AppContainerFactory = class AppContainerFactory {
 		});
 	}
 	registerCredentialTypes(container$1, credentialTypes) {
-		const registry$1 = container$1.resolve(CredentialTypeRegistryImpl);
-		for (const credentialType of credentialTypes) registry$1.register(credentialType);
+		const registry = container$1.resolve(CredentialTypeRegistryImpl);
+		for (const credentialType of credentialTypes) registry.register(credentialType);
 	}
 	registerConfiguredRegistrations(container$1, appConfig) {
 		if (appConfig.containerRegistrations.length === 0) return;
@@ -17547,7 +17500,7 @@ var AppContainerFactory = class AppContainerFactory {
 		container$1.registerInstance(CoreTokens.PersistedWorkflowTokenRegistry, container$1.resolve(PersistedWorkflowTokenRegistry));
 		container$1.register(CredentialTypeRegistryImpl, { useFactory: instanceCachingFactory(() => new CredentialTypeRegistryImpl()) });
 		container$1.register(CoreTokens.CredentialTypeRegistry, { useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(CredentialTypeRegistryImpl)) });
-		container$1.register(CodemationIdFactory, { useClass: CodemationIdFactory });
+		container$1.registerSingleton(CodemationIdFactory, CodemationIdFactory);
 		container$1.register(CoreTokens.RunIdFactory, { useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(CodemationIdFactory)) });
 		container$1.register(CoreTokens.ActivationIdFactory, { useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(CodemationIdFactory)) });
 		container$1.register(CoreTokens.LiveWorkflowRepository, { useFactory: instanceCachingFactory(() => new LiveWorkflowRepository(new AIAgentConnectionWorkflowExpander(new ConnectionCredentialNodeConfigFactory()))) });
@@ -17575,46 +17528,46 @@ var AppContainerFactory = class AppContainerFactory {
 			} }
 		});
 		container$1.registerInstance(LogLevelPolicyFactory, logLevelPolicyFactory);
-		container$1.register(ServerLoggerFactory, { useClass: ServerLoggerFactory });
+		container$1.registerSingleton(ServerLoggerFactory, ServerLoggerFactory);
 		container$1.register(ApplicationTokens.LoggerFactory, { useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(ServerLoggerFactory)) });
 		container$1.register(ApplicationTokens.PerformanceDiagnosticsLogger, { useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(ServerLoggerFactory).createPerformanceDiagnostics("codemation.performance")) });
 		container$1.register(WorkflowWebsocketServer, { useFactory: instanceCachingFactory((dependencyContainer) => {
 			if (inputs.sharedWorkflowWebsocketServer) return inputs.sharedWorkflowWebsocketServer;
 			return new WorkflowWebsocketServer(dependencyContainer.resolve(ApplicationTokens.WebSocketPort), dependencyContainer.resolve(ApplicationTokens.WebSocketBindHost), dependencyContainer.resolve(ServerLoggerFactory).create("codemation-websocket.server"));
 		}) });
-		container$1.register(PrismaClientFactory, { useClass: PrismaClientFactory });
-		container$1.register(WorkflowPolicyUiPresentationFactory, { useClass: WorkflowPolicyUiPresentationFactory });
-		container$1.register(WorkflowDefinitionMapper, { useClass: WorkflowDefinitionMapper });
-		container$1.register(RequestToWebhookItemMapper, { useClass: RequestToWebhookItemMapper });
-		container$1.register(WebhookEndpointPathValidator, { useClass: WebhookEndpointPathValidator });
-		container$1.register(CredentialSecretCipher, { useClass: CredentialSecretCipher });
-		container$1.register(CredentialMaterialResolver, { useClass: CredentialMaterialResolver });
-		container$1.register(CredentialFieldEnvOverlayService, { useClass: CredentialFieldEnvOverlayService });
-		container$1.register(CredentialRuntimeMaterialService, { useClass: CredentialRuntimeMaterialService });
-		container$1.register(WorkflowCredentialNodeResolver, { useClass: WorkflowCredentialNodeResolver });
-		container$1.register(CredentialInstanceService, { useClass: CredentialInstanceService });
-		container$1.register(CredentialBindingService, { useClass: CredentialBindingService });
-		container$1.register(WorkflowActivationPreflightRules, { useClass: WorkflowActivationPreflightRules });
-		container$1.register(WorkflowActivationPreflight, { useClass: WorkflowActivationPreflight });
-		container$1.register(CredentialTestService, { useClass: CredentialTestService });
-		container$1.register(CredentialSessionServiceImpl, { useClass: CredentialSessionServiceImpl });
+		container$1.registerSingleton(PrismaClientFactory, PrismaClientFactory);
+		container$1.registerSingleton(WorkflowPolicyUiPresentationFactory, WorkflowPolicyUiPresentationFactory);
+		container$1.registerSingleton(WorkflowDefinitionMapper, WorkflowDefinitionMapper);
+		container$1.registerSingleton(RequestToWebhookItemMapper, RequestToWebhookItemMapper);
+		container$1.registerSingleton(WebhookEndpointPathValidator, WebhookEndpointPathValidator);
+		container$1.registerSingleton(CredentialSecretCipher, CredentialSecretCipher);
+		container$1.registerSingleton(CredentialMaterialResolver, CredentialMaterialResolver);
+		container$1.registerSingleton(CredentialFieldEnvOverlayService, CredentialFieldEnvOverlayService);
+		container$1.registerSingleton(CredentialRuntimeMaterialService, CredentialRuntimeMaterialService);
+		container$1.registerSingleton(WorkflowCredentialNodeResolver, WorkflowCredentialNodeResolver);
+		container$1.registerSingleton(CredentialInstanceService, CredentialInstanceService);
+		container$1.registerSingleton(CredentialBindingService, CredentialBindingService);
+		container$1.registerSingleton(WorkflowActivationPreflightRules, WorkflowActivationPreflightRules);
+		container$1.registerSingleton(WorkflowActivationPreflight, WorkflowActivationPreflight);
+		container$1.registerSingleton(CredentialTestService, CredentialTestService);
+		container$1.registerSingleton(CredentialSessionServiceImpl, CredentialSessionServiceImpl);
 		if (!inputs.appConfig.hasConfiguredCredentialSessionServiceRegistration) container$1.register(CoreTokens.CredentialSessionService, { useToken: CredentialSessionServiceImpl });
-		container$1.register(OAuth2ProviderRegistry, { useClass: OAuth2ProviderRegistry });
-		container$1.register(OAuth2ConnectService, { useClass: OAuth2ConnectService });
-		container$1.register(CodemationFrontendAuthSnapshotFactory, { useClass: CodemationFrontendAuthSnapshotFactory });
-		container$1.register(FrontendAppConfigFactory, { useClass: FrontendAppConfigFactory });
-		container$1.register(PublicFrontendBootstrapFactory, { useClass: PublicFrontendBootstrapFactory });
-		container$1.register(InternalAuthBootstrapFactory, { useClass: InternalAuthBootstrapFactory });
-		container$1.register(DatabaseMigrations, { useClass: DatabaseMigrations });
-		container$1.register(FrontendRuntime, { useClass: FrontendRuntime });
-		container$1.register(WorkerRuntime, { useClass: WorkerRuntime });
-		container$1.register(DevelopmentSessionBypassVerifier, { useClass: DevelopmentSessionBypassVerifier });
-		container$1.register(SecureRequestDetector, { useClass: SecureRequestDetector });
-		container$1.register(InAppCallbackUrlPolicy, { useClass: InAppCallbackUrlPolicy });
-		container$1.register(AuthSessionCookieFactory, { useClass: AuthSessionCookieFactory });
-		container$1.register(CodemationBetterAuthBcryptPasswordCodec, { useClass: CodemationBetterAuthBcryptPasswordCodec });
-		container$1.register(CodemationBetterAuthDatabaseOptionsFactory, { useClass: CodemationBetterAuthDatabaseOptionsFactory });
-		container$1.register(UserAccountSessionPolicy, { useClass: UserAccountSessionPolicy });
+		container$1.registerSingleton(OAuth2ProviderRegistry, OAuth2ProviderRegistry);
+		container$1.registerSingleton(OAuth2ConnectService, OAuth2ConnectService);
+		container$1.registerSingleton(CodemationFrontendAuthSnapshotFactory, CodemationFrontendAuthSnapshotFactory);
+		container$1.registerSingleton(FrontendAppConfigFactory, FrontendAppConfigFactory);
+		container$1.registerSingleton(PublicFrontendBootstrapFactory, PublicFrontendBootstrapFactory);
+		container$1.registerSingleton(InternalAuthBootstrapFactory, InternalAuthBootstrapFactory);
+		container$1.registerSingleton(DatabaseMigrations, DatabaseMigrations);
+		container$1.registerSingleton(FrontendRuntime, FrontendRuntime);
+		container$1.registerSingleton(WorkerRuntime, WorkerRuntime);
+		container$1.registerSingleton(DevelopmentSessionBypassVerifier, DevelopmentSessionBypassVerifier);
+		container$1.registerSingleton(SecureRequestDetector, SecureRequestDetector);
+		container$1.registerSingleton(InAppCallbackUrlPolicy, InAppCallbackUrlPolicy);
+		container$1.registerSingleton(AuthSessionCookieFactory, AuthSessionCookieFactory);
+		container$1.registerSingleton(CodemationBetterAuthBcryptPasswordCodec, CodemationBetterAuthBcryptPasswordCodec);
+		container$1.registerSingleton(CodemationBetterAuthDatabaseOptionsFactory, CodemationBetterAuthDatabaseOptionsFactory);
+		container$1.registerSingleton(UserAccountSessionPolicy, UserAccountSessionPolicy);
 		container$1.register(CodemationBetterAuthBaseUrlPolicy, { useFactory: instanceCachingFactory((dependencyContainer) => new CodemationBetterAuthBaseUrlPolicy(dependencyContainer.resolve(ServerLoggerFactory).create("codemation.auth.better-auth.base-url"))) });
 		container$1.register(CodemationBetterAuthServerFactory, { useFactory: instanceCachingFactory((dependencyContainer) => new CodemationBetterAuthServerFactory(dependencyContainer.resolve(ApplicationTokens.AppConfig), dependencyContainer.resolve(CodemationBetterAuthDatabaseOptionsFactory), dependencyContainer.resolve(CodemationBetterAuthBcryptPasswordCodec), dependencyContainer.resolve(UserAccountSessionPolicy), dependencyContainer.resolve(CodemationBetterAuthBaseUrlPolicy))) });
 		container$1.register(CodemationBetterAuthRuntime, { useFactory: instanceCachingFactory((dependencyContainer) => {
@@ -17628,7 +17581,7 @@ var AppContainerFactory = class AppContainerFactory {
 			const policy = dependencyContainer.resolve(UserAccountSessionPolicy);
 			return new BetterAuthApiSessionVerifier(runtime, prismaClient ? new PrismaUserAccountSessionEligibilityChecker(prismaClient, policy) : void 0);
 		}) });
-		container$1.register(CodemationSessionVerifier, { useClass: CodemationSessionVerifier });
+		container$1.registerSingleton(CodemationSessionVerifier, CodemationSessionVerifier);
 		container$1.register(ApplicationTokens.SessionVerifier, { useFactory: instanceCachingFactory((dependencyContainer) => {
 			const appConfig = dependencyContainer.resolve(ApplicationTokens.AppConfig);
 			const isPackagedDevRuntime = Boolean(appConfig.env.CODEMATION_RUNTIME_DEV_URL?.trim());
@@ -17647,59 +17600,59 @@ var AppContainerFactory = class AppContainerFactory {
 		}) });
 	}
 	registerRepositoriesAndBuses(container$1) {
-		container$1.register(OtelIdentityFactory, { useClass: OtelIdentityFactory });
-		container$1.register(TelemetryPrivacyPolicy, { useClass: TelemetryPrivacyPolicy });
-		container$1.register(TelemetryEnricherChain, { useClass: TelemetryEnricherChain });
-		container$1.register(TelemetryRetentionTimestampFactory, { useClass: TelemetryRetentionTimestampFactory });
-		container$1.register(TelemetryQueryService, { useClass: TelemetryQueryService });
-		container$1.register(NoOpTelemetryExporter, { useClass: NoOpTelemetryExporter });
+		container$1.registerSingleton(OtelIdentityFactory, OtelIdentityFactory);
+		container$1.registerSingleton(TelemetryPrivacyPolicy, TelemetryPrivacyPolicy);
+		container$1.registerSingleton(TelemetryEnricherChain, TelemetryEnricherChain);
+		container$1.registerSingleton(TelemetryRetentionTimestampFactory, TelemetryRetentionTimestampFactory);
+		container$1.registerSingleton(TelemetryQueryService, TelemetryQueryService);
+		container$1.registerSingleton(NoOpTelemetryExporter, NoOpTelemetryExporter);
 		container$1.register(CompositeTelemetryExporter, { useFactory: instanceCachingFactory((dependencyContainer) => new CompositeTelemetryExporter([dependencyContainer.resolve(NoOpTelemetryExporter)])) });
-		container$1.register(OtelExecutionTelemetryFactory, { useClass: OtelExecutionTelemetryFactory });
-		container$1.register(InMemoryRunTraceContextRepository, { useClass: InMemoryRunTraceContextRepository });
-		container$1.register(InMemoryTelemetrySpanStore, { useClass: InMemoryTelemetrySpanStore });
-		container$1.register(InMemoryTelemetryArtifactStore, { useClass: InMemoryTelemetryArtifactStore });
-		container$1.register(InMemoryTelemetryMetricPointStore, { useClass: InMemoryTelemetryMetricPointStore });
-		container$1.register(PrismaRunTraceContextRepository, { useClass: PrismaRunTraceContextRepository });
-		container$1.register(PrismaTelemetrySpanStore, { useClass: PrismaTelemetrySpanStore });
-		container$1.register(PrismaTelemetryArtifactStore, { useClass: PrismaTelemetryArtifactStore });
-		container$1.register(PrismaTelemetryMetricPointStore, { useClass: PrismaTelemetryMetricPointStore });
-		container$1.register(WorkflowDefinitionRepositoryAdapter, { useClass: WorkflowDefinitionRepositoryAdapter });
-		container$1.register(InMemoryWorkflowRunRepository, { useClass: InMemoryWorkflowRunRepository });
-		container$1.register(InMemoryTriggerSetupStateRepository, { useClass: InMemoryTriggerSetupStateRepository });
-		container$1.register(InMemoryCredentialStore, { useClass: InMemoryCredentialStore });
-		container$1.register(WorkflowRunRepository, { useClass: WorkflowRunRepository });
-		container$1.register(InMemoryWorkflowDebuggerOverlayRepository, { useClass: InMemoryWorkflowDebuggerOverlayRepository });
-		container$1.register(PrismaTriggerSetupStateRepository, { useClass: PrismaTriggerSetupStateRepository });
-		container$1.register(PrismaWorkflowDebuggerOverlayRepository, { useClass: PrismaWorkflowDebuggerOverlayRepository });
-		container$1.register(PrismaWorkflowActivationRepository, { useClass: PrismaWorkflowActivationRepository });
-		container$1.register(InMemoryWorkflowActivationRepository, { useClass: InMemoryWorkflowActivationRepository });
-		container$1.register(PrismaCredentialStore, { useClass: PrismaCredentialStore });
+		container$1.registerSingleton(OtelExecutionTelemetryFactory, OtelExecutionTelemetryFactory);
+		container$1.registerSingleton(InMemoryRunTraceContextRepository, InMemoryRunTraceContextRepository);
+		container$1.registerSingleton(InMemoryTelemetrySpanStore, InMemoryTelemetrySpanStore);
+		container$1.registerSingleton(InMemoryTelemetryArtifactStore, InMemoryTelemetryArtifactStore);
+		container$1.registerSingleton(InMemoryTelemetryMetricPointStore, InMemoryTelemetryMetricPointStore);
+		container$1.registerSingleton(PrismaRunTraceContextRepository, PrismaRunTraceContextRepository);
+		container$1.registerSingleton(PrismaTelemetrySpanStore, PrismaTelemetrySpanStore);
+		container$1.registerSingleton(PrismaTelemetryArtifactStore, PrismaTelemetryArtifactStore);
+		container$1.registerSingleton(PrismaTelemetryMetricPointStore, PrismaTelemetryMetricPointStore);
+		container$1.registerSingleton(WorkflowDefinitionRepositoryAdapter, WorkflowDefinitionRepositoryAdapter);
+		container$1.registerSingleton(InMemoryWorkflowRunRepository, InMemoryWorkflowRunRepository);
+		container$1.registerSingleton(InMemoryTriggerSetupStateRepository, InMemoryTriggerSetupStateRepository);
+		container$1.registerSingleton(InMemoryCredentialStore, InMemoryCredentialStore);
+		container$1.registerSingleton(WorkflowRunRepository, WorkflowRunRepository);
+		container$1.registerSingleton(InMemoryWorkflowDebuggerOverlayRepository, InMemoryWorkflowDebuggerOverlayRepository);
+		container$1.registerSingleton(PrismaTriggerSetupStateRepository, PrismaTriggerSetupStateRepository);
+		container$1.registerSingleton(PrismaWorkflowDebuggerOverlayRepository, PrismaWorkflowDebuggerOverlayRepository);
+		container$1.registerSingleton(PrismaWorkflowActivationRepository, PrismaWorkflowActivationRepository);
+		container$1.registerSingleton(InMemoryWorkflowActivationRepository, InMemoryWorkflowActivationRepository);
+		container$1.registerSingleton(PrismaCredentialStore, PrismaCredentialStore);
 		container$1.register(ApplicationTokens.WorkflowDefinitionRepository, { useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(WorkflowDefinitionRepositoryAdapter)) });
-		container$1.register(InMemoryQueryBus, { useClass: InMemoryQueryBus });
-		container$1.register(InMemoryCommandBus, { useClass: InMemoryCommandBus });
-		container$1.register(InMemoryDomainEventBus, { useClass: InMemoryDomainEventBus });
-		for (const handler of AppContainerFactory.queryHandlers) container$1.register(ApplicationTokens.QueryHandler, { useClass: handler });
-		for (const handler of AppContainerFactory.commandHandlers) container$1.register(ApplicationTokens.CommandHandler, { useClass: handler });
+		container$1.registerSingleton(InMemoryQueryBus, InMemoryQueryBus);
+		container$1.registerSingleton(InMemoryCommandBus, InMemoryCommandBus);
+		container$1.registerSingleton(InMemoryDomainEventBus, InMemoryDomainEventBus);
+		for (const handler of AppContainerFactory.queryHandlers) container$1.registerSingleton(ApplicationTokens.QueryHandler, handler);
+		for (const handler of AppContainerFactory.commandHandlers) container$1.registerSingleton(ApplicationTokens.CommandHandler, handler);
 		container$1.register(ApplicationTokens.QueryBus, { useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(InMemoryQueryBus)) });
 		container$1.register(ApplicationTokens.CommandBus, { useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(InMemoryCommandBus)) });
 		container$1.register(ApplicationTokens.DomainEventBus, { useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(InMemoryDomainEventBus)) });
 		container$1.register(ApplicationTokens.TelemetryExporter, { useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(CompositeTelemetryExporter)) });
 	}
 	registerApplicationServicesAndRoutes(container$1) {
-		container$1.register(DevBootstrapSummaryAssembler, { useClass: DevBootstrapSummaryAssembler });
-		container$1.register(DevBootstrapSummaryHttpRouteHandler, { useClass: DevBootstrapSummaryHttpRouteHandler });
-		container$1.register(AuthHttpRouteHandler, { useClass: AuthHttpRouteHandler });
-		container$1.register(PublicFrontendBootstrapHttpRouteHandler, { useClass: PublicFrontendBootstrapHttpRouteHandler });
-		container$1.register(InternalAuthBootstrapHttpRouteHandler, { useClass: InternalAuthBootstrapHttpRouteHandler });
-		container$1.register(WhitelabelLogoHttpRouteHandler, { useClass: WhitelabelLogoHttpRouteHandler });
-		for (const registrar of AppContainerFactory.honoRouteRegistrars) container$1.register(ApplicationTokens.HonoApiRouteRegistrar, { useClass: registrar });
-		container$1.register(CodemationHonoApiApp, { useClass: CodemationHonoApiApp });
+		container$1.registerSingleton(DevBootstrapSummaryAssembler, DevBootstrapSummaryAssembler);
+		container$1.registerSingleton(DevBootstrapSummaryHttpRouteHandler, DevBootstrapSummaryHttpRouteHandler);
+		container$1.registerSingleton(AuthHttpRouteHandler, AuthHttpRouteHandler);
+		container$1.registerSingleton(PublicFrontendBootstrapHttpRouteHandler, PublicFrontendBootstrapHttpRouteHandler);
+		container$1.registerSingleton(InternalAuthBootstrapHttpRouteHandler, InternalAuthBootstrapHttpRouteHandler);
+		container$1.registerSingleton(WhitelabelLogoHttpRouteHandler, WhitelabelLogoHttpRouteHandler);
+		for (const registrar of AppContainerFactory.honoRouteRegistrars) container$1.registerSingleton(ApplicationTokens.HonoApiRouteRegistrar, registrar);
+		container$1.registerSingleton(CodemationHonoApiApp, CodemationHonoApiApp);
 	}
 	registerOperationalInfrastructure(container$1) {
 		container$1.register(ApplicationTokens.WorkflowWebsocketPublisher, { useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(WorkflowWebsocketServer)) });
-		container$1.register(WorkflowRunEventWebsocketRelay, { useClass: WorkflowRunEventWebsocketRelay });
-		container$1.register(RunEventBusTelemetryReporter, { useClass: RunEventBusTelemetryReporter });
-		container$1.register(WorkflowRunRetentionPruneScheduler, { useClass: WorkflowRunRetentionPruneScheduler });
+		container$1.registerSingleton(WorkflowRunEventWebsocketRelay, WorkflowRunEventWebsocketRelay);
+		container$1.registerSingleton(RunEventBusTelemetryReporter, RunEventBusTelemetryReporter);
+		container$1.registerSingleton(WorkflowRunRetentionPruneScheduler, WorkflowRunRetentionPruneScheduler);
 	}
 	async registerRuntimeInfrastructure(container$1, appConfig) {
 		const queuePrefix = appConfig.scheduler.queuePrefix ?? appConfig.eventing.queuePrefix ?? "codemation";
@@ -17819,4 +17772,4 @@ var AppContainerFactory = class AppContainerFactory {
 
 //#endregion
 export { GetWorkflowSummariesQuery as C, ListUserAccountsQuery as D, UpsertLocalBootstrapUserCommand as E, WorkflowPolicyUiPresentationFactory as S, RunBinaryAttachmentLookupService as T, FrontendAppConfigFactory as _, AppContainerLifecycle as a, ApiPaths as b, WebhookHttpRouteHandler as c, OAuth2HttpRouteHandler as d, CredentialHttpRouteHandler as f, InternalAuthBootstrapFactory as g, PublicFrontendBootstrapFactory as h, DatabaseMigrations as i, RequestToWebhookItemMapper as l, BinaryHttpRouteHandler as m, WorkerRuntime as n, WorkflowRunRetentionPruneScheduler as o, CodemationHonoApiApp as p, FrontendRuntime as r, WorkflowHttpRouteHandler as s, AppContainerFactory as t, RunHttpRouteHandler as u, CodemationFrontendAuthSnapshotFactory as v, GetWorkflowDetailQuery as w, WorkflowDefinitionMapper as x, WorkflowWebsocketServer as y };
-//# sourceMappingURL=AppContainerFactory-D9je1sSV.js.map
+//# sourceMappingURL=AppContainerFactory-Cr3JeVmg.js.map