sailfork / t3code-github / packages/ provider-core/ src/ server/ IdAllocator.ts

import {
  CheckpointId,
  CheckpointScopeId,
  CommandId,
  ContextHandoffId,
  ContextTransferId,
  EventId,
  MessageId,
  NodeId,
  PlanId,
  ProjectId,
  ProviderDriverKind,
  ProviderInstanceId,
  ProviderSessionId,
  ProviderThreadId,
  ProviderTurnId,
  RawEventId,
  RunAttemptId,
  RunId,
  RuntimeRequestId,
  ThreadId,
  TurnItemId,
} from "@t3tools/contracts";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";

import { randomUuidV4 } from "./randomUuid.ts";

export const IdAllocatorV2Kind = Schema.Literals([
  "command",
  "event",
  "raw_event",
  "project",
  "thread",
  "message",
  "run",
  "run_attempt",
  "node",
  "provider_session",
  "provider_thread",
  "provider_turn",
  "runtime_request",
  "turn_item",
  "checkpoint_scope",
  "checkpoint",
  "context_handoff",
  "context_transfer",
  "plan",
]);
export type IdAllocatorV2Kind = typeof IdAllocatorV2Kind.Type;

export class IdAllocatorV2AllocationError extends Schema.TaggedError<IdAllocatorV2AllocationError>()(
  "IdAllocatorV2AllocationError",
  {
    kind: IdAllocatorV2Kind,
    input: Schema.optional(Schema.Unknown),
    cause: Schema.optional(Schema.Defect()),
  },
) {
  override get message(): string {
    return `Failed to allocate orchestration ${this.kind} id.`;
  }
}

export const IdAllocatorV2Error = Schema.Union([IdAllocatorV2AllocationError]);
export type IdAllocatorV2Error = typeof IdAllocatorV2Error.Type;

export interface IdAllocatorV2Allocate {
  readonly command: (input: {
    readonly fixtureName: string;
    readonly commandName: string;
  }) => Effect.Effect<CommandId, IdAllocatorV2Error>;
  readonly event: (input: {
    readonly threadId?: ThreadId;
    readonly commandId?: CommandId;
    readonly providerSessionId?: ProviderSessionId;
  }) => Effect.Effect<EventId, IdAllocatorV2Error>;
  readonly rawEvent: (input: {
    readonly providerSessionId: ProviderSessionId;
    readonly method: string | null;
  }) => Effect.Effect<RawEventId, IdAllocatorV2Error>;
  readonly project: (input: {
    readonly fixtureName: string;
  }) => Effect.Effect<ProjectId, IdAllocatorV2Error>;
  readonly thread: (input: {
    readonly fixtureName?: string;
    readonly projectId?: ProjectId;
  }) => Effect.Effect<ThreadId, IdAllocatorV2Error>;
  readonly message: (input: {
    readonly threadId: ThreadId;
    readonly ordinal: number;
  }) => Effect.Effect<MessageId, IdAllocatorV2Error>;
  readonly providerSession: (input: {
    readonly providerInstanceId: ProviderInstanceId;
    readonly threadId: ThreadId;
  }) => Effect.Effect<ProviderSessionId, IdAllocatorV2Error>;
  readonly runtimeRequest: (input: {
    readonly driver: ProviderDriverKind;
    readonly providerTurnId?: ProviderTurnId;
    readonly nativeRequestId?: string;
  }) => Effect.Effect<RuntimeRequestId, IdAllocatorV2Error>;
  readonly checkpointScope: (input: {
    readonly threadId: ThreadId;
    readonly name: string;
  }) => Effect.Effect<CheckpointScopeId, IdAllocatorV2Error>;
  readonly checkpoint: (input: {
    readonly checkpointScopeId: CheckpointScopeId;
    readonly name: string;
  }) => Effect.Effect<CheckpointId, IdAllocatorV2Error>;
  readonly contextHandoff: (input: {
    readonly threadId: ThreadId;
    readonly fromProviderInstanceId: ProviderInstanceId;
    readonly toProviderInstanceId: ProviderInstanceId;
  }) => Effect.Effect<ContextHandoffId, IdAllocatorV2Error>;
  readonly contextTransfer: (input: {
    readonly sourceThreadId: ThreadId;
    readonly targetThreadId: ThreadId;
    readonly type: string;
  }) => Effect.Effect<ContextTransferId, IdAllocatorV2Error>;
  readonly plan: (input: {
    readonly threadId: ThreadId;
    readonly runId?: RunId;
    readonly driver: ProviderDriverKind;
  }) => Effect.Effect<PlanId, IdAllocatorV2Error>;
}

