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

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

@@ -1,5 +1,5 @@
 import { HarnessError } from "../errors.js";
-import { normalizeCandidate } from "../model-normalize.js";
+import { normalizeCandidate } from "../model/normalize.js";
 import { assertJson, copyJson, copyJsonObject } from "../utils/immutable.js";
 export function normalizeSessionSeed(seed) {
     try {
@@ -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;

package/dist/session/submission-stream.d.ts

@@ -1,15 +1,16 @@
 import type { InputCompletion, InputHandle, SessionEvent } from "../types/session.js";
-export declare class SubmissionStream implements InputHandle {
+import type { JsonValue } from "../types/shared.js";
+export declare class SubmissionStream implements InputHandle<JsonValue> {
     readonly inputId: string;
-    readonly completed: Promise<InputCompletion>;
+    readonly completed: Promise<InputCompletion<JsonValue>>;
     private resolveCompletion;
     private rejectCompletion;
     private readonly events;
     private readonly cleanups;
     private done;
     constructor(inputId: string);
-    emit(event: SessionEvent): void;
-    finish(status: InputCompletion["status"]): void;
+    emit(event: SessionEvent<JsonValue>): void;
+    finish(status: InputCompletion<JsonValue>["status"]): void;
     fail(error: unknown): void;
     onFinish(cleanup: () => void): void;
 }

package/dist/step/context-draft.js

@@ -1,5 +1,4 @@
 import { HarnessError } from "../errors.js";
-import { digest } from "../utils/digest.js";
 import { copyJson } from "../utils/immutable.js";
 import { SlotDraft } from "./slot-assembly.js";
 const CONTEXT_TYPE = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
@@ -36,7 +35,7 @@ export class ContextDraft {
             ...(this.hostContext === undefined ? [] : [hostContributor()]),
             ...slots.map((slot) => contributor(slot.owner, slot.reason)),
         ]);
-        return Object.freeze({ items, contributors, digest: digest(items.map(itemDigest)) });
+        return Object.freeze({ items, contributors });
     }
 }
 function normalizeItem(item) {
@@ -54,7 +53,6 @@ function hostContributor() {
         middlewareId: "host",
         slot: "session",
         order: 0,
-        digest: digest({ middlewareId: "host", slot: "session", order: 0 }),
     });
 }
 function contributor(owner, reason) {
@@ -62,10 +60,6 @@ function contributor(owner, reason) {
         middlewareId: owner.middlewareId,
         slot: owner.slot,
         order: owner.order,
-        digest: digest({ middlewareId: owner.middlewareId, slot: owner.slot, order: owner.order }),
         ...(reason === undefined ? {} : { reason }),
     });
 }
-function itemDigest(item) {
-    return item.type === undefined ? { value: item.value } : { type: item.type, value: item.value };
-}

package/dist/step/model-configuration.js

@@ -1,7 +1,6 @@
 import { bindTool } from "../build/bind-tool.js";
 import { HarnessError, isHarnessError } from "../errors.js";
-import { normalizeDirective, sameDirective } from "../model-normalize.js";
-import { digest } from "../utils/digest.js";
+import { normalizeDirective, sameDirective } from "../model/normalize.js";
 import { copyJson } from "../utils/immutable.js";
 import { checkedReason, slotOwner, SlotDraft } from "./slot-assembly.js";
 /** Per-step, middleware-owned model configuration draft. It never persists past the call. */
@@ -80,7 +79,6 @@ export class ModelConfigurationDraft {
         const toolSlots = this.#tools.values();
         const instructions = instructionSlots.flatMap((slot) => slot.value.map((text) => Object.freeze({
             text,
-            digest: digest(text),
             contributor: contributor(slot.owner, slot.reason),
         })));
         const sourcedTools = toolSlots.flatMap((slot) => slot.value.map((tool) => Object.freeze({ tool, contributor: contributor(slot.owner, slot.reason) })));
@@ -95,15 +93,6 @@ export class ModelConfigurationDraft {
             throw new HarnessError("configuration.duplicate-tool-name", `Duplicate Tool '${[...duplicate].sort().join("', '")}'`);
         const toolContracts = sourcedTools.map(({ tool, contributor: source }) => toolContract(tool, source));
         const model = this.#model?.directive;
-        const logical = digest({
-            instructions: instructions.map((item) => item.text),
-            tools: toolContracts.map(({ name, description, inputSchema }) => ({
-                name,
-                ...(description === undefined ? {} : { description }),
-                inputSchema,
-            })),
-        });
-        const modelDigest = digest(model ?? null);
         return Object.freeze({
             version: 1,
             ...(model === undefined ? {} : { model }),
@@ -115,11 +104,6 @@ export class ModelConfigurationDraft {
                 ...toolSlots.map((slot) => contributor(slot.owner, slot.reason)),
                 ...(this.#model?.owner ? [contributor(this.#model.owner, this.#model.reason)] : []),
             ]),
-            digests: Object.freeze({
-                logical,
-                model: modelDigest,
-                request: digest({ logical, model: modelDigest }),
-            }),
         });
     }
 }
