@purista/harness-bedrock 1.2.6 → 1.5.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { Buffer } from 'node:buffer';
-import { BaseModelProvider, ModelError } from '@purista/harness';
+import { BaseModelProvider, parseProviderJson, safePartialJson, toTokenUsage, withoutObjectTool } from '@purista/harness';
 import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand } from '@aws-sdk/client-bedrock-runtime';
 /**
  * Creates an Amazon Bedrock-backed harness `ModelProvider`.
@@ -30,22 +30,26 @@ class BedrockModelProvider extends BaseModelProvider {
     }
     async doText(req) {
         req.signal.throwIfAborted();
-        const response = await this.client.send(new ConverseCommand(toConverseInput(req, false)), { abortSignal: req.signal });
+        const { input, requestOptions } = toConverseRequest(req, false);
+        const response = await this.client.send(new ConverseCommand(input), { ...requestOptions, abortSignal: req.signal });
         const toolCalls = extractToolCalls(response, req, 'text');
         return {
             content: outputText(response),
             ...(toolCalls ? { toolCalls } : {}),
-            usage: toUsage(response.usage?.inputTokens, response.usage?.outputTokens),
+            usage: toTokenUsage(response.usage?.inputTokens, response.usage?.outputTokens),
             finishReason: toFinishReason(response.stopReason),
+            outcome: toOutcome(response.stopReason),
             raw: response
         };
     }
     async *doTextStream(req) {
         req.signal.throwIfAborted();
-        const response = await this.client.send(new ConverseStreamCommand(toConverseInput(req, false)), { abortSignal: req.signal });
+        const { input, requestOptions } = toConverseRequest(req, false);
+        const response = await this.client.send(new ConverseStreamCommand(input), { ...requestOptions, abortSignal: req.signal });
         const toolState = new Map();
         let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
         let finishReason = 'stop';
+        let providerFinishReason;
         for await (const event of response.stream ?? []) {
             req.signal.throwIfAborted();
             if (event.contentBlockDelta?.delta?.text) {
@@ -71,70 +75,114 @@ class BedrockModelProvider extends BaseModelProvider {
                 }
             }
             if (event.metadata?.usage) {
-                usage = toUsage(event.metadata.usage.inputTokens, event.metadata.usage.outputTokens);
+                usage = toTokenUsage(event.metadata.usage.inputTokens, event.metadata.usage.outputTokens);
             }
             if (event.messageStop?.stopReason) {
-                finishReason = toFinishReason(event.messageStop.stopReason);
+                providerFinishReason = event.messageStop.stopReason;
+                finishReason = toFinishReason(providerFinishReason);
             }
         }
-        yield { kind: 'finish', usage, finishReason };
+        yield { kind: 'finish', usage, finishReason, outcome: streamOutcome(finishReason, providerFinishReason) };
     }
     async doObject(req) {
         req.signal.throwIfAborted();
-        const response = await this.client.send(new ConverseCommand(toConverseInput(req, true)), { abortSignal: req.signal });
+        const { input, requestOptions } = toConverseRequest(req, true);
+        const response = await this.client.send(new ConverseCommand(input), { ...requestOptions, abortSignal: req.signal });
         const toolUse = response.output?.message?.content?.find((block) => block.toolUse?.name === 'harness_response')?.toolUse;
         const toolCalls = withoutObjectTool(extractToolCalls(response, req, 'object'));
         const object = (toolUse?.input ?? parseJson(outputText(response) || '{}', req, 'object'));
         return {
             object,
             ...(toolCalls ? { toolCalls } : {}),
-            usage: toUsage(response.usage?.inputTokens, response.usage?.outputTokens),
+            usage: toTokenUsage(response.usage?.inputTokens, response.usage?.outputTokens),
             finishReason: toFinishReason(response.stopReason),
+            outcome: toOutcome(response.stopReason),
             raw: response
         };
     }
     async *doObjectStream(req) {
         req.signal.throwIfAborted();
-        const response = await this.client.send(new ConverseStreamCommand(toConverseInput(req, true)), { abortSignal: req.signal });
+        const { input, requestOptions } = toConverseRequest(req, true);
+        const response = await this.client.send(new ConverseStreamCommand(input), { ...requestOptions, abortSignal: req.signal });
         let text = '';
         let objectInput = '';
+        let objectBlockIndex;
+        const toolState = new Map();
         let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
         let finishReason = 'stop';
+        let providerFinishReason;
         for await (const event of response.stream ?? []) {
             req.signal.throwIfAborted();
             if (event.contentBlockDelta?.delta?.text) {
                 text += event.contentBlockDelta.delta.text;
                 yield { kind: 'partial', partial: safePartialJson(text) };
             }
+            if (event.contentBlockStart?.start?.toolUse) {
+                // Only the synthetic `harness_response` block carries the structured
+                // object; other tool blocks are real tool calls and must not bleed
+                // into the object JSON (parity with the OpenAI/Azure adapters).
+                const blockIndex = event.contentBlockStart.contentBlockIndex ?? 0;
+                if (event.contentBlockStart.start.toolUse.name === 'harness_response' && objectBlockIndex === undefined) {
+                    objectBlockIndex = blockIndex;
+                }
+                else {
+                    toolState.set(blockIndex, {
+                        id: String(event.contentBlockStart.start.toolUse.toolUseId),
+                        name: String(event.contentBlockStart.start.toolUse.name),
+                        input: ''
+                    });
+                }
+            }
             if (event.contentBlockDelta?.delta?.toolUse?.input) {
-                objectInput += event.contentBlockDelta.delta.toolUse.input;
-                yield { kind: 'partial', partial: safePartialJson(objectInput) };
+                const blockIndex = event.contentBlockDelta.contentBlockIndex ?? 0;
+                const state = toolState.get(blockIndex);
+                if (state) {
+                    state.input += event.contentBlockDelta.delta.toolUse.input;
+                }
+                else {
+                    objectInput += event.contentBlockDelta.delta.toolUse.input;
+                    yield { kind: 'partial', partial: safePartialJson(objectInput) };
+                }
+            }
+            if (event.contentBlockStop) {
+                const state = toolState.get(event.contentBlockStop.contentBlockIndex ?? 0);
+                if (state) {
+                    yield { kind: 'tool_call', call: { id: state.id, name: state.name, arguments: parseJson(state.input || '{}', req, 'objectStream') } };
+                    toolState.delete(event.contentBlockStop.contentBlockIndex ?? 0);
+                }
             }
             if (event.metadata?.usage) {
-                usage = toUsage(event.metadata.usage.inputTokens, event.metadata.usage.outputTokens);
+                usage = toTokenUsage(event.metadata.usage.inputTokens, event.metadata.usage.outputTokens);
             }
             if (event.messageStop?.stopReason) {
-                finishReason = toFinishReason(event.messageStop.stopReason);
+                providerFinishReason = event.messageStop.stopReason;
+                finishReason = toFinishReason(providerFinishReason);
             }
         }
         const object = parseJson(objectInput || text || '{}', req, 'objectStream');
-        yield { kind: 'finish', object, usage, finishReason };
+        yield { kind: 'finish', object, usage, finishReason, outcome: streamOutcome(finishReason, providerFinishReason) };
     }
 }
 function toClientOptions(options) {
     const { client: _client, harnessLogger: _harnessLogger, telemetry: _telemetry, harnessTimeoutMs: _harnessTimeoutMs, ...clientOptions } = options;
-    return clientOptions;
+    return { maxAttempts: 1, ...clientOptions };
 }
-function toConverseInput(req, forceObject) {
+/**
+ * Builds the Converse request body and extracts `requestOptions`, which are
+ * per-request SDK transport options (mirroring the other adapters) and must
+ * not leak into the Converse request body.
+ */
+function toConverseRequest(req, forceObject) {
     const providerOptions = {
         ...(req.defaults?.providerOptions ?? {}),
         ...(req.call?.providerOptions ?? {})
     };
+    const { requestOptions, ...bodyOptions } = providerOptions;
     const { system, messages } = toBedrockMessages(req.messages);
     const modelTools = toTools(req.tools) ?? [];
     const tools = forceObject ? [...modelTools, toObjectTool(req)] : modelTools;
     const forceObjectTool = forceObject && modelTools.length === 0;
-    return {
+    const input = {
         modelId: req.model,
         messages,
         ...(system.length > 0 ? { system } : {}),
@@ -145,8 +193,9 @@ function toConverseInput(req, forceObject) {
             ...((req.call?.topP ?? req.defaults?.topP) !== undefined ? { topP: req.call?.topP ?? req.defaults?.topP } : {}),
             ...((req.call?.stopSequences ?? req.defaults?.stopSequences) !== undefined ? { stopSequences: req.call?.stopSequences ?? req.defaults?.stopSequences } : {})
         },
-        ...providerOptions
+        ...bodyOptions
     };
+    return { input, ...(requestOptions ? { requestOptions } : {}) };
 }
 function toBedrockMessages(messages) {
     const system = messages.filter((message) => message.role === 'system').map((message) => ({ text: message.content }));
@@ -215,39 +264,12 @@ function extractToolCalls(response, req, method) {
         arguments: typeof call.input === 'string' ? parseJson(call.input, req, method) : call.input ?? {}
     }));
 }
