The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 04:45 UTC
| 1 | import * as OtelEnvironment from "@t3tools/shared/otelEnvironment"; |
| 2 | import { DEFAULT_SIGNAL_EXPORT } from "@t3tools/shared/observability"; |
| 3 | import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; |
| 4 | import * as NodeServices from "@effect/platform-node/NodeServices"; |
| 5 | import type { |
| 6 | ManagedPolicyDocument, |
| 7 | ProviderDriverKind, |
| 8 | ProviderReplayTranscript, |
| 9 | } from "@t3tools/contracts"; |
| 10 | import * as Effect from "effect/Effect"; |
| 11 | import * as FileSystem from "effect/FileSystem"; |
| 12 | import * as Layer from "effect/Layer"; |
| 13 | import * as Path from "effect/Path"; |
| 14 | import * as PlatformError from "effect/PlatformError"; |
| 15 | import type * as Scope from "effect/Scope"; |
| 16 | import type * as SqlClient from "effect/sql/SqlClient"; |
| 17 | import type { MigrationError } from "effect/sql/Migrator"; |
| 18 | import type { SqlError } from "effect/sql/SqlError"; |
| 19 | |
| 20 | import * as CheckpointStore from "../../checkpointing/CheckpointStore.ts"; |
| 21 | import * as ServerConfig from "../../config.ts"; |
| 22 | import * as SqlitePersistence from "../../persistence/Sqlite.ts"; |
| 23 | import * as ServerSettings from "../../serverSettings.ts"; |
| 24 | import * as ManagedPolicy from "../../policy/ManagedPolicy.ts"; |
| 25 | import * as ThreadManagementService from "../ThreadManagementService.ts"; |
| 26 | import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions"; |
| 27 | import * as McpSessionRegistryTestkit from "../../mcp/McpSessionRegistry.testkit.ts"; |
| 28 | import * as VcsDriverRegistry from "../../vcs/VcsDriverRegistry.ts"; |
| 29 | import * as GitVcsDriver from "../../vcs/GitVcsDriver.ts"; |
| 30 | import * as VcsProcess from "../../vcs/VcsProcess.ts"; |
| 31 | import * as CheckpointCaptureService from "../CheckpointCaptureService.ts"; |
| 32 | import * as CheckpointService from "../CheckpointService.ts"; |
| 33 | import * as CheckpointRollbackService from "../CheckpointRollbackService.ts"; |
| 34 | import * as CommandPolicy from "../CommandPolicy.ts"; |
| 35 | import * as CommandReceiptStore from "../CommandReceiptStore.ts"; |
| 36 | import * as ContextHandoffService from "../ContextHandoffService.ts"; |
| 37 | import * as EffectOutbox from "../EffectOutbox.ts"; |
| 38 | import * as EffectWorker from "../EffectWorker.ts"; |
| 39 | import * as EventSink from "../EventSink.ts"; |
| 40 | import * as ThreadViewers from "../ThreadViewers.ts"; |
| 41 | import * as EventStore from "../EventStore.ts"; |
| 42 | import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator"; |
| 43 | import * as Orchestrator from "../Orchestrator.ts"; |
| 44 | import * as ProjectionStore from "../ProjectionStore.ts"; |
| 45 | import * as ProjectStore from "../ProjectStore.ts"; |
| 46 | import * as ProviderAdapterRegistry from "../ProviderAdapterRegistry.ts"; |
| 47 | import * as ProviderAuthService from "../../provider/ProviderAuthService.ts"; |
| 48 | import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests"; |
| 49 | import * as ProviderContinuationService from "../ProviderContinuationService.ts"; |
| 50 | import * as ProviderEventIngestor from "../ProviderEventIngestor.ts"; |
| 51 | import * as ProviderInstallationGate from "../../provider/ProviderInstallationGate.ts"; |
| 52 | import * as ProviderInstanceRegistry from "../../provider/ProviderInstanceRegistry.ts"; |
| 53 | import * as ProviderRuntimeRecoveryService from "../ProviderRuntimeRecoveryService.ts"; |
| 54 | import * as ProviderSessionManager from "../ProviderSessionManager.ts"; |
| 55 | import * as CommandOutputRecorder from "./CommandOutputRecorder.ts"; |
| 56 | import * as ProviderSwitchService from "../ProviderSwitchService.ts"; |
| 57 | import * as ProviderTurnControlService from "../ProviderTurnControlService.ts"; |
| 58 | import * as ProviderTurnStartService from "../ProviderTurnStartService.ts"; |
| 59 | import * as ProviderTurnStartServiceTestkit from "../ProviderTurnStartService.testkit.ts"; |
| 60 | import * as McpAppModelContext from "../../mcpApps/McpAppModelContext.ts"; |
| 61 | import * as PreviewAgentActivity from "../../preview/PreviewAgentActivity.ts"; |
| 62 | import * as RunExecutionService from "../RunExecutionService.ts"; |
| 63 | import * as RunFinalizationService from "../RunFinalizationService.ts"; |
| 64 | import * as ThreadTitleRegenerationService from "../ThreadTitleRegenerationService.ts"; |
| 65 | import * as RuntimePolicy from "../RuntimePolicy.ts"; |
| 66 | import * as TurnItemPositionStore from "../TurnItemPositionStore.ts"; |
| 67 | import * as RuntimeRequestService from "../RuntimeRequestService.ts"; |
| 68 | import * as ThreadCommandExecutor from "../ThreadCommandExecutor.ts"; |
| 69 | import * as ThreadForkService from "../ThreadForkService.ts"; |
| 70 | import { |
| 71 | runOrchestratorV2Scenario, |
| 72 | type OrchestratorV2ScenarioStepError, |
| 73 | type OrchestratorV2Scenario, |
| 74 | type OrchestratorV2ScenarioResult, |
| 75 | } from "./OrchestratorScenario.ts"; |
| 76 | import { |
| 77 | makeProviderReplayGate, |
| 78 | type ProviderReplayGate, |
| 79 | } from "@t3tools/provider-testing/replayGate"; |
| 80 | |
| 81 | export function makeReplayServerConfig( |
| 82 | scenario: string, |
| 83 | ): Effect.Effect< |
| 84 | ServerConfig.ServerConfig["Service"], |
| 85 | PlatformError.PlatformError, |
| 86 | FileSystem.FileSystem | Path.Path | Scope.Scope |
| 87 | > { |
| 88 | const safeScenario = scenario.replace(/[^a-z0-9_-]+/gi, "-"); |
| 89 | return Effect.gen(function* () { |
| 90 | const fs = yield* FileSystem.FileSystem; |
| 91 | const path = yield* Path.Path; |
| 92 | const baseDir = yield* fs.makeTempDirectoryScoped({ |
| 93 | prefix: `t3-orchestration-v2-replay-${safeScenario}-`, |
| 94 | }); |
| 95 | const stateDir = path.join(baseDir, "userdata"); |
| 96 | const logsDir = path.join(stateDir, "logs"); |
| 97 | const providerLogsDir = path.join(logsDir, "provider"); |
| 98 | const terminalLogsDir = path.join(logsDir, "terminals"); |
| 99 | const attachmentsDir = path.join(stateDir, "attachments"); |
| 100 | const environmentThemesDir = path.join(stateDir, "themes"); |
| 101 | const worktreesDir = path.join(baseDir, "worktrees"); |
| 102 | const providerStatusCacheDir = path.join(baseDir, "caches"); |
| 103 | |
| 104 | for (const directory of [ |
| 105 | stateDir, |
| 106 | logsDir, |
| 107 | providerLogsDir, |
| 108 | terminalLogsDir, |
| 109 | attachmentsDir, |
| 110 | environmentThemesDir, |
| 111 | worktreesDir, |
| 112 | providerStatusCacheDir, |
| 113 | ]) { |
| 114 | yield* fs.makeDirectory(directory, { recursive: true }); |
| 115 | } |
| 116 | |
| 117 | return { |
| 118 | logLevel: "Error", |
| 119 | traceMinLevel: "Info", |
| 120 | traceTimingEnabled: true, |
| 121 | traceBatchWindowMs: 200, |
| 122 | traceMaxBytes: 10 * 1024 * 1024, |
| 123 | traceMaxFiles: 10, |
| 124 | otelEnvironment: OtelEnvironment.none, |
| 125 | otlpTracesUrl: undefined, |
| 126 | otlpMetricsUrl: undefined, |
| 127 | otlpLogsUrl: undefined, |
| 128 | otlpTracesExport: DEFAULT_SIGNAL_EXPORT, |
| 129 | otlpMetricsExport: DEFAULT_SIGNAL_EXPORT, |
| 130 | otlpLogsExport: DEFAULT_SIGNAL_EXPORT, |
| 131 | mode: "web", |
| 132 | port: 0, |
| 133 | host: undefined, |
| 134 | cwd: process.cwd(), |
| 135 | baseDir, |
| 136 | staticDir: undefined, |
| 137 | devUrl: undefined, |
| 138 | devAllowedOrigins: [], |
| 139 | noBrowser: false, |
| 140 | startupPresentation: "browser", |
| 141 | tailscaleServeEnabled: false, |
| 142 | tailscaleServePort: 443, |
| 143 | desktopBootstrapToken: undefined, |
| 144 | autoBootstrapProjectFromCwd: false, |
| 145 | logWebSocketEvents: false, |
| 146 | stateDir, |
| 147 | dbPath: path.join(stateDir, "state.sqlite"), |
| 148 | keybindingsConfigPath: path.join(stateDir, "keybindings.json"), |
| 149 | settingsPath: path.join(stateDir, "settings.json"), |
| 150 | providerStatusCacheDir, |
| 151 | worktreesDir, |
| 152 | worktreeCheckoutCacheDir: path.join(providerStatusCacheDir, "worktree-checkouts"), |
| 153 | attachmentsDir, |
| 154 | browserArtifactsDir: path.join(stateDir, "browser-artifacts"), |
| 155 | environmentThemesDir, |
| 156 | logsDir, |
| 157 | serverLogPath: path.join(logsDir, "server.log"), |
| 158 | serverTracePath: path.join(logsDir, "server.trace.ndjson"), |
| 159 | providerLogsDir, |
| 160 | providerEventLogPath: path.join(providerLogsDir, "events.log"), |
| 161 | terminalLogsDir, |
| 162 | anonymousIdPath: path.join(stateDir, "anonymous-id"), |
| 163 | environmentIdPath: path.join(stateDir, "environment-id"), |
| 164 | serverRuntimeStatePath: path.join(stateDir, "server-runtime.json"), |
| 165 | secretsDir: path.join(stateDir, "secrets"), |
| 166 | }; |
| 167 | }); |
| 168 | } |
| 169 | |
| 170 | export interface OrchestratorV2ProviderReplayScenario< |
| 171 | Transcript extends ProviderReplayTranscript = ProviderReplayTranscript, |
| 172 | > extends OrchestratorV2Scenario { |
| 173 | readonly transcript: Transcript; |
| 174 | readonly runtimePolicyOverride?: RuntimePolicy.RuntimePolicyV2Override; |
| 175 | } |
| 176 | |
| 177 | export interface OrchestratorV2ProviderReplayHarness< |
| 178 | Transcript extends ProviderReplayTranscript = ProviderReplayTranscript, |
| 179 | Error = never, |
| 180 | > { |
| 181 | readonly driver: ProviderDriverKind; |
| 182 | readonly decodeTranscript: ( |
| 183 | transcript: ProviderReplayTranscript, |
| 184 | ) => Effect.Effect<Transcript, Error>; |
| 185 | readonly makeProviderAdapterRegistryLayer: ( |
| 186 | transcript: Transcript, |
| 187 | options?: { readonly replayGate?: ProviderReplayGate }, |
| 188 | ) => Layer.Layer< |
| 189 | ProviderAdapterRegistry.ProviderAdapterRegistryV2, |
| 190 | Error, |
| 191 | McpProviderSessions.McpProviderSessions |
| 192 | >; |
| 193 | } |
| 194 | |
| 195 | export function runOrchestratorV2ProviderReplayScenario< |
| 196 | Transcript extends ProviderReplayTranscript, |
| 197 | Error, |
| 198 | >( |
| 199 | scenario: OrchestratorV2ProviderReplayScenario<Transcript>, |
| 200 | harness: OrchestratorV2ProviderReplayHarness<Transcript, Error>, |
| 201 | options: { |
| 202 | readonly databaseLayer?: Layer.Layer< |
| 203 | SqlClient.SqlClient, |
| 204 | MigrationError | PlatformError.PlatformError | SqlError |
| 205 | >; |
| 206 | readonly runEffectWorker?: boolean; |
| 207 | readonly runContinuationWorker?: boolean; |
| 208 | readonly recoverOnStartup?: boolean; |
| 209 | readonly continueThreadsAfterServerUpdate?: boolean; |
| 210 | readonly managedPolicy?: ManagedPolicyDocument; |
| 211 | readonly providerInstances?: Partial< |
| 212 | ProviderInstanceRegistry.ProviderInstanceRegistry["Service"] |
| 213 | >; |
| 214 | } = {}, |
| 215 | ): Effect.Effect< |
| 216 | OrchestratorV2ScenarioResult, |
| 217 | | Orchestrator.OrchestratorV2Error |
| 218 | | OrchestratorV2ScenarioStepError |
| 219 | | Error |
| 220 | | MigrationError |
| 221 | | PlatformError.PlatformError |
| 222 | | SqlError, |
| 223 | never |
| 224 | > { |
| 225 | const replayGate = makeProviderReplayGate( |
| 226 | scenario.steps?.flatMap((step) => |
| 227 | step.type === "release_replay_gate" || step.type === "release_replay_gate_after_waiting" |
| 228 | ? [step.label] |
| 229 | : [], |
| 230 | ) ?? [], |
| 231 | ); |
| 232 | const layer = layerProviderReplay(scenario, harness, { |
| 233 | ...options, |
| 234 | replayGate, |
| 235 | }); |
| 236 | |
| 237 | return Effect.gen(function* () { |
| 238 | const result = yield* runOrchestratorV2Scenario(scenario, { replayGate }); |
| 239 | const recorder = yield* CommandOutputRecorder.CommandOutputRecorder; |
| 240 | return { ...result, commandOutput: yield* recorder.snapshot }; |
| 241 | }).pipe(Effect.provide(layer)); |
| 242 | } |
| 243 | |
| 244 | export function layerProviderReplay<Transcript extends ProviderReplayTranscript, Error>( |
| 245 | scenario: OrchestratorV2ProviderReplayScenario<Transcript>, |
| 246 | harness: OrchestratorV2ProviderReplayHarness<Transcript, Error>, |
| 247 | options: { |
| 248 | readonly databaseLayer?: Layer.Layer< |
| 249 | SqlClient.SqlClient, |
| 250 | MigrationError | PlatformError.PlatformError | SqlError |
| 251 | >; |
| 252 | readonly runEffectWorker?: boolean; |
| 253 | readonly runContinuationWorker?: boolean; |
| 254 | readonly recoverOnStartup?: boolean; |
| 255 | readonly continueThreadsAfterServerUpdate?: boolean; |
| 256 | readonly managedPolicy?: ManagedPolicyDocument; |
| 257 | readonly replayGate?: ProviderReplayGate; |
| 258 | readonly providerInstances?: Partial< |
| 259 | ProviderInstanceRegistry.ProviderInstanceRegistry["Service"] |
| 260 | >; |
| 261 | } = {}, |
| 262 | ): Layer.Layer< |
| 263 | | Orchestrator.OrchestratorV2 |
| 264 | | EffectWorker.OrchestrationEffectWorkerV2 |
| 265 | | EventSink.EventSinkV2 |
| 266 | | CommandOutputRecorder.CommandOutputRecorder |
| 267 | | ProviderSessionManager.ProviderSessionManagerV2, |
| 268 | Error | MigrationError | PlatformError.PlatformError | SqlError |
| 269 | > { |
| 270 | const layerRegistry = harness.makeProviderAdapterRegistryLayer( |
| 271 | scenario.transcript, |
| 272 | options.replayGate === undefined ? {} : { replayGate: options.replayGate }, |
| 273 | ); |
| 274 | return layerWithRegistry(scenario, layerRegistry, options); |
| 275 | } |
| 276 | |
| 277 | export function layerWithRegistry<Error>( |
| 278 | scenario: Pick<OrchestratorV2ProviderReplayScenario, "name" | "runtimePolicyOverride">, |
| 279 | registryLayer: Layer.Layer< |
| 280 | ProviderAdapterRegistry.ProviderAdapterRegistryV2, |
| 281 | Error, |
| 282 | McpProviderSessions.McpProviderSessions |
| 283 | >, |
| 284 | options: { |
| 285 | readonly databaseLayer?: Layer.Layer< |
| 286 | SqlClient.SqlClient, |
| 287 | MigrationError | PlatformError.PlatformError | SqlError |
| 288 | >; |
| 289 | readonly runEffectWorker?: boolean; |
| 290 | readonly runContinuationWorker?: boolean; |
| 291 | readonly recoverOnStartup?: boolean; |
| 292 | readonly continueThreadsAfterServerUpdate?: boolean; |
| 293 | /** Lets a test hold a projection read open to order concurrent dispatches. */ |
| 294 | readonly wrapProjectionStore?: ( |
| 295 | store: ProjectionStore.ProjectionStoreV2Shape, |
| 296 | ) => ProjectionStore.ProjectionStoreV2Shape; |
| 297 | readonly managedPolicy?: ManagedPolicyDocument; |
| 298 | /** The instances the ingestor reads snapshots from, such as an endpoint behind a hub. */ |
| 299 | readonly providerInstances?: Partial< |
| 300 | ProviderInstanceRegistry.ProviderInstanceRegistry["Service"] |
| 301 | >; |
| 302 | } = {}, |
| 303 | ): Layer.Layer< |
| 304 | | Orchestrator.OrchestratorV2 |
| 305 | | EffectOutbox.EffectOutboxV2 |
| 306 | | EffectWorker.OrchestrationEffectWorkerV2 |
| 307 | | EventSink.EventSinkV2 |
| 308 | | ProviderSessionManager.ProviderSessionManagerV2 |
| 309 | | CommandOutputRecorder.CommandOutputRecorder |
| 310 | | ThreadCommandExecutor.ThreadCommandExecutor, |
| 311 | Error | MigrationError | PlatformError.PlatformError | SqlError |
| 312 | > { |
| 313 | const layerServerConfig = Layer.effect( |
| 314 | ServerConfig.ServerConfig, |
| 315 | makeReplayServerConfig(scenario.name).pipe(Effect.orDie), |
| 316 | ).pipe(Layer.provide(NodeServices.layer)); |
| 317 | const layerRuntimeBase = |
| 318 | scenario.runtimePolicyOverride === undefined |
| 319 | ? RuntimePolicy.layer |
| 320 | : RuntimePolicy.layerWithOverride(scenario.runtimePolicyOverride).pipe( |
| 321 | Layer.provide(RuntimePolicy.layer), |
| 322 | ); |
| 323 | const layerDatabase = options.databaseLayer ?? SqlitePersistence.layerMemory; |
| 324 | // Share one continuation queue across adapters, orchestrator, and worker through layer memoization. |
| 325 | const layerContinuationRequests = |
| 326 | options.runContinuationWorker === true ? ProviderContinuationRequests.layer : Layer.empty; |
| 327 | const layerProvidedRegistry = registryLayer.pipe( |
| 328 | Layer.provide(Layer.merge(layerContinuationRequests, McpProviderSessions.layer)), |
| 329 | ); |
| 330 | const layerServerSettings = Layer.unwrap( |
| 331 | Effect.map(ManagedPolicy.fromDocument("/test/policy.json", options.managedPolicy), (policy) => |
| 332 | ServerSettings.layerTest( |
| 333 | { |
| 334 | responseStreamingMode: "turn", |
| 335 | ...(options.continueThreadsAfterServerUpdate === undefined |
| 336 | ? {} |
| 337 | : { continueThreadsAfterServerUpdate: options.continueThreadsAfterServerUpdate }), |
| 338 | }, |
| 339 | policy.summary, |
| 340 | ), |
| 341 | ), |
| 342 | ).pipe(Layer.orDie); |
| 343 | const layerEffectOutboxProvided = EffectOutbox.layer.pipe(Layer.provide(layerDatabase)); |
| 344 | const wrapProjectionStore = options.wrapProjectionStore; |
| 345 | const layerProjectionStore = |
| 346 | wrapProjectionStore === undefined |
| 347 | ? ProjectionStore.layer |
| 348 | : Layer.effect( |
| 349 | ProjectionStore.ProjectionStoreV2, |
| 350 | Effect.gen(function* () { |
| 351 | return wrapProjectionStore(yield* ProjectionStore.ProjectionStoreV2); |
| 352 | }), |
| 353 | ).pipe(Layer.provide(ProjectionStore.layer)); |
| 354 | const layerStores = Layer.mergeAll( |
| 355 | EventStore.layer, |
| 356 | layerProjectionStore, |
| 357 | ProjectStore.layer, |
| 358 | CommandReceiptStore.layer, |
| 359 | layerEffectOutboxProvided, |
| 360 | TurnItemPositionStore.layer, |
| 361 | ).pipe(Layer.provide(layerDatabase)); |
| 362 | const layerEventSinkProvided = EventSink.layerFromStores.pipe( |
| 363 | Layer.provide(Layer.mergeAll(layerStores, layerDatabase, ThreadViewers.layer)), |
| 364 | ); |
| 365 | const layerRuntime = RuntimePolicy.layerEnforcingCeiling.pipe( |
| 366 | Layer.provide(Layer.merge(layerRuntimeBase, layerServerSettings)), |
| 367 | ); |
| 368 | const layerCommandReceiptStoreProvided = CommandReceiptStore.layer.pipe( |
| 369 | Layer.provide(layerDatabase), |
| 370 | ); |
| 371 | const layerProviderEventIngestorProvided = ProviderEventIngestor.layer.pipe( |
| 372 | Layer.provide( |
| 373 | Layer.mergeAll( |
| 374 | Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)( |
| 375 | options.providerInstances ?? { getInstance: () => Effect.undefined }, |
| 376 | ), |
| 377 | layerStores, |
| 378 | layerEventSinkProvided, |
| 379 | IdAllocator.layer, |
| 380 | ThreadCommandExecutor.layer, |
| 381 | GitVcsDriver.layer.pipe( |
| 382 | Layer.provide(layerServerConfig), |
| 383 | Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), |
| 384 | ), |
| 385 | ), |
| 386 | ), |
| 387 | ); |
| 388 | const layerVcsDriverRegistry = VcsDriverRegistry.layer.pipe( |
| 389 | Layer.provide(VcsProcess.layer), |
| 390 | Layer.provide(layerServerConfig), |
| 391 | Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), |
| 392 | ); |
| 393 | const layerCheckpointStore = CheckpointStore.layer.pipe( |
| 394 | Layer.provide(layerVcsDriverRegistry), |
| 395 | Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), |
| 396 | ); |
| 397 | const layerCheckpointServiceProvided = CheckpointService.layer.pipe( |
| 398 | Layer.provide(Layer.mergeAll(layerCheckpointStore, IdAllocator.layer)), |
| 399 | ); |
| 400 | const layerContextHandoffServiceProvided = ContextHandoffService.layer.pipe( |
| 401 | Layer.provide(IdAllocator.layer), |
| 402 | ); |
| 403 | const layerPersistence = Layer.mergeAll( |
| 404 | layerStores, |
| 405 | layerEventSinkProvided, |
| 406 | layerCommandReceiptStoreProvided, |
| 407 | IdAllocator.layer, |
| 408 | layerProviderEventIngestorProvided, |
| 409 | ); |
| 410 | const layerCommandOutputHubProvided = CommandOutputRecorder.layer.pipe( |
| 411 | Layer.provide(Layer.merge(layerEventSinkProvided, layerStores)), |
| 412 | ); |
| 413 | const layerProviderSessionManagerProvided = ProviderSessionManager.layerWithOptions({ |
| 414 | configureMcp: false, |
| 415 | }).pipe( |
| 416 | Layer.provide( |
| 417 | Layer.mergeAll( |
| 418 | layerCommandOutputHubProvided, |
| 419 | layerProvidedRegistry, |
| 420 | layerEventSinkProvided, |
| 421 | IdAllocator.layer, |
| 422 | McpProviderSessions.layer, |
| 423 | McpSessionRegistryTestkit.layer, |
| 424 | layerProviderEventIngestorProvided, |
| 425 | layerStores, |
| 426 | ProviderInstallationGate.layer, |
| 427 | ), |
| 428 | ), |
| 429 | ); |
| 430 | const layerProviderSwitchServiceProvided = ProviderSwitchService.layer.pipe( |
| 431 | Layer.provide(layerProvidedRegistry), |
| 432 | ); |
| 433 | const layerRunExecutionServiceProvided = RunExecutionService.layer.pipe( |
| 434 | Layer.provide( |
| 435 | Layer.mergeAll( |
| 436 | McpAppModelContext.layerEmpty, |
| 437 | PreviewAgentActivity.layer, |
| 438 | layerCheckpointServiceProvided, |
| 439 | layerEventSinkProvided, |
| 440 | IdAllocator.layer, |
| 441 | layerProviderEventIngestorProvided, |
| 442 | layerServerSettings, |
| 443 | layerStores, |
| 444 | ThreadCommandExecutor.layer, |
| 445 | ), |
| 446 | ), |
| 447 | ); |
| 448 | const layerProviderTurnStartServiceProvided = ProviderTurnStartService.layer.pipe( |
| 449 | Layer.provide( |
| 450 | Layer.mergeAll( |
| 451 | layerContextHandoffServiceProvided, |
| 452 | layerEventSinkProvided, |
| 453 | IdAllocator.layer, |
| 454 | layerStores, |
| 455 | layerProviderSessionManagerProvided, |
| 456 | Layer.mock(ProviderAuthService.ProviderAuthService)({ |
| 457 | tryHandlePromptCommand: () => Effect.succeed(false), |
| 458 | }), |
| 459 | layerRunExecutionServiceProvided, |
| 460 | layerRuntime, |
| 461 | layerServerConfig, |
| 462 | layerServerSettings, |
| 463 | ), |
| 464 | ), |
| 465 | ); |
| 466 | const layerProviderTurnControlServiceProvided = ProviderTurnControlService.layer.pipe( |
| 467 | Layer.provide( |
| 468 | Layer.mergeAll( |
| 469 | layerEventSinkProvided, |
| 470 | McpAppModelContext.layerEmpty, |
| 471 | layerStores, |
| 472 | layerProviderSessionManagerProvided, |
| 473 | ), |
| 474 | ), |
| 475 | ); |
| 476 | const layerRuntimeRequestServiceProvided = RuntimeRequestService.layer.pipe( |
| 477 | Layer.provide(Layer.merge(layerStores, layerProviderSessionManagerProvided)), |
| 478 | ); |
| 479 | const layerCheckpointRollbackServiceProvided = CheckpointRollbackService.layer.pipe( |
| 480 | Layer.provide( |
| 481 | Layer.mergeAll( |
| 482 | layerCheckpointServiceProvided, |
| 483 | layerEventSinkProvided, |
| 484 | IdAllocator.layer, |
| 485 | layerStores, |
| 486 | layerProviderSessionManagerProvided, |
| 487 | ThreadCommandExecutor.layer, |
| 488 | layerRuntime, |
| 489 | layerServerConfig, |
| 490 | layerServerSettings, |
| 491 | ), |
| 492 | ), |
| 493 | ); |
| 494 | const layerCheckpointCaptureServiceProvided = CheckpointCaptureService.layer.pipe( |
| 495 | Layer.provide( |
| 496 | Layer.mergeAll( |
| 497 | layerCheckpointServiceProvided, |
| 498 | layerEventSinkProvided, |
| 499 | IdAllocator.layer, |
| 500 | layerStores, |
| 501 | ), |
| 502 | ), |
| 503 | ); |
| 504 | const layerRunFinalizationServiceProvided = RunFinalizationService.layer.pipe( |
| 505 | Layer.provide(Layer.merge(layerCheckpointCaptureServiceProvided, layerStores)), |
| 506 | ); |
| 507 | const layerThreadTitleRegenerationTest = Layer.succeed( |
| 508 | ThreadTitleRegenerationService.ThreadTitleRegenerationService, |
| 509 | ThreadTitleRegenerationService.ThreadTitleRegenerationService.of({ |
| 510 | execute: Effect.fn("ThreadTitleRegenerationService.execute")(function () { |
| 511 | return Effect.void; |
| 512 | }), |
| 513 | }), |
| 514 | ); |
| 515 | const layerOrchestratorProvided = Orchestrator.layer.pipe( |
| 516 | Layer.provide( |
| 517 | Layer.mergeAll( |
| 518 | layerCheckpointServiceProvided, |
| 519 | CommandPolicy.layer, |
| 520 | layerContextHandoffServiceProvided, |
| 521 | layerPersistence, |
| 522 | layerProvidedRegistry, |
| 523 | layerContinuationRequests, |
| 524 | layerRuntime, |
| 525 | layerProviderSessionManagerProvided, |
| 526 | layerProviderSwitchServiceProvided, |
| 527 | layerRunExecutionServiceProvided, |
| 528 | layerServerSettings, |
| 529 | ThreadForkService.layer, |
| 530 | ), |
| 531 | ), |
| 532 | ); |
| 533 | const layerThreadManagementProvided = Layer.unwrap( |
| 534 | Effect.gen(function* () { |
| 535 | const orchestrator = yield* Orchestrator.OrchestratorV2; |
| 536 | return Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 537 | dispatch: orchestrator.dispatch, |
| 538 | getThreadRecords: orchestrator.getThreadRecords, |
| 539 | getThreadProjection: orchestrator.getThreadProjection, |
| 540 | recoverDelegatedTask: orchestrator.recoverDelegatedTask, |
| 541 | cancelDelegatedTask: orchestrator.cancelDelegatedTask, |
| 542 | delegatedTaskResultPending: orchestrator.delegatedTaskResultPending, |
| 543 | streamStoredEventsFrom: orchestrator.streamStoredEventsFrom, |
| 544 | }); |
| 545 | }), |
| 546 | ).pipe(Layer.provide(layerOrchestratorProvided)); |
| 547 | const layerContinuationWorkerProvided = |
| 548 | options.runContinuationWorker === true |
| 549 | ? ProviderContinuationService.layer.pipe( |
| 550 | Layer.provide( |
| 551 | Layer.mergeAll( |
| 552 | layerContinuationRequests, |
| 553 | layerThreadManagementProvided, |
| 554 | IdAllocator.layer, |
| 555 | ), |
| 556 | ), |
| 557 | ) |
| 558 | : Layer.empty; |
| 559 | const layerEffectExecutorProvided = EffectWorker.layerExecutor.pipe( |
| 560 | Layer.provide( |
| 561 | Layer.mergeAll( |
| 562 | layerRunFinalizationServiceProvided, |
| 563 | layerCheckpointRollbackServiceProvided, |
| 564 | layerProviderSessionManagerProvided, |
| 565 | layerProviderTurnControlServiceProvided, |
| 566 | layerProviderTurnStartServiceProvided, |
| 567 | layerRuntimeRequestServiceProvided, |
| 568 | layerThreadTitleRegenerationTest, |
| 569 | layerServerSettings, |
| 570 | layerThreadManagementProvided, |
| 571 | layerStores, |
| 572 | ), |
| 573 | ), |
| 574 | ); |
| 575 | const layerEffectWorkerProvided = EffectWorker.layer.pipe( |
| 576 | Layer.provide(Layer.merge(layerStores, layerEffectExecutorProvided)), |
| 577 | ); |
| 578 | const layerReplayRuntime = Layer.mergeAll( |
| 579 | layerEffectOutboxProvided, |
| 580 | layerOrchestratorProvided, |
| 581 | layerProviderSessionManagerProvided, |
| 582 | layerEffectWorkerProvided, |
| 583 | layerEventSinkProvided, |
| 584 | layerContinuationWorkerProvided, |
| 585 | layerCommandOutputHubProvided, |
| 586 | ThreadCommandExecutor.layer, |
| 587 | ).pipe( |
| 588 | Layer.provide(ProviderTurnStartServiceTestkit.layer), |
| 589 | Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), |
| 590 | ); |
| 591 | |
| 592 | if (options.runEffectWorker === false) { |
| 593 | return layerReplayRuntime; |
| 594 | } |
| 595 | // Build recovery before runtime so it commits before the effect worker claims work. |
| 596 | const layerStartupRecovery: Layer.Layer< |
| 597 | never, |
| 598 | MigrationError | PlatformError.PlatformError | SqlError |
| 599 | > = |
| 600 | options.recoverOnStartup === true |
| 601 | ? Layer.effectDiscard( |
| 602 | ProviderRuntimeRecoveryService.ProviderRuntimeRecoveryService.use( |
| 603 | (recovery) => recovery.recover, |
| 604 | ).pipe(Effect.orDie), |
| 605 | ).pipe( |
| 606 | Layer.provide(ProviderRuntimeRecoveryService.layer), |
| 607 | Layer.provide( |
| 608 | Layer.mergeAll( |
| 609 | layerStores, |
| 610 | layerEventSinkProvided, |
| 611 | IdAllocator.layer, |
| 612 | layerServerSettings, |
| 613 | ), |
| 614 | ), |
| 615 | ) |
| 616 | : Layer.empty; |
| 617 | return Layer.effect( |
| 618 | Orchestrator.OrchestratorV2, |
| 619 | Effect.gen(function* () { |
| 620 | const orchestrator = yield* Orchestrator.OrchestratorV2; |
| 621 | yield* orchestrator.recoverDelegatedTasks; |
| 622 | yield* EffectWorker.runDaemon.pipe(Effect.forkScoped); |
| 623 | return orchestrator; |
| 624 | }), |
| 625 | ).pipe(Layer.provideMerge(layerReplayRuntime), Layer.provide(layerStartupRecovery)); |
| 626 | } |