@maiaos/sdk 0.1.0-canary.2

package/dist/request/maia-client.d.ts

@@ -0,0 +1,21 @@
+import type { ProtocolRequestEnvelope, RuntimeParser } from "@maiaos/protocol";
+export type CancellationSignal = AbortSignal;
+export type TransportRequestOptions = {
+    readonly signal?: CancellationSignal;
+};
+export type MaiaTransport = {
+    readonly request: (envelope: ProtocolRequestEnvelope<unknown>, options?: TransportRequestOptions) => Promise<unknown>;
+};
+export type RuntimeSchema<TValue> = RuntimeParser<TValue>;
+export type MaiaRequest<TInput, TOutput> = {
+    readonly inputSchema: RuntimeSchema<TInput>;
+    readonly messageId: string;
+    readonly outputSchema: RuntimeSchema<TOutput>;
+    readonly payload: TInput;
+    readonly signal?: CancellationSignal;
+};
+export type MaiaClient = {
+    readonly request: <TInput, TOutput>(request: MaiaRequest<TInput, TOutput>) => Promise<TOutput>;
+};
+export declare const createMaiaClient: (transport: MaiaTransport) => MaiaClient;
+//# sourceMappingURL=maia-client.d.ts.map

package/dist/request/maia-client.js

@@ -0,0 +1,9 @@
+import * as Effect from "effect/Effect";
+import { executeMaiaRequest, fromPromiseTransport } from "./effect.js";
+export const createMaiaClient = (transport) => {
+    const effectTransport = fromPromiseTransport(transport);
+    return {
+        request: (request) => Effect.runPromise(executeMaiaRequest(effectTransport, request)),
+    };
+};
+//# sourceMappingURL=maia-client.js.map

package/dist/request/options.d.ts

@@ -0,0 +1,9 @@
+import type { LocalNodeRequestPayload } from "@maiaos/protocol";
+export type LocalNodeRequestOptions = {
+    readonly messageId: string;
+    readonly signal?: AbortSignal;
+};
+export type LocalNodeRequester = <TOutput>(payload: LocalNodeRequestPayload, outputSchema: {
+    readonly parse: (value: unknown) => TOutput;
+}, options: LocalNodeRequestOptions) => Promise<TOutput>;
+//# sourceMappingURL=options.d.ts.map

package/dist/request/options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=options.js.map

package/dist/run-ledger/effect.d.ts

@@ -0,0 +1,5 @@
+import { type EffectClient, type LocalNodeEffectRequester } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+import type { RunLedgerClient } from "./run-ledger.js";
+export declare const makeRunLedgerOperations: <TError>(request: LocalNodeEffectRequester<TError>) => EffectClient<RunLedgerClient, MaiaClientError | TError>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/run-ledger/effect.js

