@nylorun/harness 0.8.0-beta.1 → 0.11.0-beta

package/dist/model/adapters.js

@@ -0,0 +1,545 @@
+import { HarnessError } from "../errors.js";
+import { copyJsonObject } from "../utils/immutable.js";
+import { preparedModel } from "./prepared.js";
+/** Translate a Harness call to the OpenAI Chat Completions request shape. */
+export function toChatCompletions(call) {
+    const messages = call.prompt.map((item) => {
+        if (item.kind === "instructions")
+            return { role: "system", content: textOf(item) };
+        if (item.kind === "tool-result")
+            return { role: "tool", tool_call_id: item.toolCallId, content: textOf(item) };
+        if (item.kind === "message" && item.role === "assistant") {
+            const toolCalls = toolCallsOf(item.content).map((part) => ({
+                id: part.id,
+                type: "function",
+                function: { name: part.name, arguments: JSON.stringify(part.args) },
+            }));
+            const text = textOf(item);
+            return {
+                role: "assistant",
+                content: text === "" ? null : text,
+                ...(toolCalls.length === 0 ? {} : { tool_calls: toolCalls }),
+            };
+        }
+        return { role: "user", content: chatContent(item.content) };
+    });
+    return {
+        messages,
+        ...(call.tools.length === 0
+            ? {}
+            : {
+                tools: call.tools.map((tool) => ({
+                    type: "function",
+                    function: {
+                        name: tool.name,
+                        ...(tool.description === undefined ? {} : { description: tool.description }),
+                        parameters: tool.inputSchema,
+                    },
+                })),
+            }),
+        ...chatControls(call),
+        ...(call.outputSchema === undefined
+            ? {}
+            : {
+                response_format: {
+                    type: "json_schema",
+                    json_schema: { name: "harness_output", schema: call.outputSchema },
+                },
+            }),
+    };
+}
+/** Translate a Chat Completions response into a Harness candidate. */
+export function fromChatCompletions(value, call) {
+    const response = record(value, "response");
+    const choices = array(response.choices, "response.choices");
+    if (choices.length === 0)
+        throw invalidResponse("response.choices must contain a choice", "response.choices");
+    const choice = record(choices[0], "response.choices[0]");
+    const message = record(choice.message, "response.choices[0].message");
+    const output = [];
+    if (typeof message.content === "string" && message.content !== "")
+        output.push(outputText(message.content, call?.outputSchema !== undefined));
+    if (typeof message.reasoning_content === "string" && message.reasoning_content !== "")
+        output.push({ type: "reasoning", text: message.reasoning_content });
+    for (const [index, raw] of optionalArray(message.tool_calls, "response.choices[0].message.tool_calls").entries()) {
+        const call = record(raw, `response.choices[0].message.tool_calls[${index}]`);
+        const fn = record(call.function, `response.choices[0].message.tool_calls[${index}].function`);
+        output.push({
+            type: "tool-call",
+            id: string(call.id, `response.choices[0].message.tool_calls[${index}].id`),
+            name: string(fn.name, `response.choices[0].message.tool_calls[${index}].function.name`),
+            ...argumentsOf(fn.arguments, `response.choices[0].message.tool_calls[${index}].function.arguments`),
+        });
+    }
+    return candidate({
+        output,
+        finishReason: chatFinishReason(choice.finish_reason, output),
+        usage: chatUsage(response.usage),
+        evidence: evidence(response),
+    });
+}
+/** Return a Harness adapter backed by an application-owned Chat Completions send function. */
+export function chatCompletionsAdapter(send) {
+    return preparedModel({
+        adapter: "openai.chat-completions",
+        async prepare(call) {
+            const request = toChatCompletions(call);
+            return { request, observed: request };
+        },
+        send,
+        decode: fromChatCompletions,
+    });
+}
+/** Translate a Harness call to the OpenAI Responses request shape. */
+export function toResponses(call) {
+    const instructions = call.prompt.filter((item) => item.kind === "instructions").map(textOf);
+    const input = call.prompt.flatMap((item) => {
+        if (item.kind === "instructions")
+            return [];
+        if (item.kind === "tool-result")
+            return [{ type: "function_call_output", call_id: item.toolCallId, output: textOf(item) }];
+        if (item.kind === "message" && item.role === "assistant") {
+            const text = textOf(item);
+            return [
+                ...(text === ""
+                    ? []
+                    : [{ type: "message", role: "assistant", content: text }]),
+                ...toolCallsOf(item.content).map((part) => ({
+                    type: "function_call",
+                    call_id: part.id,
+                    name: part.name,
+                    arguments: JSON.stringify(part.args),
+                })),
+            ];
+        }
+        return [{ type: "message", role: "user", content: responsesContent(item.content) }];
+    });
+    return {
+        ...(instructions.length === 0 ? {} : { instructions: instructions.join("\n\n") }),
+        input,
+        ...(call.tools.length === 0
+            ? {}
+            : {
+                tools: call.tools.map((tool) => ({
+                    type: "function",
+                    name: tool.name,
+                    ...(tool.description === undefined ? {} : { description: tool.description }),
+                    parameters: tool.inputSchema,
+                })),
+            }),
+        ...responsesControls(call),
+        ...(call.outputSchema === undefined
+            ? {}
+            : {
+                text: {
+                    format: {
+                        type: "json_schema",
+                        name: "harness_output",
+                        schema: call.outputSchema,
+                    },
+                },
+            }),
+    };
+}
+/** Translate an OpenAI Responses response into a Harness candidate. */
+export function fromResponses(value, call) {
+    const response = record(value, "response");
+    if (response.error !== undefined && response.error !== null)
+        throw invalidResponse("response.error is present", "response.error");
+    const output = [];
+    for (const [index, raw] of array(response.output, "response.output").entries()) {
+        const item = record(raw, `response.output[${index}]`);
+        if (item.type === "function_call") {
+            output.push({
+                type: "tool-call",
+                id: string(item.call_id, `response.output[${index}].call_id`),
+                name: string(item.name, `response.output[${index}].name`),
+                ...argumentsOf(item.arguments, `response.output[${index}].arguments`),
+            });
+            continue;
+        }
+        if (item.type === "message") {
+            for (const [partIndex, rawPart] of optionalArray(item.content, `response.output[${index}].content`).entries()) {
+                const part = record(rawPart, `response.output[${index}].content[${partIndex}]`);
+                if (part.type === "output_text" && typeof part.text === "string")
+                    output.push(outputText(part.text, call?.outputSchema !== undefined));
+            }
+            continue;
+        }
+        if (item.type === "reasoning") {
+            const summary = optionalArray(item.summary, `response.output[${index}].summary`)
+                .map((rawPart, partIndex) => record(rawPart, `response.output[${index}].summary[${partIndex}]`))
+                .filter((part) => part.type === "summary_text" && typeof part.text === "string")
+                .map((part) => part.text)
+                .join("\n");
+            if (summary !== "")
+                output.push({ type: "reasoning", text: summary });
+        }
+    }
+    return candidate({
+        output,
+        finishReason: responsesFinishReason(response, output),
+        usage: responsesUsage(response.usage),
+        evidence: evidence(response),
+    });
+}
+/** Return a Harness adapter backed by an application-owned Responses send function. */
+export function responsesAdapter(send) {
+    return preparedModel({
+        adapter: "openai.responses",
+        async prepare(call) {
+            const request = toResponses(call);
+            return { request, observed: request };
+        },
+        send,
+        decode: fromResponses,
+    });
+}
+/** Translate a Harness call to the Anthropic Messages request shape. */
+export function toMessages(call, defaultMaxOutputTokens) {
+    checkedMaxOutputTokens(defaultMaxOutputTokens);
+    if (call.outputSchema !== undefined)
+        throw new HarnessError("model.unsupported-output-schema", "Anthropic Messages output schemas require a custom prepared adapter");
+    const instructions = call.prompt.filter((item) => item.kind === "instructions").map(textOf);
+    const messages = call.prompt.flatMap((item) => {
+        if (item.kind === "instructions")
+            return [];
+        if (item.kind === "tool-result")
+            return [
+                {
+                    role: "user",
+                    content: [
+                        {
+                            type: "tool_result",
+                            tool_use_id: item.toolCallId,
+                            content: textOf(item),
+                            ...(item.status === "completed" ? {} : { is_error: true }),
+                        },
+                    ],
+                },
+            ];
+        if (item.kind === "message" && item.role === "assistant")
+            return [
+                {
+                    role: "assistant",
+                    content: item.content.map((part) => {
+                        if (part.type === "text")
+                            return { type: "text", text: part.text };
+                        if (part.type === "tool-call")
+                            return { type: "tool_use", id: part.id, name: part.name, input: part.args };
+                        throw unsupportedContent(part);
+                    }),
+                },
+            ];
+        return [{ role: "user", content: messagesContent(item.content) }];
+    });
+    return {
+        ...(instructions.length === 0 ? {} : { system: instructions.join("\n\n") }),
+        messages,
+        ...(call.tools.length === 0
+            ? {}
+            : {
+                tools: call.tools.map((tool) => ({
+                    name: tool.name,
+                    ...(tool.description === undefined ? {} : { description: tool.description }),
+                    input_schema: tool.inputSchema,
+                })),
+            }),
+        ...(call.model?.controls?.temperature === undefined
+            ? {}
+            : { temperature: call.model.controls.temperature }),
+        max_tokens: call.model?.controls?.maxOutputTokens ?? defaultMaxOutputTokens,
+    };
+}
+function outputText(text, structured) {
+    if (!structured)
+        return { type: "text", text };
+    try {
+        return { type: "json", value: JSON.parse(text) };
+    }
+    catch {
+        return { type: "text", text };
+    }
+}
+/** Translate an Anthropic Messages response into a Harness candidate. */
+export function fromMessages(value) {
+    const response = record(value, "response");
+    const output = [];
+    for (const [index, raw] of array(response.content, "response.content").entries()) {
+        const part = record(raw, `response.content[${index}]`);
+        if (part.type === "text" && typeof part.text === "string") {
+            output.push({ type: "text", text: part.text });
+            continue;
+        }
+        if (part.type === "thinking" && typeof part.thinking === "string") {
+            output.push({ type: "reasoning", text: part.thinking });
+            continue;
+        }
+        if (part.type === "tool_use") {
+            output.push({
+                type: "tool-call",
+                id: string(part.id, `response.content[${index}].id`),
+                name: string(part.name, `response.content[${index}].name`),
+                args: jsonObject(part.input, `response.content[${index}].input`),
+            });
+        }
+    }
+    return candidate({
+        output,
+        finishReason: messagesFinishReason(response.stop_reason, output),
+        usage: messagesUsage(response.usage),
+        evidence: evidence(response),
+    });
+}
+/** Return a Harness adapter backed by an application-owned Anthropic Messages send function. */
+export function anthropicAdapter(options) {
+    checkedMaxOutputTokens(options.defaultMaxOutputTokens);
+    return preparedModel({
+        adapter: "anthropic.messages",
+        async prepare(call) {
+            const request = toMessages(call, options.defaultMaxOutputTokens);
+            return { request, observed: request };
+        },
+        send: options.send,
+        decode: fromMessages,
+    });
+}
+function chatContent(parts) {
+    if (!parts.some((part) => part.type === "media"))
+        return textOfParts(parts);
+    return parts.map((part) => {
+        if (part.type === "text")
+            return { type: "text", text: part.text };
+        if (part.type === "media")
+            return { type: "image_url", image_url: { url: imageUrl(part) } };
+        throw unsupportedContent(part);
+    });
+}
+function responsesContent(parts) {
+    if (!parts.some((part) => part.type === "media"))
+        return textOfParts(parts);
+    return parts.map((part) => {
+        if (part.type === "text")
+            return { type: "input_text", text: part.text };
+        if (part.type === "media")
+            return { type: "input_image", image_url: imageUrl(part) };
+        throw unsupportedContent(part);
+    });
+}
+function messagesContent(parts) {
+    if (!parts.some((part) => part.type === "media"))
+        return textOfParts(parts);
+    return parts.map((part) => {
+        if (part.type === "text")
+            return { type: "text", text: part.text };
+        if (part.type === "media")
+            return { type: "image", source: { type: "url", url: imageUrl(part) } };
+        throw unsupportedContent(part);
+    });
+}
+function imageUrl(part) {
+    if (!part.mediaType.startsWith("image/"))
+        throw unsupportedContent(part);
+    const reference = part.reference;
+    if (!reference || typeof reference !== "object" || Array.isArray(reference))
+        throw unsupportedContent(part);
+    const url = reference.url;
+    if (typeof url !== "string" || url === "")
+        throw unsupportedContent(part);
+    return url;
+}
+function unsupportedContent(part) {
+    const label = part.type === "media" ? part.mediaType : part.type;
+    return new HarnessError("model.unsupported-content", `Adapter does not support ${label} content without a custom prepared adapter`);
+}
+function textOf(item) {
+    const unsupported = item.content.find((part) => part.type === "media");
+    if (unsupported)
+        throw unsupportedContent(unsupported);
+    return textOfParts(item.content);
+}
+function textOfParts(parts) {
+    return parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+}
+function toolCallsOf(parts) {
+    return parts.filter((part) => part.type === "tool-call");
+}
+function chatControls(call) {
+    return {
+        ...(call.model?.controls?.temperature === undefined
+            ? {}
+            : { temperature: call.model.controls.temperature }),
+        ...(call.model?.controls?.maxOutputTokens === undefined
+            ? {}
+            : { max_completion_tokens: call.model.controls.maxOutputTokens }),
+    };
+}
+function responsesControls(call) {
+    return {
+        ...(call.model?.controls?.temperature === undefined
+            ? {}
+            : { temperature: call.model.controls.temperature }),
+        ...(call.model?.controls?.maxOutputTokens === undefined
+            ? {}
+            : { max_output_tokens: call.model.controls.maxOutputTokens }),
+    };
+}
+function argumentsOf(value, path) {
+    const raw = string(value, path);
+    try {
+        return { args: jsonObject(JSON.parse(raw), path), raw };
+    }
+    catch (error) {
+        throw invalidResponse(`${path} must be a JSON object`, path, error);
+    }
+}
+function jsonObject(value, path) {
+    try {
+        return copyJsonObject(value, path);
+    }
+    catch (error) {
+        throw invalidResponse(`${path} must be a JSON object`, path, error);
+    }
+}
+function candidate(value) {
+    return {
+        output: value.output,
+        ...(value.finishReason === undefined ? {} : { finishReason: value.finishReason }),
+        ...(value.usage === undefined ? {} : { usage: value.usage }),
+        ...(value.evidence === undefined ? {} : { evidence: value.evidence }),
+    };
+}
+function chatFinishReason(value, output) {
+    if (value === "tool_calls" || value === "function_call")
+        return "tool-calls";
+    if (value === "length")
+        return "length";
+    if (value === "content_filter")
+        return "content-filter";
+    if (value === "stop" || value === null || value === undefined)
+        return hasToolCall(output) ? "tool-calls" : "stop";
+    return "other";
+}
+function responsesFinishReason(response, output) {
+    if (response.status === "incomplete") {
+        const details = response.incomplete_details === undefined
+            ? undefined
+            : record(response.incomplete_details, "response.incomplete_details");
+        return details?.reason === "max_output_tokens" ? "length" : "other";
+    }
+    if (response.status === "failed" || response.status === "cancelled")
+        throw invalidResponse(`response.status is ${String(response.status)}`, "response.status");
+    return hasToolCall(output) ? "tool-calls" : "stop";
+}
+function messagesFinishReason(value, output) {
+    if (value === "tool_use")
+        return "tool-calls";
+    if (value === "max_tokens")
+        return "length";
+    if (value === "end_turn" || value === "stop_sequence" || value === undefined || value === null)
+        return hasToolCall(output) ? "tool-calls" : "stop";
+    return "other";
+}
+function chatUsage(value) {
+    const usage = optionalRecord(value, "response.usage");
+    if (usage === undefined)
+        return undefined;
+    return usageOf({
+        inputTokens: usage.prompt_tokens,
+        outputTokens: usage.completion_tokens,
+        totalTokens: usage.total_tokens,
+        cachedTokens: optionalRecord(usage.prompt_tokens_details, "response.usage.prompt_tokens_details")?.cached_tokens,
+        reasoningTokens: optionalRecord(usage.completion_tokens_details, "response.usage.completion_tokens_details")?.reasoning_tokens,
+    }, "response.usage");
+}
+function responsesUsage(value) {
+    const usage = optionalRecord(value, "response.usage");
+    if (usage === undefined)
+        return undefined;
+    return usageOf({
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        totalTokens: usage.total_tokens,
+        cachedTokens: optionalRecord(usage.input_tokens_details, "response.usage.input_tokens_details")?.cached_tokens,
+        reasoningTokens: optionalRecord(usage.output_tokens_details, "response.usage.output_tokens_details")?.reasoning_tokens,
+    }, "response.usage");
+}
+function messagesUsage(value) {
+    const usage = optionalRecord(value, "response.usage");
+    if (usage === undefined)
+        return undefined;
+    return usageOf({
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        cachedTokens: usage.cache_read_input_tokens,
+    }, "response.usage");
+}
+function usageOf(value, path) {
+    const fields = Object.entries(value).flatMap(([key, raw]) => {
+        if (raw === undefined)
+            return [];
+        if (!isNonNegativeInteger(raw))
+            throw invalidResponse(`${path}.${key} must be a non-negative integer`, `${path}.${key}`);
+        return [[key, raw]];
+    });
+    return Object.fromEntries(fields);
+}
+function evidence(response) {
+    const requestId = optionalString(response.id, "response.id");
+    const resolvedModel = optionalString(response.model, "response.model");
+    return requestId === undefined && resolvedModel === undefined
+        ? undefined
+        : {
+            ...(requestId === undefined ? {} : { requestId }),
+            ...(resolvedModel === undefined ? {} : { resolvedModel }),
+        };
+}
+function record(value, path) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw invalidResponse(`${path} must be an object`, path);
+    return value;
+}
+function optionalRecord(value, path) {
+    return value === undefined || value === null ? undefined : record(value, path);
+}
+function array(value, path) {
+    if (!Array.isArray(value))
+        throw invalidResponse(`${path} must be an array`, path);
+    return value;
+}
+function optionalArray(value, path) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        throw invalidResponse(`${path} must be an array`, path);
+    return value;
+}
+function string(value, path) {
+    if (typeof value !== "string")
+        throw invalidResponse(`${path} must be a string`, path);
+    return value;
+}
+function optionalString(value, path) {
+    if (value === undefined || value === null)
+        return undefined;
+    return string(value, path);
+}
+function checkedMaxOutputTokens(value) {
+    if (!isNonNegativeInteger(value))
+        throw new HarnessError("model.adapter-invalid-options", "Anthropic defaultMaxOutputTokens must be a non-negative integer", { details: { path: "defaultMaxOutputTokens" } });
+}
+function isNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function hasToolCall(output) {
+    return output.some((part) => part.type === "tool-call");
+}
+function invalidResponse(message, path, cause) {
+    return new HarnessError("model.adapter-invalid-response", message, {
+        ...(cause === undefined ? {} : { cause }),
+        details: { path },
+    });
+}

