@ai-sdk/harness-deepagents 1.0.72 → 1.0.74

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @ai-sdk/harness-deepagents
 
+## 1.0.74
+
+### Patch Changes
+
+- @ai-sdk/harness@1.0.74
+
+## 1.0.73
+
+### Patch Changes
+
+- 62a9c2a: feat(harness): add support for structured output to `HarnessAgent` via `output` property
+- Updated dependencies [62a9c2a]
+- Updated dependencies [d25cae2]
+  - @ai-sdk/harness@1.0.73
+
 ## 1.0.72
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -57,7 +57,6 @@ async function runBridge(options) {
   let currentBoundPort = 0;
   let currentTurnState = "init";
   let activeSocket;
-  let activeSocketReadyForLiveEvents = false;
   let isFirstTurn = true;
   let turnAbort;
   let currentUserMessages;
@@ -141,14 +140,6 @@ async function runBridge(options) {
     } catch {
     }
   };
-  const sendControl = (msg) => {
-    if (activeSocket?.readyState === WS_OPEN) {
-      try {
-        activeSocket.send(JSON.stringify(msg));
-      } catch {
-      }
-    }
-  };
   const emit = (event) => {
     const seq = ++seqCounter;
     const line = JSON.stringify({ ...event, seq });
@@ -156,7 +147,7 @@ async function runBridge(options) {
     diskBuffer += `${line}
 `;
     scheduleEventFlush();
-    if (activeSocketReadyForLiveEvents && activeSocket?.readyState === WS_OPEN) {
+    if (activeSocket?.readyState === WS_OPEN) {
       try {
         activeSocket.send(line);
       } catch {
@@ -259,8 +250,7 @@ async function runBridge(options) {
   const handleInbound = async (msg, ws) => {
     switch (msg.type) {
       case "start": {
-        if (activeSocket !== ws) return;
-        activeSocketReadyForLiveEvents = true;
+        activeSocket = ws;
         const firstTurn = isFirstTurn;
         isFirstTurn = false;
         eventLog = [];
@@ -340,9 +330,8 @@ async function runBridge(options) {
         turnAbort?.abort();
         return;
       case "resume":
-        if (activeSocket !== ws) return;
+        activeSocket = ws;
         replay(ws, msg.lastSeenEventId);
-        activeSocketReadyForLiveEvents = true;
         return;
       case "destroy":
         currentTurnState = "done";
@@ -354,7 +343,7 @@ async function runBridge(options) {
         currentTurnState = "done";
         void writeBridgeMeta("done");
         const data = await onStop?.() ?? {};
-        sendControl({ type: "bridge-stop", data });
+        sendControl(ws, { type: "bridge-stop", data });
         drainThenExit(ws, 1e3, "stop");
         return;
       }
@@ -407,9 +396,7 @@ async function runBridge(options) {
       ws.close(1008, "unauthorized");
       return;
     }
-    activeSocket = ws;
-    activeSocketReadyForLiveEvents = false;
-    sendControl({
+    sendControl(ws, {
       type: "bridge-hello",
       state: currentTurnState,
       lastSeq: seqCounter
@@ -420,7 +407,7 @@ async function runBridge(options) {
         const text = typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8");
         parsed = JSON.parse(text);
       } catch (err) {
-        sendControl({
+        sendControl(ws, {
           type: "error",
           error: `protocol parse error: ${err.message}`
         });
@@ -431,7 +418,6 @@ async function runBridge(options) {
     ws.on("close", () => {
       if (activeSocket === ws) {
         activeSocket = void 0;
-        activeSocketReadyForLiveEvents = false;
       }
     });
     ws.on("error", () => {
@@ -458,6 +444,14 @@ async function runBridge(options) {
     })
   };
 }
+function sendControl(socket, message) {
+  if (socket?.readyState === WS_OPEN) {
+    try {
+      socket.send(JSON.stringify(message));
+    } catch {
+    }
+  }
+}
 function serialiseError(err) {
   if (err instanceof Error) {
     return { name: err.name, message: err.message, stack: err.stack };
@@ -569,11 +563,149 @@ import { tool } from "@langchain/core/tools";
 
 // ../../node_modules/.pnpm/langchain@1.5.3_@langchain+core@1.2.3_@opentelemetry+api@1.9.1_@opentelemetry+exporter-_a0dbd4fc7a66247dcd0e899a4ff3ea34/node_modules/langchain/dist/agents/errors.js
 import { isGraphBubbleUp } from "@langchain/langgraph";
+var StructuredOutputParsingError = class extends Error {
+  toolName;
+  errors;
+  constructor(toolName, errors) {
+    super(`Failed to parse structured output for tool '${toolName}':${errors.map((e) => `
+  - ${e}`).join("")}.`);
+    this.toolName = toolName;
+    this.errors = errors;
+  }
+};
+
+// ../../node_modules/.pnpm/langchain@1.5.3_@langchain+core@1.2.3_@opentelemetry+api@1.9.1_@opentelemetry+exporter-_a0dbd4fc7a66247dcd0e899a4ff3ea34/node_modules/langchain/dist/agents/model.js
+function isBaseChatModel(model) {
+  return "invoke" in model && typeof model.invoke === "function" && "_streamResponseChunks" in model;
+}
 
 // ../../node_modules/.pnpm/langchain@1.5.3_@langchain+core@1.2.3_@opentelemetry+api@1.9.1_@opentelemetry+exporter-_a0dbd4fc7a66247dcd0e899a4ff3ea34/node_modules/langchain/dist/agents/responses.js
 import { isInteropZodObject, isInteropZodSchema } from "@langchain/core/utils/types";
 import { Validator, toJsonSchema } from "@langchain/core/utils/json_schema";
 import { isSerializableSchema } from "@langchain/core/utils/standard_schema";
+var PROVIDER_STRATEGY_DEFAULT_STRICT = true;
+var bindingIdentifier = 0;
+var ToolStrategy = class ToolStrategy2 {
+  constructor(schema, tool4, options) {
+    this.schema = schema;
+    this.tool = tool4;
+    this.options = options;
+  }
+  get name() {
+    return this.tool.function.name;
+  }
+  static fromSchema(schema, outputOptions) {
+    function getFunctionName(name) {
+      return name ?? `extract-${++bindingIdentifier}`;
+    }
+    if (isSerializableSchema(schema) || isInteropZodSchema(schema)) {
+      const asJsonSchema = toJsonSchema(schema);
+      return new ToolStrategy2(asJsonSchema, {
+        type: "function",
+        function: {
+          name: getFunctionName(asJsonSchema.title),
+          strict: false,
+          description: asJsonSchema.description ?? "Tool for extracting structured output from the model's response.",
+          parameters: asJsonSchema
+        }
+      }, outputOptions);
+    }
+    let functionDefinition;
+    if (typeof schema.name === "string" && typeof schema.parameters === "object" && schema.parameters != null) functionDefinition = schema;
+    else functionDefinition = {
+      name: getFunctionName(schema.title),
+      description: schema.description ?? "",
+      parameters: schema.schema || schema
+    };
+    return new ToolStrategy2(toJsonSchema(schema), {
+      type: "function",
+      function: functionDefinition
+    }, outputOptions);
+  }
+  /**
+  * Parse tool arguments according to the schema.
+  *
+  * @throws {StructuredOutputParsingError} if the response is not valid
+  * @param toolArgs - The arguments from the tool call
+  * @returns The parsed response according to the schema type
+  */
+  parse(toolArgs) {
+    const result = new Validator(this.schema).validate(toolArgs);
+    if (!result.valid) throw new StructuredOutputParsingError(this.name, result.errors.map((e) => e.error));
+    return toolArgs;
+  }
+};
+var ProviderStrategy = class ProviderStrategy2 {
+  _schemaType;
+  /**
+  * The schema to use for the provider strategy
+  */
+  schema;
+  /**
+  * Whether to use strict mode for the provider strategy
+  */
+  strict;
+  constructor(schemaOrOptions, strict) {
+    if ("schema" in schemaOrOptions && typeof schemaOrOptions.schema === "object" && schemaOrOptions.schema !== null && !("type" in schemaOrOptions)) {
+      const options = schemaOrOptions;
+      this.schema = options.schema;
+      this.strict = options.strict ?? PROVIDER_STRATEGY_DEFAULT_STRICT;
+    } else {
+      this.schema = schemaOrOptions;
+      this.strict = strict ?? PROVIDER_STRATEGY_DEFAULT_STRICT;
+    }
+  }
+  static fromSchema(schema, strict) {
+    return new ProviderStrategy2(toJsonSchema(schema), strict);
+  }
+  /**
+  * Parse tool arguments according to the schema. If the response is not valid, return undefined.
+  *
+  * @param response - The AI message response to parse
+  * @returns The parsed response according to the schema type
+  */
+  parse(response) {
+    let textContent;
+    if (typeof response.content === "string") textContent = response.content;
+    else if (Array.isArray(response.content)) {
+      for (const block of response.content) if (typeof block === "object" && block !== null && "type" in block && block.type === "text" && "text" in block && typeof block.text === "string") {
+        textContent = block.text;
+        break;
+      }
+    }
+    if (!textContent || textContent === "") return;
+    try {
+      const content = JSON.parse(textContent);
+      if (!new Validator(this.schema).validate(content).valid) return;
+      return content;
+    } catch {
+    }
+  }
+};
+function transformResponseFormat(responseFormat, options, model) {
+  if (!responseFormat) return [];
+  if (typeof responseFormat === "object" && responseFormat !== null && "__responseFormatUndefined" in responseFormat) return [];
+  if (Array.isArray(responseFormat)) {
+    if (responseFormat.every((item) => item instanceof ToolStrategy || item instanceof ProviderStrategy)) return responseFormat;
+    if (responseFormat.every((item) => isSerializableSchema(item))) return responseFormat.map((item) => ToolStrategy.fromSchema(item, options));
+    if (responseFormat.every((item) => isInteropZodObject(item))) return responseFormat.map((item) => ToolStrategy.fromSchema(item, options));
+    if (responseFormat.every((item) => typeof item === "object" && item !== null && !isInteropZodObject(item) && !isSerializableSchema(item))) return responseFormat.map((item) => ToolStrategy.fromSchema(item, options));
+    throw new Error("Invalid response format: list contains mixed types.\nAll items must be either InteropZodObject, Standard Schema, or plain JSON schema objects.");
+  }
+  if (responseFormat instanceof ToolStrategy || responseFormat instanceof ProviderStrategy) return [responseFormat];
+  const useProviderStrategy = hasSupportForJsonSchemaOutput(model);
+  if (isSerializableSchema(responseFormat)) return useProviderStrategy ? [ProviderStrategy.fromSchema(responseFormat)] : [ToolStrategy.fromSchema(responseFormat, options)];
+  if (isInteropZodObject(responseFormat)) return useProviderStrategy ? [ProviderStrategy.fromSchema(responseFormat)] : [ToolStrategy.fromSchema(responseFormat, options)];
+  if (typeof responseFormat === "object" && responseFormat !== null && "properties" in responseFormat) return useProviderStrategy ? [ProviderStrategy.fromSchema(responseFormat)] : [ToolStrategy.fromSchema(responseFormat, options)];
+  throw new Error(`Invalid response format: ${String(responseFormat)}`);
+}
+function toolStrategy(responseFormat, options) {
+  return transformResponseFormat(responseFormat, options);
+}
+function hasSupportForJsonSchemaOutput(model) {
+  if (!model || !isBaseChatModel(model) || !("profile" in model) || typeof model.profile !== "object" || !model.profile) return false;
+  return "structuredOutput" in model.profile && model.profile.structuredOutput === true;
+}
 
 // ../../node_modules/.pnpm/langchain@1.5.3_@langchain+core@1.2.3_@opentelemetry+api@1.9.1_@opentelemetry+exporter-_a0dbd4fc7a66247dcd0e899a4ff3ea34/node_modules/langchain/dist/agents/middleware/utils.js
 import { AIMessage, ToolMessage } from "@langchain/core/messages";
@@ -1321,6 +1453,7 @@ function createEmitStreamEvent({
   configuredModel,
   hostToolNames,
   mcpToolNames: mcpToolNames2,
+  structuredOutputToolNames = /* @__PURE__ */ new Set(),
   emit
 }) {
   return (event) => {
@@ -1391,6 +1524,7 @@ function createEmitStreamEvent({
       }
     } else if (kind === "on_tool_start") {
       const toolName = event.name ?? "unknown";
+      if (structuredOutputToolNames.has(toolName)) return;
       const runId = event.run_id ?? "";
       if (!nested && !hostToolNames.has(toolName)) {
         const isMcpTool = mcpToolNames2.has(toolName);
@@ -1415,6 +1549,7 @@ 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);
@@ -1732,6 +1867,16 @@ var agent;
 var currentTurn;
 var mcpClient;
 var mcpToolNames = /* @__PURE__ */ new Set();
+var currentResponseFormat;
+var responseFormatMiddleware = createMiddleware({
+  name: "HarnessResponseFormat",
+  wrapModelCall(request, handler) {
+    return handler({
+      ...request,
+      ...currentResponseFormat == null ? {} : { responseFormat: currentResponseFormat }
+    });
+  }
+});
 function buildHostTools(toolSchemas) {
   return (toolSchemas ?? []).map(
     (schema) => tool3(
@@ -1759,6 +1904,7 @@ function buildHostTools(toolSchemas) {
 }
 async function runTurn(start, turn) {
   currentTurn = turn;
+  currentResponseFormat = start.responseFormat?.type === "json" && start.responseFormat.schema != null ? toolStrategy(start.responseFormat.schema) : void 0;
   const emit = (event) => turn.emit(event);
   const interruptOn = buildInterruptOn(
     start.permissionMode,
@@ -1785,6 +1931,7 @@ async function runTurn(start, turn) {
       }
     );
     const middleware = [
+      responseFormatMiddleware,
       ...reasoningMiddleware ? [reasoningMiddleware] : [],
       ...builtinToolFilteringMiddleware ? [builtinToolFilteringMiddleware] : []
     ];
@@ -1819,6 +1966,9 @@ async function runTurn(start, turn) {
     configuredModel: start.model,
     hostToolNames,
     mcpToolNames,
+    structuredOutputToolNames: new Set(
+      currentResponseFormat?.map((format) => format.name) ?? []
+    ),
     emit
   });
   const config = {
@@ -1842,10 +1992,25 @@ async function runTurn(start, turn) {
   let resumeInput = {
     messages: [{ role: "user", content: start.prompt }]
   };
+  let emittedStructuredOutput = false;
   while (true) {
     const stream = await agent.streamEvents(resumeInput, config);
     for await (const event of stream) {
       emitStreamEvent(event);
+      const streamEvent = event;
+      const namespace = streamEvent.metadata?.langgraph_checkpoint_ns ?? "";
+      const output = streamEvent.data?.output;
+      if (!emittedStructuredOutput && streamEvent.event === "on_chain_end" && !namespace.includes("|") && output?.structuredResponse !== void 0) {
+        const id = `structured-output-${randomUUID2()}`;
+        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();
     if (actionRequests.length === 0) break;