@@ -0,0 +1,72 @@
+import { runLedgerCreateResultSchema, runLedgerListResultSchema, runLedgerTaskDispatchResultSchema, runLedgerTaskListResultSchema, runLedgerTaskSettleResultSchema, runLedgerTaskShowResultSchema, } from "@maiaos/protocol";
+import { verifiedMutation, } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+const requireMatch = (matches) => {
+    if (!matches)
+        throw new MaiaClientError("invalid_response", "The Run ledger response did not match the request.");
+};
+const parseCreate = (value, input) => {
+    const result = runLedgerCreateResultSchema.parse(value);
+    requireMatch(result.commandId === input.commandId &&
+        result.run.workspaceId === input.workspaceId &&
+        result.tasks.map((task) => task.clientKey).join("\n") ===
+            input.tasks.map((task) => task.clientKey).join("\n"));
+    return result;
+};
+const parseDispatch = (value, input) => {
+    const result = runLedgerTaskDispatchResultSchema.parse(value);
+    requireMatch(result.commandId === input.commandId &&
+        result.task.runId === input.runId &&
+        result.task.id === input.taskId &&
+        result.dispatch.sessionId === input.sessionId &&
+        BigInt(result.task.revision) === BigInt(input.expectedTaskRevision) + 1n);
+    return result;
+};
+const parseSettle = (value, input) => {
+    const result = runLedgerTaskSettleResultSchema.parse(value);
+    const settled = result.task.dispatches.at(-1);
+    requireMatch(result.commandId === input.commandId &&
+        result.task.runId === input.runId &&
+        result.task.id === input.taskId &&
+        settled?.sessionId === input.sessionId &&
+        settled.state === input.outcome &&
+        settled.evidence === input.evidence &&
+        (input.turnId === undefined || settled.settledTurnId === input.turnId) &&
+        BigInt(result.task.revision) === BigInt(input.expectedTaskRevision) + 1n);
+    return result;
+};
+const parseList = (value, input) => {
+    const result = runLedgerListResultSchema.parse(value);
+    requireMatch(result.items.length <= input.limit &&
+        result.items.every((run) => run.workspaceId === input.workspaceId) &&
+        (result.nextCursor === undefined ||
+            result.nextCursor !== input.afterCursor));
+    return result;
+};
+const parseTaskList = (value, input) => {
+    const result = runLedgerTaskListResultSchema.parse(value);
+    requireMatch(result.run.id === input.runId &&
+        (input.ready !== true ||
+            result.items.every((task) => task.state === "ready")));
+    return result;
+};
+const parseTaskShow = (value, input) => {
+    const result = runLedgerTaskShowResultSchema.parse(value);
+    requireMatch(result.task.runId === input.runId && result.task.id === input.taskId);
+    return result;
+};
+const makeRunLedgerMutations = (request) => ({
+    createRunLedger: (parameters, options) => request({ method: "run.ledger.create", parameters }, { parse: (value) => parseCreate(value, parameters) }, options),
+    dispatchRunLedgerTask: (parameters, options) => request({ method: "run.ledger.task.dispatch", parameters }, { parse: (value) => parseDispatch(value, parameters) }, options),
+    settleRunLedgerTask: (parameters, options) => request({ method: "run.ledger.task.settle", parameters }, { parse: (value) => parseSettle(value, parameters) }, options),
+});
+export const makeRunLedgerOperations = (request) => {
+    const verified = (payload, output, options) => verifiedMutation(request(payload, output, options), options);
+    return {
+        ...makeRunLedgerMutations(verified),
+        listRunLedgers: (parameters, options) => request({ method: "run.ledger.list", parameters }, { parse: (value) => parseList(value, parameters) }, options),
+        listRunLedgerTasks: (parameters, options) => request({ method: "run.ledger.task.list", parameters }, { parse: (value) => parseTaskList(value, parameters) }, options),
+        showRunLedgerTask: (parameters, options) => request({ method: "run.ledger.task.show", parameters }, { parse: (value) => parseTaskShow(value, parameters) }, options),
+    };
+};
+//# sourceMappingURL=effect.js.map

package/dist/run-ledger/index.d.ts

@@ -0,0 +1,2 @@
+export { MAX_RUN_LEDGER_EVIDENCE_BYTES, MAX_RUN_LEDGER_FAILED_DISPATCHES, MAX_RUN_LEDGER_LIST_PAGE_SIZE, RUN_LEDGER_ERROR_CODES, RUN_LEDGER_SCHEMA_VERSION, type RunLedgerClient, type RunLedgerCreateParameters, runLedgerCreateParametersSchema, type RunLedgerCreateResult, runLedgerCreateResultSchema, type RunLedgerDispatch, type RunLedgerDispatchSummary, type RunLedgerErrorCode, type RunLedgerListParameters, runLedgerListParametersSchema, type RunLedgerListResult, runLedgerListResultSchema, type RunLedgerRun, type RunLedgerTask, type RunLedgerTaskDispatchParameters, runLedgerTaskDispatchParametersSchema, type RunLedgerTaskDispatchResult, runLedgerTaskDispatchResultSchema, type RunLedgerTaskListParameters, runLedgerTaskListParametersSchema, type RunLedgerTaskListResult, runLedgerTaskListResultSchema, type RunLedgerTaskSettleParameters, runLedgerTaskSettleParametersSchema, type RunLedgerTaskSettleResult, runLedgerTaskSettleResultSchema, type RunLedgerTaskShowParameters, runLedgerTaskShowParametersSchema, type RunLedgerTaskShowResult, runLedgerTaskShowResultSchema, type RunLedgerTaskSummary, } from "./run-ledger.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/run-ledger/index.js

@@ -0,0 +1,2 @@
+export { MAX_RUN_LEDGER_EVIDENCE_BYTES, MAX_RUN_LEDGER_FAILED_DISPATCHES, MAX_RUN_LEDGER_LIST_PAGE_SIZE, RUN_LEDGER_ERROR_CODES, RUN_LEDGER_SCHEMA_VERSION, runLedgerCreateParametersSchema, runLedgerCreateResultSchema, runLedgerListParametersSchema, runLedgerListResultSchema, runLedgerTaskDispatchParametersSchema, runLedgerTaskDispatchResultSchema, runLedgerTaskListParametersSchema, runLedgerTaskListResultSchema, runLedgerTaskSettleParametersSchema, runLedgerTaskSettleResultSchema, runLedgerTaskShowParametersSchema, runLedgerTaskShowResultSchema, } from "./run-ledger.js";
+//# sourceMappingURL=index.js.map

package/dist/run-ledger/run-ledger.d.ts

