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

package/dist/model/adapters.js

@@ -1,5 +1,6 @@
 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) => {
@@ -20,7 +21,7 @@ export function toChatCompletions(call) {
                 ...(toolCalls.length === 0 ? {} : { tool_calls: toolCalls }),
             };
         }
-        return { role: "user", content: textOf(item) };
+        return { role: "user", content: chatContent(item.content) };
     });
     return {
         messages,
@@ -37,10 +38,18 @@ export function toChatCompletions(call) {
                 })),
             }),
         ...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) {
+export function fromChatCompletions(value, call) {
     const response = record(value, "response");
     const choices = array(response.choices, "response.choices");
     if (choices.length === 0)
@@ -49,7 +58,7 @@ export function fromChatCompletions(value) {
     const message = record(choice.message, "response.choices[0].message");
     const output = [];
     if (typeof message.content === "string" && message.content !== "")
-        output.push({ type: "text", text: 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()) {
@@ -71,7 +80,15 @@ export function fromChatCompletions(value) {
 }
 /** Return a Harness adapter backed by an application-owned Chat Completions send function. */
 export function chatCompletionsAdapter(send) {
-    return async (call, context) => fromChatCompletions(await send(toChatCompletions(call), call, context));
+    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) {
@@ -95,7 +112,7 @@ export function toResponses(call) {
                 })),
             ];
         }
-        return [{ type: "message", role: "user", content: textOf(item) }];
+        return [{ type: "message", role: "user", content: responsesContent(item.content) }];
     });
     return {
         ...(instructions.length === 0 ? {} : { instructions: instructions.join("\n\n") }),
@@ -111,10 +128,21 @@ export function toResponses(call) {
                 })),
             }),
         ...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) {
+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");
@@ -134,7 +162,7 @@ export function fromResponses(value) {
             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({ type: "text", text: part.text });
+                    output.push(outputText(part.text, call?.outputSchema !== undefined));
             }
             continue;
         }
