@maiaos/node 0.1.0-canary.44938d4.manual.1

package/dist/harness/pi-rpc/conversation.js

@@ -0,0 +1,885 @@
+import { dirname, isAbsolute, normalize } from "node:path";
+import { Deferred, Effect, Queue, Schema, SchemaError, Stream, } from "effect";
+import { createActor, setup } from "xstate";
+import { PiRpcFailure, piRpcFailure, piRpcLimits, } from "./contract.js";
+import { encodeStrictJsonlRecord, StrictLfJsonlDecoder } from "./jsonl.js";
+const responseSchema = Schema.Struct({
+    command: Schema.String,
+    data: Schema.optional(Schema.Unknown),
+    error: Schema.optional(Schema.String.check(Schema.isLengthBetween(0, 4096))),
+    id: Schema.String.check(Schema.isLengthBetween(1, 128)),
+    success: Schema.Boolean,
+    type: Schema.Literal("response"),
+});
+const recordEnvelopeSchema = Schema.Struct({
+    type: Schema.String.check(Schema.isLengthBetween(1, 64)),
+});
+const messageRecordSchema = Schema.Record(Schema.String, Schema.Unknown);
+const userMessageSchema = Schema.StructWithRest(Schema.Struct({ role: Schema.Literal("user") }), [messageRecordSchema]);
+const assistantMessageSchema = Schema.StructWithRest(Schema.Struct({ role: Schema.Literal("assistant") }), [messageRecordSchema]);
+const toolResultMessageSchema = Schema.StructWithRest(Schema.Struct({ role: Schema.Literal("toolResult") }), [messageRecordSchema]);
+const piRpcMessageSchema = Schema.Union([
+    userMessageSchema,
+    assistantMessageSchema,
+    toolResultMessageSchema,
+]);
+const messageEndSchema = Schema.Struct({
+    message: piRpcMessageSchema,
+    type: Schema.Literal("message_end"),
+});
+const agentSettledSchema = Schema.Struct({
+    type: Schema.Literal("agent_settled"),
+});
+const sessionInfoChangedSchema = Schema.Struct({
+    name: Schema.String.check(Schema.isLengthBetween(1, 1024)),
+    type: Schema.Literal("session_info_changed"),
+});
+const sessionStateSchema = Schema.Struct({
+    autoCompactionEnabled: Schema.Boolean,
+    followUpMode: Schema.Literals(["all", "one-at-a-time"]),
+    isCompacting: Schema.Boolean,
+    isStreaming: Schema.Boolean,
+    messageCount: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    model: Schema.optional(Schema.Unknown),
+    pendingMessageCount: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    sessionFile: Schema.optional(Schema.String.check(Schema.isLengthBetween(1, 4096))),
+    sessionId: Schema.String.check(Schema.isLengthBetween(1, 128)),
+    sessionName: Schema.optional(Schema.String.check(Schema.isLengthBetween(0, 1024))),
+    steeringMode: Schema.Literals(["all", "one-at-a-time"]),
+    thinkingLevel: Schema.String.check(Schema.isLengthBetween(1, 32)),
+});
+const decodeResponse = Schema.decodeUnknownSync(responseSchema, {
+    errors: "all",
+    onExcessProperty: "error",
+});
+const decodeRecordEnvelope = Schema.decodeUnknownSync(recordEnvelopeSchema);
+const decodeMessageEnd = Schema.decodeUnknownSync(messageEndSchema, {
+    errors: "all",
+    onExcessProperty: "error",
+});
+const decodeAgentSettled = Schema.decodeUnknownSync(agentSettledSchema, {
+    errors: "all",
+    onExcessProperty: "error",
+});
+const decodeSessionInfoChanged = Schema.decodeUnknownSync(sessionInfoChangedSchema, { errors: "all", onExcessProperty: "error" });
+const decodeSessionState = Schema.decodeUnknownSync(sessionStateSchema, {
+    errors: "all",
+    onExcessProperty: "error",
+});
+export const piRpcPromptLifecycleMachine = setup({
+    types: {
+        context: {},
+        events: {},
+    },
+}).createMachine({
+    context: {},
+    id: "maia-pi-rpc-prompt",
+    initial: "awaitingAcceptance",
+    states: {
+        aborting: {
+            on: {
+                fail: "failed",
+                messageEnd: "aborting",
+                settle: "settled",
+                unknown: "outcomeUnknown",
+            },
+        },
+        accepted: {
+            on: {
+                abortRequest: "aborting",
+                fail: "failed",
+                messageEnd: "messageEnded",
+                settle: "settled",
+                unknown: "outcomeUnknown",
+            },
+        },
+        awaitingAcceptance: {
+            on: {
+                accept: "accepted",
+                fail: "failed",
+                reject: "rejected",
+                unknown: "outcomeUnknown",
+            },
+        },
+        failed: { type: "final" },
+        messageEnded: {
+            on: {
+                abortRequest: "aborting",
+                fail: "failed",
+                messageEnd: "messageEnded",
+                settle: "settled",
+                unknown: "outcomeUnknown",
+            },
+        },
+        outcomeUnknown: { type: "final" },
+        rejected: { type: "final" },
+        settled: { type: "final" },
+    },
+});
+export const describePiRpcPromptLifecycle = (value) => {
+    if (value === "awaitingAcceptance")
+        return "awaiting-acceptance";
+    if (value === "messageEnded")
+        return "message-ended";
+    if (value === "outcomeUnknown")
+        return "outcome-unknown";
+    if (value === "aborting" ||
+        value === "accepted" ||
+        value === "failed" ||
+        value === "rejected" ||
+        value === "settled") {
+        return value;
+    }
+    throw new TypeError("The Pi RPC prompt lifecycle snapshot is invalid.");
+};
+const validRequestId = /^[A-Za-z0-9](?:[A-Za-z0-9._:-]*[A-Za-z0-9])?$/u;
+const requireRequestId = (requestId) => {
+    if (!validRequestId.test(requestId) ||
+        Buffer.byteLength(requestId, "utf8") > piRpcLimits.maximumRequestIdBytes) {
+        throw piRpcFailure("invalid_request", "The Pi RPC request id is invalid.");
+    }
+    return requestId;
+};
+const validateRequestId = (requestId) => Effect.try({
+    catch: (error) => error instanceof PiRpcFailure
+        ? error
+        : piRpcFailure("invalid_request", "The Pi RPC request id is invalid."),
+    try: () => requireRequestId(requestId),
+});
+const schemaFailure = () => piRpcFailure("protocol_invalid", "A Pi RPC output record is invalid.");
+const decodeProtocol = (decode) => {
+    try {
+        return decode();
+    }
+    catch (error) {
+        if (error instanceof PiRpcFailure)
+            throw error;
+        if (SchemaError.isSchemaError(error))
+            throw schemaFailure();
+        throw error;
+    }
+};
+const transitionPrompt = (run, event) => {
+    if (!run.actor.getSnapshot().can(event)) {
+        throw piRpcFailure("lifecycle_invalid", "The Pi RPC prompt lifecycle record is out of order.");
+    }
+    run.actor.send(event);
+};
+const failPrompt = Effect.fn("PiRpcConversation.failPrompt")(function* (run, failure) {
+    const event = {
+        type: failure.reason === "prompt_acceptance_unknown" ||
+            failure.reason === "request_outcome_unknown"
+            ? "unknown"
+            : "fail",
+    };
+    if (run.actor.getSnapshot().can(event)) {
+        run.actor.send(event);
+    }
+    yield* Deferred.fail(run.messageEnd, failure);
+    yield* Deferred.fail(run.settled, failure);
+    run.actor.stop();
+});
+const failPendingRequests = (pending, failure) => Effect.all(pending.map(({ response }) => Deferred.fail(response, failure)), { discard: true });
+const failConversation = Effect.fn("PiRpcConversation.fail")(function* (state, failure) {
+    if (state.failure !== undefined || state.released)
+        return;
+    state.failure = failure;
+    const pending = [...state.pending.values()];
+    state.pending.clear();
+    const activePrompt = state.activePrompt;
+    state.activePrompt = undefined;
+    yield* Deferred.fail(state.fatal, failure);
+    yield* failPendingRequests(pending, failure);
+    if (activePrompt !== undefined) {
+        yield* failPrompt(activePrompt, failure);
+    }
+    yield* Queue.shutdown(state.input);
+});
+const addTombstone = (tombstones, requestId) => {
+    if (tombstones.size >= piRpcLimits.maximumOutstandingRequests * 2) {
+        const oldest = tombstones.values().next().value;
+        if (oldest !== undefined)
+            tombstones.delete(oldest);
+    }
+    tombstones.add(requestId);
+};
+const removePending = (state, wireRequestId) => {
+    const pending = state.pending.get(wireRequestId);
+    if (pending === undefined || !state.pending.delete(wireRequestId))
+        return;
+    addTombstone(state.wireTombstones, wireRequestId);
+    if (pending.callerRequestId !== undefined) {
+        addTombstone(state.callerTombstones, pending.callerRequestId);
+    }
+};
+const hasPendingInputCapacity = (state, bytes) => state.pendingInputBytes + bytes.byteLength <=
+    piRpcLimits.maximumPendingInputBytes;
+const reservePendingInput = (state, bytes) => Effect.try({
+    catch: (error) => error instanceof PiRpcFailure
+        ? error
+        : piRpcFailure("transport_failed", "Pi RPC input admission failed."),
+    try: () => {
+        if (state.failure !== undefined)
+            throw state.failure;
+        if (!hasPendingInputCapacity(state, bytes)) {
+            throw piRpcFailure("input_limit_exceeded", "The Pi RPC pending-input byte limit was exceeded.");
+        }
+        const input = { accounted: true, bytes };
+        state.pendingInputBytes += bytes.byteLength;
+        return input;
+    },
+});
+const releasePendingInput = (state, input) => Effect.sync(() => {
+    if (!input.accounted)
+        return;
+    input.accounted = false;
+    state.pendingInputBytes = Math.max(0, state.pendingInputBytes - input.bytes.byteLength);
+});
+const enqueueInput = Effect.fn("PiRpcConversation.enqueueInput")(function* (state, bytes) {
+    return yield* Effect.uninterruptible(Effect.gen(function* () {
+        const input = yield* reservePendingInput(state, bytes);
+        const offered = yield* Queue.offer(state.input, input);
+        if (!offered) {
+            yield* releasePendingInput(state, input);
+            return yield* Effect.fail(state.failure ??
+                piRpcFailure("transport_failed", "The Pi RPC input queue closed."));
+        }
+    }));
+});
+const runSerializedInputWriter = Effect.fn("PiRpcConversation.runSerializedInputWriter")(function* (state, process_) {
+    yield* Effect.forever(Queue.take(state.input).pipe(Effect.flatMap((input) => {
+        const { bytes } = input;
+        return process_.standardInput
+            .write(bytes)
+            .pipe(Effect.ensuring(releasePendingInput(state, input)));
+    }))).pipe(Effect.catch((error) => failConversation(state, error instanceof PiRpcFailure
+        ? error
+        : piRpcFailure("transport_failed", "The Pi RPC input writer failed."))));
+});
+const isRequestSaturated = (state, callerRequestId) => state.pending.size >= piRpcLimits.maximumOutstandingRequests ||
+    (callerRequestId !== undefined &&
+        (state.callerTombstones.has(callerRequestId) ||
+            [...state.pending.values()].some((pending) => pending.callerRequestId === callerRequestId)));
+const encodeRequest = (options, requestId) => encodeStrictJsonlRecord({ ...options.request, id: requestId }, piRpcLimits.maximumInputRecordBytes);
+const reserveRequest = ({ callerRequestId, options, response, state, }) => {
+    if (state.failure !== undefined)
+        throw state.failure;
+    if (isRequestSaturated(state, callerRequestId)) {
+        throw piRpcFailure("saturated", "The Pi RPC request admission is saturated or the id was already used.");
+    }
+    state.nextWireRequestId += 1n;
+    const wireRequestId = `maia.pi.rpc.${state.nextWireRequestId.toString(36)}`;
+    const bytes = encodeRequest(options, wireRequestId);
+    state.pending.set(wireRequestId, {
+        ...(callerRequestId === undefined ? {} : { callerRequestId }),
+        command: options.command,
+        ...(options.expectedSessionName === undefined
+            ? {}
+            : { expectedSessionName: options.expectedSessionName }),
+        response,
+        sessionInfoChanged: false,
+    });
+    return { bytes, response, wireRequestId };
+};
+const admitRequest = Effect.fn("PiRpcConversation.admitRequest")(function* (state, options) {
+    const response = yield* Deferred.make();
+    const callerRequestId = options.callerRequestId === undefined
+        ? undefined
+        : yield* validateRequestId(options.callerRequestId);
+    return yield* Effect.try({
+        catch: (error) => error instanceof PiRpcFailure
+            ? error
+            : piRpcFailure("invalid_request", "The Pi RPC request is invalid."),
+        try: () => reserveRequest({
+            ...(callerRequestId === undefined ? {} : { callerRequestId }),
+            options,
+            response,
+            state,
+        }),
+    });
+});
+const awaitResponse = (state, options, admitted) => Deferred.await(admitted.response).pipe(Effect.timeoutOrElse({
+    duration: piRpcLimits.requestDeadline,
+    orElse: () => {
+        const failure = piRpcFailure(options.timeoutReason, "The Pi RPC request outcome is unknown after its response deadline.");
+        return failConversation(state, failure).pipe(Effect.andThen(Effect.fail(failure)));
+    },
+}));
+const sendRequest = Effect.fn("PiRpcConversation.sendRequest")(function* (state, options) {
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+        const admitted = yield* admitRequest(state, options);
+        return yield* restore(enqueueInput(state, admitted.bytes).pipe(Effect.andThen(awaitResponse(state, options, admitted)))).pipe(Effect.onInterrupt(() => Effect.sync(() => {
+            removePending(state, admitted.wireRequestId);
+        })));
+    }));
+});
+const findPendingResponse = Effect.fn("PiRpcConversation.findPendingResponse")(function* (state, requestId) {
+    const pending = state.pending.get(requestId);
+    if (pending !== undefined)
+        return pending;
+    if (state.wireTombstones.has(requestId))
+        return undefined;
+    yield* failConversation(state, piRpcFailure("protocol_invalid", "Pi RPC returned a response for an unknown request."));
+    return undefined;
+});
+const completeResponse = Effect.fn("PiRpcConversation.completeResponse")(function* (pending, response) {
+    if (!response.success) {
+        yield* Deferred.fail(pending.response, piRpcFailure("command_rejected", `Pi RPC rejected ${pending.command} before acceptance.`));
+        return;
+    }
+    yield* Deferred.succeed(pending.response, response.data);
+});
+const decodeConversationRecord = (state, decode) => Effect.gen(function* () {
+    try {
+        return decodeProtocol(decode);
+    }
+    catch (error) {
+        yield* failConversation(state, error instanceof PiRpcFailure ? error : schemaFailure());
+        return;
+    }
+});
+const responseValidationFailure = (pending, response) => {
+    if (response.command !== pending.command) {
+        return piRpcFailure("protocol_invalid", "Pi RPC returned a response for the wrong command.");
+    }
+    if (pending.expectedSessionName !== undefined &&
+        !pending.sessionInfoChanged) {
+        return piRpcFailure("lifecycle_invalid", "Pi RPC acknowledged session materialization before its identity event.");
+    }
+};
+const acceptResponse = Effect.fn("PiRpcConversation.acceptResponse")(function* (state, value) {
+    const response = yield* decodeConversationRecord(state, () => decodeResponse(value));
+    if (response === undefined)
+        return;
+    const pending = yield* findPendingResponse(state, response.id);
+    if (pending === undefined)
+        return;
+    const failure = responseValidationFailure(pending, response);
+    if (failure !== undefined)
+        return yield* failConversation(state, failure);
+    removePending(state, response.id);
+    yield* completeResponse(pending, response);
+});
+const acceptSessionInfoChanged = Effect.fn("PiRpcConversation.acceptSessionInfoChanged")(function* (state, value) {
+    const event = yield* decodeConversationRecord(state, () => decodeSessionInfoChanged(value));
+    if (event === undefined)
+        return;
+    const pending = [...state.pending.values()].filter((request) => request.command === "set_session_name");
+    const request = pending[0];
+    if (pending.length !== 1 ||
+        request?.expectedSessionName !== event.name ||
+        request.sessionInfoChanged) {
+        return yield* failConversation(state, piRpcFailure("lifecycle_invalid", "Pi RPC emitted an invalid session materialization identity event."));
+    }
+    request.sessionInfoChanged = true;
+});
+const requireActivePrompt = Effect.fn("PiRpcConversation.requireActivePrompt")(function* (state, eventName) {
+    if (state.activePrompt !== undefined)
+        return state.activePrompt;
+    yield* failConversation(state, piRpcFailure("lifecycle_invalid", `Pi RPC emitted ${eventName} without an active prompt.`));
+    return undefined;
+});
+const tryPromptTransition = Effect.fn("PiRpcConversation.tryPromptTransition")(function* (state, run, event) {
+    try {
+        transitionPrompt(run, event);
+        return true;
+    }
+    catch (error) {
+        yield* failConversation(state, error instanceof PiRpcFailure ? error : schemaFailure());
+        return false;
+    }
+});
+const messageEndFailure = (reason, message) => piRpcFailure(reason, message);
+const messageRoleIsOrdered = (messages, message) => {
+    const previous = messages.at(-1);
+    return ((message.role === "user" && previous === undefined) ||
+        (message.role === "assistant" && previous?.role === "user"));
+};
+const rejectMessageEnd = (run, message) => {
+    if (run.messages.length >= piRpcLimits.maximumMessageEndRecords) {
+        return messageEndFailure("output_limit_exceeded", "The Pi RPC prompt emitted too many message_end records.");
+    }
+    if (!messageRoleIsOrdered(run.messages, message)) {
+        return messageEndFailure("lifecycle_invalid", "Pi RPC emitted a message_end role outside the conversation-only order.");
+    }
+};
+const recordMessageEnd = Effect.fn("PiRpcConversation.recordMessageEnd")(function* (state, run, message) {
+    const rejection = rejectMessageEnd(run, message);
+    if (rejection !== undefined)
+        return yield* failConversation(state, rejection);
+    run.messages.push(message);
+    run.messageEndCount = run.messages.length;
+    if (message.role === "assistant") {
+        run.latestMessage = message;
+        yield* Deferred.succeed(run.messageEnd, {
+            message,
+            state: "message_end",
+        });
+    }
+});
+const acceptMessageEnd = Effect.fn("PiRpcConversation.acceptMessageEnd")(function* (state, value) {
+    const event = yield* decodeConversationRecord(state, () => decodeMessageEnd(value));
+    if (event === undefined)
+        return;
+    const run = yield* requireActivePrompt(state, "message_end");
+    if (run === undefined)
+        return;
+    const transitioned = yield* tryPromptTransition(state, run, {
+        type: "messageEnd",
+    });
+    if (transitioned)
+        yield* recordMessageEnd(state, run, event.message);
+});
+const completeSettlement = Effect.fn("PiRpcConversation.completeSettlement")(function* (state, run) {
+    state.activePrompt = undefined;
+    run.actor.stop();
+    yield* Deferred.succeed(run.messageEnd, {
+        state: "not_emitted_before_settlement",
+    });
+    yield* Deferred.succeed(run.settled, {
+        ...(run.latestMessage === undefined
+            ? {}
+            : { latestMessage: run.latestMessage }),
+        messageEndCount: run.messageEndCount,
+        messages: [...run.messages],
+        state: "agent_settled",
+    });
+});
+const acceptAgentSettled = Effect.fn("PiRpcConversation.acceptAgentSettled")(function* (state, value) {
+    const event = yield* decodeConversationRecord(state, () => decodeAgentSettled(value));
+    if (event === undefined)
+        return;
+    const run = yield* requireActivePrompt(state, "agent_settled");
+    if (run === undefined)
+        return;
+    const transitioned = yield* tryPromptTransition(state, run, {
+        type: "settle",
+    });
+    if (transitioned)
+        yield* completeSettlement(state, run);
+});
+const ignoredConversationEvents = new Set([
+    "agent_end",
+    "agent_start",
+    "message_start",
+    "message_update",
+    "turn_end",
+    "turn_start",
+]);
+const forbiddenConversationEvents = new Set([
+    "auto_retry_end",
+    "auto_retry_start",
+    "bash_execution_update",
+    "compaction_end",
+    "compaction_start",
+    "extension_error",
+    "extension_ui_request",
+    "queue_update",
+    "summarization_retry_attempt_start",
+    "summarization_retry_finished",
+    "summarization_retry_scheduled",
+    "tool_execution_end",
+    "tool_execution_start",
+    "tool_execution_update",
+]);
+const readRecordType = Effect.fn("PiRpcConversation.readRecordType")(function* (state, value) {
+    try {
+        return decodeProtocol(() => decodeRecordEnvelope(value)).type;
+    }
+    catch (error) {
+        yield* failConversation(state, error instanceof PiRpcFailure ? error : schemaFailure());
+        return undefined;
+    }
+});
+const unsupportedRecordFailure = (type) => piRpcFailure(forbiddenConversationEvents.has(type)
+    ? "lifecycle_invalid"
+    : "protocol_invalid", forbiddenConversationEvents.has(type)
+    ? "Pi RPC emitted a surface disabled by the conversation-only tier."
+    : "Pi RPC emitted an unsupported record type.");
+const acceptRecord = Effect.fn("PiRpcConversation.acceptRecord")(function* (state, value) {
+    const type = yield* readRecordType(state, value);
+    if (type === undefined)
+        return;
+    if (type === "response")
+        return yield* acceptResponse(state, value);
+    if (type === "message_end")
+        return yield* acceptMessageEnd(state, value);
+    if (type === "agent_settled") {
+        return yield* acceptAgentSettled(state, value);
+    }
+    if (type === "session_info_changed") {
+        return yield* acceptSessionInfoChanged(state, value);
+    }
+    if (ignoredConversationEvents.has(type))
+        return;
+    return yield* failConversation(state, unsupportedRecordFailure(type));
+});
+const decodeStdoutChunk = Effect.fn("PiRpcConversation.decodeStdoutChunk")(function* (state, decoder, chunk) {
+    state.stdoutBytes += chunk.byteLength;
+    if (state.stdoutBytes > piRpcLimits.maximumStdoutBytes) {
+        yield* failConversation(state, piRpcFailure("output_limit_exceeded", "Pi RPC stdout exceeded its process byte limit."));
+        return undefined;
+    }
+    try {
+        return decoder.accept(chunk);
+    }
+    catch (error) {
+        yield* failConversation(state, error instanceof PiRpcFailure ? error : schemaFailure());
+        return undefined;
+    }
+});
+const acceptStdoutChunk = Effect.fn("PiRpcConversation.acceptStdout")(function* (state, decoder, chunk) {
+    const records = yield* decodeStdoutChunk(state, decoder, chunk);
+    if (records === undefined)
+        return;
+    yield* Effect.forEach(records, (record) => state.failure === undefined ? acceptRecord(state, record) : Effect.void, { concurrency: 1, discard: true });
+});
+const finishStdout = Effect.fn("PiRpcConversation.finishStdout")(function* (state, decoder) {
+    if (state.failure === undefined) {
+        try {
+            decoder.finish();
+        }
+        catch (error) {
+            yield* failConversation(state, error instanceof PiRpcFailure ? error : schemaFailure());
+        }
+    }
+    state.stdoutEnded = true;
+    yield* Deferred.succeed(state.stdoutEndedSignal, true);
+    if (state.failure === undefined && !state.released) {
+        yield* failConversation(state, piRpcFailure("runtime_exited", "Pi RPC stdout reached EOF."));
+    }
+});
+const runStdout = Effect.fn("PiRpcConversation.runStdout")(function* (state, process_) {
+    const decoder = new StrictLfJsonlDecoder(piRpcLimits.maximumOutputRecordBytes, piRpcLimits.maximumOutputRecordsPerChunk);
+    const streamOutcome = yield* Effect.exit(Stream.runForEach(process_.standardOutput, (chunk) => state.failure === undefined
+        ? acceptStdoutChunk(state, decoder, chunk)
+        : Effect.void));
+    if (streamOutcome._tag === "Failure" && state.failure === undefined) {
+        yield* failConversation(state, piRpcFailure("transport_failed", "The Pi RPC stdout stream failed."));
+    }
+    yield* finishStdout(state, decoder);
+});
+const acceptStderrChunk = Effect.fn("PiRpcConversation.acceptStderr")(function* (state, chunk) {
+    state.stderrBytes += chunk.byteLength;
+    if (state.stderrBytes > piRpcLimits.maximumStderrBytes &&
+        state.failure === undefined) {
+        yield* failConversation(state, piRpcFailure("output_limit_exceeded", "Pi RPC stderr exceeded its process byte limit."));
+    }
+    // Continue draining after crossing the diagnostic byte limit.
+});
+const runStderr = Effect.fn("PiRpcConversation.runStderr")(function* (state, process_) {
+    yield* Stream.runForEach(process_.standardError, (chunk) => acceptStderrChunk(state, chunk)).pipe(Effect.catch(() => state.failure === undefined
+        ? failConversation(state, piRpcFailure("transport_failed", "The Pi RPC stderr stream failed."))
+        : Effect.void));
+});
+const failExitSupervision = (state, failure) => Deferred.fail(state.processExit, failure).pipe(Effect.andThen(state.failure === undefined && !state.released
+    ? failConversation(state, failure)
+    : Effect.void));
+const waitForStdoutAfterExit = (state) => Deferred.await(state.stdoutEndedSignal).pipe(Effect.timeoutOrElse({
+    duration: piRpcLimits.exitDrainDeadline,
+    orElse: () => state.failure === undefined && !state.released
+        ? failConversation(state, piRpcFailure("runtime_exited", "The Pi RPC process exited before stdout drained."))
+        : Effect.void,
+}), Effect.asVoid);
+const superviseExit = Effect.fn("PiRpcConversation.superviseExit")(function* (state, process_) {
+    yield* process_.exit.pipe(Effect.matchEffect({
+        onFailure: (failure) => failExitSupervision(state, failure instanceof PiRpcFailure
+            ? failure
+            : piRpcFailure("transport_failed", "The Pi RPC process exit failed.")),
+        onSuccess: (exit) => Deferred.succeed(state.processExit, exit).pipe(Effect.andThen(state.stdoutEnded || state.released
+            ? Effect.void
+            : waitForStdoutAfterExit(state))),
+    }));
+});
+const hasValidSessionState = (state, plan) => state.sessionId === plan.activation.sessionId &&
+    state.sessionFile !== undefined &&
+    isAbsolute(state.sessionFile) &&
+    normalize(state.sessionFile) === state.sessionFile &&
+    dirname(state.sessionFile) === plan.sessionDirectory &&
+    state.sessionFile.endsWith(".jsonl") &&
+    !state.autoCompactionEnabled;
+const isIdleSessionState = (state) => !state.isStreaming && !state.isCompacting && state.pendingMessageCount === 0;
+const requireSessionState = (value, plan) => {
+    const state = decodeProtocol(() => decodeSessionState(value));
+    if (!hasValidSessionState(state, plan)) {
+        throw piRpcFailure("protocol_invalid", "Pi RPC returned an invalid node-private session identity or policy state.");
+    }
+    if (plan.activation.sessionFile !== undefined &&
+        state.sessionFile !== plan.activation.sessionFile) {
+        throw piRpcFailure("protocol_invalid", "Pi RPC did not resume the exact persisted session file.");
+    }
+    return state;
+};
+const requireIdleSessionState = (state) => {
+    if (!isIdleSessionState(state)) {
+        throw piRpcFailure("lifecycle_invalid", "Pi RPC activation returned a session that was not idle.");
+    }
+};
+const getState = Effect.fn("PiRpcConversation.getState")(function* (state, plan) {
+    const value = yield* sendRequest(state, {
+        command: "get_state",
+        request: { type: "get_state" },
+        timeoutReason: "request_outcome_unknown",
+    });
+    try {
+        return requireSessionState(value, plan);
+    }
+    catch (error) {
+        const failure = error instanceof PiRpcFailure ? error : schemaFailure();
+        yield* failConversation(state, failure);
+        return yield* Effect.fail(failure);
+    }
+});
+const disableAutomaticWork = Effect.fn("PiRpcConversation.disableAutomaticWork")(function* (state) {
+    yield* sendRequest(state, {
+        command: "set_auto_retry",
+        request: { enabled: false, type: "set_auto_retry" },
+        timeoutReason: "request_outcome_unknown",
+    });
+    yield* sendRequest(state, {
+        command: "set_auto_compaction",
+        request: { enabled: false, type: "set_auto_compaction" },
+        timeoutReason: "request_outcome_unknown",
+    });
+});
+const materializeFreshSession = Effect.fn("PiRpcConversation.materializeFreshSession")(function* (state, plan) {
+    if (plan.activation.kind !== "fresh")
+        return;
+    const name = `Maia session ${plan.activation.sessionId}`;
+    const value = yield* sendRequest(state, {
+        command: "set_session_name",
+        expectedSessionName: name,
+        request: {
+            name,
+            type: "set_session_name",
+        },
+        timeoutReason: "request_outcome_unknown",
+    });
+    if (value !== undefined) {
+        const failure = piRpcFailure("protocol_invalid", "Pi RPC returned unexpected session materialization data.");
+        yield* failConversation(state, failure);
+        return yield* Effect.fail(failure);
+    }
+});
+const makePromptRun = Effect.fn("PiRpcConversation.makePromptRun")(function* (requestId) {
+    const messageEnd = yield* Deferred.make();
+    const settled = yield* Deferred.make();
+    return {
+        actor: createActor(piRpcPromptLifecycleMachine).start(),
+        messageEnd,
+        messageEndCount: 0,
+        messages: [],
+        requestId,
+        settled,
+    };
+});
+const validatePromptInput = Effect.fn("PiRpcConversation.validatePromptInput")(function* (input) {
+    const requestId = yield* validateRequestId(input.requestId);
+    if (input.message.length === 0 ||
+        Buffer.byteLength(input.message, "utf8") > piRpcLimits.maximumPromptBytes) {
+        return yield* Effect.fail(piRpcFailure("invalid_request", "The Pi RPC prompt is empty or exceeds its byte limit."));
+    }
+    return requestId;
+});
+const handlePromptRejection = (state, run, error) => {
+    if (state.activePrompt === run) {
+        if (run.actor.getSnapshot().can({ type: "reject" })) {
+            if (error.reason === "command_rejected") {
+                run.actor.send({ type: "reject" });
+            }
+            else {
+                run.actor.send({ type: "fail" });
+            }
+        }
+        state.activePrompt = undefined;
+        run.actor.stop();
+    }
+    return Effect.fail(error);
+};
+const promptAcceptance = (state, run, message) => sendRequest(state, {
+    callerRequestId: run.requestId,
+    command: "prompt",
+    request: { message, type: "prompt" },
+    timeoutReason: "prompt_acceptance_unknown",
+}).pipe(Effect.onInterrupt(() => failConversation(state, piRpcFailure("prompt_acceptance_unknown", "Pi RPC prompt acceptance became unknown after interruption."))), Effect.catch((error) => handlePromptRejection(state, run, error)));
+const acceptPromptAcknowledgement = Effect.fn("PiRpcConversation.acceptPromptAcknowledgement")(function* (state, run, value) {
+    if (value !== undefined) {
+        const failure = piRpcFailure("protocol_invalid", "Pi RPC returned unexpected prompt response data.");
+        yield* failConversation(state, failure);
+        return yield* Effect.fail(failure);
+    }
+    const transitioned = yield* tryPromptTransition(state, run, {
+        type: "accept",
+    });
+    if (!transitioned)
+        return yield* Effect.fail(state.failure ?? schemaFailure());
+});
+const startPrompt = Effect.fn("PiRpcConversation.prompt")(function* (state, input) {
+    const requestId = yield* validatePromptInput(input);
+    const run = yield* makePromptRun(requestId);
+    if (state.activePrompt !== undefined) {
+        run.actor.stop();
+        return yield* Effect.fail(piRpcFailure("saturated", "The Pi RPC conversation already has an active prompt."));
+    }
+    state.activePrompt = run;
+    const acknowledgement = yield* promptAcceptance(state, run, input.message);
+    yield* acceptPromptAcknowledgement(state, run, acknowledgement);
+    return {
+        acceptance: "accepted",
+        messageEnd: Deferred.await(run.messageEnd),
+        requestId,
+        settled: Deferred.await(run.settled),
+    };
+});
+const transitionToAborting = (run) => Effect.try({
+    catch: (error) => (error instanceof PiRpcFailure ? error : schemaFailure()),
+    try: () => {
+        transitionPrompt(run, { type: "abortRequest" });
+    },
+});
+const acceptAbortAcknowledgement = Effect.fn("PiRpcConversation.acceptAbortAcknowledgement")(function* (state, value) {
+    if (value === undefined)
+        return;
+    const failure = piRpcFailure("protocol_invalid", "Pi RPC returned unexpected abort response data.");
+    yield* failConversation(state, failure);
+    return yield* Effect.fail(failure);
+});
+const failAbortRequest = (state, failure) => failConversation(state, failure).pipe(Effect.andThen(Effect.fail(failure)));
+const sendAbortRequest = (state, requestId) => sendRequest(state, {
+    callerRequestId: requestId,
+    command: "abort",
+    request: { type: "abort" },
+    timeoutReason: "request_outcome_unknown",
+}).pipe(Effect.onInterrupt(() => failConversation(state, piRpcFailure("request_outcome_unknown", "Pi RPC abort outcome became unknown after interruption."))), Effect.catch((error) => failAbortRequest(state, error)));
+const abortPrompt = Effect.fn("PiRpcConversation.abort")(function* (state, input) {
+    const requestId = yield* validateRequestId(input.requestId);
+    const run = state.activePrompt;
+    if (run === undefined) {
+        return yield* Effect.fail(piRpcFailure("invalid_request", "The Pi RPC conversation has no active prompt to abort."));
+    }
+    yield* transitionToAborting(run);
+    const acknowledgement = yield* sendAbortRequest(state, requestId);
+    yield* acceptAbortAcknowledgement(state, acknowledgement);
+    return {
+        acknowledged: true,
+        requestId,
+        settlement: Deferred.await(run.settled),
+    };
+});
+const stopProcess = (process_) => process_.shutdown.pipe(Effect.timeoutOrElse({
+    duration: "2 seconds",
+    orElse: () => Effect.fail(piRpcFailure("cleanup_unknown", "The Pi RPC process shutdown deadline expired.")),
+}), Effect.match({
+    onFailure: (failure) => ({
+        failure: failure instanceof PiRpcFailure
+            ? failure
+            : piRpcFailure("cleanup_unknown", "The Pi RPC process shutdown failed."),
+        state: "cleanup_unknown",
+    }),
+    onSuccess: () => ({ state: "clean" }),
+}));
+const stopProcessOnce = Effect.fn("PiRpcConversation.stopProcessOnce")(function* (state, process_) {
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+        if (state.cleanupStarted)
+            return yield* Deferred.await(state.cleanup);
+        state.cleanupStarted = true;
+        const interrupted = {
+            failure: piRpcFailure("cleanup_unknown", "The Pi RPC process shutdown was interrupted."),
+            state: "cleanup_unknown",
+        };
+        const outcome = yield* restore(stopProcess(process_)).pipe(Effect.onInterrupt(() => Deferred.succeed(state.cleanup, interrupted)));
+        yield* Deferred.succeed(state.cleanup, outcome);
+        return outcome;
+    }));
+});
+const stopProcessAfterFatal = Effect.fn("PiRpcConversation.stopProcessAfterFatal")(function* (state, process_) {
+    yield* Deferred.await(state.fatal).pipe(Effect.flip);
+    yield* stopProcessOnce(state, process_);
+});
+const releaseConversation = Effect.fn("PiRpcConversation.release")(function* (state, process_) {
+    if (state.released)
+        return;
+    state.released = true;
+    const failure = piRpcFailure("runtime_exited", "The Pi RPC conversation scope closed.");
+    const pending = [...state.pending.values()];
+    state.pending.clear();
+    const activePrompt = state.activePrompt;
+    state.activePrompt = undefined;
+    yield* failPendingRequests(pending, failure);
+    if (activePrompt !== undefined) {
+        yield* failPrompt(activePrompt, failure);
+    }
+    yield* Queue.shutdown(state.input);
+    yield* stopProcessOnce(state, process_);
+});
+const makeConversationState = Effect.fn("PiRpcConversation.makeState")(function* () {
+    return {
+        callerTombstones: new Set(),
+        cleanup: yield* Deferred.make(),
+        cleanupStarted: false,
+        fatal: yield* Deferred.make(),
+        input: yield* Queue.bounded(piRpcLimits.maximumPendingInputRecords),
+        nextWireRequestId: 0n,
+        pending: new Map(),
+        pendingInputBytes: 0,
+        processExit: yield* Deferred.make(),
+        released: false,
+        stderrBytes: 0,
+        stdoutBytes: 0,
+        stdoutEnded: false,
+        stdoutEndedSignal: yield* Deferred.make(),
+        wireTombstones: new Set(),
+    };
+});
+const attachConversationSupervision = Effect.fn("PiRpcConversation.attachSupervision")(function* (state, process_) {
+    yield* Effect.uninterruptible(Effect.gen(function* () {
+        yield* Effect.forkScoped(runSerializedInputWriter(state, process_));
+        yield* Effect.forkScoped(runStdout(state, process_));
+        yield* Effect.forkScoped(runStderr(state, process_));
+        yield* Effect.forkScoped(superviseExit(state, process_));
+        yield* Effect.forkScoped(stopProcessAfterFatal(state, process_));
+        yield* Effect.addFinalizer(() => releaseConversation(state, process_));
+    }));
+});
+const projectConversation = (state, plan, initialState) => ({
+    abort: (input) => abortPrompt(state, input),
+    activation: {
+        kind: plan.activation.kind,
+        promptReplay: "never",
+        sessionFile: initialState.sessionFile,
+        sessionId: initialState.sessionId,
+    },
+    cleanup: Deferred.await(state.cleanup),
+    failure: Deferred.await(state.fatal),
+    getState: getState(state, plan),
+    processExit: Deferred.await(state.processExit),
+    prompt: (input) => startPrompt(state, input),
+});
+/**
+ * Attaches the protocol core to an already-authorized process. It performs no
+ * launch, artifact verification, filesystem creation, or public composition.
+ */
+export const acquirePiRpcConversation = Effect.fn("PiRpcConversation.acquire")(function* (process_, plan) {
+    const state = yield* makeConversationState();
+    yield* attachConversationSupervision(state, process_);
+    yield* disableAutomaticWork(state);
+    yield* getState(state, plan);
+    yield* materializeFreshSession(state, plan);
+    const initialState = yield* getState(state, plan);
+    try {
+        requireIdleSessionState(initialState);
+    }
+    catch (error) {
+        const failure = error instanceof PiRpcFailure ? error : schemaFailure();
+        yield* failConversation(state, failure);
+        return yield* Effect.fail(failure);
+    }
+    const sessionFile = initialState.sessionFile;
+    if (sessionFile === undefined) {
+        const failure = piRpcFailure("protocol_invalid", "Pi RPC omitted its persistent session file.");
+        yield* failConversation(state, failure);
+        return yield* Effect.fail(failure);
+    }
+    return projectConversation(state, plan, { ...initialState, sessionFile });
+});
+//# sourceMappingURL=conversation.js.map