@@ -0,0 +1,12 @@
+import type { RunLedgerCreateParameters, RunLedgerCreateResult, RunLedgerListParameters, RunLedgerListResult, RunLedgerTaskDispatchParameters, RunLedgerTaskDispatchResult, RunLedgerTaskListParameters, RunLedgerTaskListResult, RunLedgerTaskSettleParameters, RunLedgerTaskSettleResult, RunLedgerTaskShowParameters, RunLedgerTaskShowResult } from "@maiaos/protocol";
+import type { LocalNodeRequestOptions } from "../request/index.js";
+export type RunLedgerClient = {
+    readonly createRunLedger: (parameters: RunLedgerCreateParameters, options: LocalNodeRequestOptions) => Promise<RunLedgerCreateResult>;
+    readonly dispatchRunLedgerTask: (parameters: RunLedgerTaskDispatchParameters, options: LocalNodeRequestOptions) => Promise<RunLedgerTaskDispatchResult>;
+    readonly listRunLedgers: (parameters: RunLedgerListParameters, options: LocalNodeRequestOptions) => Promise<RunLedgerListResult>;
+    readonly listRunLedgerTasks: (parameters: RunLedgerTaskListParameters, options: LocalNodeRequestOptions) => Promise<RunLedgerTaskListResult>;
+    readonly settleRunLedgerTask: (parameters: RunLedgerTaskSettleParameters, options: LocalNodeRequestOptions) => Promise<RunLedgerTaskSettleResult>;
+    readonly showRunLedgerTask: (parameters: RunLedgerTaskShowParameters, options: LocalNodeRequestOptions) => Promise<RunLedgerTaskShowResult>;
+};
+export { MAX_RUN_LEDGER_EVIDENCE_BYTES, MAX_RUN_LEDGER_FAILED_DISPATCHES, MAX_RUN_LEDGER_LIST_PAGE_SIZE, RUN_LEDGER_ERROR_CODES, RUN_LEDGER_SCHEMA_VERSION, type RunLedgerCreateParameters, runLedgerCreateParametersSchema, type RunLedgerCreateResult, runLedgerCreateResultSchema, type RunLedgerDispatch, type RunLedgerDispatchSummary, type RunLedgerErrorCode, type RunLedgerListParameters, runLedgerListParametersSchema, type RunLedgerListResult, runLedgerListResultSchema, type RunLedgerRun, type RunLedgerTask, type RunLedgerTaskDispatchParameters, runLedgerTaskDispatchParametersSchema, type RunLedgerTaskDispatchResult, runLedgerTaskDispatchResultSchema, type RunLedgerTaskListParameters, runLedgerTaskListParametersSchema, type RunLedgerTaskListResult, runLedgerTaskListResultSchema, type RunLedgerTaskSettleParameters, runLedgerTaskSettleParametersSchema, type RunLedgerTaskSettleResult, runLedgerTaskSettleResultSchema, type RunLedgerTaskShowParameters, runLedgerTaskShowParametersSchema, type RunLedgerTaskShowResult, runLedgerTaskShowResultSchema, type RunLedgerTaskSummary, } from "@maiaos/protocol";
+//# sourceMappingURL=run-ledger.d.ts.map

package/dist/run-ledger/run-ledger.js

@@ -0,0 +1,2 @@
+export { MAX_RUN_LEDGER_EVIDENCE_BYTES, MAX_RUN_LEDGER_FAILED_DISPATCHES, MAX_RUN_LEDGER_LIST_PAGE_SIZE, RUN_LEDGER_ERROR_CODES, RUN_LEDGER_SCHEMA_VERSION, runLedgerCreateParametersSchema, runLedgerCreateResultSchema, runLedgerListParametersSchema, runLedgerListResultSchema, runLedgerTaskDispatchParametersSchema, runLedgerTaskDispatchResultSchema, runLedgerTaskListParametersSchema, runLedgerTaskListResultSchema, runLedgerTaskSettleParametersSchema, runLedgerTaskSettleResultSchema, runLedgerTaskShowParametersSchema, runLedgerTaskShowResultSchema, } from "@maiaos/protocol";
+//# sourceMappingURL=run-ledger.js.map

package/dist/session/effect.d.ts

@@ -0,0 +1,4 @@
+import type { EffectClient, LocalNodeEffectRequester } from "../request/effect.js";
+import type { SessionMailboxClient } from "./mailbox.js";
+export declare const makeSessionMailboxOperations: <TError>(request: LocalNodeEffectRequester<TError>) => EffectClient<SessionMailboxClient, TError>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/session/effect.js