export interface IdAllocatorV2Derive {
  readonly providerSession: (input: {
    readonly providerInstanceId: ProviderInstanceId;
  }) => ProviderSessionId;
  readonly delegatedTaskNode: (input: { readonly commandId: CommandId }) => NodeId;
  readonly delegatedTaskThread: (input: { readonly commandId: CommandId }) => ThreadId;
  readonly delegatedTaskMessage: (input: { readonly commandId: CommandId }) => MessageId;
  readonly delegatedTaskTurnItem: (input: { readonly commandId: CommandId }) => TurnItemId;
  readonly createdThreadTurnItem: (input: { readonly commandId: CommandId }) => TurnItemId;
  readonly threadFromProviderThread: (input: {
    readonly driver: ProviderDriverKind;
    readonly nativeThreadId: string;
    readonly providerInstanceId?: ProviderInstanceId;
  }) => ThreadId;
  readonly run: (input: { readonly threadId: ThreadId; readonly ordinal: number }) => RunId;
  readonly runAttempt: (input: {
    readonly runId: RunId;
    readonly attemptOrdinal: number;
  }) => RunAttemptId;
  readonly rootNode: (input: { readonly runId: RunId }) => NodeId;
  readonly rootNodeAttempt: (input: {
    readonly runId: RunId;
    readonly attemptOrdinal: number;
  }) => NodeId;
  readonly userTurnItem: (input: { readonly messageId: MessageId }) => TurnItemId;
  readonly runSignalTurnItem: (input: {
    readonly runId: RunId;
    readonly signal: string;
  }) => TurnItemId;
  readonly providerThread: (input: {
    readonly driver: ProviderDriverKind;
    readonly nativeThreadId: string;
    readonly providerInstanceId?: ProviderInstanceId;
  }) => ProviderThreadId;
  readonly providerTurn: (input: {
    readonly driver: ProviderDriverKind;
    readonly nativeTurnId: string;
  }) => ProviderTurnId;
  readonly nodeFromProviderItem: (input: {
    readonly driver: ProviderDriverKind;
    readonly nativeItemId: string;
  }) => NodeId;
  readonly messageFromProviderItem: (input: {
    readonly driver: ProviderDriverKind;
    readonly nativeItemId: string;
  }) => MessageId;
  readonly turnItemFromProviderItem: (input: {
    readonly driver: ProviderDriverKind;
    readonly nativeItemId: string;
  }) => TurnItemId;
  readonly approvalNode: (input: { readonly requestId: RuntimeRequestId }) => NodeId;
  readonly approvalTurnItem: (input: { readonly requestId: RuntimeRequestId }) => TurnItemId;
}

export class IdAllocatorV2 extends Context.Service<
  IdAllocatorV2,
  {
    readonly allocate: IdAllocatorV2Allocate;
    readonly derive: IdAllocatorV2Derive;
  }
>()("@t3tools/provider-core/server/IdAllocator/IdAllocatorV2") {}

const encodePart = (part: string | number): string => encodeURIComponent(String(part));

const joinId = (prefix: string, ...parts: ReadonlyArray<string | number>): string =>
  [prefix, ...parts.map(encodePart)].join(":");

export function deriveThreadFromProviderThread(input: {
  readonly driver: ProviderDriverKind;
  readonly providerInstanceId?: ProviderInstanceId;
  readonly nativeThreadId: string;
}): ThreadId {
  return ThreadId.make(
    joinId(
      "thread",
      "provider",
      input.driver,
      ...(input.providerInstanceId === undefined
        ? []
        : ["provider-instance", input.providerInstanceId]),
      "native-thread",
      input.nativeThreadId,
    ),
  );
}