@@ -134,7 +118,6 @@ function contributor(owner, reason) {
         middlewareId: owner.middlewareId,
         slot: owner.slot,
         order: owner.order,
-        digest: digest({ middlewareId: owner.middlewareId, slot: owner.slot, order: owner.order }),
         ...(reason === undefined ? {} : { reason }),
     });
 }
@@ -142,10 +125,13 @@ function providerTool(tool) {
     return {
         name: tool.name,
         ...(tool.description === undefined ? {} : { description: tool.description }),
-        inputSchema: copyJson(tool.parameters.jsonSchema),
+        inputSchema: copyJson(tool.inputSchema.jsonSchema),
+        ...(tool.outputSchema === undefined
+            ? {}
+            : { outputSchema: copyJson(tool.outputSchema.jsonSchema) }),
     };
 }
 function toolContract(tool, source) {
     const value = providerTool(tool);
-    return Object.freeze({ ...value, digest: digest(value), contributor: source });
+    return Object.freeze({ ...value, contributor: source });
 }

package/dist/step/project.js

@@ -9,9 +9,10 @@ export function projectModelCall(request) {
         tools: Object.freeze(request.configuration.tools.map((tool) => Object.freeze({
             name: tool.name,
             ...(tool.description === undefined ? {} : { description: tool.description }),
-            inputSchema: copyJson(tool.parameters.jsonSchema),
+            inputSchema: copyJson(tool.inputSchema.jsonSchema),
         }))),
         ...(request.model === undefined ? {} : { model: copyJson(request.model) }),
+        ...(request.outputSchema === undefined ? {} : { outputSchema: copyJson(request.outputSchema) }),
         sessionId: request.sessionId,
     });
 }
@@ -45,12 +46,28 @@ function projectEntry(entry) {
     if (entry.kind === "input") {
         if (entry.event.kind !== "user-message" && entry.event.kind !== "interrupt")
             return [];
-        return [freezeItem({ kind: "message", role: "user", content: [textPart(entry.event.text)] })];
+        return [
+            freezeItem({
+                kind: "message",
+                role: "user",
+                content: "content" in entry.event
+                    ? entry.event.content.map((part) => part.type === "text"
+                        ? textPart(part.text)
+                        : Object.freeze({
+                            type: "media",
+                            mediaType: part.mediaType,
+                            reference: copyJson(part.reference),
+                        }))
+                    : [textPart(entry.event.text)],
+            }),
+        ];
     }
     if (entry.kind === "candidate") {
         const content = entry.candidate.output.flatMap((block) => {
             if (block.type === "text")
                 return [textPart(block.text)];
+            if (block.type === "json")
+                return [textPart(JSON.stringify(block.value))];
             if (block.type === "tool-call")
                 return [
                     Object.freeze({
@@ -84,7 +101,12 @@ function toolResultPayload(result) {
         return result.output;
     if (result.kind === "denied")
         return { kind: result.kind, reason: result.reason };
-    return { kind: result.kind, code: result.code, message: result.message };
+    return {
+        kind: result.kind,
+        code: result.code,
+        message: result.message,
+        ...(result.details === undefined ? {} : { details: result.details }),
+    };
 }
 function textPart(text) {
     return Object.freeze({ type: "text", text });

package/dist/step/resolve.d.ts

@@ -6,4 +6,5 @@ export declare function resolveModelRequest(input: {
     context: StepContext;
     arrivals: readonly InputEvent[];
     toolResults: readonly ToolResult[];
+    output?: import("../session/output-contract.js").TurnOutputContract;
 }): ModelRequest;

package/dist/step/resolve.js

@@ -12,5 +12,6 @@ export function resolveModelRequest(input) {
         arrivals: Object.freeze([...input.arrivals]),
         toolResults: Object.freeze([...input.toolResults]),
         tools: Object.freeze([...ctx.offeredTools]),
+        ...(input.output === undefined ? {} : { outputSchema: input.output.schema.jsonSchema }),
     });
 }

package/dist/step/run.d.ts

@@ -28,5 +28,6 @@ export declare function runStep(input: {
         readonly context?: import("../types/shared.js").JsonObject;
     }>;
     states: CapabilityStateRegistry;
+    output?: import("../session/output-contract.js").TurnOutputContract;
     recordModelRequested(state: SessionSnapshot, active: ActiveModelExecutionRecord): Promise<SessionSnapshot>;
 }): Promise<StepRunResult>;

package/dist/step/run.js

@@ -1,4 +1,4 @@
-import { normalizeCandidate } from "../model-normalize.js";
+import { normalizeCandidate } from "../model/normalize.js";
 import { HarnessError, isHarnessError } from "../errors.js";
 import { copyJson } from "../utils/immutable.js";
 import { runMiddleware } from "./compose.js";
@@ -52,6 +52,7 @@ export async function runStep(input) {
             context,
             arrivals: input.arrivals,
             toolResults: input.toolResults,
+            output: input.output,
         });
         requestedModelId = request.model?.id;
         const call = projectModelCall(request);
@@ -76,10 +77,26 @@ export async function runStep(input) {
             }),
         }));
         try {
+            let prepared = false;
             const outcome = await input.agent.invoke(call, {
                 request,
                 invocationId,
                 signal: input.signal,
+                reportPreparedCall(value) {
+                    if (prepared)
+                        throw new HarnessError("model.adapter-invalid-options", "Model adapter may report only one prepared call per invocation");
+                    if (typeof value.adapter !== "string" || value.adapter === "")
+                        throw new HarnessError("model.adapter-invalid-options", "Prepared model call adapter must be a non-empty string");
+                    prepared = true;
+                    const reported = Object.freeze({ adapter: value.adapter, call: copyJson(value.call) });
+                    input.observe(() => ({
+                        type: "model.prepared",
+                        turnId: input.turnId,
+                        stepId: input.stepId,
+                        ...(request.model?.id === undefined ? {} : { requestedModelId: request.model.id }),
+                        attributes: reported,
+                    }));
+                },
             });
             if (input.signal.aborted)
                 throw input.signal.reason;
@@ -103,7 +120,7 @@ export async function runStep(input) {
             });
         }
     }, input.observe);