@@ -157,11 +185,21 @@ export function fromResponses(value) {
 }
 /** Return a Harness adapter backed by an application-owned Responses send function. */
 export function responsesAdapter(send) {
-    return async (call, context) => fromResponses(await send(toResponses(call), call, context));
+    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")
@@ -184,12 +222,16 @@ export function toMessages(call, defaultMaxOutputTokens) {
             return [
                 {
                     role: "assistant",
-                    content: item.content.map((part) => part.type === "text"
-                        ? { type: "text", text: part.text }
-                        : { type: "tool_use", id: part.id, name: part.name, input: part.args }),
+                    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: textOf(item) }];
+        return [{ role: "user", content: messagesContent(item.content) }];
     });
     return {
         ...(instructions.length === 0 ? {} : { system: instructions.join("\n\n") }),
@@ -209,6 +251,16 @@ export function toMessages(call, defaultMaxOutputTokens) {
         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");
@@ -242,10 +294,72 @@ export function fromMessages(value) {
 /** Return a Harness adapter backed by an application-owned Anthropic Messages send function. */
 export function anthropicAdapter(options) {
     checkedMaxOutputTokens(options.defaultMaxOutputTokens);
-    return async (call, context) => fromMessages(await options.send(toMessages(call, options.defaultMaxOutputTokens), call, context));
+    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) {
-    return item.content
+    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("");

package/dist/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 { 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;

package/dist/session/input-queue.js

@@ -7,6 +7,18 @@ export function snapshotInput(event) {
     switch (event.kind) {
         case "user-message":
         case "interrupt":
+            if ("content" in event)
+                return Object.freeze({
+                    kind: event.kind,
+                    content: Object.freeze(event.content.map((part) => part.type === "text"
+                        ? Object.freeze({ type: "text", text: part.text })
+                        : Object.freeze({
+                            type: "media",
+                            mediaType: part.mediaType,
+                            reference: copyJson(part.reference),
+                        }))),
+                    ...(event.metadata ? { metadata: copyJsonObject(event.metadata, "input metadata") } : {}),
+                });
             return Object.freeze({
                 kind: event.kind,
                 text: event.text,

package/dist/session/output-contract.d.ts

@@ -0,0 +1,6 @@
+import type { BoundToolSchema, ToolSchemaSource } from "../types/tool.js";
+/** Runtime-only validator paired with the portable JSON Schema projected to models. */
+export interface TurnOutputContract {
+    readonly schema: BoundToolSchema<unknown>;
+}
+export declare function bindOutputContract(source: ToolSchemaSource): TurnOutputContract;

package/dist/session/output-contract.js

@@ -0,0 +1,12 @@
+import { HarnessError, isHarnessError } from "../errors.js";
+import { normalizeSchema } from "../build/schema.js";
+export function bindOutputContract(source) {
+    try {
+        return Object.freeze({ schema: normalizeSchema(source, "output") });
+    }
+    catch (cause) {
+        if (isHarnessError(cause))
+            throw new HarnessError("output.invalid-schema", cause.message, { cause });
+        throw new HarnessError("output.invalid-schema", String(cause), { cause });
+    }
+}

package/dist/session/scheduler.js

@@ -257,7 +257,7 @@ export class SessionScheduler {
                 ? await this.resumeTurn(submission, context)
                 : submission.event.kind === "continue"
                     ? await this.turns.continue(this.snapshotValue, context)
-                    : await this.turns.start(this.snapshotValue, submission.event, context);
+                    : await this.turns.start(this.snapshotValue, submission.event, context, submission.options?.output);
             this.applyTurnOutcome(submission.stream, outcome);
         }
         catch (error) {

package/dist/session/seed.js

@@ -82,13 +82,12 @@ function entryAt(value, index) {
         case "final":
             exactKeys(entry, ["kind", "turnId", "stepId", "output"], `Transcript entry ${index}`);
             requiredString(entry.stepId, `Transcript entry ${index} stepId`);
-            if (typeof entry.output !== "string")
-                fail(`Transcript entry ${index} output must be a string`);
+            assertJson(entry.output, `Transcript entry ${index} output`);
             return Object.freeze({
                 kind: "final",
                 turnId: entry.turnId,
                 stepId: entry.stepId,
-                output: entry.output,
+                output: copyJson(entry.output),
             });
         default:
             fail(`Transcript entry ${index} has unknown kind '${String(entry.kind)}'`);
@@ -101,6 +100,18 @@ function inputEvent(value, index) {
     switch (event.kind) {
         case "user-message":
         case "interrupt":
+            if ("content" in event) {
+                exactKeys(event, ["kind", "content", "metadata"], `Transcript input ${index}`);
+                if (!Array.isArray(event.content))
+                    fail(`Transcript input ${index} content must be an array`);
+                return Object.freeze({
+                    kind: event.kind,
+                    content: contentParts(event.content, index),
+                    ...(event.metadata === undefined
+                        ? {}
+                        : { metadata: copyJsonObject(event.metadata, `transcript input ${index} metadata`) }),
+                });
+            }
             exactKeys(event, ["kind", "text", "metadata"], `Transcript input ${index}`);
             if (typeof event.text !== "string")
                 fail(`Transcript input ${index} text must be a string`);
@@ -134,6 +145,31 @@ function inputEvent(value, index) {
             fail(`Transcript input ${index} has unknown kind '${String(event.kind)}'`);
     }
 }
+function contentParts(value, inputIndex) {
+    return Object.freeze(value.map((value, partIndex) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            fail(`Transcript input ${inputIndex} content part ${partIndex} must be an object`);
+        const part = value;
+        if (part.type === "text") {
+            exactKeys(part, ["type", "text"], `Transcript input ${inputIndex} content part ${partIndex}`);
+            if (typeof part.text !== "string")
+                fail(`Transcript input ${inputIndex} text part ${partIndex} must contain text`);
+            return Object.freeze({ type: "text", text: part.text });
+        }
+        if (part.type === "media") {
+            exactKeys(part, ["type", "mediaType", "reference"], `Transcript input ${inputIndex} content part ${partIndex}`);
+            if (typeof part.mediaType !== "string" || part.mediaType === "")
+                fail(`Transcript input ${inputIndex} media part ${partIndex} must contain mediaType`);
+            assertJson(part.reference, `transcript input ${inputIndex} media reference ${partIndex}`);
+            return Object.freeze({
+                type: "media",
+                mediaType: part.mediaType,
+                reference: copyJson(part.reference),
+            });
+        }
+        fail(`Transcript input ${inputIndex} content part ${partIndex} has unknown type`);
+    }));
+}
 function toolResult(value, index) {
     if (!value || typeof value !== "object")
         fail(`Tool result ${index} must be an object`);
@@ -152,7 +188,7 @@ function toolResult(value, index) {
                 fail(`Tool result ${index} reason must be a string`);
             return Object.freeze({ ...base, kind: "denied", reason: result.reason });
         case "failed":
-            exactKeys(result, ["callId", "toolName", "kind", "code", "message"], `Tool result ${index}`);
+            exactKeys(result, ["callId", "toolName", "kind", "code", "message", "details"], `Tool result ${index}`);
             if (typeof result.code !== "string" || typeof result.message !== "string")
                 fail(`Tool result ${index} code and message must be strings`);
             return Object.freeze({
@@ -160,11 +196,44 @@ function toolResult(value, index) {
                 kind: "failed",
                 code: result.code,
                 message: result.message,
+                ...(result.details === undefined
+                    ? {}
+                    : { details: validationDetails(result.details, index) }),
             });
         default:
             fail(`Tool result ${index} has unknown kind '${String(result.kind)}'`);
     }
 }
+function validationDetails(value, index) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        fail(`Tool result ${index} details must be an object`);
+    const details = value;
+    exactKeys(details, ["phase", "issues"], `Tool result ${index} details`);
+    if (details.phase !== "input" && details.phase !== "output")
+        fail(`Tool result ${index} details phase must be input or output`);
+    if (!Array.isArray(details.issues))
+        fail(`Tool result ${index} details issues must be an array`);
+    return Object.freeze({
+        phase: details.phase,
+        issues: Object.freeze(details.issues.map((issue, issueIndex) => {
+            if (!issue || typeof issue !== "object" || Array.isArray(issue))
+                fail(`Tool result ${index} details issue ${issueIndex} must be an object`);
+            const item = issue;
+            exactKeys(item, ["path", "code", "message"], `Tool result ${index} details issue ${issueIndex}`);
+            if (!Array.isArray(item.path))
+                fail(`Tool result ${index} details issue ${issueIndex} path must be an array`);
+            if (item.path.some((part) => typeof part !== "string" && typeof part !== "number"))
+                fail(`Tool result ${index} details issue ${issueIndex} path must contain strings or numbers`);
+            if (typeof item.code !== "string" || typeof item.message !== "string")
+                fail(`Tool result ${index} details issue ${issueIndex} code and message must be strings`);
+            return Object.freeze({
+                path: Object.freeze([...item.path]),
+                code: item.code,
+                message: item.message,
+            });
+        })),
+    });
+}
 function validateSeedCandidate(value, index) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         fail(`Candidate at transcript ${index} must be an object`);
@@ -182,6 +251,11 @@ function validateSeedCandidate(value, index) {
                 fail(`Candidate output ${blockIndex} text must be a string`);
             return;
         }
+        if (block.type === "json") {
+            exactKeys(block, ["type", "value"], `Candidate output ${blockIndex}`);
+            assertJson(block.value, `Candidate output ${blockIndex} value`);
+            return;
+        }
         if (block.type === "tool-call") {
             exactKeys(block, ["type", "id", "name", "args", "raw"], `Candidate output ${blockIndex}`);
             requiredString(block.id, `Candidate output ${blockIndex} id`);

package/dist/session/session.d.ts

@@ -1,15 +1,18 @@
 import type { InputHandle, InputOptions, MessageInput, Session, SessionEvent, SessionRunOptions, SessionSnapshot, SessionInput } from "../types/session.js";
-import type { Observer } from "../types/shared.js";
+import type { ToolSchemaSource } from "../types/tool.js";
+import type { JsonValue, Observer } from "../types/shared.js";
 import type { LoopAgent } from "../build/agent.js";
 export declare class LiveSession implements Session {
     readonly id: string;
     private readonly scheduler;
     constructor(id: string, agent: LoopAgent, options: SessionRunOptions);
     get state(): SessionSnapshot;
-    input(event: SessionInput, options?: InputOptions): InputHandle;
-    interrupt(event: MessageInput, options?: InputOptions): InputHandle;
-    continue(options?: InputOptions): InputHandle;
-    stream(): AsyncIterable<SessionEvent>;
+    input(event: SessionInput, options?: InputOptions & {
+        readonly outputSchema?: ToolSchemaSource;
+    }): InputHandle<any>;
+    interrupt(event: MessageInput, options?: InputOptions): InputHandle<any>;
+    continue(options?: InputOptions): InputHandle<any>;
+    stream(): AsyncIterable<SessionEvent<JsonValue>>;
     observe(listener: Observer): () => void;
     stop(reason?: string): Promise<void>;
 }

package/dist/session/session.js

@@ -1,6 +1,8 @@
+import { HarnessError } from "../errors.js";
 import { SessionScheduler } from "./scheduler.js";
-import { copyJsonObject } from "../utils/immutable.js";
+import { copyJson, copyJsonObject } from "../utils/immutable.js";
 import { normalizeSessionSeed } from "./seed.js";
+import { bindOutputContract } from "./output-contract.js";
 export class LiveSession {
     id;
     scheduler;
@@ -24,7 +26,13 @@ export class LiveSession {
         return this.scheduler.snapshot;
     }
     input(event, options) {
-        return this.scheduler.submit(normalizeInput(event), options);
+        const output = options?.outputSchema === undefined ? undefined : bindOutputContract(options.outputSchema);
+        if (output && isInteractionReply(event))
+            throw new HarnessError("output.invalid-schema", "Interaction replies cannot define a turn outputSchema");
+        return this.scheduler.submit(normalizeInput(event), {
+            ...(options?.signal === undefined ? {} : { signal: options.signal }),
+            ...(output === undefined ? {} : { output }),
+        });
     }
     interrupt(event, options) {
         return this.scheduler.submit(normalizeMessage("interrupt", event), options);
@@ -50,6 +58,14 @@ function isInteractionReply(value) {
 function normalizeMessage(kind, value) {
     if (typeof value === "string")
         return { kind, text: value };
+    if ("content" in value)
+        return {
+            kind,
+            content: snapshotContent(value.content),
+            ...(value.metadata === undefined
+                ? {}
+                : { metadata: copyJsonObject(value.metadata, "input metadata") }),
+        };
     return {
         kind,
         text: value.text,
@@ -65,3 +81,23 @@ function normalizeInput(input) {
         return input;
     return normalizeMessage("user-message", input);
 }
+function snapshotContent(value) {
+    if (!Array.isArray(value))
+        throw new HarnessError("input.invalid-content", "Input content must be an array");
+    return Object.freeze(value.map((part, index) => {
+        if (!part || typeof part !== "object")
+            throw new HarnessError("input.invalid-content", `Input content part ${index} must be an object`);
+        if (part.type === "text") {
+            if (typeof part.text !== "string")
+                throw new HarnessError("input.invalid-content", `Input text part ${index} must contain text`);
+            return Object.freeze({ type: "text", text: part.text });
+        }
+        if (part.type !== "media" || typeof part.mediaType !== "string" || part.mediaType === "")
+            throw new HarnessError("input.invalid-content", `Input media part ${index} must contain a non-empty mediaType`);
+        return Object.freeze({
+            type: "media",
+            mediaType: part.mediaType,
+            reference: copyJson(part.reference),
+        });
+    }));
+}

package/dist/session/state.d.ts

@@ -12,4 +12,4 @@ export declare function beginTurn(state: SessionSnapshot, turnId: string, event?
 export declare const commitInput: (state: SessionSnapshot, turnId: string, event: InputEvent) => SessionSnapshot;
 export declare const commitCandidate: (state: SessionSnapshot, turnId: string, stepId: string, candidate: ModelCandidate) => SessionSnapshot;
 export declare const commitToolResults: (state: SessionSnapshot, turnId: string, stepId: string, results: readonly ToolResult[]) => SessionSnapshot;
-export declare const commitFinal: (state: SessionSnapshot, turnId: string, stepId: string, output: string) => SessionSnapshot;
+export declare const commitFinal: (state: SessionSnapshot, turnId: string, stepId: string, output: import("../types/shared.js").JsonValue) => SessionSnapshot;