package/dist/{model-normalize.d.ts → model/normalize.d.ts}

@@ -1,5 +1,5 @@
-import { HarnessError } from "./errors.js";
-import type { ModelCandidate, ModelDirective, ModelOutputBlock } from "./types/model.js";
+import { HarnessError } from "../errors.js";
+import type { ModelCandidate, ModelDirective, ModelOutputBlock } from "../types/model.js";
 export declare function normalizeDirective(value: unknown): ModelDirective | HarnessError;
 export declare function sameDirective(left: ModelDirective, right: ModelDirective): boolean;
 export declare function textFromOutput(output: readonly ModelOutputBlock[]): string;

package/dist/{model-normalize.js → model/normalize.js}

@@ -1,6 +1,5 @@
-import { HarnessError, isHarnessError } from "./errors.js";
-import { digest } from "./utils/digest.js";
-import { copyJsonObject } from "./utils/immutable.js";
+import { HarnessError, isHarnessError } from "../errors.js";
+import { assertJson, copyJson, copyJsonObject } from "../utils/immutable.js";
 const FINISH_REASONS = new Set([
     "stop",
     "length",
@@ -55,7 +54,25 @@ export function normalizeDirective(value) {
     });
 }
 export function sameDirective(left, right) {
-    return digest(left) === digest(right);
+    return sameJson(left, right);
+}
+function sameJson(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (left === null || right === null || typeof left !== "object" || typeof right !== "object")
+        return false;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+            return false;
+        return left.every((item, index) => sameJson(item, right[index]));
+    }
+    const leftRecord = left;
+    const rightRecord = right;
+    const keys = Object.keys(leftRecord);
+    if (keys.length !== Object.keys(rightRecord).length)
+        return false;
+    return keys.every((key) => Object.prototype.hasOwnProperty.call(rightRecord, key) &&
+        sameJson(leftRecord[key], rightRecord[key]));
 }
 export function textFromOutput(output) {
     return output.flatMap((block) => (block.type === "text" ? [block.text] : [])).join("");
@@ -108,6 +125,20 @@ function normalizeBlock(value, index) {
             throw invalidCandidate(`Model output[${index}].text must be a string`, `output[${index}].text`);
         return Object.freeze({ type: block.type, text });
     }
+    if (block.type === "json") {
+        rejectUnknownKeys(value, ["type", "value"], `Model output[${index}]`);
+        try {
+            const raw = value.value;
+            assertJson(raw, `Model output[${index}].value`);
+            return Object.freeze({
+                type: "json",
+                value: copyJson(raw),
+            });
+        }
+        catch (error) {
+            throw invalidCandidate(`Model output[${index}].value must be JSON-safe`, `output[${index}].value`, error);
+        }
+    }
     if (block.type === "tool-call") {
         rejectUnknownKeys(value, ["type", "id", "name", "args", "raw"], `Model output[${index}]`);
         const raw = value;

package/dist/model/prepared.d.ts

@@ -0,0 +1,16 @@
+import type { ModelAdapter, ModelAdapterContext, ModelCandidate, ModelCall } from "../types/model.js";
+import type { DeferredOutcome, JsonValue } from "../types/shared.js";
+export interface PreparedModelOptions<Wire> {
+    readonly adapter: string;
+    prepare(call: ModelCall, context: ModelAdapterContext): Promise<{
+        readonly request: Wire;
+        readonly observed: JsonValue;
+    }>;
+    send(request: Wire, call: ModelCall, context: ModelAdapterContext): Promise<unknown>;
+    decode(response: unknown, call: ModelCall): ModelCandidate | string | DeferredOutcome;
+}
+/**
+ * Builds a ModelAdapter that reports the provider request derived from Harness's canonical call.
+ * The observed value is deliberately JSON-only; opaque wire data remains adapter-local.
+ */
+export declare function preparedModel<Wire>(options: PreparedModelOptions<Wire>): ModelAdapter;

package/dist/model/prepared.js

@@ -0,0 +1,11 @@
+/**
+ * Builds a ModelAdapter that reports the provider request derived from Harness's canonical call.
+ * The observed value is deliberately JSON-only; opaque wire data remains adapter-local.
+ */
+export function preparedModel(options) {
+    return async (call, context) => {
+        const prepared = await options.prepare(call, context);
+        context.reportPreparedCall({ adapter: options.adapter, call: prepared.observed });
+        return options.decode(await options.send(prepared.request, call, context), call);
+    };
+}

package/dist/session/event-log.d.ts

@@ -1,11 +1,12 @@
 import type { SessionEvent } from "../types/session.js";
+import type { JsonValue } from "../types/shared.js";
 /** Session-lifetime conversation log. Each stream() call replays from the start. */
-export declare class SessionEventLog implements AsyncIterable<SessionEvent> {
+export declare class SessionEventLog implements AsyncIterable<SessionEvent<JsonValue>> {
     private readonly events;
     private readonly subscribers;
     private done;
-    emit(event: SessionEvent): void;
+    emit(event: SessionEvent<JsonValue>): void;
     finish(): void;
-    [Symbol.asyncIterator](): AsyncIterator<SessionEvent>;
+    [Symbol.asyncIterator](): AsyncIterator<SessionEvent<JsonValue>>;
     private wake;
 }

package/dist/session/input-queue.d.ts

@@ -1,18 +1,21 @@
 import type { InputEvent, InputOptions } from "../types/session.js";
+import type { TurnOutputContract } from "./output-contract.js";
 import { SubmissionStream } from "./submission-stream.js";
 export type WorkEvent = InputEvent | {
     readonly kind: "continue";
 };
 export interface QueuedInput {
     readonly event: WorkEvent;
-    readonly options?: InputOptions;
+    readonly options?: InputOptions & {
+        readonly output?: TurnOutputContract;
+    };
     readonly stream: SubmissionStream;
     cancelled: boolean;
 }
 export type QueuedInterrupt = Omit<QueuedInput, "event"> & {
-    readonly event: Extract<InputEvent, {
-        kind: "interrupt";
-    }>;
+    readonly event: InputEvent & {
+        readonly kind: "interrupt";
+    };
 };
 export interface QueueAbortHandlers {
     readonly isActive: () => boolean;