-    const output = sealStep(context);
+    const output = sealStep(context, input.output);
     const candidate = output.kind === "tools" ? output.plan.candidate : context.currentCandidate;
     return Object.freeze({
         stepId: input.stepId,
@@ -136,7 +153,6 @@ function snapshotConfiguration(configuration) {
         tools: snapshotTools(configuration.tools),
         toolContracts: copyJson(configuration.toolContracts),
         contributors: copyJson(configuration.contributors),
-        digests: copyJson(configuration.digests),
     });
 }
 function snapshotTools(tools) {
@@ -144,6 +160,11 @@ function snapshotTools(tools) {
         name: tool.name,
         ...(tool.description === undefined ? {} : { description: tool.description }),
         owner: tool.owner,
-        parameters: Object.freeze({ jsonSchema: copyJson(tool.parameters.jsonSchema) }),
+        inputSchema: Object.freeze({ jsonSchema: copyJson(tool.inputSchema.jsonSchema) }),
+        ...(tool.outputSchema === undefined
+            ? {}
+            : {
+                outputSchema: Object.freeze({ jsonSchema: copyJson(tool.outputSchema.jsonSchema) }),
+            }),
     })));
 }

package/dist/step/seal.d.ts

@@ -2,11 +2,13 @@ import type { ModelCandidate } from "../types/model.js";
 import type { Tripwire } from "../types/shared.js";
 import type { BoundToolDefinition, RequiredInteraction, SealedToolCall, ToolOwner, ToolResult } from "../types/tool.js";
 import type { StepContext } from "./step-context.js";
+import type { TurnOutputContract } from "../session/output-contract.js";
 export interface ExecutablePlanEntry {
     readonly call: SealedToolCall;
     readonly invocationId: string;
     readonly owner: ToolOwner;
     readonly execute: BoundToolDefinition["execute"];
+    readonly outputSchema?: BoundToolDefinition["outputSchema"];
     readonly interaction?: RequiredInteraction;
 }
 export interface InternalToolPlan {
@@ -23,7 +25,7 @@ export type SealedStepOutput = {
     readonly tripwire: Tripwire;
 } | {
     readonly kind: "final";
-    readonly output: string;
+    readonly output: import("../types/shared.js").JsonValue;
 } | {
     readonly kind: "deferred-model";
     readonly active: import("../types/session.js").ActiveModelExecutionRecord;
@@ -32,4 +34,4 @@ export type SealedStepOutput = {
     readonly plan: InternalToolPlan;
 };
 /** Converts the reviewed canonical candidate into either a final response or an executable tool plan. */
-export declare function sealStep(context: StepContext): SealedStepOutput;
+export declare function sealStep(context: StepContext, outputContract?: TurnOutputContract): SealedStepOutput;