@@ -0,0 +1,7 @@
+import { sessionInboxAckResultSchema, sessionInboxCheckResultSchema, sessionMessageSendResultSchema, } from "@maiaos/protocol";
+export const makeSessionMailboxOperations = (request) => ({
+    acknowledgeSessionDelivery: (parameters, options) => request({ method: "session.inbox.ack", parameters }, sessionInboxAckResultSchema, options),
+    checkSessionInbox: (parameters, options) => request({ method: "session.inbox.check", parameters }, sessionInboxCheckResultSchema, options),
+    sendSessionMessage: (parameters, options) => request({ method: "session.message.send", parameters }, sessionMessageSendResultSchema, options),
+});
+//# sourceMappingURL=effect.js.map

package/dist/session/index.d.ts

@@ -0,0 +1,2 @@
+export { makeSessionMailboxClient, type SessionMailboxClient, } from "./mailbox.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/session/index.js

@@ -0,0 +1,2 @@
+export { makeSessionMailboxClient, } from "./mailbox.js";
+//# sourceMappingURL=index.js.map

package/dist/session/mailbox.d.ts

@@ -0,0 +1,9 @@
+import type { SessionInboxAckParameters, SessionInboxAckResult, SessionInboxCheckParameters, SessionInboxCheckResult, SessionMessageSendParameters, SessionMessageSendResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type SessionMailboxClient = {
+    readonly acknowledgeSessionDelivery: (parameters: SessionInboxAckParameters, options: LocalNodeRequestOptions) => Promise<SessionInboxAckResult>;
+    readonly checkSessionInbox: (parameters: SessionInboxCheckParameters, options: LocalNodeRequestOptions) => Promise<SessionInboxCheckResult>;
+    readonly sendSessionMessage: (parameters: SessionMessageSendParameters, options: LocalNodeRequestOptions) => Promise<SessionMessageSendResult>;
+};
+export declare const makeSessionMailboxClient: (request: LocalNodeRequester) => SessionMailboxClient;
+//# sourceMappingURL=mailbox.d.ts.map

package/dist/session/mailbox.js

@@ -0,0 +1,4 @@
+import { fromPromiseRequester, toPromiseClient } from "../request/effect.js";
+import { makeSessionMailboxOperations } from "./effect.js";
+export const makeSessionMailboxClient = (request) => toPromiseClient(makeSessionMailboxOperations(fromPromiseRequester(request)));
+//# sourceMappingURL=mailbox.js.map

package/dist/session-creation/effect.d.ts

@@ -0,0 +1,25 @@
+import type { Session } from "@maiaos/protocol";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import type { EffectClient } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+import { type SessionCreationClient, type SessionCreationInput, type SessionCreationOutcome, type SessionCreationPlan } from "./tasks.js";
+export type SessionCreationEffectClient<TError = MaiaClientError> = EffectClient<SessionCreationClient, TError>;
+export type NextIdentifier = (prefix: "command" | "request") => Effect.Effect<string>;
+export declare const fromPromiseClient: <TClient extends Partial<SessionCreationClient>>(client: TClient) => EffectClient<TClient, unknown>;
+export declare const planSessionCreationWith: <TError>(client: SessionCreationEffectClient<TError>, input: SessionCreationInput, nextId: NextIdentifier) => Effect.Effect<SessionCreationPlan, MaiaClientError | TError>;
+export declare const awaitSessionRunningWith: <TError>(client: Pick<SessionCreationEffectClient<TError>, "showSession">, sessionId: string, options: {
+    readonly deadlineMilliseconds: number;
+    readonly nextId: NextIdentifier;
+}) => Effect.Effect<Session, MaiaClientError | TError>;
+type RunOptions = {
+    readonly nextId: NextIdentifier;
+    readonly previous?: readonly SessionCreationOutcome[];
+    readonly report?: (outcomes: readonly SessionCreationOutcome[]) => Effect.Effect<void>;
+};
+export declare const createSessionsWith: <TError>(client: SessionCreationEffectClient<TError>, plan: SessionCreationPlan, options: RunOptions) => Effect.Effect<readonly SessionCreationOutcome[]>;
+export declare const planSessionCreationEffect: (client: SessionCreationEffectClient, input: SessionCreationInput) => Effect.Effect<SessionCreationPlan, MaiaClientError, Crypto.Crypto>;
+export declare const createSessionsEffect: (client: SessionCreationEffectClient, plan: SessionCreationPlan, options?: Omit<RunOptions, "nextId">) => Effect.Effect<readonly SessionCreationOutcome[], never, Crypto.Crypto>;
+export declare const awaitSessionRunningEffect: (client: Pick<SessionCreationEffectClient, "showSession">, sessionId: string, deadlineMilliseconds: number) => Effect.Effect<Session, MaiaClientError, Crypto.Crypto>;
+export {};
+//# sourceMappingURL=effect.d.ts.map

package/dist/session-creation/effect.js

@@ -0,0 +1,269 @@
+import * as Crypto from "effect/Crypto";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import * as Schedule from "effect/Schedule";
+import { classifyClientError, MaiaClientError } from "../request/index.js";
+import { orderExecutionWorkspaces, sessionCreationSettled, splitTasks, } from "./tasks.js";
+const ITEM_CONCURRENCY = 4;
+const RUNNING_DEADLINE_MILLISECONDS = 120_000;
+const WORKSPACE_PAGE = 100;
+export const fromPromiseClient = (client) => Object.fromEntries(Object.entries(client).map(([name, operation]) => [
+    name,
+    (parameters, options) => Effect.tryPromise({
+        catch: (error) => error,
+        try: (signal) => operation(parameters, { ...options, signal }),
+    }),
+]));
+const invalid = (message) => new MaiaClientError("invalid_request", message);
+const pickWorkspace = (workspaces, workspaceId) => {
+    const ready = orderExecutionWorkspaces(workspaces);
+    const chosen = workspaceId === undefined
+        ? ready[0]
+        : ready.find((workspace) => workspace.id === workspaceId);
+    return chosen === undefined
+        ? Effect.fail(invalid("The Project has no ready execution Workspace by that ID."))
+        : Effect.succeed(chosen.id);
+};
+const chooseWorkspace = (client, input, nextId) => {
+    const { projectId, workspaceId } = input;
+    if (projectId === undefined)
+        return workspaceId === undefined
+            ? Effect.fail(invalid("Name a Project or a Workspace."))
+            : Effect.succeed(workspaceId);
+    return nextId("request").pipe(Effect.flatMap((messageId) => client.listWorkspaces({ afterCursor: "0", limit: WORKSPACE_PAGE, projectId }, { messageId })), Effect.flatMap((page) => pickWorkspace(page.items, workspaceId)));
+};
+const mintCommands = (nextId) => Effect.all({
+    create: nextId("command"),
+    send: nextId("command"),
+    start: nextId("command"),
+});
+export const planSessionCreationWith = (client, input, nextId) => Effect.gen(function* () {
+    const { accepted, refusals } = splitTasks(input);
+    if (accepted.length === 0)
+        return yield* Effect.fail(invalid("Add at least one task line."));
+    const workspaceId = yield* chooseWorkspace(client, input, nextId);
+    const items = yield* Effect.forEach(accepted, (entry, index) => Effect.map(mintCommands(nextId), (commands) => ({
+        commands,
+        index,
+        ...entry,
+    })));
+    return { items, refusals, session: input.session, workspaceId };
+});
+const STOPPED_STATES = new Set([
+    "failed",
+    "stopped",
+    "stopping",
+]);
+const SETTLED_STATES = new Set([
+    ...STOPPED_STATES,
+    "running",
+]);
+const backoff = Schedule.min([
+    Schedule.exponential("250 millis"),
+    Schedule.spaced("2 seconds"),
+]);
+const neverSeen = () => new MaiaClientError("deadline_exceeded", "The Session did not answer before the deadline.");
+const showWhileOffline = (client, sessionId, nextId) => nextId("request").pipe(Effect.flatMap((messageId) => client.showSession({ sessionId }, { messageId })), Effect.map((result) => result.session), Effect.retry({
+    schedule: backoff,
+    while: (error) => classifyClientError(error, { mutation: false }).kind === "offline",
+}));
+export const awaitSessionRunningWith = (client, sessionId, options) => Effect.flatMap(Ref.make(Option.none()), (last) => showWhileOffline(client, sessionId, options.nextId).pipe(Effect.tap((session) => Ref.set(last, Option.some(session))), Effect.repeat({
+    schedule: backoff,
+    until: (session) => SETTLED_STATES.has(session.state),
+}), Effect.timeoutOrElse({
+    duration: options.deadlineMilliseconds,
+    orElse: () => Effect.flatMap(Ref.get(last), (seen) => Option.match(seen, {
+        onNone: () => Effect.fail(neverSeen()),
+        onSome: (session) => Effect.succeed(session),
+    })),
+})));
+class StepFailure extends Data.TaggedError("SessionCreationStepFailure") {
+}
+const update = (context, change) => Ref.update(context.outcome, change).pipe(Effect.andThen(context.publish));
+const send = (context, step) => update(context, ({ error: _error, ...outcome }) => ({
+    ...outcome,
+    sent: step.record(outcome.sent),
+})).pipe(Effect.andThen(context.nextId("request")), Effect.flatMap((messageId) => step.request(step.parameters, { messageId })), Effect.mapError((cause) => new StepFailure({ cause, operation: step.operation })));
+const sentBefore = (context) => Effect.map(Ref.get(context.outcome), (outcome) => outcome.sent);
+const createStep = (context, item) => Effect.gen(function* () {
+    const parameters = (yield* sentBefore(context))
+        .create ?? {
+        ...context.plan.session,
+        commandId: item.commands.create,
+        expectedRevision: "0",
+        workspaceId: context.plan.workspaceId,
+    };
+    const result = yield* send(context, {
+        operation: "session.create",
+        parameters,
+        record: (sent) => ({ ...sent, create: parameters }),
+        request: context.client.createSession,
+    });
+    yield* update(context, (outcome) => ({
+        ...outcome,
+        receipts: { ...outcome.receipts, create: result.receipt },
+        sessionId: result.session.id,
+        stage: "created",
+    }));
+    return result.session;
+});
+const startStep = (context, item, session) => Effect.gen(function* () {
+    const parameters = (yield* sentBefore(context))
+        .start ?? {
+        commandId: item.commands.start,
+        expectedRevision: session.revision,
+        sessionId: session.id,
+    };
+    const result = yield* send(context, {
+        operation: "session.start",
+        parameters,
+        record: (sent) => ({ ...sent, start: parameters }),
+        request: context.client.startSession,
+    });
+    yield* update(context, (outcome) => ({
+        ...outcome,
+        receipts: { ...outcome.receipts, start: result.receipt },
+        stage: "started",
+    }));
+});
+const runningStep = (context, sessionId) => awaitSessionRunningWith(context.client, sessionId, {
+    deadlineMilliseconds: RUNNING_DEADLINE_MILLISECONDS,
+    nextId: context.nextId,
+}).pipe(Effect.mapError((cause) => new StepFailure({ cause, operation: "session.show" })), Effect.filterOrFail((session) => session.state === "running", (session) => new StepFailure({
+    operation: "session.show",
+    state: session.state,
+    ...(session.failure === undefined
+        ? {}
+        : { failure: session.failure }),
+})), Effect.tap(() => update(context, (outcome) => ({ ...outcome, stage: "running" }))));
+const sendStep = (context, item, session) => Effect.gen(function* () {
+    const parameters = (yield* sentBefore(context))
+        .send ?? {
+        commandId: item.commands.send,
+        expectedRevision: session.revision,
+        input: { text: item.task, type: "text" },
+        sessionId: session.id,
+    };
+    const result = yield* send(context, {
+        operation: "turn.send",
+        parameters,
+        record: (sent) => ({ ...sent, send: parameters }),
+        request: context.client.sendTurn,
+    });
+    yield* update(context, (outcome) => ({
+        ...outcome,
+        receipts: { ...outcome.receipts, send: result.receipt },
+        stage: "sent",
+        turnId: result.turn.id,
+    }));
+});
+const failedCommand = (sent, operationId) => {
+    switch (operationId) {
+        case "session.create":
+            return sent.create?.commandId;
+        case "session.start":
+            return sent.start?.commandId;
+        case "turn.send":
+            return sent.send?.commandId;
+        case "session.show":
+            return undefined;
+    }
+};
+const failedOutcome = (outcome, failure) => {
+    const operationId = failure.operation;
+    const error = failure.state === undefined
+        ? classifyClientError(failure.cause, {
+            mutation: operationId !== "session.show",
+            operationId,
+        })
+        : {
+            _tag: "MaiaError",
+            code: `session_${failure.state}`,
+            kind: "refused",
+            operationId,
+            retryable: !STOPPED_STATES.has(failure.state),
+        };
+    const commandId = failedCommand(outcome.sent, operationId);
+    return {
+        ...outcome,
+        error: {
+            ...error,
+            ...(commandId === undefined ? {} : { commandId }),
+            ...(failure.failure === undefined ? {} : { failure: failure.failure }),
+            operationId,
+        },
+        stage: error.kind === "outcome_unknown" ? "unknown" : "refused",
+    };
+};
+const runItem = (context, item) => Effect.gen(function* () {
+    const created = yield* createStep(context, item);
+    yield* startStep(context, item, created);
+    const { task } = item;
+    if (task === undefined)
+        return;
+    const replay = (yield* sentBefore(context)).send !== undefined;
+    const running = replay ? created : yield* runningStep(context, created.id);
+    yield* sendStep(context, { ...item, task }, running);
+}).pipe(Effect.catch((error) => update(context, (outcome) => failedOutcome(outcome, error))));
+const pending = (item) => ({
+    index: item.index,
+    receipts: {},
+    sent: {},
+    stage: "pending",
+});
+const publisher = (outcomes, report) => report === undefined
+    ? Effect.void
+    : Effect.flatMap(Effect.forEach(outcomes, Ref.get), report);
+const belongsTo = (plan, item, { sent }) => (sent.create === undefined ||
+    (sent.create.commandId === item.commands.create &&
+        sent.create.workspaceId === plan.workspaceId)) &&
+    (sent.start === undefined || sent.start.commandId === item.commands.start) &&
+    (sent.send === undefined ||
+        (sent.send.commandId === item.commands.send &&
+            sent.send.input.text === item.task));
+const foreign = (item) => ({
+    error: {
+        _tag: "MaiaError",
+        code: "previous_mismatch",
+        kind: "invalid",
+        operationId: "session.create",
+        retryable: false,
+    },
+    index: item.index,
+    receipts: {},
+    sent: {},
+    stage: "refused",
+});
+const startingOutcomes = (plan, previous) => plan.items.map((item) => {
+    const prior = previous?.find((outcome) => outcome.index === item.index);
+    if (prior === undefined)
+        return [pending(item), true];
+    return belongsTo(plan, item, prior)
+        ? [prior, !sessionCreationSettled(prior, item)]
+        : [foreign(item), false];
+});
+export const createSessionsWith = (client, plan, options) => Effect.gen(function* () {
+    const starting = startingOutcomes(plan, options.previous);
+    const outcomes = yield* Effect.forEach(starting, ([outcome]) => Ref.make(outcome));
+    const publish = publisher(outcomes, options.report);
+    const { nextId } = options;
+    yield* publish;
+    yield* Effect.forEach(plan.items, (item, index) => {
+        const outcome = outcomes[index];
+        return outcome === undefined || starting[index]?.[1] !== true
+            ? Effect.void
+            : runItem({ client, nextId, outcome, plan, publish }, item);
+    }, { concurrency: ITEM_CONCURRENCY, discard: true });
+    return yield* Effect.forEach(outcomes, Ref.get);
+});
+const cryptoIdentifier = (crypto) => (prefix) => Effect.map(Effect.orDie(crypto.randomUUIDv4), (uuid) => `${prefix}_${uuid.replaceAll("-", "")}`);
+const withCrypto = (program) => Effect.flatMap(Crypto.Crypto, (crypto) => program(cryptoIdentifier(crypto)));
+export const planSessionCreationEffect = (client, input) => withCrypto((nextId) => planSessionCreationWith(client, input, nextId));
+export const createSessionsEffect = (client, plan, options = {}) => withCrypto((nextId) => createSessionsWith(client, plan, { ...options, nextId }));
+export const awaitSessionRunningEffect = (client, sessionId, deadlineMilliseconds) => withCrypto((nextId) => awaitSessionRunningWith(client, sessionId, {
+    deadlineMilliseconds,
+    nextId,
+}));
+//# sourceMappingURL=effect.js.map

package/dist/session-creation/index.d.ts

@@ -0,0 +1,3 @@
+export { awaitSessionRunning, createSessions, type NewIdentifier, planSessionCreation, } from "./session-creation.js";
+export { MAX_SESSION_CREATION_TASKS, orderExecutionWorkspaces, type SessionCreationClient, type SessionCreationInput, type SessionCreationItem, type SessionCreationOperation, type SessionCreationOutcome, type SessionCreationPlan, type SessionCreationReceipts, type SessionCreationRefusal, type SessionCreationStage, type SessionCreationTemplate, } from "./tasks.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/session-creation/index.js

@@ -0,0 +1,3 @@
+export { awaitSessionRunning, createSessions, planSessionCreation, } from "./session-creation.js";
+export { MAX_SESSION_CREATION_TASKS, orderExecutionWorkspaces, } from "./tasks.js";
+//# sourceMappingURL=index.js.map

package/dist/session-creation/session-creation.d.ts

@@ -0,0 +1,18 @@
+import type { Session } from "@maiaos/protocol";
+import type { LocalNodeClient } from "../client/index.js";
+import type { SessionCreationClient, SessionCreationInput, SessionCreationOutcome, SessionCreationPlan } from "./tasks.js";
+export type NewIdentifier = (prefix: "command" | "request") => string;
+type FacadeOptions = {
+    readonly newId: NewIdentifier;
+    readonly signal?: AbortSignal;
+};
+export declare const planSessionCreation: (client: SessionCreationClient, input: SessionCreationInput, options: FacadeOptions) => Promise<SessionCreationPlan>;
+export declare const createSessions: (client: SessionCreationClient, plan: SessionCreationPlan, options: FacadeOptions & {
+    readonly onProgress?: (outcomes: readonly SessionCreationOutcome[]) => void;
+    readonly previous?: readonly SessionCreationOutcome[];
+}) => Promise<readonly SessionCreationOutcome[]>;
+export declare const awaitSessionRunning: (client: Pick<LocalNodeClient, "showSession">, sessionId: string, options: FacadeOptions & {
+    readonly deadlineMilliseconds: number;
+}) => Promise<Session>;
+export {};
+//# sourceMappingURL=session-creation.d.ts.map

package/dist/session-creation/session-creation.js

@@ -0,0 +1,24 @@
+import * as Effect from "effect/Effect";
+import { awaitSessionRunningWith, createSessionsWith, fromPromiseClient, planSessionCreationWith, } from "./effect.js";
+const run = (program, signal) => Effect.runPromise(program, signal === undefined ? undefined : { signal });
+const nextId = (newId) => (prefix) => Effect.sync(() => newId(prefix));
+export const planSessionCreation = (client, input, options) => run(planSessionCreationWith(fromPromiseClient(client), input, nextId(options.newId)), options.signal);
+export const createSessions = (client, plan, options) => {
+    const { newId, onProgress, previous, signal } = options;
+    return run(createSessionsWith(fromPromiseClient(client), plan, {
+        nextId: nextId(newId),
+        ...(previous === undefined ? {} : { previous }),
+        ...(onProgress === undefined
+            ? {}
+            : {
+                report: (outcomes) => Effect.ignore(Effect.try(() => {
+                    onProgress(outcomes);
+                })),
+            }),
+    }), signal);
+};
+export const awaitSessionRunning = (client, sessionId, options) => run(awaitSessionRunningWith(fromPromiseClient(client), sessionId, {
+    deadlineMilliseconds: options.deadlineMilliseconds,
+    nextId: nextId(options.newId),
+}), options.signal);
+//# sourceMappingURL=session-creation.js.map

package/dist/session-creation/tasks.d.ts

@@ -0,0 +1,69 @@
+import { type CommandReceipt, type FailureDetail, type SessionCreateParameters, type SessionStartParameters, type TurnSendParameters, type Workspace } from "@maiaos/protocol";
+import type { LocalNodeClient } from "../client/index.js";
+import type { MaiaError } from "../request/index.js";
+export declare const MAX_SESSION_CREATION_TASKS = 32;
+export type SessionCreationTemplate = Omit<SessionCreateParameters, "commandId" | "expectedRevision" | "workspaceId">;
+export type SessionCreationInput = {
+    readonly projectId?: string;
+    readonly session: SessionCreationTemplate;
+    readonly split: "lines" | "whole";
+    readonly text: string;
+    readonly workspaceId?: string;
+};
+export type SessionCreationItem = {
+    readonly commands: {
+        readonly create: string;
+        readonly send: string;
+        readonly start: string;
+    };
+    readonly index: number;
+    readonly line: number;
+    readonly task?: string;
+};
+export type SessionCreationRefusal = {
+    readonly line: number;
+    readonly reason: "over_batch_limit" | "too_long";
+};
+export type SessionCreationPlan = {
+    readonly items: readonly SessionCreationItem[];
+    readonly refusals: readonly SessionCreationRefusal[];
+    readonly session: SessionCreationTemplate;
+    readonly workspaceId: string;
+};
+export type SessionCreationStage = "created" | "pending" | "refused" | "running" | "sent" | "started" | "unknown";
+export type SessionCreationOperation = "session.create" | "session.show" | "session.start" | "turn.send";
+export type SessionCreationReceipts = {
+    readonly create?: CommandReceipt;
+    readonly send?: CommandReceipt;
+    readonly start?: CommandReceipt;
+};
+export type SessionCreationOutcome = {
+    readonly error?: MaiaError & {
+        readonly commandId?: string;
+        readonly failure?: FailureDetail;
+        readonly operationId: SessionCreationOperation;
+    };
+    readonly index: number;
+    readonly receipts: SessionCreationReceipts;
+    readonly sent: {
+        readonly create?: SessionCreateParameters;
+        readonly send?: TurnSendParameters;
+        readonly start?: SessionStartParameters;
+    };
+    readonly sessionId?: string;
+    readonly stage: SessionCreationStage;
+    readonly turnId?: string;
+};
+export type SessionCreationClient = Pick<LocalNodeClient, "createSession" | "listWorkspaces" | "sendTurn" | "showSession" | "startSession">;
+export declare const orderExecutionWorkspaces: (workspaces: readonly Workspace[]) => readonly Workspace[];
+type TaskLine = {
+    readonly line: number;
+    readonly task?: string;
+};
+export declare const splitTasks: (input: SessionCreationInput) => {
+    readonly accepted: readonly TaskLine[];
+    readonly refusals: readonly SessionCreationRefusal[];
+};
+export declare const sessionCreationSettled: (outcome: SessionCreationOutcome, item: SessionCreationItem) => boolean;
+export {};
+//# sourceMappingURL=tasks.d.ts.map