export function deriveProviderThread(input: {
  readonly driver: ProviderDriverKind;
  readonly providerInstanceId?: ProviderInstanceId;
  readonly nativeThreadId: string;
}): ProviderThreadId {
  return ProviderThreadId.make(
    joinId(
      "provider-thread",
      "provider",
      input.driver,
      ...(input.providerInstanceId === undefined
        ? []
        : ["provider-instance", input.providerInstanceId]),
      "native-thread",
      input.nativeThreadId,
    ),
  );
}

const randomId =
  <Id, Input>(input: {
    readonly kind: IdAllocatorV2Kind;
    readonly prefix: string;
    readonly parts: ReadonlyArray<string | number>;
    readonly make: (value: string) => Id;
  }) =>
  (allocationInput: Input): Effect.Effect<Id, IdAllocatorV2Error> =>
    randomUuidV4.pipe(
      Effect.map((uuid) => input.make(joinId(input.prefix, ...input.parts, uuid))),
      Effect.mapError(
        (cause) =>
          new IdAllocatorV2AllocationError({
            kind: input.kind,
            input: allocationInput,
            cause,
          }),
      ),
    );

export const derive: IdAllocatorV2Derive = {
  providerSession: (input) =>
    ProviderSessionId.make(
      joinId("provider-session", "provider-instance", input.providerInstanceId, "shared"),
    ),
  delegatedTaskNode: (input) => NodeId.make(joinId("node", "delegated-task", input.commandId)),
  delegatedTaskThread: (input) =>
    ThreadId.make(joinId("thread", "delegated-task", input.commandId)),
  delegatedTaskMessage: (input) =>
    MessageId.make(joinId("message", "delegated-task", input.commandId)),
  delegatedTaskTurnItem: (input) =>
    TurnItemId.make(joinId("turn-item", "delegated-task", input.commandId)),
  createdThreadTurnItem: (input) =>
    TurnItemId.make(joinId("turn-item", "created-thread", input.commandId)),
  threadFromProviderThread: deriveThreadFromProviderThread,
  run: (input) => RunId.make(joinId("run", "thread", input.threadId, "ordinal", input.ordinal)),
  runAttempt: (input) =>
    RunAttemptId.make(joinId("run-attempt", "run", input.runId, "attempt", input.attemptOrdinal)),
  rootNode: (input) => NodeId.make(joinId("node", "run", input.runId, "root")),
  rootNodeAttempt: (input) =>
    NodeId.make(joinId("node", "run", input.runId, "attempt", input.attemptOrdinal, "root")),
  userTurnItem: (input) => TurnItemId.make(joinId("turn-item", "message", input.messageId)),
  runSignalTurnItem: (input) =>
    TurnItemId.make(joinId("turn-item", "run", input.runId, "signal", input.signal)),
  providerThread: deriveProviderThread,
  providerTurn: (input) =>
    ProviderTurnId.make(
      joinId("provider-turn", "provider", input.driver, "native-turn", input.nativeTurnId),
    ),
  nodeFromProviderItem: (input) =>
    NodeId.make(joinId("node", "provider", input.driver, "native-item", input.nativeItemId)),
  messageFromProviderItem: (input) =>
    MessageId.make(joinId("message", "provider", input.driver, "native-item", input.nativeItemId)),
  turnItemFromProviderItem: (input) =>
    TurnItemId.make(
      joinId("turn-item", "provider", input.driver, "native-item", input.nativeItemId),
    ),
  approvalNode: (input) => NodeId.make(joinId("node", "runtime-request", input.requestId)),
  approvalTurnItem: (input) =>
    TurnItemId.make(joinId("turn-item", "runtime-request", input.requestId)),
};

