@ai-sdk/harness 1.0.149 → 1.0.151

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness",
-  "version": "1.0.149",
+  "version": "1.0.151",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -46,7 +46,7 @@
   "dependencies": {
     "@ai-sdk/provider": "4.0.27",
     "@ai-sdk/provider-utils": "5.0.59",
-    "ai": "7.0.138"
+    "ai": "7.0.140"
   },
   "peerDependencies": {
     "ws": "^8.21.0",
@@ -58,7 +58,7 @@
     }
   },
   "devDependencies": {
-    "@ai-sdk/otel": "1.0.138",
+    "@ai-sdk/otel": "1.0.140",
     "@opentelemetry/sdk-trace-base": "2.7.1",
     "@types/node": "22.19.19",
     "@types/ws": "^8.5.13",

package/src/agent/harness-agent-tool-approval-continuation.ts

@@ -14,6 +14,9 @@ import type {
  * locally to find the original tool call before it can resume the paused turn.
  * Responses that already have a tool result are ignored, because those
  * approvals were already consumed by a prior continuation.
+ * An `execution-denied` result is synthesized by `convertToModelMessages`
+ * for a newly denied approval; it does not mean the harness has received
+ * the decision, so that approval response must still continue the turn.
  */
 export function collectHarnessAgentToolApprovalContinuations(input: {
   messages: readonly ModelMessage[];
@@ -38,7 +41,10 @@ export function collectHarnessAgentToolApprovalContinuations(input: {
 
   const toolResultIds = new Set<string>();
   for (const part of lastMessage.content) {
-    if (part.type === 'tool-result') {
+    if (
+      part.type === 'tool-result' &&
+      part.output.type !== 'execution-denied'
+    ) {
       toolResultIds.add(part.toolCallId);
     }
   }

package/src/agent/internal/harness-stream-text-result.ts

@@ -4,6 +4,7 @@ import {
   type AssistantModelMessage,
   type Context,
   type ToolModelMessage,
+  type ToolResultOutput,
   type ToolSet,
 } from '@ai-sdk/provider-utils';
 import {
@@ -11,6 +12,7 @@ import {
   asLanguageModelUsage,
   createAsyncIterableStream,
   createNullLanguageModelUsage,
+  createToolModelOutput,
   DefaultStepResult,
   toResponseMessages,
 } from 'ai/internal';
@@ -22,6 +24,7 @@ import {
   createUIMessageStreamResponse,
   toUIMessageStream as toUIMessageStreamHelper,
   type CallWarning,
+  type Citation,
   type ContentPart,
   type FinishReason,
   type InferUIMessageChunk,
@@ -53,6 +56,19 @@ type EnrichedStreamPart<TOOLS extends ToolSet, PARTIAL_OUTPUT> = {
   partialOutput: PARTIAL_OUTPUT | undefined;
 };
 
+type AccumulatedTextContent = {
+  type: 'text';
+  text: string;
+  citations?: Citation[];
+  providerMetadata?: ProviderMetadata;
+};
+
+type AccumulatedReasoningContent = {
+  type: 'reasoning';
+  text: string;
+  providerMetadata?: ProviderMetadata;
+};
+
 /**
  * Concrete `StreamTextResult` implementation backed by a single
  * harness prompt turn.
@@ -149,11 +165,17 @@ export class HarnessStreamTextResult<
 
   private readonly stepsBuffer: StepResult<TOOLS, RUNTIME_CONTEXT>[] = [];
   private currentStepContent: ContentPart<TOOLS>[] = [];
+  private currentStepTextContent = new Map<string, AccumulatedTextContent>();
+  private currentStepReasoningContent = new Map<
+    string,
+    AccumulatedReasoningContent
+  >();
   private currentStepWarnings: CallWarning[] = [];
   private stepNumber = 0;
   private stepStarted = false;
 
   private readonly tools: TOOLS;
+  private readonly toolModelOutputs = new Map<string, ToolResultOutput>();
   private readonly runtimeContext: RUNTIME_CONTEXT;
   private readonly toolsContext: InferToolSetContext<TOOLS>;
   private readonly providerName: string;
@@ -169,6 +191,13 @@ export class HarnessStreamTextResult<
   private aggregateWarnings: CallWarning[] = [];
   private settled = false;
 
+  setToolModelOutput(input: {
+    toolCallId: string;
+    output: ToolResultOutput;
+  }): void {
+    this.toolModelOutputs.set(input.toolCallId, input.output);
+  }
+
   constructor(options: {
     tools: TOOLS;
     runtimeContext: RUNTIME_CONTEXT;
@@ -261,6 +290,8 @@ export class HarnessStreamTextResult<
    */
   discardCurrentStepContent(): void {
     this.currentStepContent = [];
+    this.currentStepTextContent.clear();
+    this.currentStepReasoningContent.clear();
     this.currentStepWarnings = [];
     this.stepStarted = false;
   }
@@ -334,6 +365,8 @@ export class HarnessStreamTextResult<
 
     this.stepNumber += 1;
     this.currentStepContent = [];
+    this.currentStepTextContent.clear();
+    this.currentStepReasoningContent.clear();
     this.currentStepWarnings = [];
     this.stepStarted = false;
 
@@ -421,14 +454,12 @@ export class HarnessStreamTextResult<
       >,
     );
     this._text.resolve(finalStep.text);
-    // Reasoning content parts are not yet derived from harness events; the
-    // foundation surfaces an empty array. Adapters that emit reasoning
-    // deltas can be wired up to produce real reasoning content in a later
-    // pass.
     this._reasoning.resolve(
-      [] as StreamProp<TOOLS, RUNTIME_CONTEXT, OUTPUT, 'reasoning'>,
+      finalStep.content.filter(
+        part => part.type === 'reasoning' || part.type === 'reasoning-file',
+      ) as StreamProp<TOOLS, RUNTIME_CONTEXT, OUTPUT, 'reasoning'>,
     );
-    this._reasoningText.resolve(undefined);
+    this._reasoningText.resolve(finalStep.reasoningText);
     this._files.resolve(this.stepsBuffer.flatMap(s => s.files));
     this._sources.resolve(this.stepsBuffer.flatMap(s => s.sources));
     this._toolCalls.resolve(
@@ -491,10 +522,29 @@ export class HarnessStreamTextResult<
     this._response.resolve(finalStep.response);
     this._providerMetadata.resolve(this.finalProviderMetadata);
 
-    const responseMessages = await toResponseMessages<TOOLS>({
-      content: aggregatedContent,
-      tools: this.tools,
-    });
+    const responseTools: ToolSet = {};
+    for (const [name, tool] of Object.entries(this.tools)) {
+      responseTools[name] = {
+        ...tool,
+        toModelOutput: (options: {
+          toolCallId: string;
+          input: unknown;
+          output: unknown;
+        }) =>
+          this.toolModelOutputs.get(options.toolCallId) ??
+          createToolModelOutput({ ...options, tool, errorMode: 'none' }),
+      };
+    }
+    const responseMessages: Array<AssistantModelMessage | ToolModelMessage> =
+      [];
+    for (const step of this.stepsBuffer) {
+      responseMessages.push(
+        ...(await toResponseMessages<TOOLS>({
+          content: step.content,
+          tools: responseTools as TOOLS,
+        })),
+      );
+    }
     this._responseMessages.resolve(responseMessages);
 
     // Forward AI SDK finish event before closing.
@@ -755,6 +805,8 @@ export class HarnessStreamTextResult<
   toUIMessageStream<UI_MESSAGE extends UIMessage>({
     originalMessages,
     generateMessageId,
+    onStepEnd,
+    onStepFinish,
     onEnd,
     onFinish,
     messageMetadata,
@@ -772,6 +824,8 @@ export class HarnessStreamTextResult<
         tools: this.tools,
         originalMessages,
         generateMessageId,
+        onStepEnd,
+        onStepFinish,
         onEnd,
         onFinish,
         messageMetadata,
@@ -795,6 +849,8 @@ export class HarnessStreamTextResult<
   toUIMessageStreamResponse<UI_MESSAGE extends UIMessage>({
     originalMessages,
     generateMessageId,
+    onStepEnd,
+    onStepFinish,
     onEnd,
     onFinish,
     messageMetadata,
@@ -813,6 +869,8 @@ export class HarnessStreamTextResult<
       stream: this.toUIMessageStream<UI_MESSAGE>({
         originalMessages,
         generateMessageId,
+        onStepEnd,
+        onStepFinish,
         onEnd,
         onFinish,
         messageMetadata,
@@ -834,30 +892,88 @@ export class HarnessStreamTextResult<
 
   private appendToCurrentStepContent(part: TextStreamPart<TOOLS>): void {
     switch (part.type) {
+      case 'text-start': {
+        const content: AccumulatedTextContent = {
+          type: 'text',
+          text: '',
+          ...(part.providerMetadata != null
+            ? { providerMetadata: part.providerMetadata }
+            : {}),
+        };
+        this.currentStepTextContent.set(part.id, content);
+        this.currentStepContent.push(content);
+        return;
+      }
       case 'text-delta': {
-        // Coalesce contiguous text-deltas with the same id into one text part.
-        const last =
-          this.currentStepContent[this.currentStepContent.length - 1];
-        if (last && last.type === 'text') {
-          (last as { text: string }).text += part.text;
-        } else {
-          this.currentStepContent.push({
+        let content = this.currentStepTextContent.get(part.id);
+        if (content == null) {
+          content = {
             type: 'text',
-            text: part.text,
-          } as ContentPart<TOOLS>);
+            text: '',
+            ...(part.providerMetadata != null
+              ? { providerMetadata: part.providerMetadata }
+              : {}),
+          };
+          this.currentStepTextContent.set(part.id, content);
+          this.currentStepContent.push(content);
+        }
+        content.text += part.text;
+        if (part.providerMetadata != null) {
+          content.providerMetadata = part.providerMetadata;
+        }
+        return;
+      }
+      case 'text-end': {
+        const content = this.currentStepTextContent.get(part.id);
+        if (content != null) {
+          if (part.providerMetadata != null) {
+            content.providerMetadata = part.providerMetadata;
+          }
+          if (part.citations != null) {
+            content.citations = part.citations;
+          }
+          this.currentStepTextContent.delete(part.id);
         }
         return;
       }
+      case 'reasoning-start': {
+        const content: AccumulatedReasoningContent = {
+          type: 'reasoning',
+          text: '',
+          ...(part.providerMetadata != null
+            ? { providerMetadata: part.providerMetadata }
+            : {}),
+        };
+        this.currentStepReasoningContent.set(part.id, content);
+        this.currentStepContent.push(content);
+        return;
+      }
       case 'reasoning-delta': {
-        const last =
-          this.currentStepContent[this.currentStepContent.length - 1];
-        if (last && last.type === 'reasoning') {
-          (last as { text: string }).text += part.text;
-        } else {
-          this.currentStepContent.push({
+        let content = this.currentStepReasoningContent.get(part.id);
+        if (content == null) {
+          content = {
             type: 'reasoning',
-            text: part.text,
-          } as ContentPart<TOOLS>);
+            text: '',
+            ...(part.providerMetadata != null
+              ? { providerMetadata: part.providerMetadata }
+              : {}),
+          };
+          this.currentStepReasoningContent.set(part.id, content);
+          this.currentStepContent.push(content);
+        }
+        content.text += part.text;
+        if (part.providerMetadata != null) {
+          content.providerMetadata = part.providerMetadata;
+        }
+        return;
+      }
+      case 'reasoning-end': {
+        const content = this.currentStepReasoningContent.get(part.id);
+        if (content != null) {
+          if (part.providerMetadata != null) {
+            content.providerMetadata = part.providerMetadata;
+          }
+          this.currentStepReasoningContent.delete(part.id);
         }
         return;
       }

package/src/agent/internal/run-prompt.ts

@@ -24,6 +24,7 @@ import {
   type Experimental_SandboxSession as SandboxSession,
   type ToolApprovalResponse,
   type ToolResultPart,
+  type ToolResultOutput,
   type ToolSet,
 } from '@ai-sdk/provider-utils';
 import {
@@ -36,6 +37,7 @@ import {
   addLanguageModelUsage,
   asLanguageModelUsage,
   createNullLanguageModelUsage,
+  createToolModelOutput,
   parseToolCall,
   validateToolContext,
 } from 'ai/internal';
@@ -68,6 +70,8 @@ import {
 import { resolveCustomToolApproval } from './permission-mode';
 import { logBridgeError } from '../../utils/bridge-diagnostics';
 import { pinSandboxChannelEventCheckpoint } from '../../utils/sandbox-channel';
+import { normalizeHarnessToolModelOutput } from '../../utils/normalize-harness-tool-model-output';
+import { HarnessCapabilityUnsupportedError } from '../../errors/harness-capability-unsupported-error';
 
 const invalidToolInputMessage = 'Tool input validation failed.';
 
@@ -303,12 +307,15 @@ export function runPrompt<
     >();
     /*
      * Host results are echoed back as `tool-result` events too, so the event
-     * alone cannot say who ran the tool — classify by the originating
-     * `tool-call`. Only an explicit `true` counts: `LanguageModelV4ToolCall`
-     * defines an omitted flag as client-executed. A call missing from the map
-     * arrived in an earlier slice, where nothing here can classify it.
+     * alone cannot provide the parsed input or say who ran the tool — restore
+     * both from the originating `tool-call`. Only an explicit `true` counts:
+     * `LanguageModelV4ToolCall` defines an omitted flag as client-executed. A
+     * call missing from the map arrived in an earlier slice, where nothing
+     * here can classify it.
      */
     const translateOptions = {
+      getToolCall: (toolCallId: string) =>
+        toolCallsByToolCallId.get(toolCallId),
       isProviderExecuted: (toolCallId: string): boolean => {
         const rawToolCall = rawToolCallsByToolCallId.get(toolCallId);
         return rawToolCall == null || rawToolCall.providerExecuted === true;
@@ -421,9 +428,24 @@ export function runPrompt<
       toolExecutions.clear();
       bufferedToolOutcomes = [];
     };
-    let expectedStepToolCallCount: number | undefined;
-    let observedStepToolCallCount = 0;
-    let pauseAfterStepToolCalls = false;
+    type FinishStepPart = Extract<HarnessV1StreamPart, { type: 'finish-step' }>;
+    /*
+     * An approval request or a pending client tool result does not end the
+     * response right away: the rest of the step (other tool calls, native
+     * results, host tool executions) still has to be surfaced. The pause
+     * happens at the next `finish-step`, once every host tool started in
+     * this response has been echoed back by the runtime.
+     */
+    let hostInputPauseRequested = false;
+    let deferredPauseFinishStep: FinishStepPart | undefined;
+    /*
+     * A `finish-step` that arrives while host tools started in this step have
+     * not been echoed back is the adapter signalling that the runtime waits on
+     * host input, not the end of the step. It is remembered so the step can
+     * still be closed if the turn finishes without another `finish-step`.
+     */
+    let ignoredFinishStep: FinishStepPart | undefined;
+    const hostToolCallIdsAwaitingEcho = new Set<string>();
     const buildModelCallContent = (): ContentPart<TOOLS>[] => {
       const parts: ContentPart<TOOLS>[] = [];
       if (stepText) parts.push({ type: 'text', text: stepText });
@@ -441,9 +463,7 @@ export function runPrompt<
       stepApprovalRequests = [];
       bufferedToolOutcomes = [];
       toolExecutions.clear();
-      expectedStepToolCallCount = undefined;
-      observedStepToolCallCount = 0;
-      pauseAfterStepToolCalls = false;
+      ignoredFinishStep = undefined;
     };
     const zeroUsage: LanguageModelV4Usage = {
       inputTokens: {
@@ -484,25 +504,27 @@ export function runPrompt<
       resetStepContent();
       return step;
     };
-    const finishForHostInputPause = async (options: {
-      completeCurrentStep: boolean;
-    }): Promise<void> => {
+    const finishForHostInputPause = async (): Promise<void> => {
       await waitForOutstandingHostToolExecutions();
-      if (options.completeCurrentStep) {
-        await completeStep({
-          finishReason: toolCallsFinishReason,
-          usage: zeroUsage,
-          providerMetadata: undefined,
-        });
-      } else {
-        await publishToolExecutions();
-      }
+      await publishToolExecutions();
       await lifecycle.end({
         steps: completedSteps,
         usage: asLanguageModelUsage(zeroUsage),
       });
       await result.finish();
     };
+    const pauseForHostInput = async (
+      finishStep: FinishStepPart | undefined,
+    ): Promise<void> => {
+      await waitForOutstandingHostToolExecutions();
+      closingResumedStep = false;
+      await completeStep({
+        finishReason: toolCallsFinishReason,
+        usage: finishStep?.usage ?? zeroUsage,
+        providerMetadata: finishStep?.harnessMetadata,
+      });
+      await finishForHostInputPause();
+    };
     const enqueueApprovalRequest = (approval: {
       approvalId: string;
       toolCall: ToolCallTextStreamPart;
@@ -609,7 +631,37 @@ export function runPrompt<
     };
     const submitToolResult: HarnessV1PromptControl['submitToolResult'] =
       async submission => {
+        if (submission.toolResult != null) {
+          let output: ToolResultOutput;
+          try {
+            output = normalizeHarnessToolModelOutput({
+              output: submission.toolResult.output,
+            });
+          } catch (error) {
+            if (
+              !continuationsByToolCallId.has(submission.toolCallId) ||
+              !HarnessCapabilityUnsupportedError.isInstance(error)
+            ) {
+              throw error;
+            }
+            output = {
+              type: 'text',
+              value: JSON.stringify(submission.output) ?? 'null',
+            };
+          }
+          submission = {
+            ...submission,
+            toolResult: { ...submission.toolResult, output },
+          };
+          result.setToolModelOutput({
+            toolCallId: submission.toolCallId,
+            output,
+          });
+        }
         if (!input.isTurnSuspending?.()) {
+          if (!settledHostToolCallIds.has(submission.toolCallId)) {
+            hostToolCallIdsAwaitingEcho.add(submission.toolCallId);
+          }
           return control.submitToolResult(submission);
         }
         const toolCall =
@@ -808,7 +860,7 @@ export function runPrompt<
       });
       if (!execution.executed) {
         recordPendingToolResult({ toolCall: rawToolCall });
-        await finishForHostInputPause({ completeCurrentStep: false });
+        await finishForHostInputPause();
         return 'awaiting-tool-result';
       }
       const toolExecution = toolExecutions.get(rawToolCall.toolCallId)!;
@@ -852,11 +904,10 @@ export function runPrompt<
 
       while (true) {
         if (
-          pauseAfterStepToolCalls &&
-          expectedStepToolCallCount != null &&
-          observedStepToolCallCount >= expectedStepToolCallCount
+          deferredPauseFinishStep != null &&
+          hostToolCallIdsAwaitingEcho.size === 0
         ) {
-          await finishForHostInputPause({ completeCurrentStep: true });
+          await pauseForHostInput(deferredPauseFinishStep);
           return;
         }
 
@@ -874,6 +925,9 @@ export function runPrompt<
           result.enqueueRaw(value.rawValue);
           continue;
         }
+        if (value.type === 'tool-result') {
+          hostToolCallIdsAwaitingEcho.delete(value.toolCallId);
+        }
 
         if (pendingStopBoundary != null) {
           if (value.type === 'finish') {
@@ -964,6 +1018,45 @@ export function runPrompt<
         if (settledHostInputReplay || settledBuiltinApprovalReplay) {
           continue;
         }
+        if (value.type === 'finish-step') {
+          if (hostInputPauseRequested) {
+            await waitForOutstandingHostToolExecutions();
+            if (hostToolCallIdsAwaitingEcho.size === 0) {
+              await pauseForHostInput(value);
+              return;
+            }
+            deferredPauseFinishStep = value;
+            continue;
+          }
+          if (hostToolCallIdsAwaitingEcho.size > 0) {
+            ignoredFinishStep = value;
+            continue;
+          }
+          ignoredFinishStep = undefined;
+        }
+        if (value.type === 'finish') {
+          if (hostInputPauseRequested) {
+            await pauseForHostInput(deferredPauseFinishStep);
+            return;
+          }
+          if (ignoredFinishStep != null) {
+            const finishStep = ignoredFinishStep;
+            ignoredFinishStep = undefined;
+            await waitForOutstandingHostToolExecutions();
+            if (closingResumedStep) {
+              closingResumedStep = false;
+              await publishToolExecutions();
+              resetStepContent();
+              result.discardCurrentStepContent();
+            } else {
+              await completeStep({
+                finishReason: finishStep.finishReason,
+                usage: finishStep.usage,
+                providerMetadata: finishStep.harnessMetadata,
+              });
+            }
+          }
+        }
         if (displayValue.type === 'finish-step' && closingResumedStep) {
           closingResumedStep = false;
           await publishToolExecutions();
@@ -994,6 +1087,12 @@ export function runPrompt<
                 `Harness '${input.harness.harnessId}' emitted a built-in tool approval request but does not support approval responses.`,
               );
             }
+            /*
+             * The runtime may report a step boundary while it waits for this
+             * decision. The decision is answered here, so that boundary must
+             * not end the step before the denied call's result arrives.
+             */
+            hostToolCallIdsAwaitingEcho.add(displayValue.toolCallId);
             await control.submitToolApproval({
               approvalId: displayValue.approvalId,
               approved: false,
@@ -1100,8 +1199,6 @@ export function runPrompt<
         }
 
         if (value.type === 'tool-call') {
-          observedStepToolCallCount += 1;
-          expectedStepToolCallCount ??= value.stepToolCallCount;
           const toolCall = toolCallsByToolCallId.get(value.toolCallId);
           if (toolCall != null) {
             stepToolCalls.push(toolCall as ContentPart<TOOLS>);
@@ -1201,8 +1298,8 @@ export function runPrompt<
             approvalId: pendingApproval.approvalId,
             toolCall,
           });
-          await finishForHostInputPause({ completeCurrentStep: true });
-          return;
+          hostInputPauseRequested = true;
+          continue;
         }
 
         // Drive step boundaries.
@@ -1270,15 +1367,8 @@ export function runPrompt<
           }
           if (isClientExecutedBuiltin) {
             recordPendingToolResult({ toolCall });
-            if (
-              expectedStepToolCallCount != null &&
-              observedStepToolCallCount < expectedStepToolCallCount
-            ) {
-              pauseAfterStepToolCalls = true;
-              continue;
-            }
-            await finishForHostInputPause({ completeCurrentStep: true });
-            return;
+            hostInputPauseRequested = true;
+            continue;
           }
           if (validatedHostToolCall == null) {
             throw new Error(
@@ -1393,28 +1483,15 @@ export function runPrompt<
               approvalId: pendingApproval.approvalId,
               toolCall: pendingParsedToolCall,
             });
-            if (
-              expectedStepToolCallCount != null &&
-              observedStepToolCallCount < expectedStepToolCallCount
-            ) {
-              pauseAfterStepToolCalls = true;
-              continue;
-            }
-            await finishForHostInputPause({ completeCurrentStep: true });
-            return;
+            hostInputPauseRequested = true;
+            continue;
           }
           if (!isExecutableTool(activeTools[toolCall.toolName])) {
             recordPendingToolResult({ toolCall });
-            if (
-              expectedStepToolCallCount != null &&
-              observedStepToolCallCount < expectedStepToolCallCount
-            ) {
-              pauseAfterStepToolCalls = true;
-              continue;
-            }
-            await finishForHostInputPause({ completeCurrentStep: true });
-            return;
+            hostInputPauseRequested = true;
+            continue;
           }
+          hostToolCallIdsAwaitingEcho.add(toolCall.toolCallId);
           startHostToolExecution(
             (async () => {
               const toolExecution = toolExecutions.get(toolCall.toolCallId);
@@ -1481,6 +1558,10 @@ export function runPrompt<
           );
         }
       }
+      if (hostInputPauseRequested && input.isTurnSuspending?.() !== true) {
+        await pauseForHostInput(deferredPauseFinishStep);
+        return;
+      }
       await waitForOutstandingHostToolExecutions();
       const isTurnSuspending = input.isTurnSuspending?.() === true;
       if (isTurnSuspending) {
@@ -1695,6 +1776,22 @@ async function maybeExecuteHostTool<TOOLS extends ToolSet>(input: {
     await input.submitToolResult({
       toolCallId: input.event.toolCallId,
       output,
+      ...(tool.toModelOutput == null
+        ? {}
+        : {
+            toolResult: {
+              type: 'tool-result' as const,
+              toolCallId: input.event.toolCallId,
+              toolName: input.event.toolName,
+              output: await createToolModelOutput({
+                toolCallId: input.event.toolCallId,
+                input: input.parsedToolCall.input,
+                output,
+                tool,
+                errorMode: 'none',
+              }),
+            },
+          }),
     });
     return { executed: true, outcome: { ok: true, output } };
   } catch (err) {