@ai-agent-forge/agent-forge 0.85.0

package/dist/remote/server-assembly.js

@@ -0,0 +1,1189 @@
+/**
+ * Minimal coding-agent runtime -> remote server assembly (1B.7h).
+ *
+ * Adapts first-party `AgentSession` instances to the public `@agent-forge/server`
+ * session boundary so a preinstalled session adapter can run a deterministic
+ * server end to end. The adapter only consumes the public `AgentSession` surface
+ * and never reads private session objects.
+ *
+ * Snapshot transcripts use positional ids (`t-<index>`) that are stable within
+ * one revision but not across history rewrites such as compaction; snapshots
+ * stay authoritative and durable replay is journal-based, so replay does not
+ * depend on these ids. Streaming is reported as snapshot-change notifications;
+ * amortized delta progress belongs to a later slice.
+ *
+ * Durable operations and artifacts (E4-c): when a `DurableServiceV1` is
+ * supplied, the service exposes the server `operations`/`artifacts` surfaces as
+ * a thin adapter over the durable service — it never creates a second artifact
+ * store. Artifact records project the protocol `ArtifactRef` 1:1 onto the SDK
+ * `OutputArtifactRef` and carry base64 bytes so remote `artifact_stat` /
+ * `artifact_read` survive restarts via the durable log replay; the runtime
+ * in-memory artifact store remains the live write path (built in
+ * capability-runtime). Keyed mutation commands (`operationId` on prompt/steer/
+ * abort/set_model/set_thinking) persist their successful response snapshots as
+ * deterministic `mutation-response:<sessionId>:<operationId>` artifact records
+ * so a retry after a restart replays the recorded response; the server's
+ * in-process LRU stays the live dedup path. Without a durable service the
+ * surfaces stay undefined and the server answers `durable_unavailable` /
+ * `not_implemented` explicitly.
+ *
+ * Deployment boundary: the durable writer lease is process-local memory. This
+ * assembly is single-instance per durable store — the durable backend's file
+ * writes are cross-process mutually exclusive (its `.lock`), while the writer
+ * lease single-instance semantics remain process-local: who should claim the
+ * lease still needs deployment-level coordination. On
+ * startup the service claims the writer lease and, when the restored state
+ * marks a dead writer (snapshot import), recovers it; a live foreign writer
+ * keeps the service unavailable instead of fighting over the lease. Operations
+ * left pending by a crashed process are swept to a rejected terminal so no
+ * submitted operation can hang as `accepted` forever.
+ */
+import { Buffer } from "node:buffer";
+import { randomUUID } from "node:crypto";
+import { PiServer, PiServerError, } from "@agent-forge/server";
+import { DurableServiceErrorV1 } from "../durable/durable-service.js";
+function requireIdle(session, action) {
+    if (!session.isIdle) {
+        throw new PiServerError("busy", `Cannot ${action} while the session is busy`);
+    }
+}
+function toError(error) {
+    if (error instanceof PiServerError)
+        return error;
+    const message = error instanceof Error ? error.message : String(error);
+    if (/reload in progress/i.test(message))
+        return new PiServerError("busy", message);
+    if (/compaction is in progress/i.test(message))
+        return new PiServerError("busy", message);
+    if (/already processing/i.test(message))
+        return new PiServerError("busy", message);
+    // Operational session failures (missing credentials, no active model,
+    // extension rejections) must reach the remote client with their original
+    // message instead of being folded into an unspecific internal error.
+    return new PiServerError("invalid_request", message);
+}
+function jsonSafe(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(jsonSafe);
+    if (typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype)
+        return false;
+    return Object.values(value).every(jsonSafe);
+}
+/** Parses an adapter-owned operation payload; undefined for foreign or malformed records. */
+function parseOperationPayload(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (record.status !== "pending" && record.status !== "completed" && record.status !== "rejected")
+        return undefined;
+    if (typeof record.sessionId !== "string" || record.sessionId === "")
+        return undefined;
+    if (typeof record.operationType !== "string")
+        return undefined;
+    if (typeof record.submittedAt !== "number" || !Number.isFinite(record.submittedAt))
+        return undefined;
+    let error;
+    if (record.error !== undefined) {
+        if (typeof record.error !== "object" || record.error === null || Array.isArray(record.error))
+            return undefined;
+        const entry = record.error;
+        if (typeof entry.code !== "string" || typeof entry.message !== "string")
+            return undefined;
+        error = { code: entry.code, message: entry.message };
+    }
+    return {
+        status: record.status,
+        sessionId: record.sessionId,
+        operationType: record.operationType,
+        ...(typeof record.idempotencyKey === "string" ? { idempotencyKey: record.idempotencyKey } : {}),
+        ...(record.result === undefined ? {} : { result: record.result }),
+        ...(error === undefined ? {} : { error }),
+        submittedAt: record.submittedAt,
+        ...(typeof record.terminalAt === "number" ? { terminalAt: record.terminalAt } : {}),
+    };
+}
+/** Parses an adapter-owned artifact payload; undefined for foreign or malformed records. */
+function parseArtifactPayload(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const ref = record.ref;
+    if (typeof ref !== "object" || ref === null || Array.isArray(ref))
+        return undefined;
+    const entry = ref;
+    if (typeof entry.sessionId !== "string" ||
+        typeof entry.operationId !== "string" ||
+        typeof entry.artifactId !== "string" ||
+        typeof entry.kind !== "string" ||
+        typeof entry.mediaType !== "string" ||
+        typeof entry.truncated !== "boolean" ||
+        typeof entry.createdAt !== "number" ||
+        typeof record.bytes !== "string") {
+        return undefined;
+    }
+    return {
+        ref: {
+            sessionId: entry.sessionId,
+            operationId: entry.operationId,
+            artifactId: entry.artifactId,
+            kind: entry.kind,
+            mediaType: entry.mediaType,
+            ...(typeof entry.sizeBytes === "number" ? { sizeBytes: entry.sizeBytes } : {}),
+            truncated: entry.truncated,
+            createdAt: entry.createdAt,
+        },
+        bytes: record.bytes,
+    };
+}
+/**
+ * Parses a stored mutation-response payload; undefined for foreign or
+ * malformed records. The required-field assertion is deliberately minimal: the
+ * full `SessionSnapshot` shape is already enforced by the wire codec when the
+ * replayed snapshot is encoded into a response, so a damaged record only needs
+ * to fail this check to fall back to a fresh execution.
+ */
+function parseMutationResponsePayload(value, sessionId) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (record.id !== sessionId ||
+        typeof record.cwd !== "string" ||
+        record.cwd === "" ||
+        typeof record.revision !== "number" ||
+        !Number.isInteger(record.revision) ||
+        record.revision < 0 ||
+        !Array.isArray(record.transcript)) {
+        return undefined;
+    }
+    return value;
+}
+/** Protocol `ArtifactRef` is a 1:1 projection of the SDK `OutputArtifactRef`. */
+function toProtocolArtifactRef(ref) {
+    return {
+        sessionId: ref.sessionId,
+        operationId: ref.operationId,
+        artifactId: ref.artifactId,
+        kind: ref.kind,
+        mediaType: ref.mediaType,
+        ...(ref.sizeBytes === undefined ? {} : { sizeBytes: ref.sizeBytes }),
+        truncated: ref.truncated,
+        createdAt: ref.createdAt,
+    };
+}
+function projectUsage(usage) {
+    if (!usage || typeof usage !== "object" || Array.isArray(usage))
+        return undefined;
+    const record = usage;
+    const readCount = (key) => {
+        const value = record[key];
+        return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : undefined;
+    };
+    const input = readCount("input");
+    const output = readCount("output");
+    const cacheRead = readCount("cacheRead");
+    const cacheWrite = readCount("cacheWrite");
+    const totalTokens = readCount("totalTokens");
+    if (input === undefined || output === undefined || cacheRead === undefined || cacheWrite === undefined) {
+        return undefined;
+    }
+    if (totalTokens === undefined)
+        return undefined;
+    const cost = record.cost;
+    if (!cost || typeof cost !== "object" || Array.isArray(cost))
+        return undefined;
+    const costRecord = cost;
+    const readCost = (key) => {
+        const value = costRecord[key];
+        return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+    };
+    const costInput = readCost("input");
+    const costOutput = readCost("output");
+    const costCacheRead = readCost("cacheRead");
+    const costCacheWrite = readCost("cacheWrite");
+    const costTotal = readCost("total");
+    if (costInput === undefined ||
+        costOutput === undefined ||
+        costCacheRead === undefined ||
+        costCacheWrite === undefined ||
+        costTotal === undefined) {
+        return undefined;
+    }
+    const reasoning = readCount("reasoning");
+    return {
+        input,
+        output,
+        cacheRead,
+        cacheWrite,
+        ...(reasoning === undefined ? {} : { reasoning }),
+        totalTokens,
+        cost: {
+            input: costInput,
+            output: costOutput,
+            cacheRead: costCacheRead,
+            cacheWrite: costCacheWrite,
+            total: costTotal,
+        },
+    };
+}
+function projectUserContent(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    const projected = [];
+    for (const part of content) {
+        if (!part || typeof part !== "object")
+            continue;
+        const record = part;
+        if (record.type === "text" && typeof record.text === "string") {
+            projected.push({ type: "text", text: record.text });
+        }
+        else if (record.type === "image" && typeof record.data === "string" && typeof record.mimeType === "string") {
+            projected.push({ type: "image", data: record.data, mimeType: record.mimeType });
+        }
+    }
+    return projected;
+}
+function projectToolResultContent(content) {
+    return projectUserContent(content);
+}
+/**
+ * Projects the current `AgentSession` messages onto the protocol transcript.
+ * Tool inputs are recovered from the matching assistant `toolCall` content;
+ * `null` marks an unrecoverable input instead of fabricating one. `!`-command
+ * bash executions project as `bash` tool items. Session-level summary and
+ * extension messages (`branchSummary`, `compactionSummary`, `custom`) project
+ * as snapshot-only `note` items; they never enter streaming progress. Note
+ * items carry the text/summary face only — custom-message `details` and image
+ * content parts are not projected. Item ids
+ * stay positional (`t-<index>`): they are stable within one revision but not
+ * across history rewrites such as compaction.
+ */
+export function projectSessionTranscript(session) {
+    const messages = session.messages;
+    const toolInputs = new Map();
+    for (const message of messages) {
+        if (message.role !== "assistant")
+            continue;
+        for (const part of message.content) {
+            if (part.type === "toolCall")
+                toolInputs.set(part.id, part.arguments);
+        }
+    }
+    const items = [];
+    for (const message of messages) {
+        const id = `t-${items.length}`;
+        const timestamp = Math.max(0, Math.trunc(message.timestamp));
+        if (message.role === "user") {
+            items.push({
+                id,
+                role: "user",
+                content: projectUserContent(message.content),
+                timestamp,
+            });
+            continue;
+        }
+        if (message.role === "toolResult") {
+            const input = toolInputs.get(message.toolCallId);
+            const usage = projectUsage(message.usage);
+            const details = jsonSafe(message.details) ? message.details : undefined;
+            const base = {
+                id,
+                role: "tool",
+                toolCallId: message.toolCallId,
+                toolName: message.toolName,
+                input: input !== undefined && jsonSafe(input) ? input : null,
+                content: projectToolResultContent(message.content),
+                ...(details === undefined ? {} : { details }),
+                ...(usage === undefined ? {} : { usage }),
+                timestamp,
+            };
+            if (message.isError) {
+                const item = { ...base, status: "error", isError: true };
+                items.push(item);
+            }
+            else {
+                const item = { ...base, status: "complete", isError: false };
+                items.push(item);
+            }
+            continue;
+        }
+        if (message.role === "bashExecution") {
+            const failed = message.cancelled || (message.exitCode !== undefined && message.exitCode !== 0);
+            const base = {
+                id,
+                role: "tool",
+                toolCallId: `bash-${id}`,
+                toolName: "bash",
+                input: { command: message.command },
+                content: [{ type: "text", text: message.output }],
+                details: {
+                    exitCode: message.exitCode ?? null,
+                    cancelled: message.cancelled,
+                    truncated: message.truncated,
+                },
+                timestamp,
+            };
+            if (failed) {
+                const item = { ...base, status: "error", isError: true };
+                items.push(item);
+            }
+            else {
+                const item = { ...base, status: "complete", isError: false };
+                items.push(item);
+            }
+            continue;
+        }
+        if (message.role === "branchSummary") {
+            items.push({
+                id,
+                role: "note",
+                kind: "branchSummary",
+                text: message.summary,
+                fromId: message.fromId,
+                timestamp,
+            });
+            continue;
+        }
+        if (message.role === "compactionSummary") {
+            items.push({
+                id,
+                role: "note",
+                kind: "compactionSummary",
+                text: message.summary,
+                tokensBefore: Math.max(0, Math.trunc(message.tokensBefore)),
+                timestamp,
+            });
+            continue;
+        }
+        if (message.role === "custom") {
+            const text = typeof message.content === "string"
+                ? message.content
+                : message.content
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("\n");
+            items.push({
+                id,
+                role: "note",
+                kind: "custom",
+                text,
+                customType: message.customType,
+                display: message.display,
+                timestamp,
+            });
+            continue;
+        }
+        if (message.role !== "assistant")
+            continue;
+        const streaming = session.isStreaming && message === messages.at(-1);
+        const content = message.content.map((part) => {
+            if (part.type === "text")
+                return { type: "text", text: part.text };
+            if (part.type === "thinking") {
+                return {
+                    type: "thinking",
+                    thinking: part.thinking,
+                    ...(part.redacted === undefined ? {} : { redacted: part.redacted }),
+                };
+            }
+            return {
+                type: "toolCall",
+                toolCallId: part.id,
+                toolName: part.name,
+                input: part.arguments,
+            };
+        });
+        const usage = projectUsage(message.usage);
+        const common = {
+            id,
+            role: "assistant",
+            content,
+            model: { provider: message.provider, id: message.model },
+            ...(message.responseModel ? { responseModel: message.responseModel } : {}),
+            ...(usage === undefined ? {} : { usage }),
+            timestamp,
+        };
+        if (streaming || message.stopReason === "pending" || message.stopReason === "deferred") {
+            const item = { ...common, status: "streaming" };
+            items.push(item);
+        }
+        else if (message.stopReason === "error") {
+            const item = {
+                ...common,
+                status: "error",
+                stopReason: "error",
+                ...(message.errorMessage ? { errorMessage: message.errorMessage } : {}),
+            };
+            items.push(item);
+        }
+        else if (message.stopReason === "aborted") {
+            const item = {
+                ...common,
+                status: "aborted",
+                stopReason: "aborted",
+                ...(message.errorMessage ? { errorMessage: message.errorMessage } : {}),
+            };
+            items.push(item);
+        }
+        else {
+            const item = { ...common, status: "complete", stopReason: message.stopReason };
+            items.push(item);
+        }
+    }
+    return items;
+}
+function sessionPhase(session) {
+    if (session.isCompacting)
+        return "compaction";
+    if (session.isStreaming)
+        return "turn";
+    return "idle";
+}
+/** Server-side runtime over one exclusively owned coding-agent session. */
+export class CodingAgentSessionRuntime {
+    session;
+    descriptor;
+    models;
+    listeners = new Set();
+    unsubscribe;
+    onDisposed;
+    disposed = false;
+    constructor(session, descriptor, options) {
+        this.session = session;
+        this.descriptor = descriptor;
+        this.models = options?.models ?? {
+            list: async () => [],
+            resolve: () => {
+                throw new PiServerError("not_implemented", "Model resolution is not configured");
+            },
+        };
+        this.onDisposed = options?.onDisposed;
+        this.unsubscribe = session.subscribe((event) => this.onSessionEvent(event));
+    }
+    snapshot() {
+        const queuedSteer = this.session.getSteeringMessages();
+        const name = this.session.sessionName ?? this.descriptor.name;
+        return {
+            id: this.descriptor.id,
+            ...(name === undefined ? {} : { name }),
+            // The protocol requires a non-empty snapshot cwd. This runtime only
+            // describes acquired sessions: creates validate a non-empty cwd and
+            // opens fall back to a non-empty cwd inside the source, so the
+            // SessionManager cwd is the authoritative value when the descriptor
+            // carries none (legacy sessions record no cwd).
+            cwd: this.descriptor.cwd ?? this.session.sessionManager.getCwd(),
+            createdAt: this.descriptor.createdAt,
+            updatedAt: this.descriptor.updatedAt,
+            phase: sessionPhase(this.session),
+            model: this.currentModelRef(),
+            thinkingLevel: this.session.thinkingLevel,
+            ...(this.descriptor.profileId === undefined ? {} : { profileId: this.descriptor.profileId }),
+            ...(this.descriptor.profileVersion === undefined ? {} : { profileVersion: this.descriptor.profileVersion }),
+            attached: false,
+            locked: false,
+            // Durable revision: the SessionManager entry sequence. It survives
+            // reopen and only advances when a persisted entry lands.
+            revision: this.session.getRevision().sequence,
+            transcript: projectSessionTranscript(this.session),
+            queuedSteer: queuedSteer.map((text, index) => ({
+                id: `steer-${index}`,
+                role: "user",
+                content: [{ type: "text", text }],
+                timestamp: this.descriptor.updatedAt,
+            })),
+            queuedSteerCount: queuedSteer.length,
+        };
+    }
+    getPhase() {
+        return sessionPhase(this.session);
+    }
+    async prompt(input) {
+        this.assertUsable();
+        requireIdle(this.session, "submit a prompt");
+        try {
+            await this.session.prompt(input.text);
+        }
+        catch (error) {
+            throw toError(error);
+        }
+    }
+    async steer(input) {
+        this.assertUsable();
+        if (this.session.isIdle) {
+            throw new PiServerError("busy", "There is no active prompt to steer");
+        }
+        try {
+            await this.session.steer(input.text);
+        }
+        catch (error) {
+            throw toError(error);
+        }
+    }
+    async abort() {
+        this.assertUsable();
+        try {
+            await this.session.abort();
+        }
+        catch (error) {
+            throw toError(error);
+        }
+    }
+    async setModel(model) {
+        this.assertUsable();
+        requireIdle(this.session, "change the model");
+        let resolved;
+        try {
+            resolved = await this.models.resolve(model);
+            await this.session.setModel(resolved);
+        }
+        catch (error) {
+            throw toError(error);
+        }
+    }
+    async setThinking(thinkingLevel) {
+        this.assertUsable();
+        requireIdle(this.session, "change the thinking level");
+        try {
+            this.session.setThinkingLevel(thinkingLevel);
+        }
+        catch (error) {
+            throw toError(error);
+        }
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.unsubscribe();
+        try {
+            await this.session.dispose();
+        }
+        finally {
+            this.onDisposed?.();
+        }
+    }
+    assertUsable() {
+        if (this.disposed)
+            throw new PiServerError("invalid_request", "Session runtime is disposed");
+    }
+    onSessionEvent(_event) {
+        // Every event still broadcasts a snapshot, but the revision value is the
+        // durable SessionManager sequence: events that persist no entry keep the
+        // same revision number. Clients accept equal-revision snapshots (only
+        // regressions are dropped), so no state is lost.
+        for (const listener of [...this.listeners]) {
+            try {
+                listener({ type: "snapshot" });
+            }
+            catch {
+                // Snapshot observers must not affect the session.
+            }
+        }
+    }
+    currentModelRef() {
+        const model = this.session.model;
+        // Defensive layer: the create/open preflights reject model-less sessions,
+        // so a live runtime always has a model. A residual model-less runtime must
+        // still fail diagnosably instead of surfacing as an unspecific internal
+        // error through snapshot projection.
+        if (!model)
+            throw new PiServerError("invalid_request", "Session has no active model");
+        return { provider: model.provider, id: model.id };
+    }
+}
+/** Exclusive `PiServerService` over a coding-agent session source. */
+export class CodingAgentServerService {
+    source;
+    models;
+    now;
+    acquired = new Map();
+    opening = new Set();
+    durable;
+    executors = new Map();
+    /** In-memory operation store surface; undefined without a durable service. */
+    operationStore;
+    /** In-memory artifact store surface; undefined without a durable service. */
+    artifactStore;
+    /** Durable mutation-response store surface; undefined without a durable service. */
+    mutationResponseStore;
+    writerId;
+    leaseReady = false;
+    /** Idempotency key (`sessionId\0key`) -> recorded operation. */
+    idempotencyIndex = new Map();
+    /** Operation id -> recorded payload snapshot for idempotent acks. */
+    recordedOperations = new Map();
+    /** Active executor abort controllers by operation id. */
+    inFlight = new Map();
+    /** Cancel requests observed while the executor was still draining. */
+    cancelRequested = new Set();
+    constructor(options) {
+        this.source = options.sessions;
+        this.models = options.models;
+        this.now = options.now ?? (() => Date.now());
+        for (const executor of options.operationExecutors ?? [])
+            this.executors.set(executor.operationType, executor);
+        if (options.durable) {
+            this.durable = options.durable;
+            this.writerId = options.writerId ?? randomUUID();
+            this.claimWriterLease();
+            if (this.leaseReady)
+                this.sweepInterruptedOperations();
+            this.operationStore = {
+                submit: (input) => this.submitOperation(input),
+                cancel: (input) => this.cancelOperation(input),
+                result: (input) => this.resultOperation(input),
+            };
+            this.artifactStore = {
+                stat: (sessionId, artifactId) => this.statArtifact(sessionId, artifactId),
+                read: (sessionId, artifactId, readerOptions) => this.readArtifact(sessionId, artifactId, readerOptions),
+            };
+            this.mutationResponseStore = {
+                load: (sessionId, operationId) => this.loadMutationResponse(sessionId, operationId),
+                record: (sessionId, operationId, snapshot) => this.recordMutationResponse(sessionId, operationId, snapshot),
+            };
+        }
+    }
+    /** Remote artifact access; unconfigured without a durable service. */
+    get artifacts() {
+        return this.artifactStore;
+    }
+    /** Durable operation commands; unconfigured without a durable service. */
+    get operations() {
+        return this.operationStore;
+    }
+    /** Durable replay of mutation-command responses; unconfigured without a durable service. */
+    get mutationResponses() {
+        return this.mutationResponseStore;
+    }
+    // -------------------------------------------------------------------------
+    // Durable writer lease (single-instance boundary)
+    // -------------------------------------------------------------------------
+    /**
+     * Claims the writer lease at startup. A holder found in restored state
+     * belonged to a dead process (snapshot import), so it is recovered; a live
+     * foreign writer keeps the lease and this service stays unavailable.
+     */
+    claimWriterLease() {
+        const durable = this.durable;
+        const writerId = this.writerId;
+        if (!durable || !writerId)
+            return;
+        if (durable.claimWriter(writerId).status === "claimed") {
+            this.leaseReady = true;
+            return;
+        }
+        this.leaseReady = durable.recoverWriter(writerId).status === "recovered";
+    }
+    /**
+     * Releases the store writer lease on graceful shutdown (D-067 phase 2 S2)
+     * so a successor process can claim immediately. Best-effort: only a held
+     * lease is released, and failures are swallowed — a crashed process leaves
+     * the lease for the TTL recovery path instead.
+     */
+    releaseWriterLease() {
+        const durable = this.durable;
+        const writerId = this.writerId;
+        if (!durable || !writerId || !this.leaseReady)
+            return;
+        try {
+            durable.releaseWriter(writerId);
+            this.leaseReady = false;
+        }
+        catch {
+            // Shutdown release is advisory; the TTL recovery path handles the rest.
+        }
+    }
+    /** Persists one adapter-owned operation record; a lost lease degrades to `durable_unavailable`. */
+    persistOperation(operationId, sessionId, payload) {
+        try {
+            this.durable?.persistOperation({
+                writerId: this.writerId ?? "",
+                operationId,
+                sessionId,
+                data: payload,
+            });
+        }
+        catch (error) {
+            if (error instanceof DurableServiceErrorV1) {
+                throw new PiServerError("durable_unavailable", error.message);
+            }
+            throw error;
+        }
+    }
+    requireDurable() {
+        if (!this.durable || !this.leaseReady) {
+            throw new PiServerError("durable_unavailable", "Durable operation store is not ready");
+        }
+        return this.durable;
+    }
+    /**
+     * Rejects operations that were pending when the previous process stopped:
+     * no executor survives a crash, so replayed `pending` records are swept to
+     * a rejected terminal and their idempotency keys keep returning that
+    /**
+     * recorded terminal.
+     */
+    sweepInterruptedOperations() {
+        const durable = this.durable;
+        if (!durable)
+            return;
+        for (const record of durable.exportState().operations) {
+            const payload = parseOperationPayload(record.data);
+            if (!payload)
+                continue;
+            const resolved = payload.status === "pending"
+                ? {
+                    ...payload,
+                    status: "rejected",
+                    error: { code: "internal_error", message: "Operation did not complete before the server stopped" },
+                    terminalAt: this.now(),
+                }
+                : payload;
+            if (resolved !== payload)
+                this.persistOperation(record.operationId, payload.sessionId, resolved);
+            this.recordOperation(record.operationId, resolved);
+        }
+    }
+    recordOperation(operationId, payload) {
+        this.recordedOperations.set(operationId, { operationId, payload });
+        if (payload.idempotencyKey !== undefined) {
+            this.idempotencyIndex.set(`${payload.sessionId}\0${payload.idempotencyKey}`, { operationId, payload });
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Operation commands (server `operations` surface)
+    // -------------------------------------------------------------------------
+    async submitOperation(input) {
+        this.requireDurable();
+        // Idempotent replay precedes the live-session check: a recorded terminal
+        // must stay answerable after a restart even though no runtime is open.
+        if (input.idempotencyKey !== undefined) {
+            const recorded = this.idempotencyIndex.get(`${input.sessionId}\0${input.idempotencyKey}`);
+            if (recorded)
+                return this.ackOf(recorded);
+        }
+        const runtime = this.acquired.get(input.sessionId);
+        if (!runtime)
+            throw new PiServerError("not_found", `Session is not open: ${input.sessionId}`);
+        if (input.expectedRevision !== undefined) {
+            const revision = (await runtime.snapshot()).revision;
+            if (revision !== input.expectedRevision) {
+                throw new PiServerError("operation_conflict", `Session revision is ${revision}, expectedRevision was ${input.expectedRevision}`);
+            }
+        }
+        const operationId = randomUUID();
+        const payload = {
+            status: "pending",
+            sessionId: input.sessionId,
+            operationType: input.operationType,
+            ...(input.idempotencyKey === undefined ? {} : { idempotencyKey: input.idempotencyKey }),
+            submittedAt: this.now(),
+        };
+        this.persistOperation(operationId, input.sessionId, payload);
+        this.recordOperation(operationId, payload);
+        // Fire-and-forget execution: the ack must reach the client immediately,
+        // otherwise a long operation hides its own operationId and cancel/result
+        // stay unreachable. `executeOperation` records executor failures as
+        // rejected terminals; only a terminal persist failure can still escape,
+        // so pin the in-memory record to a rejected terminal carrying the
+        // original error. The durable log keeps `pending` and the restart sweep
+        // converges the record.
+        this.executeOperation(operationId, payload, input.input).catch((error) => {
+            this.recordOperation(operationId, {
+                ...payload,
+                status: "rejected",
+                error: { code: "internal_error", message: error instanceof Error ? error.message : String(error) },
+                terminalAt: this.now(),
+            });
+        });
+        return this.ackOf({ operationId, payload });
+    }
+    /**
+     * Runs the executor and persists the terminal state. Cancel is only a
+     * request: the terminal record is written strictly after the executor
+     * drains, so `cancel -> drain -> terminal` is the observable order.
+     */
+    async executeOperation(operationId, payload, input) {
+        const executor = this.executors.get(payload.operationType);
+        if (!executor) {
+            return this.completeOperation(operationId, {
+                ...payload,
+                status: "rejected",
+                error: {
+                    code: "not_implemented",
+                    message: `No executor is registered for operation type ${payload.operationType}`,
+                },
+                terminalAt: this.now(),
+            });
+        }
+        const controller = new AbortController();
+        this.inFlight.set(operationId, controller);
+        let terminal;
+        try {
+            const result = await executor.execute({
+                sessionId: payload.sessionId,
+                operationId,
+                ...(input === undefined ? {} : { input }),
+                signal: controller.signal,
+            });
+            terminal = { ...payload, status: "completed", result, terminalAt: this.now() };
+        }
+        catch (error) {
+            terminal = {
+                ...payload,
+                status: "rejected",
+                error: this.toTerminalError(operationId, error),
+                terminalAt: this.now(),
+            };
+        }
+        finally {
+            this.inFlight.delete(operationId);
+            this.cancelRequested.delete(operationId);
+        }
+        return this.completeOperation(operationId, terminal);
+    }
+    toTerminalError(operationId, error) {
+        if (this.cancelRequested.has(operationId)) {
+            return { code: "operation_cancelled", message: "Operation was cancelled before completion" };
+        }
+        if (error instanceof PiServerError)
+            return { code: error.code, message: error.message };
+        const message = error instanceof Error ? error.message : String(error);
+        return { code: "invalid_request", message };
+    }
+    completeOperation(operationId, terminal) {
+        this.persistOperation(operationId, terminal.sessionId, terminal);
+        this.recordOperation(operationId, terminal);
+        return this.ackOf({ operationId, payload: terminal });
+    }
+    cancelOperation(input) {
+        this.requireDurable();
+        const recorded = this.recordedOperations.get(input.operationId);
+        // Session ownership is part of the lookup: a foreign session gets the
+        // same not-found answer as a missing id, without leaking ownership.
+        if (!recorded || recorded.payload.sessionId !== input.sessionId) {
+            throw new PiServerError("operation_not_found", `Unknown operation: ${input.operationId}`);
+        }
+        if (recorded.payload.status !== "pending")
+            return this.ackOf(recorded);
+        // Record the cancel request and signal the executor. The terminal state
+        // is only written once the executor drained (or nothing is draining).
+        this.cancelRequested.add(input.operationId);
+        this.inFlight.get(input.operationId)?.abort();
+        return { operationId: input.operationId, status: "accepted" };
+    }
+    resultOperation(input) {
+        this.requireDurable();
+        const recorded = this.recordedOperations.get(input.operationId);
+        // Session ownership is part of the lookup: a foreign session gets the
+        // same not-found answer as a missing id, without leaking ownership.
+        if (!recorded || recorded.payload.sessionId !== input.sessionId) {
+            throw new PiServerError("operation_not_found", `Unknown operation: ${input.operationId}`);
+        }
+        return this.ackOf(recorded);
+    }
+    ackOf(recorded) {
+        const { operationId, payload } = recorded;
+        if (payload.status === "completed") {
+            return {
+                operationId,
+                status: "completed",
+                ...(payload.result === undefined ? {} : { result: payload.result }),
+            };
+        }
+        if (payload.status === "rejected") {
+            return {
+                operationId,
+                status: "rejected",
+                ...(payload.error === undefined
+                    ? {}
+                    : { error: { code: payload.error.code, message: payload.error.message } }),
+            };
+        }
+        return { operationId, status: "accepted" };
+    }
+    // -------------------------------------------------------------------------
+    // Artifact adapter (output-artifacts face + durable persistence)
+    // -------------------------------------------------------------------------
+    /**
+     * Mirrors one runtime output artifact into the durable store so remote
+     * `artifact_stat`/`artifact_read` can serve it, including after a restart
+     * via log replay. The runtime in-memory store (capability-runtime) stays
+     * the live write path; this adds durable persistence, not a second store.
+     */
+    persistOutputArtifact(sessionId, ref, bytes) {
+        this.requireDurable();
+        if (ref.sessionId !== sessionId) {
+            throw new PiServerError("invalid_request", "Artifact sessionId must match the owning session");
+        }
+        if (ref.artifactId === "")
+            throw new PiServerError("invalid_request", "Artifact id must not be empty");
+        if (ref.sizeBytes !== undefined && ref.sizeBytes !== bytes.byteLength) {
+            throw new PiServerError("invalid_request", "Artifact sizeBytes must match the payload length");
+        }
+        try {
+            this.durable?.persistArtifact({
+                writerId: this.writerId ?? "",
+                artifactId: ref.artifactId,
+                sessionId,
+                data: { ref, bytes: Buffer.from(bytes).toString("base64") },
+            });
+        }
+        catch (error) {
+            if (error instanceof DurableServiceErrorV1) {
+                throw new PiServerError("durable_unavailable", error.message);
+            }
+            throw error;
+        }
+        return toProtocolArtifactRef(ref);
+    }
+    statArtifact(sessionId, artifactId) {
+        return toProtocolArtifactRef(this.loadArtifactPayload(sessionId, artifactId).ref);
+    }
+    readArtifact(sessionId, artifactId, options) {
+        const payload = this.loadArtifactPayload(sessionId, artifactId);
+        const bytes = Buffer.from(payload.bytes, "base64");
+        const end = Math.min(options.offset + options.maxBytes, bytes.byteLength);
+        const data = new Uint8Array(bytes.subarray(options.offset, end));
+        const eof = end >= bytes.byteLength;
+        return {
+            artifact: toProtocolArtifactRef(payload.ref),
+            data,
+            ...(eof ? {} : { nextOffset: end }),
+            eof,
+        };
+    }
+    /**
+     * Loads one artifact payload through the durable service.
+     */
+    loadArtifactPayload(sessionId, artifactId) {
+        const durable = this.requireDurable();
+        const record = durable.loadArtifact({ artifactId });
+        if (!record || record.sessionId !== sessionId) {
+            throw new PiServerError("not_found", `Unknown artifact: ${artifactId}`);
+        }
+        const payload = parseArtifactPayload(record.data);
+        if (!payload || payload.ref.sessionId !== sessionId || payload.ref.artifactId !== artifactId) {
+            throw new PiServerError("durable_unavailable", "Stored artifact record is malformed");
+        }
+        return payload;
+    }
+    // -------------------------------------------------------------------------
+    // Mutation-response store (idempotent replay of keyed mutation commands)
+    // -------------------------------------------------------------------------
+    /**
+     * Deterministic artifact id for one mutation-command response, following the
+     * `agent-task:<taskId>` precedent for derived artifact ids.
+     */
+    mutationResponseArtifactId(sessionId, operationId) {
+        return `mutation-response:${sessionId}:${operationId}`;
+    }
+    /**
+     * Loads a recorded response through the durable service. The durable log
+     * was already replayed into memory at construction, so this read never
+     * touches the disk. A missing or malformed record yields undefined so the
+     * caller re-executes; unexpected durable failures propagate and are
+     * reported (and treated as a miss) by the server's idempotency layer.
+     */
+    async loadMutationResponse(sessionId, operationId) {
+        const durable = this.requireDurable();
+        const record = durable.loadArtifact({
+            artifactId: this.mutationResponseArtifactId(sessionId, operationId),
+        });
+        if (record === undefined || record.sessionId !== sessionId)
+            return undefined;
+        const snapshot = parseMutationResponsePayload(record.data, sessionId);
+        return snapshot === undefined ? undefined : structuredClone(snapshot);
+    }
+    /**
+     * Persists one successful response snapshot as a durable artifact record so
+     * retries after a restart replay it. The payload is the `SessionSnapshot`
+     * itself: every field is JSON-safe, so the JSONL durable log round-trips it
+     * without an adapter-specific envelope.
+     */
+    async recordMutationResponse(sessionId, operationId, snapshot) {
+        const durable = this.requireDurable();
+        try {
+            durable.persistArtifact({
+                writerId: this.writerId ?? "",
+                artifactId: this.mutationResponseArtifactId(sessionId, operationId),
+                sessionId,
+                data: snapshot,
+            });
+        }
+        catch (error) {
+            if (error instanceof DurableServiceErrorV1) {
+                throw new PiServerError("durable_unavailable", error.message);
+            }
+            throw error;
+        }
+    }
+    async listSessions() {
+        const descriptors = await this.source.list();
+        return descriptors.map((descriptor) => ({
+            id: descriptor.id,
+            createdAt: descriptor.createdAt,
+            updatedAt: descriptor.updatedAt,
+            ...(descriptor.name === undefined ? {} : { sessionName: descriptor.name }),
+            // Legacy sessions record no cwd; the protocol marks it optional.
+            ...(descriptor.cwd === undefined ? {} : { cwd: descriptor.cwd }),
+        }));
+    }
+    async listModels() {
+        return [...(await this.models.list())];
+    }
+    async createSession(options) {
+        this.assertNotAcquired(options.id);
+        if (options.cwd === undefined || options.cwd.trim() === "") {
+            throw new PiServerError("invalid_request", "Creating a coding-agent session requires a cwd");
+        }
+        // The protocol carries a model ref; resolve it to a Model instance the
+        // same way runtime `set_model` does. An unknown ref fails the create
+        // instead of being silently dropped.
+        let model;
+        try {
+            model = options.model === undefined ? undefined : await this.models.resolve(options.model);
+        }
+        catch (error) {
+            throw toError(error);
+        }
+        const timestamp = Math.max(0, Math.trunc(this.now()));
+        const descriptor = {
+            id: options.id,
+            ...(options.name === undefined ? {} : { name: options.name }),
+            cwd: options.cwd,
+            ...(model === undefined ? {} : { model }),
+            ...(options.thinkingLevel === undefined ? {} : { thinkingLevel: options.thinkingLevel }),
+            ...(options.profileId === undefined ? {} : { profileId: options.profileId }),
+            ...(options.profileVersion === undefined ? {} : { profileVersion: options.profileVersion }),
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        let session;
+        try {
+            session = await this.openExclusively(descriptor.id, () => this.source.create(descriptor));
+        }
+        catch (error) {
+            throw toError(error);
+        }
+        // Lazy-model contract: createAgentSession does not fail when no model is
+        // resolvable (no auth, empty catalog); it returns a session whose model is
+        // undefined. A model-less live session cannot serve prompts and breaks
+        // every client's list/server_snapshot, so the create fails explicitly.
+        // Disposing rolls the session back before any registration; the
+        // SessionManager has not flushed the JSONL yet (persistence defers until
+        // the first assistant message), so nothing stays on disk, and a flushed
+        // residue would still be harmless: reopening it runs into the same
+        // preflight in openSession.
+        if (session.model === undefined) {
+            // Keep the structured rejection even if rollback fails; the cleanup
+            // failure is appended to the message instead of masking it.
+            let cleanupNote = "";
+            try {
+                await session.dispose();
+            }
+            catch (disposeError) {
+                cleanupNote = ` (session cleanup also failed: ${disposeError instanceof Error ? disposeError.message : String(disposeError)})`;
+            }
+            throw new PiServerError("invalid_request", `Creating a coding-agent session requires a resolvable model; none is available for this server's agent directory${cleanupNote}`);
+        }
+        return this.acquireRuntime(descriptor, session);
+    }
+    async openSession(sessionId) {
+        this.assertNotAcquired(sessionId);
+        const descriptors = await this.source.list();
+        const descriptor = descriptors.find((entry) => entry.id === sessionId);
+        if (!descriptor)
+            throw new PiServerError("not_found", `Unknown session: ${sessionId}`);
+        let session;
+        try {
+            session = await this.openExclusively(descriptor.id, () => this.source.open(descriptor));
+        }
+        catch (error) {
+            throw toError(error);
+        }
+        // Same preflight as create: a history session whose stored model no longer
+        // resolves (model removed, auth missing) must fail the open instead of
+        // going live model-less and breaking every client's list/server_snapshot.
+        if (session.model === undefined) {
+            let cleanupNote = "";
+            try {
+                await session.dispose();
+            }
+            catch (disposeError) {
+                cleanupNote = ` (session cleanup also failed: ${disposeError instanceof Error ? disposeError.message : String(disposeError)})`;
+            }
+            throw new PiServerError("invalid_request", `Reopening session ${sessionId} requires a resolvable model; none is available for this server's agent directory${cleanupNote}`);
+        }
+        return this.acquireRuntime(descriptor, session);
+    }
+    /** Serializes the acquired-check with the async source call to keep opens exclusive. */
+    async openExclusively(id, open) {
+        if (this.opening.has(id) || this.acquired.has(id)) {
+            throw new PiServerError("session_locked", `Session is already open: ${id}`);
+        }
+        this.opening.add(id);
+        try {
+            return await open();
+        }
+        finally {
+            this.opening.delete(id);
+        }
+    }
+    acquireRuntime(descriptor, session) {
+        // Auto-mirror: with a durable service configured, every artifact committed
+        // by the session's capability runtime is mirrored here, so the wire face
+        // serves it without an explicit persist call. Without a durable service
+        // nothing is registered (no behavior change). Mirror failures surface as
+        // runtime commit-observer log records; they never fail the artifact put.
+        const unsubscribeArtifactMirror = this.durable === undefined
+            ? undefined
+            : session.onOutputArtifactCommit(({ ref, bytes }) => {
+                this.persistOutputArtifact(descriptor.id, ref, bytes);
+            });
+        const runtime = new CodingAgentSessionRuntime(session, descriptor, {
+            models: this.models,
+            onDisposed: () => {
+                unsubscribeArtifactMirror?.();
+                this.acquired.delete(descriptor.id);
+            },
+        });
+        this.acquired.set(descriptor.id, runtime);
+        return runtime;
+    }
+    assertNotAcquired(id) {
+        if (this.acquired.has(id) || this.opening.has(id)) {
+            throw new PiServerError("session_locked", `Session is already open: ${id}`);
+        }
+    }
+}
+/** Composes the coding-agent service with transport, journal, and auth hooks into one server. */
+export function assembleCodingAgentServer(options) {
+    const service = new CodingAgentServerService({
+        sessions: options.sessions,
+        models: options.models,
+        now: options.now,
+        ...(options.durable === undefined ? {} : { durable: options.durable }),
+        ...(options.writerId === undefined ? {} : { writerId: options.writerId }),
+        ...(options.operationExecutors === undefined ? {} : { operationExecutors: options.operationExecutors }),
+    });
+    const server = new PiServer(service, {
+        listeners: options.listeners,
+        ...(options.journal === undefined ? {} : { journal: options.journal }),
+        ...(options.authenticate === undefined ? {} : { authenticate: options.authenticate }),
+        ...(options.authorize === undefined ? {} : { authorize: options.authorize }),
+        ...(options.serverId === undefined ? {} : { serverId: options.serverId }),
+        ...(options.maxFrameLength === undefined ? {} : { maxFrameLength: options.maxFrameLength }),
+        ...(options.handshakeTimeoutMs === undefined ? {} : { handshakeTimeoutMs: options.handshakeTimeoutMs }),
+        ...(options.onError === undefined ? {} : { onError: options.onError }),
+    });
+    return { server, service };
+}
+//# sourceMappingURL=server-assembly.js.map