import {  ModelSelection,  OrchestrationV2ThreadProjection,  ProviderSessionId,  ProviderThreadId,  ThreadId,} from "@t3tools/contracts";import { modelSelectionsEqual } from "@t3tools/shared/model";import * as Context from "effect/Context";import * as DateTime from "effect/DateTime";import * as Effect from "effect/Effect";import * as Layer from "effect/Layer";import * as Option from "effect/Option";import * as Schema from "effect/Schema"; import * as ProviderAdapterRegistry from "./ProviderAdapterRegistry.ts";import {  decideProviderSessionTransition,  type ProviderSessionTransition,} from "./ProviderSessionTransitionPolicy.ts"; export interface ProviderSwitchPlanV2 {  readonly instanceChanged: boolean;  readonly modelChanged: boolean;  readonly targetProviderThreadId: ProviderThreadId | null;  readonly releaseProviderSessionIds: ReadonlyArray<ProviderSessionId>;  readonly transition: ProviderSessionTransition;} export class ProviderSwitchPlanError extends Schema.TaggedErrorClass<ProviderSwitchPlanError>()(  "ProviderSwitchPlanError",  {    threadId: ThreadId,    targetProviderInstanceId: Schema.String,    cause: Schema.optional(Schema.Defect()),  },) {} export interface ProviderSwitchServiceV2Shape {  readonly plan: (input: {    readonly projection: OrchestrationV2ThreadProjection;    readonly targetModelSelection: ModelSelection;  }) => Effect.Effect<ProviderSwitchPlanV2, ProviderSwitchPlanError>;} export class ProviderSwitchServiceV2 extends Context.Service<  ProviderSwitchServiceV2,  ProviderSwitchServiceV2Shape>()("t3/orchestration-v2/ProviderSwitchService/ProviderSwitchServiceV2") {} export const layer: Layer.Layer<  ProviderSwitchServiceV2,  never,  ProviderAdapterRegistry.ProviderAdapterRegistryV2> = Layer.effect(  ProviderSwitchServiceV2,  Effect.gen(function* () {    const adapters = yield* ProviderAdapterRegistry.ProviderAdapterRegistryV2;    return ProviderSwitchServiceV2.of({      plan: ({ projection, targetModelSelection }) =>        Effect.gen(function* () {          const current = projection.thread.modelSelection;          const instanceChanged = current.instanceId !== targetModelSelection.instanceId;          const modelChanged = current.model !== targetModelSelection.model;          const getMetadata = (instanceId: typeof current.instanceId) =>            adapters.getMetadata !== undefined              ? adapters.getMetadata(instanceId)              : adapters.get(instanceId).pipe(                  Effect.flatMap((adapter) =>                    adapter.getCapabilities().pipe(                      Effect.map((capabilities) => ({                        driver: adapter.driver,                        continuationKey: `${adapter.driver}:instance:${instanceId}`,                        enabled: true,                        capabilities,                      })),                    ),                  ),                );          const currentInstance = yield* Effect.option(getMetadata(current.instanceId));          const targetInstance = yield* Effect.option(getMetadata(targetModelSelection.instanceId));          const targetAdapter = yield* Effect.option(adapters.get(targetModelSelection.instanceId));          const currentSession = projection.providerSessions            .filter((session) => session.providerInstanceId === current.instanceId)            .toSorted(              (left, right) =>                DateTime.toEpochMillis(right.updatedAt) - DateTime.toEpochMillis(left.updatedAt),            )[0];          const selectionTransition =            current.instanceId === targetModelSelection.instanceId &&            !modelSelectionsEqual(current, targetModelSelection) &&            Option.isSome(targetAdapter) &&            currentSession !== undefined              ? yield* targetAdapter.value.planSelectionTransition({                  current,                  target: targetModelSelection,                  sessionCapabilities: currentSession.capabilities,                })              : undefined;          const transition =            Option.isNone(targetInstance) || Option.isNone(targetAdapter)              ? ({                  type: "reject",                  reason: "The target provider instance is unavailable.",                } as const)              : decideProviderSessionTransition({                  current:                    Option.isNone(currentInstance) || currentSession === undefined                      ? null                      : {                          driver: currentInstance.value.driver,                          continuationIdentity: {                            driverKind: currentInstance.value.driver,                            continuationKey: currentInstance.value.continuationKey,                          },                          modelSelection: current,                          runtimeMode: projection.thread.runtimeMode,                          interactionMode: projection.thread.interactionMode,                          workspace: currentSession.cwd,                          capabilities: currentSession.capabilities,                        },                  target: {                    driver: targetInstance.value.driver,                    continuationIdentity: {                      driverKind: targetInstance.value.driver,                      continuationKey: targetInstance.value.continuationKey,                    },                    modelSelection: targetModelSelection,                    runtimeMode: projection.thread.runtimeMode,                    interactionMode: projection.thread.interactionMode,                    workspace:                      projection.thread.worktreePath ??                      currentSession?.cwd ??                      "<unresolved-workspace>",                    capabilities: targetInstance.value.capabilities,                    available: targetInstance.value.enabled,                  },                  ...(selectionTransition === undefined ? {} : { selectionTransition }),                });          if (transition.type === "reject") {            return yield* new ProviderSwitchPlanError({              threadId: projection.thread.id,              targetProviderInstanceId: targetModelSelection.instanceId,              cause: transition.reason,            });          }          const targetProviderThread = projection.providerThreads            .filter(              (thread) =>                thread.appThreadId === projection.thread.id &&                thread.ownerNodeId === null &&                thread.providerInstanceId === targetModelSelection.instanceId,            )            .toSorted(              (left, right) =>                DateTime.toEpochMillis(right.updatedAt) - DateTime.toEpochMillis(left.updatedAt),            )[0];          const releaseProviderSessionIds = projection.providerSessions            .filter((session) => {              if (session.status === "stopped" || session.status === "error") return false;              if (transition.type === "restart_and_resume") {                return session.id === currentSession?.id;              }              if (transition.type === "create_with_handoff") {                return session.providerInstanceId !== targetModelSelection.instanceId;              }              return false;            })            .map((session) => session.id);          return {            instanceChanged,            modelChanged,            targetProviderThreadId: targetProviderThread?.id ?? null,            releaseProviderSessionIds,            transition,          };        }).pipe(          Effect.mapError(            (cause) =>              new ProviderSwitchPlanError({                threadId: projection.thread.id,                targetProviderInstanceId: targetModelSelection.instanceId,                cause,              }),          ),        ),    });  }),);