@ai-sdk/harness 1.0.72 → 1.0.73

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @ai-sdk/harness
 
+## 1.0.73
+
+### Patch Changes
+
+- 62a9c2a: feat(harness): add support for structured output to `HarnessAgent` via `output` property
+- d25cae2: fix(harness): claim the bridge event stream on start/resume instead of on connect
+
 ## 1.0.72
 
 ### Patch Changes

package/README.md

@@ -81,6 +81,23 @@ try {
 }
 ```
 
+Set `output` on `HarnessAgent` to require the same typed, schema-backed output
+on every turn. `generate()` exposes the validated value as `result.output`, and
+`stream()` additionally exposes `partialOutputStream`; the JSON also remains on
+the normal text and stream surfaces.
+
+```ts
+import { Output } from 'ai';
+
+const agent = new HarnessAgent({
+  harness: claudeCode,
+  sandbox,
+  output: Output.object({
+    schema: z.object({ answer: z.string() }),
+  }),
+});
+```
+
 Use `session.detach()` to park a bridge-backed session for later attach, `session.stop()` to save state and stop the sandbox, or `session.destroy()` to clean up without keeping resume state. Bridge-backed adapters such as Claude Code, Codex, OpenCode, and DeepAgents require a sandbox provider that exposes ports — `@ai-sdk/sandbox-vercel` is the supported choice today. `@ai-sdk/sandbox-just-bash` is suitable only for host-runtime or otherwise non-bridge flows, such as Pi.
 
 `sandbox` is a required `HarnessV1SandboxProvider` — the agent calls `provider.createSession()` when a session starts. Use `sandboxConfig` for agent specific sandbox configuration that works independently from the sandbox provider that is used:
@@ -111,6 +128,12 @@ See the [harness adapters documentation](https://ai-sdk.dev/v7/docs/ai-sdk-harne
 
 Implement the `HarnessV1` factory and a `HarnessV1Session` whose `doPromptTurn` emits events; the agent surface, streaming, tool execution, and multi-turn state are handled for you. Read `startOpts.sandboxSession` for the network sandbox session the agent created and will stop on cleanup. Call `sandboxSession.restricted()` for the tool-safe file-IO/exec/spawn surface.
 
+Each prompt and continuation receives an optional `responseFormat`. JSON
+formats carry a caller-provided JSON Schema plus optional name and description;
+the adapter must enforce the schema and emit the resulting JSON through normal
+text parts. If the runtime cannot honor the format, throw
+`HarnessCapabilityUnsupportedError` before starting the turn.
+
 Bootstrap recipe paths may be absolute or relative. Relative `bootstrapDir` and
 file paths are resolved against `sandboxSession.defaultWorkingDirectory`.
 The framework creates `bootstrapDir` before writing files, and bootstrap

package/dist/agent/index.d.ts

@@ -1,6 +1,6 @@
 import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
 import { Experimental_SandboxSession, UserModelMessage, ToolSet, FlexibleSchema, Tool, Context, Arrayable, ToolApprovalResponse, ModelMessage } from '@ai-sdk/provider-utils';
-import { StopCondition, ToolApprovalStatus, TelemetryOptions, ActiveTools, StreamTextResult, Agent, AgentCallParameters, GenerateTextResult, AgentStreamParameters, Telemetry } from 'ai';
+import { OutputInterface, StopCondition, ToolApprovalStatus, TelemetryOptions, ActiveTools, StreamTextResult, Agent, AgentCallParameters, GenerateTextResult, AgentStreamParameters, Telemetry } from 'ai';
 import { z } from 'zod/v4';
 import { JSONValue, LanguageModelV4ToolCall, LanguageModelV4ToolApprovalRequest, LanguageModelV4ToolResult, LanguageModelV4FinishReason, LanguageModelV4Usage, JSONSchema7, AISDKError } from '@ai-sdk/provider';
 
@@ -435,6 +435,30 @@ type HarnessV1PromptControl = {
     readonly done: PromiseLike<void>;
 };
 
+type HarnessV1JSONValue = null | boolean | number | string | HarnessV1JSONArray | HarnessV1JSONObject;
+interface HarnessV1JSONArray extends Array<HarnessV1JSONValue> {
+}
+interface HarnessV1JSONObject {
+    [key: string]: HarnessV1JSONValue | undefined;
+}
+type HarnessV1JSONSchema = HarnessV1JSONObject;
+/**
+ * Requested response format for one harness turn.
+ *
+ * This intentionally mirrors the AI SDK provider response-format shape
+ * without depending on `@ai-sdk/provider`. Harness implementations receive
+ * JSON Schema rather than the caller's original Zod or Standard Schema so the
+ * contract can cross process and package boundaries.
+ */
+type HarnessV1ResponseFormat = {
+    readonly type: 'text';
+} | {
+    readonly type: 'json';
+    readonly schema?: HarnessV1JSONSchema;
+    readonly name?: string;
+    readonly description?: string;
+};
+
 type HarnessV1PendingToolApproval = {
     readonly approvalId: string;
     readonly toolCallId: string;
@@ -764,6 +788,11 @@ type HarnessV1PromptTurnOptions = {
      * so prior turns are never replayed across the contract.
      */
     readonly prompt: HarnessV1Prompt;
+    /**
+     * Response format requested for this turn. Adapters that cannot honor a
+     * JSON response format must throw `HarnessCapabilityUnsupportedError`.
+     */
+    readonly responseFormat?: HarnessV1ResponseFormat;
     /**
      * Host-defined tools to make available to the underlying runtime for this
      * turn. The harness emits `tool-call` events when the runtime calls one
@@ -799,6 +828,11 @@ type HarnessV1PromptTurnOptions = {
  * that was previously suspended temporarily, e.g. by the workflow slice loop.
  */
 type HarnessV1ContinueTurnOptions = {
+    /**
+     * Response format of the in-flight turn. Rerun-based adapters use this when
+     * reconstructing the turn; attach-based adapters may ignore it.
+     */
+    readonly responseFormat?: HarnessV1ResponseFormat;
     /**
      * Host-defined tools to make available for the continued turn. Same shape
      * as `doPromptTurn`'s `tools`. An adapter that purely attaches to a live turn
@@ -1235,7 +1269,7 @@ type HarnessAgentToolFilteringSettings<TOOLS extends ToolSet> = {
      */
     readonly inactiveTools?: HarnessTools<TOOLS>;
 };
-type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}, RUNTIME_CONTEXT extends Context = Context> = {
+type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends OutputInterface = never> = {
     /**
      * The harness adapter driving the underlying agent runtime. Its
      * `builtinTools` are merged with the user-defined `tools` and exposed to
@@ -1269,6 +1303,11 @@ type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAge
      * it to the first user message of a fresh session.
      */
     readonly instructions?: string;
+    /**
+     * Optional specification for generating typed output. The same output
+     * requirement is active for every turn run by this agent.
+     */
+    readonly output?: OUTPUT;
     /**
      * Conditions that stop the current result after a completed harness tool
      * step that can continue into another model step. The underlying turn remains
@@ -1366,8 +1405,8 @@ declare function collectHarnessAgentToolResultContinuations(input: {
     messages: readonly ModelMessage[];
 }): readonly HarnessAgentToolResultContinuation[];
 
-type HarnessAgentTurnResult<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context> = {
-    result: StreamTextResult<TOOLS, RUNTIME_CONTEXT, never>;
+type HarnessAgentTurnResult<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface> = {
+    result: StreamTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
     done: Promise<void>;
 };
 type HarnessAgentTurnState = 'idle' | 'running' | 'awaiting-approval' | 'awaiting-tool-result' | 'suspended';
@@ -1425,7 +1464,7 @@ declare class HarnessAgentSession {
         turnState?: HarnessAgentTurnState;
     });
     hasUnfinishedTurn(): boolean;
-    promptTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context>(options: {
+    promptTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface>(options: {
         prompt: HarnessAgentPrompt;
         instructions: string | undefined;
         tools: TOOLS;
@@ -1434,10 +1473,12 @@ declare class HarnessAgentSession {
         builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
         runtimeContext: RUNTIME_CONTEXT;
         abortSignal: AbortSignal | undefined;
+        responseFormat: HarnessV1ResponseFormat | undefined;
+        output: OUTPUT | undefined;
         telemetry: TelemetryOptions | undefined;
         stopConditions: ReadonlyArray<StopCondition<TOOLS, RUNTIME_CONTEXT>>;
-    }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT>;
-    continueTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context>(options: {
+    }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
+    continueTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface>(options: {
         instructions: string | undefined;
         tools: TOOLS;
         activeTools: ToolSet;
@@ -1445,11 +1486,13 @@ declare class HarnessAgentSession {
         builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
         runtimeContext: RUNTIME_CONTEXT;
         abortSignal: AbortSignal | undefined;
+        responseFormat: HarnessV1ResponseFormat | undefined;
+        output: OUTPUT | undefined;
         telemetry: TelemetryOptions | undefined;
         stopConditions: ReadonlyArray<StopCondition<TOOLS, RUNTIME_CONTEXT>>;
         toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[] | undefined;
         toolResultContinuations?: readonly HarnessAgentToolResultContinuation[] | undefined;
-    }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT>;
+    }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
     /**
      * Ask the underlying runtime to compact its context. The runtime performs
      * the compaction itself; when it completes, a `compaction` part appears on
@@ -1556,7 +1599,7 @@ interface HarnessAgentCallExtensions {
  *    `Experimental_SandboxSession`) is handed to user-tool `execute()` calls
  *    via `experimental_sandbox`.
  */
-declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}, RUNTIME_CONTEXT extends Context = Context> implements Agent<never, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, never> {
+declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends OutputInterface = never> implements Agent<never, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT> {
     readonly version: "agent-v1";
     readonly id: string | undefined;
     /**
@@ -1572,7 +1615,7 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
     private readonly activeUserTools;
     private readonly builtinToolFiltering;
     private readonly permissionMode;
-    constructor(settings: HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT>);
+    constructor(settings: HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, OUTPUT>);
     /** Identifier of the harness backing this agent. */
     get harnessId(): string;
     /**
@@ -1605,8 +1648,8 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
         continueFrom?: HarnessAgentContinueTurnState;
         abortSignal?: AbortSignal;
     }): Promise<HarnessAgentSession>;
-    generate(options: AgentCallParameters<never, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, never>>;
-    stream(options: AgentStreamParameters<never, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, never>>;
+    generate(options: AgentCallParameters<never, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
+    stream(options: AgentStreamParameters<never, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
     /**
      * Continue the in-flight turn **without a new prompt**, draining it like
      * {@link generate}. Used after `createSession({ continueFrom })` to finish
@@ -1617,7 +1660,7 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
         toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[];
         toolResultContinuations?: readonly HarnessAgentToolResultContinuation[];
         abortSignal?: AbortSignal;
-    }): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, never>>;
+    }): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
     /**
      * Continue the in-flight turn **without a new prompt**, streaming its events
      * like {@link stream}. Used to keep consuming a turn that is still running
@@ -1631,12 +1674,13 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
         toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[];
         toolResultContinuations?: readonly HarnessAgentToolResultContinuation[];
         abortSignal?: AbortSignal;
-    }): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, never>>;
+    }): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
     private _startTurn;
     private _acquireSandbox;
     private _resolveTurnInput;
     private _toToolSpecs;
     private _toGenerateResult;
+    private _resolveResponseFormat;
 }
 
 type SandboxBootstrapSettings = Omit<HarnessAgentSandboxConfig, 'onSession'>;

package/dist/agent/index.js

@@ -250,6 +250,7 @@ var HarnessStreamTextResult = class {
     this.toolsContext = options.toolsContext;
     this.providerName = `harness:${options.harnessId}`;
     this.modelId = options.sessionId;
+    this.outputSpecification = options.output;
     let controllerRef;
     const baseStream = new ReadableStream({
       start(c) {
@@ -258,18 +259,13 @@ var HarnessStreamTextResult = class {
       }
     });
     this.fullStreamController = controllerRef;
-    const [forFull, forText] = baseStream.tee();
-    this.stream = forFull;
-    this.fullStream = this.stream;
-    this.textStream = forText.pipeThrough(
+    this.baseStream = options.output == null ? baseStream.pipeThrough(
       new TransformStream({
         transform(part, controller) {
-          if (part.type === "text-delta") {
-            controller.enqueue(part.text);
-          }
+          controller.enqueue({ part, partialOutput: void 0 });
         }
       })
-    );
+    ) : baseStream.pipeThrough(createOutputTransformStream(options.output));
   }
   // ─── Writer-side methods used by the driver ────────────────────────
   /**
@@ -525,6 +521,38 @@ var HarnessStreamTextResult = class {
     }
   }
   // ─── Reader-side public surface (StreamTextResult contract) ────────
+  teeStream() {
+    const [stream, remainingStream] = this.baseStream.tee();
+    this.baseStream = remainingStream;
+    return stream;
+  }
+  get stream() {
+    return createAsyncIterableStream(
+      this.teeStream().pipeThrough(
+        new TransformStream({
+          transform({ part }, controller) {
+            controller.enqueue(part);
+          }
+        })
+      )
+    );
+  }
+  get fullStream() {
+    return this.stream;
+  }
+  get textStream() {
+    return createAsyncIterableStream(
+      this.stream.pipeThrough(
+        new TransformStream({
+          transform(part, controller) {
+            if (part.type === "text-delta") {
+              controller.enqueue(part.text);
+            }
+          }
+        })
+      )
+    );
+  }
   get content() {
     return this._content.promise;
   }
@@ -594,18 +622,48 @@ var HarnessStreamTextResult = class {
   get providerMetadata() {
     return this._providerMetadata.promise;
   }
-  // Output-specification surfaces are not yet supported.
   get experimental_partialOutputStream() {
-    throw notSupportedYet("partial output stream");
+    return this.partialOutputStream;
   }
   get partialOutputStream() {
-    throw notSupportedYet("partial output stream");
+    return createAsyncIterableStream(
+      this.teeStream().pipeThrough(
+        new TransformStream({
+          transform({ partialOutput }, controller) {
+            if (partialOutput != null) {
+              controller.enqueue(partialOutput);
+            }
+          }
+        })
+      )
+    );
   }
   get elementStream() {
-    throw notSupportedYet("element stream");
+    var _a4, _b4, _c;
+    const transform = (_a4 = this.outputSpecification) == null ? void 0 : _a4.createElementStreamTransform();
+    if (transform == null) {
+      throw notSupportedYet(
+        `element streams in ${(_c = (_b4 = this.outputSpecification) == null ? void 0 : _b4.name) != null ? _c : "text"} mode`
+      );
+    }
+    return createAsyncIterableStream(
+      this.teeStream().pipeThrough(transform)
+    );
   }
   get output() {
-    throw notSupportedYet("structured output");
+    return this.finalStep.then((step) => {
+      if (this.outputSpecification == null) {
+        throw notSupportedYet("structured output");
+      }
+      return this.outputSpecification.parseCompleteOutput(
+        { text: step.text },
+        {
+          response: step.response,
+          usage: step.usage,
+          finishReason: step.finishReason
+        }
+      );
+    });
   }
   async consumeStream() {
     const reader = this.fullStream.getReader();
@@ -725,6 +783,73 @@ var HarnessStreamTextResult = class {
     }
   }
 };
+function createOutputTransformStream(output) {
+  let firstTextChunkId;
+  let text = "";
+  let textChunk = "";
+  let textProviderMetadata;
+  let lastPublishedValue = "";
+  const publishTextChunk = (options) => {
+    options.controller.enqueue({
+      part: {
+        type: "text-delta",
+        id: firstTextChunkId,
+        text: textChunk,
+        providerMetadata: textProviderMetadata
+      },
+      partialOutput: options.partialOutput
+    });
+    textChunk = "";
+  };
+  return new TransformStream({
+    async transform(chunk, controller) {
+      var _a4;
+      if (chunk.type === "finish-step" && textChunk.length > 0) {
+        publishTextChunk({ controller });
+      }
+      if (chunk.type !== "text-delta" && chunk.type !== "text-start" && chunk.type !== "text-end") {
+        controller.enqueue({ part: chunk, partialOutput: void 0 });
+        return;
+      }
+      if (firstTextChunkId == null) {
+        firstTextChunkId = chunk.id;
+      } else if (chunk.id !== firstTextChunkId) {
+        controller.enqueue({ part: chunk, partialOutput: void 0 });
+        return;
+      }
+      if (chunk.type === "text-start") {
+        controller.enqueue({ part: chunk, partialOutput: void 0 });
+        return;
+      }
+      if (chunk.type === "text-end") {
+        if (textChunk.length > 0) {
+          publishTextChunk({ controller });
+        }
+        controller.enqueue({ part: chunk, partialOutput: void 0 });
+        return;
+      }
+      text += chunk.text;
+      textChunk += chunk.text;
+      textProviderMetadata = (_a4 = chunk.providerMetadata) != null ? _a4 : textProviderMetadata;
+      if (chunk.text.length === 0 && chunk.providerMetadata != null) {
+        controller.enqueue({ part: chunk, partialOutput: void 0 });
+        return;
+      }
+      const result = await output.parsePartialOutput({ text });
+      if (result === void 0) {
+        return;
+      }
+      const currentValue = typeof result.partial === "string" ? result.partial : JSON.stringify(result.partial);
+      if (currentValue !== lastPublishedValue) {
+        publishTextChunk({
+          controller,
+          partialOutput: result.partial
+        });
+        lastPublishedValue = currentValue;
+      }
+    }
+  });
+}
 function createEmptyPerformance() {
   return {
     effectiveOutputTokensPerSecond: 0,
@@ -1372,7 +1497,8 @@ function runPrompt(input) {
     // toolsContext is not configurable for harnesses; pass undefined cast.
     toolsContext: void 0,
     harnessId: input.harness.harnessId,
-    sessionId: input.session.sessionId
+    sessionId: input.session.sessionId,
+    output: input.output
   });
   const pendingToolApprovals = (_a4 = input.pendingToolApprovals) != null ? _a4 : [];
   const pendingToolResults = (_b4 = input.pendingToolResults) != null ? _b4 : [];
@@ -1413,6 +1539,7 @@ function runPrompt(input) {
     try {
       bridge = await toHarnessStream({
         invoke: input.mode === "continue" ? (emit) => input.session.doContinueTurn({
+          responseFormat: input.responseFormat,
           tools: input.toolSpecs,
           instructions: input.instructions,
           abortSignal: input.abortSignal,
@@ -1425,6 +1552,7 @@ function runPrompt(input) {
           }
           return input.session.doPromptTurn({
             prompt: input.prompt,
+            responseFormat: input.responseFormat,
             tools: input.toolSpecs,
             instructions: input.instructions,
             abortSignal: input.abortSignal,
@@ -2273,6 +2401,8 @@ var HarnessAgentSession = class {
         sessionWorkDir: this.sessionWorkDir,
         runtimeContext: options.runtimeContext,
         abortSignal: options.abortSignal,
+        responseFormat: options.responseFormat,
+        output: options.output,
         telemetry: options.telemetry,
         stopConditions: options.stopConditions,
         toolApproval: this.toolApproval,
@@ -2326,6 +2456,8 @@ var HarnessAgentSession = class {
         sessionWorkDir: this.sessionWorkDir,
         runtimeContext: options.runtimeContext,
         abortSignal: options.abortSignal,
+        responseFormat: options.responseFormat,
+        output: options.output,
         telemetry: options.telemetry,
         stopConditions: options.stopConditions,
         toolApproval: this.toolApproval,
@@ -3342,11 +3474,13 @@ var HarnessAgent = class {
   async generate(options) {
     const turnInput = this._resolveTurnInput(options);
     const runtimeContext = {};
+    const responseFormat = await this._resolveResponseFormat();
     const { result, done } = this._startTurn({
       session: options.session,
       turnInput,
       runtimeContext,
-      abortSignal: options.abortSignal
+      abortSignal: options.abortSignal,
+      responseFormat
     });
     await done;
     return this._toGenerateResult(result);
@@ -3354,11 +3488,13 @@ var HarnessAgent = class {
   async stream(options) {
     const turnInput = this._resolveTurnInput(options);
     const runtimeContext = {};
+    const responseFormat = await this._resolveResponseFormat();
     const { result } = this._startTurn({
       session: options.session,
       turnInput,
       runtimeContext,
-      abortSignal: options.abortSignal
+      abortSignal: options.abortSignal,
+      responseFormat
     });
     return result;
   }
@@ -3370,6 +3506,7 @@ var HarnessAgent = class {
   async continueGenerate(options) {
     var _a4, _b4;
     const runtimeContext = {};
+    const responseFormat = await this._resolveResponseFormat();
     const { result, done } = this._startTurn({
       session: options.session,
       turnInput: {
@@ -3378,7 +3515,8 @@ var HarnessAgent = class {
         toolResultContinuations: (_b4 = options.toolResultContinuations) != null ? _b4 : []
       },
       runtimeContext,
-      abortSignal: options.abortSignal
+      abortSignal: options.abortSignal,
+      responseFormat
     });
     await done;
     return this._toGenerateResult(result);
@@ -3394,6 +3532,7 @@ var HarnessAgent = class {
   async continueStream(options) {
     var _a4, _b4;
     const runtimeContext = {};
+    const responseFormat = await this._resolveResponseFormat();
     const { result } = this._startTurn({
       session: options.session,
       turnInput: {
@@ -3402,7 +3541,8 @@ var HarnessAgent = class {
         toolResultContinuations: (_b4 = options.toolResultContinuations) != null ? _b4 : []
       },
       runtimeContext,
-      abortSignal: options.abortSignal
+      abortSignal: options.abortSignal,
+      responseFormat
     });
     return result;
   }
@@ -3417,6 +3557,8 @@ var HarnessAgent = class {
         builtinToolFiltering: this.builtinToolFiltering,
         runtimeContext: input.runtimeContext,
         abortSignal: input.abortSignal,
+        responseFormat: input.responseFormat,
+        output: this.settings.output,
         telemetry: this.settings.telemetry,
         stopConditions: this.stopConditions,
         toolApprovalContinuations: input.turnInput.toolApprovalContinuations,
@@ -3432,6 +3574,8 @@ var HarnessAgent = class {
       builtinToolFiltering: this.builtinToolFiltering,
       runtimeContext: input.runtimeContext,
       abortSignal: input.abortSignal,
+      responseFormat: input.responseFormat,
+      output: this.settings.output,
       telemetry: this.settings.telemetry,
       stopConditions: this.stopConditions
     });
@@ -3516,20 +3660,34 @@ var HarnessAgent = class {
     return specs;
   }
   async _toGenerateResult(streamResult) {
-    const [steps, usage, responseMessages] = await Promise.all([
+    const [steps, usage, responseMessages, output] = await Promise.all([
       streamResult.steps,
       streamResult.usage,
-      streamResult.responseMessages
+      streamResult.responseMessages,
+      this.settings.output == null ? Promise.resolve(void 0) : streamResult.output
     ]);
-    return new HarnessGenerateTextResult({ steps, usage, responseMessages });
+    return new HarnessGenerateTextResult({ steps, usage, responseMessages, output });
+  }
+  async _resolveResponseFormat() {
+    var _a4;
+    const responseFormat = await ((_a4 = this.settings.output) == null ? void 0 : _a4.responseFormat);
+    if (responseFormat == null || responseFormat.type === "text") {
+      return responseFormat == null ? void 0 : { type: "text" };
+    }
+    return {
+      type: "json",
+      ...responseFormat.schema == null ? {} : { schema: responseFormat.schema },
+      ...responseFormat.name == null ? {} : { name: responseFormat.name },
+      ...responseFormat.description == null ? {} : { description: responseFormat.description }
+    };
   }
 };
 var HarnessGenerateTextResult = class {
   constructor(options) {
-    this.output = void 0;
     this.steps = options.steps;
     this.usage = options.usage;
     this.responseMessages = options.responseMessages;
+    this.output = options.output;
   }
   get finalStep() {
     return this.steps.at(-1);