export const layer: Layer.Layer<IdAllocatorV2> = Layer.succeed(
  IdAllocatorV2,
  IdAllocatorV2.of({
    allocate: {
      command: (input) =>
        randomId<CommandId, typeof input>({
          kind: "command",
          prefix: "command",
          parts: ["fixture", input.fixtureName, input.commandName],
          make: CommandId.make,
        })(input),
      event: (input) =>
        randomId<EventId, typeof input>({
          kind: "event",
          prefix: "event",
          parts: [
            ...(input.threadId === undefined ? [] : ["thread", input.threadId]),
            ...(input.commandId === undefined ? [] : ["command", input.commandId]),
            ...(input.providerSessionId === undefined
              ? []
              : ["provider-session", input.providerSessionId]),
          ],
          make: EventId.make,
        })(input),
      rawEvent: (input) =>
        randomId<RawEventId, typeof input>({
          kind: "raw_event",
          prefix: "raw-event",
          parts: [
            "provider-session",
            input.providerSessionId,
            ...(input.method === null ? [] : ["method", input.method]),
          ],
          make: RawEventId.make,
        })(input),
      project: (input) =>
        randomId<ProjectId, typeof input>({
          kind: "project",
          prefix: "project",
          parts: ["fixture", input.fixtureName],
          make: ProjectId.make,
        })(input),
      thread: (input) =>
        randomId<ThreadId, typeof input>({
          kind: "thread",
          prefix: "thread",
          parts: [
            ...(input.fixtureName === undefined ? [] : ["fixture", input.fixtureName]),
            ...(input.projectId === undefined ? [] : ["project", input.projectId]),
          ],
          make: ThreadId.make,
        })(input),
      message: (input) =>
        randomId<MessageId, typeof input>({
          kind: "message",
          prefix: "message",
          parts: ["thread", input.threadId, "ordinal", input.ordinal],
          make: MessageId.make,
        })(input),
      providerSession: (input) =>
        randomId<ProviderSessionId, typeof input>({
          kind: "provider_session",
          prefix: "provider-session",
          parts: ["provider-instance", input.providerInstanceId, "thread", input.threadId],
          make: ProviderSessionId.make,
        })(input),
      runtimeRequest: (input) =>
        randomId<RuntimeRequestId, typeof input>({
          kind: "runtime_request",
          prefix: "runtime-request",
          parts: [
            "provider",
            input.driver,
            ...(input.providerTurnId === undefined ? [] : ["provider-turn", input.providerTurnId]),
            ...(input.nativeRequestId === undefined
              ? []
              : ["native-request", input.nativeRequestId]),
          ],
          make: RuntimeRequestId.make,
        })(input),
      checkpointScope: (input) =>
        Effect.succeed(
          CheckpointScopeId.make(
            joinId("checkpoint-scope", "thread", input.threadId, "name", input.name),
          ),
        ),
      checkpoint: (input) =>
        Effect.succeed(
          CheckpointId.make(
            joinId("checkpoint", "scope", input.checkpointScopeId, "name", input.name),
          ),
        ),
      contextHandoff: (input) =>
        randomId<ContextHandoffId, typeof input>({
          kind: "context_handoff",
          prefix: "context-handoff",
          parts: [
            "thread",
            input.threadId,
            "from-provider-instance",
            input.fromProviderInstanceId,
            "to-provider-instance",
            input.toProviderInstanceId,
          ],
          make: ContextHandoffId.make,
        })(input),
      contextTransfer: (input) =>
        randomId<ContextTransferId, typeof input>({
          kind: "context_transfer",
          prefix: "context-transfer",
          parts: [
            "type",
            input.type,
            "source-thread",
            input.sourceThreadId,
            "target-thread",
            input.targetThreadId,
          ],
          make: ContextTransferId.make,
        })(input),
      plan: (input) =>
        randomId<PlanId, typeof input>({
          kind: "plan",
          prefix: "plan",
          parts: [
            "thread",
            input.threadId,
            "provider",
            input.driver,
            ...(input.runId === undefined ? [] : ["run", input.runId]),
          ],
          make: PlanId.make,
        })(input),
    },
    derive,
  }),
);