-function withoutObjectTool(calls) {
-    const filtered = calls?.filter((call) => call.name !== 'harness_response');
-    return filtered && filtered.length > 0 ? filtered : undefined;
+const MALFORMED_JSON_MESSAGE = 'Amazon Bedrock returned malformed structured JSON.';
+function callContext(req, method) {
+    return { provider: 'bedrock', model: req.model, method };
 }
 function parseJson(content, req, method) {
-    try {
-        return JSON.parse(content);
-    }
-    catch (error) {
-        throw malformedResponseError(req, method, 'Amazon Bedrock returned malformed structured JSON.', content, error);
-    }
-}
-function malformedResponseError(req, method, message, body, cause) {
-    return new ModelError(message, {
-        provider: 'bedrock',
-        model: req.model,
-        method,
-        reason: 'malformed_response',
-        providerBody: body
-    }, cause);
-}
-function safePartialJson(content) {
-    try {
-        return JSON.parse(content);
-    }
-    catch {
-        return { _partial: content };
-    }
-}
-function toUsage(inputTokens, outputTokens) {
-    const input = inputTokens ?? 0;
-    const output = outputTokens ?? 0;
-    return { inputTokens: input, outputTokens: output, totalTokens: input + output };
+    return parseProviderJson(content, callContext(req, method), MALFORMED_JSON_MESSAGE);
 }
 function toFinishReason(value) {
     switch (value) {
@@ -261,7 +283,29 @@ function toFinishReason(value) {
         case 'content_filtered':
         case 'guardrail_intervened':
             return 'content_filter';
+        case 'malformed_model_output':
+        case 'malformed_tool_use':
+            return 'malformed';
+        case 'model_context_window_exceeded':
+            return 'context_limit';
         default:
             return 'error';
     }
 }
+function toOutcome(value) {
+    const finishReason = toFinishReason(value);
+    return {
+        finishReason,
+        ...(typeof value === 'string' ? { providerFinishReason: value } : {})
+    };
+}
+/**
+ * Stream outcome built from the tracked finish reason; `providerFinishReason`
+ * is omitted entirely when the provider never sent a stop reason.
+ */
+function streamOutcome(finishReason, providerFinishReason) {
+    return {
+        finishReason,
+        ...(typeof providerFinishReason === 'string' ? { providerFinishReason } : {})
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purista/harness-bedrock",
-  "version": "1.2.6",
+  "version": "1.5.0",
   "description": "Amazon Bedrock model provider adapter for @purista/harness.",
   "type": "module",
   "main": "./dist/index.js",
@@ -48,7 +48,7 @@
     "vitest": "^4.1.8"
   },
   "peerDependencies": {
-    "@purista/harness": "*"
+    "@purista/harness": "^1.5.0"
   },
   "engines": {
     "node": ">=24.15.0"