@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/agent/harness/compaction/utils.js

@@ -0,0 +1,119 @@
+import { andorraContentText } from "../../../ai/index.js";
+/** Create an empty file-operation accumulator. */
+export function andorraCreateFileOps() {
+    return {
+        read: new Set(),
+        written: new Set(),
+        edited: new Set(),
+    };
+}
+/** Add file operations from assistant tool calls to an accumulator. */
+export function andorraExtractFileOpsFromMessage(message, fileOps) {
+    if (message.role !== "assistant")
+        return;
+    if (!("content" in message) || !Array.isArray(message.content))
+        return;
+    for (const block of message.content) {
+        if (typeof block !== "object" || block === null)
+            continue;
+        if (!("type" in block) || block.type !== "toolCall")
+            continue;
+        if (!("arguments" in block) || !("name" in block))
+            continue;
+        const args = block.arguments;
+        if (!args)
+            continue;
+        const path = typeof args.path === "string" ? args.path : undefined;
+        if (!path)
+            continue;
+        switch (block.name) {
+            case "read":
+                fileOps.read.add(path);
+                break;
+            case "write":
+                fileOps.written.add(path);
+                break;
+            case "edit":
+                fileOps.edited.add(path);
+                break;
+        }
+    }
+}
+/** Compute sorted read-only and modified file lists from accumulated operations. */
+export function andorraComputeFileLists(fileOps) {
+    const modified = new Set([...fileOps.edited, ...fileOps.written]);
+    const readOnly = [...fileOps.read].filter((f) => !modified.has(f)).sort();
+    const modifiedFiles = [...modified].sort();
+    return { readFiles: readOnly, modifiedFiles };
+}
+/** Format file lists as summary metadata tags. */
+export function andorraFormatFileOperations(readFiles, modifiedFiles) {
+    const sections = [];
+    if (readFiles.length > 0) {
+        sections.push(`<read-files>\n${readFiles.join("\n")}\n</read-files>`);
+    }
+    if (modifiedFiles.length > 0) {
+        sections.push(`<modified-files>\n${modifiedFiles.join("\n")}\n</modified-files>`);
+    }
+    if (sections.length === 0)
+        return "";
+    return `\n\n${sections.join("\n\n")}`;
+}
+const TOOL_RESULT_MAX_CHARS = 2000;
+function andorraSafeJsonStringify(value) {
+    try {
+        return JSON.stringify(value) ?? "undefined";
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
+function andorraTruncateForSummary(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const truncatedChars = text.length - maxChars;
+    return `${text.slice(0, maxChars)}\n\n[... ${truncatedChars} more characters truncated]`;
+}
+/** Serialize LLM messages to plain text for summarization prompts. */
+export function andorraSerializeConversation(messages) {
+    const parts = [];
+    for (const msg of messages) {
+        if (msg.role === "user") {
+            const content = andorraContentText(msg.content, "");
+            if (content)
+                parts.push(`[User]: ${content}`);
+        }
+        else if (msg.role === "assistant") {
+            const thinkingParts = [];
+            const toolCalls = [];
+            for (const block of msg.content) {
+                if (block.type === "thinking") {
+                    thinkingParts.push(block.thinking);
+                }
+                else if (block.type === "toolCall") {
+                    const args = block.arguments;
+                    const argsStr = Object.entries(args)
+                        .map(([k, v]) => `${k}=${andorraSafeJsonStringify(v)}`)
+                        .join(", ");
+                    toolCalls.push(`${block.name}(${argsStr})`);
+                }
+            }
+            if (thinkingParts.length > 0) {
+                parts.push(`[Assistant thinking]: ${thinkingParts.join("\n")}`);
+            }
+            if (msg.content.some((block) => block.type === "text")) {
+                parts.push(`[Assistant]: ${andorraContentText(msg.content)}`);
+            }
+            if (toolCalls.length > 0) {
+                parts.push(`[Assistant tool calls]: ${toolCalls.join("; ")}`);
+            }
+        }
+        else if (msg.role === "toolResult") {
+            const content = andorraContentText(msg.content, "");
+            if (content) {
+                parts.push(`[Tool result]: ${andorraTruncateForSummary(content, TOOL_RESULT_MAX_CHARS)}`);
+            }
+        }
+    }
+    return parts.join("\n\n");
+}

package/dist/vendor/engine/runtime/agent/harness/config.d.ts

@@ -0,0 +1,8 @@
+import { type RetryPolicy } from "../../ai/index.js";
+import type { CompactionSettings } from "./compaction/compaction.js";
+export declare const DEFAULT_RETRY_POLICY: RetryPolicy;
+export declare function andorraValidateToolNames(tools: readonly {
+    name: string;
+}[]): void;
+export declare function andorraValidateRetryPolicy(policy: RetryPolicy): void;
+export declare function andorraValidateCompactionSettings(settings: CompactionSettings): void;

package/dist/vendor/engine/runtime/agent/harness/config.js

@@ -0,0 +1,34 @@
+import { DEFAULT_MAX_AGENT_RETRY_DELAY_MS } from "../../ai/index.js";
+export const DEFAULT_RETRY_POLICY = {
+    enabled: true,
+    maxRetries: 3,
+    baseDelayMs: 1_000,
+    maxAgentDelayMs: DEFAULT_MAX_AGENT_RETRY_DELAY_MS,
+};
+export function andorraValidateToolNames(tools) {
+    const names = new Set();
+    for (const tool of tools) {
+        if (names.has(tool.name))
+            throw new TypeError(`Duplicate tool name: ${JSON.stringify(tool.name)}`);
+        names.add(tool.name);
+    }
+}
+export function andorraValidateRetryPolicy(policy) {
+    if (!Number.isSafeInteger(policy.maxRetries) ||
+        policy.maxRetries < 0 ||
+        policy.maxRetries === Number.MAX_SAFE_INTEGER ||
+        !Number.isSafeInteger(policy.baseDelayMs) ||
+        policy.baseDelayMs < 0 ||
+        (policy.maxAgentDelayMs !== undefined &&
+            (!Number.isSafeInteger(policy.maxAgentDelayMs) || policy.maxAgentDelayMs < 0))) {
+        throw new RangeError("Retry policy values must be finite non-negative safe integers");
+    }
+}
+export function andorraValidateCompactionSettings(settings) {
+    if (!Number.isSafeInteger(settings.reserveTokens) ||
+        settings.reserveTokens < 0 ||
+        !Number.isSafeInteger(settings.keepRecentTokens) ||
+        settings.keepRecentTokens < 0) {
+        throw new RangeError("Compaction token counts must be finite non-negative safe integers");
+    }
+}

package/dist/vendor/engine/runtime/agent/harness/context.d.ts

@@ -0,0 +1,8 @@
+import type { Context, ContextKey } from "../../chord/index.js";
+import { andorraAwaitWithContext, BACKGROUND_CONTEXT, andorraCreateContextKey, TODO_CONTEXT, andorraWithAbortSignal, andorraWithCancel, andorraWithContextValue, andorraWithoutAbortSignal } from "../../chord/context/index.js";
+import { type TelemetryContext } from "../../telemetry/index.js";
+export { andorraAwaitWithContext, BACKGROUND_CONTEXT, type Context, type ContextKey, andorraCreateContextKey, TODO_CONTEXT, andorraWithAbortSignal, andorraWithCancel, andorraWithContextValue, andorraWithoutAbortSignal, };
+/** Return the telemetry parent attached to a context, or the shared no-op parent. */
+export declare function andorraGetTelemetryContext(context: Context): TelemetryContext;
+/** Derive a context whose telemetry children use the supplied parent or active span. */
+export declare function andorraWithTelemetryContext(telemetryContext: TelemetryContext, context: Context): Context;

package/dist/vendor/engine/runtime/agent/harness/context.js

@@ -0,0 +1,12 @@
+import { andorraAwaitWithContext, BACKGROUND_CONTEXT, andorraCreateContextKey, TODO_CONTEXT, andorraWithAbortSignal, andorraWithCancel, andorraWithContextValue, andorraWithoutAbortSignal, } from "../../chord/context/index.js";
+import { NOOP_TELEMETRY_CONTEXT } from "../../telemetry/index.js";
+export { andorraAwaitWithContext, BACKGROUND_CONTEXT, andorraCreateContextKey, TODO_CONTEXT, andorraWithAbortSignal, andorraWithCancel, andorraWithContextValue, andorraWithoutAbortSignal, };
+const TELEMETRY_CONTEXT_KEY = andorraCreateContextKey("pi.telemetryContext");
+/** Return the telemetry parent attached to a context, or the shared no-op parent. */
+export function andorraGetTelemetryContext(context) {
+    return context.value(TELEMETRY_CONTEXT_KEY) ?? NOOP_TELEMETRY_CONTEXT;
+}
+/** Derive a context whose telemetry children use the supplied parent or active span. */
+export function andorraWithTelemetryContext(telemetryContext, context) {
+    return andorraWithContextValue(TELEMETRY_CONTEXT_KEY, telemetryContext, context);
+}

package/dist/vendor/engine/runtime/agent/harness/events.d.ts

@@ -0,0 +1,24 @@
+import type { EventListener, Events, HarnessEvent, HarnessEventType, WatchHandle } from "./agent-harness.js";
+import type { Context } from "./context.js";
+type ResnapshotCapture<T> = (context: Context, markBoundary: () => void) => Promise<T>;
+/** Passive harness event bus with isolated handler failures. */
+export declare class AndorraHarnessEventBus implements Events {
+    private readonly listeners;
+    private readonly watchListeners;
+    private deliveryTail;
+    private closedError;
+    on<TType extends HarnessEventType>(type: TType, listener: EventListener<Extract<HarnessEvent, {
+        type: TType;
+    }>>): () => void;
+    emit(event: HarnessEvent, context: Context): Promise<void>;
+    /** Bind current recipients and append one contiguous batch to the global delivery tail. */
+    emitBatch(events: readonly HarnessEvent[], context: Context): Promise<void>;
+    watch<T>(snapshot: T, filter: (event: HarnessEvent) => boolean, _context: Context, resnapshot?: ResnapshotCapture<T>): WatchHandle<T>;
+    watchFromSnapshot<T>(capture: (context: Context) => Promise<T>, filter: (event: HarnessEvent) => boolean, context: Context): Promise<WatchHandle<T>>;
+    close(error: Error): void;
+    private installWatcher;
+    private enqueueBarrier;
+    private snapshotRecipients;
+    private deliver;
+}
+export {};

package/dist/vendor/engine/runtime/agent/harness/events.js

@@ -0,0 +1,249 @@
+/** Passive harness event bus with isolated handler failures. */
+export class AndorraHarnessEventBus {
+    listeners = new Map();
+    watchListeners = new Set();
+    deliveryTail = Promise.resolve();
+    closedError;
+    on(type, listener) {
+        if (this.closedError !== undefined)
+            throw this.closedError;
+        const andorraWrapped = (event, context) => listener(event, context);
+        let listeners = this.listeners.get(type);
+        if (listeners === undefined) {
+            listeners = new Set();
+            this.listeners.set(type, listeners);
+        }
+        listeners.add(andorraWrapped);
+        return () => listeners?.delete(andorraWrapped);
+    }
+    emit(event, context) {
+        return this.emitBatch([event], context);
+    }
+    /** Bind current recipients and append one contiguous batch to the global delivery tail. */
+    emitBatch(events, context) {
+        if (this.closedError !== undefined || events.length === 0)
+            return Promise.resolve();
+        const bound = events.map((event) => {
+            const payload = structuredClone(event);
+            return { payload, recipients: this.snapshotRecipients(payload) };
+        });
+        const delivery = this.deliveryTail.then(async () => {
+            for (const { payload, recipients } of bound)
+                await this.deliver(payload, recipients, true, context);
+        });
+        this.deliveryTail = delivery.catch(() => { });
+        return delivery;
+    }
+    watch(snapshot, filter, _context, resnapshot) {
+        if (this.closedError !== undefined)
+            throw this.closedError;
+        return this.installWatcher(snapshot, filter, resnapshot);
+    }
+    async watchFromSnapshot(capture, filter, context) {
+        if (this.closedError !== undefined)
+            throw this.closedError;
+        const watcher = this.installWatcher(undefined, filter, async (captureContext, markBoundary) => {
+            const snapshot = await capture(captureContext);
+            markBoundary();
+            return snapshot;
+        });
+        try {
+            watcher.setSnapshot(await capture(context));
+            return watcher;
+        }
+        catch (error) {
+            watcher.unsubscribe();
+            throw error;
+        }
+    }
+    close(error) {
+        this.closedError ??= error;
+        void this.deliveryTail.finally(() => {
+            this.listeners.clear();
+            this.watchListeners.clear();
+        });
+    }
+    installWatcher(snapshot, filter, resnapshot) {
+        let watcher;
+        const capture = resnapshot === undefined
+            ? undefined
+            : async (context) => {
+                let marked = false;
+                const next = await resnapshot(context, () => {
+                    if (marked)
+                        throw new Error("Resnapshot boundary was already marked");
+                    marked = true;
+                    this.enqueueBarrier(() => watcher.markResnapshotBoundary());
+                });
+                if (!marked)
+                    throw new Error("Resnapshot capture did not mark its boundary");
+                return next;
+            };
+        watcher = new AndorraBufferedEventWatcher(snapshot, capture, async (error, event, context) => {
+            if (event.type === "handler_error")
+                return;
+            const normalized = error instanceof Error ? error : new Error(String(error));
+            const lane = "lane" in event && typeof event.lane === "string" ? event.lane : undefined;
+            await this.emit({
+                type: "handler_error",
+                kind: "event",
+                event: event.type,
+                error: normalized.message,
+                ...(normalized.stack === undefined ? {} : { stack: normalized.stack }),
+                ...(lane === undefined ? {} : { lane }),
+            }, context);
+        });
+        const andorraWatchListener = (event, context) => {
+            if (filter(event))
+                watcher.push(event, context);
+        };
+        this.watchListeners.add(andorraWatchListener);
+        watcher.setUnsubscribe(() => this.watchListeners.delete(andorraWatchListener));
+        return watcher;
+    }
+    enqueueBarrier(barrier) {
+        const delivery = this.deliveryTail.then(barrier);
+        this.deliveryTail = delivery.catch(() => { });
+    }
+    snapshotRecipients(event) {
+        return [...(this.listeners.get(event.type) ?? []), ...this.watchListeners];
+    }
+    async deliver(event, recipients, reportErrors, context) {
+        for (const listener of recipients) {
+            try {
+                await listener(structuredClone(event), context);
+            }
+            catch (error) {
+                if (!reportErrors || event.type === "handler_error")
+                    continue;
+                const normalized = error instanceof Error ? error : new Error(String(error));
+                const lane = "lane" in event && typeof event.lane === "string" ? event.lane : undefined;
+                const handlerError = {
+                    type: "handler_error",
+                    kind: "event",
+                    event: event.type,
+                    error: normalized.message,
+                    ...(normalized.stack === undefined ? {} : { stack: normalized.stack }),
+                    ...(lane === undefined ? {} : { lane }),
+                };
+                await this.deliver(handlerError, this.snapshotRecipients(handlerError), false, context);
+            }
+        }
+    }
+}
+class AndorraBufferedEventWatcher {
+    snapshot;
+    resnapshotCallback;
+    onError;
+    buffer = [];
+    listener;
+    unsubscribeCallback;
+    deliveryTail = Promise.resolve();
+    epoch = 0;
+    resnapshotState;
+    state = "buffering";
+    constructor(snapshot, resnapshot, onError) {
+        this.snapshot = snapshot;
+        this.resnapshotCallback = resnapshot;
+        this.onError = onError;
+    }
+    setSnapshot(snapshot) {
+        this.snapshot = snapshot;
+    }
+    start(listener) {
+        if (this.state !== "buffering")
+            throw new Error("WatchHandle.start() may be called only once");
+        this.state = "started";
+        this.listener = listener;
+        const buffered = this.buffer;
+        this.buffer = [];
+        for (const bufferedEvent of buffered) {
+            this.enqueue(bufferedEvent.event, bufferedEvent.context, bufferedEvent.epoch);
+        }
+    }
+    async resnapshot(context) {
+        if (this.state === "unsubscribed")
+            throw new Error("WatchHandle is unsubscribed");
+        if (this.resnapshotCallback === undefined)
+            throw new Error("WatchHandle does not support resnapshot");
+        if (this.resnapshotState !== undefined)
+            throw new Error("WatchHandle resnapshot is already in progress");
+        let resolveReached;
+        const reached = new Promise((resolve) => {
+            resolveReached = resolve;
+        });
+        const resnapshotState = {
+            phase: "dropping",
+            held: [],
+            reached,
+            resolveReached,
+        };
+        this.epoch++;
+        this.resnapshotState = resnapshotState;
+        try {
+            const snapshot = await this.resnapshotCallback(context);
+            await reached;
+            this.snapshot = snapshot;
+            this.resnapshotState = undefined;
+            for (const held of resnapshotState.held)
+                this.push(held.event, held.context);
+            return snapshot;
+        }
+        catch (error) {
+            this.resnapshotState = undefined;
+            for (const held of resnapshotState.held)
+                this.push(held.event, held.context);
+            throw error;
+        }
+    }
+    markResnapshotBoundary() {
+        const resnapshot = this.resnapshotState;
+        if (resnapshot === undefined || resnapshot.phase !== "dropping")
+            return;
+        resnapshot.phase = "holding";
+        resnapshot.resolveReached();
+    }
+    unsubscribe() {
+        if (this.state === "unsubscribed")
+            return;
+        this.state = "unsubscribed";
+        this.buffer = [];
+        this.listener = undefined;
+        this.unsubscribeCallback?.();
+        this.unsubscribeCallback = undefined;
+    }
+    push(event, context) {
+        if (this.state === "unsubscribed")
+            return;
+        if (this.resnapshotState?.phase === "dropping")
+            return;
+        if (this.resnapshotState?.phase === "holding") {
+            this.resnapshotState.held.push({ event, context });
+            return;
+        }
+        if (this.state === "buffering") {
+            this.buffer.push({ event, context, epoch: this.epoch });
+            return;
+        }
+        this.enqueue(event, context, this.epoch);
+    }
+    setUnsubscribe(callback) {
+        this.unsubscribeCallback = callback;
+    }
+    enqueue(event, context, epoch) {
+        const listener = this.listener;
+        if (listener === undefined)
+            return;
+        this.deliveryTail = this.deliveryTail
+            .then(async () => {
+            if (this.state === "started" && epoch === this.epoch)
+                await listener(event, context);
+        })
+            .catch(async (error) => {
+            try {
+                await this.onError(error, event, context);
+            }
+            catch { }
+        });
+    }
+}

package/dist/vendor/engine/runtime/agent/harness/execution/assistant.d.ts

@@ -0,0 +1,41 @@
+import type { Context as AiContext, Api, AssistantMessage, AssistantMessageEvent, AndorraAssistantMessageEventStream, Message, Model, SimpleStreamOptions, Tool } from "../../../ai/index.js";
+import type { AgentMessage, ThinkingLevel } from "../../types.js";
+import { type Context } from "../context.js";
+import type { SettledAssistantMessage } from "../session/types.js";
+import type { AgentHarnessStreamOptions } from "../types.js";
+/** HTTP response metadata captured before the provider response body is consumed. */
+export interface AssistantResponseMetadata {
+    status?: number;
+    headers?: Record<string, string>;
+}
+/** Process-local lifecycle observer for one assistant stream. */
+export interface AssistantStreamObserver {
+    start(message: AssistantMessage, event: Extract<AssistantMessageEvent, {
+        type: "start";
+    }>, context: Context): void | Promise<void>;
+    update(message: AssistantMessage, event: AssistantMessageEvent, context: Context): void | Promise<void>;
+    end(message: SettledAssistantMessage, context: Context): void | Promise<void>;
+}
+/** Executable inputs for one already-approved assistant provider request. */
+export interface HarnessAssistantStreamConfig {
+    model: Model<Api>;
+    systemPrompt: string;
+    tools?: Tool[];
+    thinkingLevel: ThinkingLevel;
+    streamOptions: AgentHarnessStreamOptions;
+    transformContext?: (requestContext: {
+        messages: AgentMessage[];
+        systemPrompt: string;
+    }, context: Context) => Promise<{
+        messages: AgentMessage[];
+        systemPrompt: string;
+    }>;
+    toProviderMessages: (messages: AgentMessage[], context: Context) => Message[] | Promise<Message[]>;
+    beforePayload?: (payload: unknown, model: Model<Api>, context: Context) => unknown | undefined | Promise<unknown | undefined>;
+    afterResponse?: (message: SettledAssistantMessage, metadata: AssistantResponseMetadata, context: Context) => Promise<SettledAssistantMessage>;
+    request(aiContext: AiContext, options: SimpleStreamOptions, context: Context): AndorraAssistantMessageEventStream | Promise<AndorraAssistantMessageEventStream>;
+    observer: AssistantStreamObserver;
+}
+export declare function andorraConsumeAssistantStream(stream: AndorraAssistantMessageEventStream, observer: AssistantStreamObserver, afterResponse: ((message: SettledAssistantMessage, context: Context) => Promise<SettledAssistantMessage>) | undefined, context: Context): Promise<SettledAssistantMessage>;
+/** Stream one assistant response without mutating the caller's message list. */
+export declare function andorraStreamHarnessAssistant(messages: AgentMessage[], config: HarnessAssistantStreamConfig, context: Context): Promise<SettledAssistantMessage>;

package/dist/vendor/engine/runtime/agent/harness/execution/assistant.js

@@ -0,0 +1,81 @@
+import { andorraGetTelemetryContext } from "../context.js";
+import { AndorraAbortRequested } from "./effect-gate.js";
+function andorraCreateRequestOptions(config, captureMetadata, context) {
+    const options = config.streamOptions;
+    return {
+        transport: options.transport,
+        timeoutMs: options.timeoutMs,
+        maxRetries: options.maxRetries,
+        maxRetryDelayMs: options.maxRetryDelayMs,
+        headers: options.headers,
+        metadata: options.metadata,
+        cacheRetention: options.cacheRetention,
+        deferred: options.deferred,
+        ...(config.thinkingLevel === "off" ? {} : { reasoning: config.thinkingLevel }),
+        signal: context.abortSignal,
+        telemetryContext: andorraGetTelemetryContext(context),
+        onPayload: config.beforePayload === undefined
+            ? undefined
+            : (payload, model) => config.beforePayload?.(payload, model, context),
+        onResponse: (response) => {
+            captureMetadata({ status: response.status, headers: response.headers });
+        },
+    };
+}
+function andorraIsUpdateEvent(event) {
+    return event.type !== "start" && event.type !== "done" && event.type !== "error";
+}
+export async function andorraConsumeAssistantStream(stream, observer, afterResponse, context) {
+    let started = false;
+    for await (const event of stream) {
+        if (event.type === "start") {
+            if (started)
+                throw new Error("Assistant message stream emitted more than one start event");
+            started = true;
+            await observer.start({ ...event.partial }, event, context);
+        }
+        else if (andorraIsUpdateEvent(event)) {
+            if (!started)
+                throw new Error(`Assistant message stream emitted ${event.type} before start`);
+            await observer.update({ ...event.partial }, event, context);
+        }
+        else if (event.type === "done" && !started) {
+            throw new Error("Assistant message stream emitted done before start");
+        }
+    }
+    const settled = (await stream.result());
+    let finalMessage = settled;
+    if (afterResponse !== undefined) {
+        try {
+            finalMessage = await afterResponse(settled, context);
+        }
+        catch (error) {
+            if (!(error instanceof AndorraAbortRequested))
+                throw error;
+            await error.cancellation;
+        }
+    }
+    await observer.end(finalMessage, context);
+    return finalMessage;
+}
+/** Stream one assistant response without mutating the caller's message list. */
+export async function andorraStreamHarnessAssistant(messages, config, context) {
+    let requestContext = { messages: messages.slice(), systemPrompt: config.systemPrompt };
+    if (config.transformContext) {
+        requestContext = await config.transformContext(requestContext, context);
+    }
+    const providerMessages = await config.toProviderMessages(requestContext.messages, context);
+    const aiContext = {
+        systemPrompt: requestContext.systemPrompt,
+        messages: providerMessages,
+        tools: config.tools,
+    };
+    let metadata = {};
+    const stream = await config.request(aiContext, andorraCreateRequestOptions(config, (nextMetadata) => {
+        metadata = nextMetadata;
+    }, context), context);
+    const afterResponse = config.afterResponse;
+    return andorraConsumeAssistantStream(stream, config.observer, afterResponse === undefined
+        ? undefined
+        : (message, afterContext) => afterResponse(message, metadata, afterContext), context);
+}

package/dist/vendor/engine/runtime/agent/harness/execution/effect-gate.d.ts

@@ -0,0 +1,21 @@
+/** Expected internal control flow when cancellation wins effect admission. */
+export declare class AndorraAbortRequested extends Error {
+    readonly cancellation: Promise<void>;
+    constructor(cancellation: Promise<void>);
+}
+/** Procedure-facing synchronous admission capability for one drive pass. */
+export interface Gate {
+    readonly signal: AbortSignal;
+    admit<T>(invoke: () => T): T;
+}
+/** Owner-facing lifecycle controls for one drive pass. */
+export interface GateControl {
+    beginAbort(cancellation: Promise<void>): void;
+    signalAbort(): void;
+    close(error: Error): void;
+}
+/** Create separate procedure-facing and owner-facing views of one effect gate. */
+export declare function andorraCreateGate(): {
+    gate: Gate;
+    control: GateControl;
+};

package/dist/vendor/engine/runtime/agent/harness/execution/effect-gate.js

@@ -0,0 +1,48 @@
+/** Expected internal control flow when cancellation wins effect admission. */
+export class AndorraAbortRequested extends Error {
+    cancellation;
+    constructor(cancellation) {
+        super("Abort requested");
+        this.name = "AbortRequested";
+        this.cancellation = cancellation;
+    }
+}
+/** Create separate procedure-facing and owner-facing views of one effect gate. */
+export function andorraCreateGate() {
+    let state = { status: "open" };
+    const controller = new AbortController();
+    const andorraCheck = () => {
+        if (state.status === "aborting")
+            throw new AndorraAbortRequested(state.cancellation);
+        if (state.status === "closed")
+            throw state.error;
+    };
+    return {
+        gate: {
+            admit(invoke) {
+                andorraCheck();
+                return invoke();
+            },
+            signal: controller.signal,
+        },
+        control: {
+            beginAbort(cancellation) {
+                if (state.status !== "open")
+                    return;
+                state = { status: "aborting", cancellation };
+            },
+            signalAbort() {
+                if (state.status !== "aborting" || controller.signal.aborted)
+                    return;
+                controller.abort(new AndorraAbortRequested(state.cancellation));
+            },
+            close(error) {
+                if (state.status === "closed")
+                    return;
+                state = { status: "closed", error };
+                if (!controller.signal.aborted)
+                    controller.abort(error);
+            },
+        },
+    };
+}