@ai-sdk/harness-deepagents 1.0.71 → 1.0.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-deepagents",
-  "version": "1.0.71",
+  "version": "1.0.73",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -27,7 +27,7 @@
   },
   "dependencies": {
     "ws": "8.21.0",
-    "@ai-sdk/harness": "1.0.71",
+    "@ai-sdk/harness": "1.0.73",
     "@ai-sdk/provider-utils": "5.0.27"
   },
   "peerDependencies": {

package/src/bridge/create-emit-stream-event.ts

@@ -63,12 +63,14 @@ export function createEmitStreamEvent({
   configuredModel,
   hostToolNames,
   mcpToolNames,
+  structuredOutputToolNames = new Set(),
   emit,
 }: {
   state: DeepAgentsStreamEventState;
   configuredModel: string | undefined;
   hostToolNames: ReadonlySet<string>;
   mcpToolNames: ReadonlySet<string>;
+  structuredOutputToolNames?: ReadonlySet<string>;
   emit: Emit;
 }): (event: DeepAgentsStreamEvent) => void {
   return event => {
@@ -173,6 +175,7 @@ export function createEmitStreamEvent({
       }
     } else if (kind === 'on_tool_start') {
       const toolName = event.name ?? 'unknown';
+      if (structuredOutputToolNames.has(toolName)) return;
       const runId = event.run_id ?? '';
       // Host tools emit their own tool-call; surface only top-level builtin (providerExecuted) tools.
       if (!nested && !hostToolNames.has(toolName)) {
@@ -199,6 +202,7 @@ export function createEmitStreamEvent({
       }
     } else if (kind === 'on_tool_end') {
       const toolName = event.name ?? 'unknown';
+      if (structuredOutputToolNames.has(toolName)) return;
       const runId = event.run_id ?? '';
       if (!nested && !hostToolNames.has(toolName)) {
         const dynamic = state.dynamicToolRunIds.delete(runId);

package/src/bridge/index.ts

@@ -15,7 +15,7 @@ import {
   type ClientConfig,
 } from '@langchain/mcp-adapters';
 import { createDeepAgent } from 'deepagents';
-import { createMiddleware } from 'langchain';
+import { createMiddleware, toolStrategy } from 'langchain';
 import type { StartMessage } from '../deepagents-bridge-protocol';
 import { buildInterruptOn, collectActionRequests } from './approvals';
 import {
@@ -131,6 +131,30 @@ let agent: ReturnType<typeof createDeepAgent> | undefined;
 let currentTurn: BridgeTurn | undefined;
 let mcpClient: MultiServerMCPClient | undefined;
 let mcpToolNames = new Set<string>();
+let currentResponseFormat: ReturnType<typeof toolStrategy> | undefined;
+
+type DeepAgentsJsonSchema = Record<string, unknown> & {
+  type:
+    | 'null'
+    | 'boolean'
+    | 'object'
+    | 'array'
+    | 'number'
+    | 'string'
+    | 'integer';
+};
+
+const responseFormatMiddleware = createMiddleware({
+  name: 'HarnessResponseFormat',
+  wrapModelCall(request, handler) {
+    return handler({
+      ...request,
+      ...(currentResponseFormat == null
+        ? {}
+        : { responseFormat: currentResponseFormat }),
+    });
+  },
+});
 
 // Host tools become LangChain tools that emit a `tool-call` and block on the host's `tool-result`.
 function buildHostTools(toolSchemas: StartMessage['tools']) {
@@ -161,6 +185,10 @@ function buildHostTools(toolSchemas: StartMessage['tools']) {
 
 async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
   currentTurn = turn;
+  currentResponseFormat =
+    start.responseFormat?.type === 'json' && start.responseFormat.schema != null
+      ? toolStrategy(start.responseFormat.schema as DeepAgentsJsonSchema)
+      : undefined;
   const emit = (event: Record<string, unknown>) =>
     turn.emit(event as BridgeEvent);
 
@@ -191,6 +219,7 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
       },
     );
     const middleware = [
+      responseFormatMiddleware,
       ...(reasoningMiddleware ? [reasoningMiddleware] : []),
       ...(builtinToolFilteringMiddleware
         ? [builtinToolFilteringMiddleware]
@@ -230,6 +259,9 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     configuredModel: start.model,
     hostToolNames,
     mcpToolNames,
+    structuredOutputToolNames: new Set(
+      currentResponseFormat?.map(format => format.name) ?? [],
+    ),
     emit,
   });
 
@@ -259,12 +291,33 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
   let resumeInput: unknown = {
     messages: [{ role: 'user', content: start.prompt }],
   };
+  let emittedStructuredOutput = false;
 
   while (true) {
     const stream = await agent.streamEvents(resumeInput as never, config);
 
     for await (const event of stream) {
       emitStreamEvent(event as DeepAgentsStreamEvent);
+      const streamEvent = event as DeepAgentsStreamEvent;
+      const namespace = streamEvent.metadata?.langgraph_checkpoint_ns ?? '';
+      const output = (streamEvent.data as { output?: unknown } | undefined)
+        ?.output as { structuredResponse?: unknown } | undefined;
+      if (
+        !emittedStructuredOutput &&
+        streamEvent.event === 'on_chain_end' &&
+        !namespace.includes('|') &&
+        output?.structuredResponse !== undefined
+      ) {
+        const id = `structured-output-${randomUUID()}`;
+        emit({ type: 'text-start', id });
+        emit({
+          type: 'text-delta',
+          id,
+          delta: JSON.stringify(output.structuredResponse),
+        });
+        emit({ type: 'text-end', id });
+        emittedStructuredOutput = true;
+      }
     }
 
     const actionRequests = await readPendingApprovals();

package/src/deepagents-auth.ts

@@ -1,6 +1,44 @@
-import { getAiGatewayAuthFromEnv } from '@ai-sdk/harness/utils';
+import type { HarnessV1RequestTransformation } from '@ai-sdk/harness';
+import {
+  createCredentialRequestTransformation,
+  getAiGatewayAuthFromEnv,
+} from '@ai-sdk/harness/utils';
 
-export type DeepAgentsAuthenticationMode = 'auto' | 'anthropic' | 'ai-gateway';
+export const DEEPAGENTS_CREDENTIAL_ENVIRONMENT_VARIABLES = [
+  'AI_GATEWAY_API_KEY',
+  'ANTHROPIC_API_KEY',
+  'ANTHROPIC_AUTH_TOKEN',
+] as const;
+
+export function createDeepAgentsRequestTransformations(
+  env: Record<string, string>,
+  auth: DeepAgentsResolvedAuthenticationMode,
+): HarnessV1RequestTransformation[] {
+  const headers: Record<string, string> = {};
+  if (env.ANTHROPIC_API_KEY) {
+    headers['x-api-key'] = env.ANTHROPIC_API_KEY;
+  }
+  if (env.ANTHROPIC_AUTH_TOKEN) {
+    headers.Authorization = `Bearer ${env.ANTHROPIC_AUTH_TOKEN}`;
+  }
+  return Object.keys(headers).length === 0
+    ? []
+    : [
+        createCredentialRequestTransformation({
+          baseUrl:
+            auth === 'ai-gateway'
+              ? env.ANTHROPIC_BASE_URL
+              : (env.ANTHROPIC_BASE_URL ?? 'https://api.anthropic.com'),
+          headers,
+        }),
+      ];
+}
+
+export type DeepAgentsResolvedAuthenticationMode = 'anthropic' | 'ai-gateway';
+
+export type DeepAgentsAuthenticationMode =
+  | DeepAgentsResolvedAuthenticationMode
+  | 'auto';
 
 /**
  * @deprecated Passing an object to auth options is deprecated. Use a `DeepAgentsAuthenticationMode` string value ("auto" | "anthropic" | "ai-gateway") instead, and pass credentials via environment variables.
@@ -51,6 +89,24 @@ export function resolveDeepAgentsEnv({
   return pickAnthropic({ processEnv });
 }
 
+export function resolveDeepAgentsAuthenticationMode({
+  auth,
+  processEnv = process.env,
+}: {
+  auth?: DeepAgentsAuthOptions;
+  processEnv?: Record<string, string | undefined>;
+}): DeepAgentsResolvedAuthenticationMode {
+  if (auth === 'anthropic' || (typeof auth !== 'string' && auth?.anthropic)) {
+    return 'anthropic';
+  }
+  if (auth === 'ai-gateway' || (typeof auth !== 'string' && auth?.gateway)) {
+    return 'ai-gateway';
+  }
+  return getAiGatewayAuthFromEnv({ env: processEnv }).apiKey
+    ? 'ai-gateway'
+    : 'anthropic';
+}
+
 function normalizeDeepAgentsAuthToLegacyAuth(
   auth: DeepAgentsAuthOptions | undefined,
 ): LegacyDeepAgentsAuthOptions | undefined {

package/src/deepagents-bootstrap.ts

@@ -0,0 +1,87 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import type { HarnessV1Bootstrap } from '@ai-sdk/harness';
+
+/*
+ * Bootstrap is derived state stored under the sandbox's default working
+ * directory so snapshot-capable providers preserve its installation and
+ * recipe marker without requiring root filesystem access.
+ */
+export const DEEPAGENTS_BOOTSTRAP_DIR = '.harness-bootstrap/deepagents';
+
+/*
+ * Pinned ripgrep release and per-architecture tarball checksums are verified
+ * before installation.
+ */
+const RIPGREP_VERSION = '14.1.1';
+const RIPGREP_SHA256_X64 =
+  '4cf9f2741e6c465ffdb7c26f38056a59e2a2544b51f7cc128ef28337eeae4d8e';
+const RIPGREP_SHA256_ARM =
+  'c827481c4ff4ea10c9dc7a4022c8de5db34a5737cb74484d62eb94a95841ab2f';
+
+let cachedBootstrap: HarnessV1Bootstrap | undefined;
+
+export async function getDeepAgentsBootstrap(): Promise<HarnessV1Bootstrap> {
+  if (cachedBootstrap != null) return cachedBootstrap;
+  const [bridge, pkg, lock] = await Promise.all([
+    readBridgeAsset('index.mjs'),
+    readBridgeAsset('package.json'),
+    readBridgeAsset('pnpm-lock.yaml'),
+  ]);
+  cachedBootstrap = {
+    harnessId: 'deepagents',
+    bootstrapDir: DEEPAGENTS_BOOTSTRAP_DIR,
+    files: [
+      { path: `${DEEPAGENTS_BOOTSTRAP_DIR}/bridge.mjs`, content: bridge },
+      { path: `${DEEPAGENTS_BOOTSTRAP_DIR}/package.json`, content: pkg },
+      { path: `${DEEPAGENTS_BOOTSTRAP_DIR}/pnpm-lock.yaml`, content: lock },
+    ],
+    commands: [
+      { command: installRipgrepCommand() },
+      {
+        command: 'pnpm install --frozen-lockfile --store-dir .pnpm-store',
+      },
+    ],
+  };
+  return cachedBootstrap;
+}
+
+/*
+ * DeepAgents' grep shells out to `rg`. Without it, the fallback reads the
+ * entire workdir, including node_modules, into memory and can run out of
+ * memory. The checksum-verified installation is skipped when `rg` exists.
+ */
+function installRipgrepCommand(): string {
+  const v = RIPGREP_VERSION;
+  return [
+    'command -v rg >/dev/null 2>&1 || {',
+    'case "$(uname -m)" in',
+    `aarch64) a=aarch64-unknown-linux-gnu; sha=${RIPGREP_SHA256_ARM} ;;`,
+    `*) a=x86_64-unknown-linux-musl; sha=${RIPGREP_SHA256_X64} ;;`,
+    'esac;',
+    `f=/tmp/ripgrep-${v}.tar.gz;`,
+    `curl -fsSL "https://github.com/BurntSushi/ripgrep/releases/download/${v}/ripgrep-${v}-$a.tar.gz" -o "$f"`,
+    '&& echo "$sha  $f" | sha256sum -c -',
+    '&& tar xzf "$f" -C /tmp',
+    `&& mv "/tmp/ripgrep-${v}-$a/rg" /usr/local/bin/rg && chmod +x /usr/local/bin/rg;`,
+    '}',
+  ].join(' ');
+}
+
+async function readBridgeAsset(name: string): Promise<string> {
+  const candidates = [
+    new URL(`./bridge/${name}`, import.meta.url),
+    new URL(`../bridge/${name}`, import.meta.url),
+  ];
+  let lastErr: unknown;
+  for (const url of candidates) {
+    try {
+      return await readFile(fileURLToPath(url), 'utf8');
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code !== 'ENOENT') throw err;
+      lastErr = err;
+    }
+  }
+  throw lastErr ?? new Error(`bridge asset not found: ${name}`);
+}

package/src/deepagents-harness.ts

@@ -1,13 +1,10 @@
 import { randomBytes } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
 import { posix } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import {
   commonTool,
   HarnessCapabilityUnsupportedError,
   harnessV1DiagnosticFromBridgeFrame,
   type HarnessV1,
-  type HarnessV1Bootstrap,
   type HarnessV1BuiltinTool,
   type HarnessV1BuiltinToolFiltering,
   type HarnessV1ContinueTurnState,
@@ -15,6 +12,7 @@ import {
   type HarnessV1PermissionMode,
   type HarnessV1Prompt,
   type HarnessV1PromptControl,
+  type HarnessV1PortEndpoint,
   type HarnessV1ResumeSessionState,
   type HarnessV1Session,
   type HarnessV1Skill,
@@ -26,9 +24,11 @@ import {
   createBridgeStartupError,
   drainBridgeProcessStream,
   forwardBridgeProcessStream,
+  maskSandboxCredentials,
   resolveSandboxHomeDir,
   SandboxChannel,
   shellQuote,
+  warnCredentialBrokeringUnavailable,
   waitForBridgeReady,
   writeSkills as writeHarnessSkills,
 } from '@ai-sdk/harness/utils';
@@ -36,6 +36,13 @@ import { tool, type Experimental_SandboxProcess } from '@ai-sdk/provider-utils';
 import { WebSocket } from 'ws';
 import { z } from 'zod/v4';
 import {
+  DEEPAGENTS_BOOTSTRAP_DIR as BOOTSTRAP_DIR,
+  getDeepAgentsBootstrap,
+} from './deepagents-bootstrap';
+import {
+  createDeepAgentsRequestTransformations,
+  DEEPAGENTS_CREDENTIAL_ENVIRONMENT_VARIABLES,
+  resolveDeepAgentsAuthenticationMode,
   resolveDeepAgentsEnv,
   type DeepAgentsAuthOptions,
 } from './deepagents-auth';
@@ -48,12 +55,6 @@ import { VERSION } from './version';
 
 type DeepAgentsChannel = SandboxChannel<OutboundMessage, InboundMessage>;
 
-/*
- * Bootstrap is derived state stored under the sandbox's default working
- * directory so snapshot-capable providers preserve its installation and
- * recipe marker without requiring root filesystem access.
- */
-const BOOTSTRAP_DIR = '.harness-bootstrap/deepagents';
 /**
  * Value to use in User-Agent and `x-client-app` headers.
  */
@@ -73,32 +74,6 @@ export type DeepAgentsThinkingConfig =
       readonly type: 'disabled';
     };
 
-// Pinned ripgrep release + per-arch tarball checksums (verified before install).
-const RIPGREP_VERSION = '14.1.1';
-const RIPGREP_SHA256_X64 =
-  '4cf9f2741e6c465ffdb7c26f38056a59e2a2544b51f7cc128ef28337eeae4d8e';
-const RIPGREP_SHA256_ARM =
-  'c827481c4ff4ea10c9dc7a4022c8de5db34a5737cb74484d62eb94a95841ab2f';
-
-// Idempotent, checksum-verified install of a static ripgrep binary into a PATH dir.
-// DeepAgents' grep shells out to `rg`; without it, its fallback reads the whole workdir (incl. node_modules) into memory and OOMs. Skipped if `rg` already exists.
-function installRipgrepCommand(): string {
-  const v = RIPGREP_VERSION;
-  return [
-    'command -v rg >/dev/null 2>&1 || {',
-    'case "$(uname -m)" in',
-    `aarch64) a=aarch64-unknown-linux-gnu; sha=${RIPGREP_SHA256_ARM} ;;`,
-    `*) a=x86_64-unknown-linux-musl; sha=${RIPGREP_SHA256_X64} ;;`,
-    'esac;',
-    `f=/tmp/ripgrep-${v}.tar.gz;`,
-    `curl -fsSL "https://github.com/BurntSushi/ripgrep/releases/download/${v}/ripgrep-${v}-$a.tar.gz" -o "$f"`,
-    '&& echo "$sha  $f" | sha256sum -c -',
-    '&& tar xzf "$f" -C /tmp',
-    `&& mv "/tmp/ripgrep-${v}-$a/rg" /usr/local/bin/rg && chmod +x /usr/local/bin/rg;`,
-    '}',
-  ].join(' ');
-}
-
 // Skills source subpath, written under $HOME (out of the work dir so it can't clash with code cloned into the work dir) and also discovered from <workDir> for repo-provided skills.
 const SKILLS_SOURCE_PATH = '/.agents/skills';
 
@@ -212,8 +187,6 @@ type DeepAgentsBridgeCoords = z.infer<typeof deepAgentsBridgeCoordsSchema>;
 export function createDeepAgents(
   settings: DeepAgentsHarnessSettings = {},
 ): HarnessV1<typeof DEEPAGENTS_BUILTIN_TOOLS> {
-  let cachedBootstrap: HarnessV1Bootstrap | undefined;
-
   return {
     specificationVersion: 'harness-v1',
     harnessId: 'deepagents',
@@ -221,33 +194,35 @@ export function createDeepAgents(
     // Built-in tool approvals are gated in-bridge via DeepAgents' interruptOn (HITL) middleware.
     supportsBuiltinToolApprovals: true,
     lifecycleStateSchema: deepAgentsResumeStateSchema,
-    getBootstrap: async () => {
-      if (cachedBootstrap != null) return cachedBootstrap;
-      const [bridge, pkg, lock] = await Promise.all([
-        readBridgeAsset('index.mjs'),
-        readBridgeAsset('package.json'),
-        readBridgeAsset('pnpm-lock.yaml'),
-      ]);
-      cachedBootstrap = {
-        harnessId: 'deepagents',
-        bootstrapDir: BOOTSTRAP_DIR,
-        files: [
-          { path: `${BOOTSTRAP_DIR}/bridge.mjs`, content: bridge },
-          { path: `${BOOTSTRAP_DIR}/package.json`, content: pkg },
-          { path: `${BOOTSTRAP_DIR}/pnpm-lock.yaml`, content: lock },
-        ],
-        commands: [
-          { command: installRipgrepCommand() },
-          {
-            command: 'pnpm install --frozen-lockfile --store-dir .pnpm-store',
-          },
-        ],
-      };
-      return cachedBootstrap;
-    },
+    getBootstrap: getDeepAgentsBootstrap,
     doStart: async startOpts => {
       const permissionMode = startOpts.permissionMode;
       const sandboxSession = startOpts.sandboxSession;
+      const authenticationMode = resolveDeepAgentsAuthenticationMode({
+        auth: settings.auth,
+      });
+      const resolvedAuthEnvironment = resolveDeepAgentsEnv({
+        auth: settings.auth,
+      });
+      let sandboxAuthEnvironment = resolvedAuthEnvironment;
+      if (sandboxSession.addRequestTransformations != null) {
+        const requestTransformations = createDeepAgentsRequestTransformations(
+          resolvedAuthEnvironment,
+          authenticationMode,
+        );
+        if (requestTransformations.length > 0) {
+          await sandboxSession.addRequestTransformations(
+            requestTransformations,
+          );
+        }
+        sandboxAuthEnvironment = maskSandboxCredentials({
+          environment: resolvedAuthEnvironment,
+          credentialEnvironmentVariables:
+            DEEPAGENTS_CREDENTIAL_ENVIRONMENT_VARIABLES,
+        });
+      } else {
+        warnCredentialBrokeringUnavailable();
+      }
       const session = sandboxSession.restricted();
       const sandboxId = sandboxSession.id;
       const bootstrapDir = posix.resolve(
@@ -286,13 +261,16 @@ export function createDeepAgents(
       // Attach to the still-running bridge (continueFrom replays past the cursor); on failure fall through to a fresh spawn.
       if (coords) {
         try {
-          const attachUrl =
-            (await sandboxSession.getPortUrl({
-              port: coords.port,
-              protocol: 'ws',
-            })) + `?agent_bridge_token=${encodeURIComponent(coords.token)}`;
+          const endpoint = await sandboxSession.getPortEndpoint({
+            port: coords.port,
+            protocol: 'ws',
+          });
+          const attachEndpoint = withBridgeToken({
+            endpoint,
+            token: coords.token,
+          });
           const attachChannel: DeepAgentsChannel = new SandboxChannel({
-            connect: () => openWebSocket(attachUrl),
+            connect: () => openWebSocket(attachEndpoint),
             outboundSchema: outboundMessageSchema,
             initialLastSeenEventId: coords.lastSeenEventId,
             onDiagnostic,
@@ -347,7 +325,7 @@ export function createDeepAgents(
       }
 
       const env = {
-        ...resolveDeepAgentsEnv({ auth: settings.auth }),
+        ...sandboxAuthEnvironment,
         AI_SDK_HARNESS_CLIENT_APP: DEEPAGENTS_CLIENT_APP,
         BRIDGE_CHANNEL_TOKEN: token,
         BRIDGE_WS_PORT: String(port),
@@ -404,14 +382,14 @@ export function createDeepAgents(
       });
       void drainBridgeProcessStream(proc.stdout);
 
-      const wsUrl =
-        (await sandboxSession.getPortUrl({
-          port: boundPort,
-          protocol: 'ws',
-        })) + `?agent_bridge_token=${encodeURIComponent(token)}`;
+      const endpoint = await sandboxSession.getPortEndpoint({
+        port: boundPort,
+        protocol: 'ws',
+      });
+      const bridgeEndpoint = withBridgeToken({ endpoint, token });
 
       const channel: DeepAgentsChannel = new SandboxChannel({
-        connect: () => openWebSocket(wsUrl),
+        connect: () => openWebSocket(bridgeEndpoint),
         outboundSchema: outboundMessageSchema,
         onDiagnostic,
         onBridgeError,
@@ -455,24 +433,6 @@ function resolveBridgePort(
   });
 }
 
-async function readBridgeAsset(name: string): Promise<string> {
-  const candidates = [
-    new URL(`./bridge/${name}`, import.meta.url),
-    new URL(`../bridge/${name}`, import.meta.url),
-  ];
-  let lastErr: unknown;
-  for (const url of candidates) {
-    try {
-      return await readFile(fileURLToPath(url), 'utf8');
-    } catch (err) {
-      const code = (err as NodeJS.ErrnoException).code;
-      if (code !== 'ENOENT') throw err;
-      lastErr = err;
-    }
-  }
-  throw lastErr ?? new Error(`bridge asset not found: ${name}`);
-}
-
 // Materialize each skill as a native deepagents `<name>/SKILL.md` folder (+ attached files) under the given root, so skills load on demand and file references resolve.
 async function writeSkills({
   sandbox,
@@ -503,9 +463,14 @@ async function writeSkills({
   });
 }
 
-function openWebSocket(url: string): Promise<WebSocket> {
+function openWebSocket({
+  url,
+  headers,
+}: HarnessV1PortEndpoint): Promise<WebSocket> {
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket(url);
+    const ws = new WebSocket(url, {
+      headers: headers == null ? undefined : { ...headers },
+    });
     const onOpen = () => {
       ws.off('error', onError);
       resolve(ws);
@@ -519,6 +484,18 @@ function openWebSocket(url: string): Promise<WebSocket> {
   });
 }
 
+function withBridgeToken({
+  endpoint,
+  token,
+}: {
+  endpoint: HarnessV1PortEndpoint;
+  token: string;
+}): HarnessV1PortEndpoint {
+  const bridgeUrl = new URL(endpoint.url);
+  bridgeUrl.searchParams.set('agent_bridge_token', token);
+  return { ...endpoint, url: bridgeUrl.toString() };
+}
+
 function createSession({
   sessionId,
   channel,
@@ -691,6 +668,16 @@ function createSession({
     isResume,
     modelId: model,
     doPromptTurn: async promptOpts => {
+      if (
+        promptOpts.responseFormat?.type === 'json' &&
+        promptOpts.responseFormat.schema == null
+      ) {
+        throw new HarnessCapabilityUnsupportedError({
+          message:
+            "Harness 'deepagents' requires a JSON schema for structured output.",
+          harnessId: 'deepagents',
+        });
+      }
       const control = wireTurn({
         emit: promptOpts.emit,
         abortSignal: promptOpts.abortSignal,
@@ -709,6 +696,9 @@ function createSession({
           description: t.description,
           inputSchema: t.inputSchema,
         })),
+        ...(promptOpts.responseFormat == null
+          ? {}
+          : { responseFormat: promptOpts.responseFormat }),
         ...(model ? { model } : {}),
         ...(thinking ? { thinking } : {}),
         ...(effort ? { effort } : {}),
@@ -722,6 +712,16 @@ function createSession({
       return control;
     },
     doContinueTurn: async continueOpts => {
+      if (
+        continueOpts.responseFormat?.type === 'json' &&
+        continueOpts.responseFormat.schema == null
+      ) {
+        throw new HarnessCapabilityUnsupportedError({
+          message:
+            "Harness 'deepagents' requires a JSON schema for structured output.",
+          harnessId: 'deepagents',
+        });
+      }
       // Attach/replay: doStart opened with `{ resume: true }` so the bridge replays past the cursor; no `start` is sent (that would clear the replay log).
       return wireTurn({
         emit: continueOpts.emit,