@purista/harness-bedrock 1.0.0

package/LICENSE

@@ -0,0 +1,4 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+

package/README.md

@@ -0,0 +1,24 @@
+# @purista/harness-bedrock
+
+Amazon Bedrock model provider adapter for `@purista/harness`.
+
+## Install
+
+```bash
+npm install @purista/harness @purista/harness-bedrock
+```
+
+Configure AWS credentials with the standard AWS SDK credential chain and pass
+the target region in application code.
+
+```ts
+import { bedrock } from '@purista/harness-bedrock'
+
+bedrock({ region: process.env.AWS_REGION ?? 'us-east-1' })
+```
+
+## Package Format
+
+This package is ESM-only and ships compiled JavaScript plus TypeScript
+declarations from `dist/`. Source files, tests, source maps, and local configs
+are not included in the published package.

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import type { BaseModelProviderOptions, ModelProvider } from '@purista/harness';
+import { type BedrockRuntimeClientConfig } from '@aws-sdk/client-bedrock-runtime';
+export interface BedrockFactoryOptions extends BedrockRuntimeClientConfig {
+    /** Optional injected client for tests or custom transport behavior. */
+    client?: BedrockClient;
+    /** Optional adapter-level logger override. Defaults to the harness logger when registered. */
+    harnessLogger?: BaseModelProviderOptions['logger'];
+    /** Optional adapter-level telemetry override. Defaults to the harness telemetry shim when registered. */
+    telemetry?: BaseModelProviderOptions['telemetry'];
+    /** Optional adapter-level timeout override. Defaults to the harness model timeout when registered. */
+    harnessTimeoutMs?: number;
+}
+/**
+ * Creates an Amazon Bedrock-backed harness `ModelProvider`.
+ *
+ * @example
+ * ```ts
+ * import { bedrock } from '@purista/harness-bedrock'
+ *
+ * const provider = bedrock({ region: 'us-east-1' })
+ * ```
+ */
+export declare function bedrock(options?: BedrockFactoryOptions): ModelProvider;
+export type BedrockClient = {
+    send(command: unknown, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<any>;
+};

package/dist/index.js

@@ -0,0 +1,259 @@
+import { Buffer } from 'node:buffer';
+import { BaseModelProvider, ModelError } from '@purista/harness';
+import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand } from '@aws-sdk/client-bedrock-runtime';
+/**
+ * Creates an Amazon Bedrock-backed harness `ModelProvider`.
+ *
+ * @example
+ * ```ts
+ * import { bedrock } from '@purista/harness-bedrock'
+ *
+ * const provider = bedrock({ region: 'us-east-1' })
+ * ```
+ */
+export function bedrock(options = {}) {
+    return new BedrockModelProvider(options);
+}
+class BedrockModelProvider extends BaseModelProvider {
+    options;
+    client;
+    constructor(options) {
+        super({
+            id: 'bedrock',
+            genAiSystem: 'aws.bedrock',
+            ...(options.harnessLogger ? { logger: options.harnessLogger } : {}),
+            ...(options.telemetry ? { telemetry: options.telemetry } : {}),
+            ...(options.harnessTimeoutMs !== undefined ? { timeoutMs: options.harnessTimeoutMs } : {})
+        });
+        this.options = options;
+        this.client = options.client ?? new BedrockRuntimeClient(toClientOptions(options));
+    }
+    async doText(req) {
+        req.signal.throwIfAborted();
+        const response = await this.client.send(new ConverseCommand(toConverseInput(req, false)), { abortSignal: req.signal });
+        const toolCalls = extractToolCalls(response, req, 'text');
+        return {
+            content: outputText(response),
+            ...(toolCalls ? { toolCalls } : {}),
+            usage: toUsage(response.usage?.inputTokens, response.usage?.outputTokens),
+            finishReason: toFinishReason(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 toolState = new Map();
+        let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+        let finishReason = 'stop';
+        for await (const event of response.stream ?? []) {
+            req.signal.throwIfAborted();
+            if (event.contentBlockDelta?.delta?.text) {
+                yield { kind: 'delta', text: event.contentBlockDelta.delta.text };
+            }
+            if (event.contentBlockStart?.start?.toolUse) {
+                toolState.set(event.contentBlockStart.contentBlockIndex ?? 0, {
+                    id: String(event.contentBlockStart.start.toolUse.toolUseId),
+                    name: String(event.contentBlockStart.start.toolUse.name),
+                    input: ''
+                });
+            }
+            if (event.contentBlockDelta?.delta?.toolUse?.input) {
+                const state = toolState.get(event.contentBlockDelta.contentBlockIndex ?? 0);
+                if (state)
+                    state.input += event.contentBlockDelta.delta.toolUse.input;
+            }
+            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, 'textStream') } };
+                    toolState.delete(event.contentBlockStop.contentBlockIndex ?? 0);
+                }
+            }
+            if (event.metadata?.usage) {
+                usage = toUsage(event.metadata.usage.inputTokens, event.metadata.usage.outputTokens);
+            }
+            if (event.messageStop?.stopReason) {
+                finishReason = toFinishReason(event.messageStop.stopReason);
+            }
+        }
+        yield { kind: 'finish', usage, finishReason };
+    }
+    async doObject(req) {
+        req.signal.throwIfAborted();
+        const response = await this.client.send(new ConverseCommand(toConverseInput(req, true)), { abortSignal: req.signal });
+        const toolUse = response.output?.message?.content?.find((block) => block.toolUse?.name === 'harness_response')?.toolUse;
+        const object = (toolUse?.input ?? parseJson(outputText(response) || '{}', req, 'object'));
+        return {
+            object,
+            usage: toUsage(response.usage?.inputTokens, response.usage?.outputTokens),
+            finishReason: toFinishReason(response.stopReason),
+            raw: response
+        };
+    }
+    async *doObjectStream(req) {
+        req.signal.throwIfAborted();
+        const response = await this.client.send(new ConverseStreamCommand(toConverseInput(req, true)), { abortSignal: req.signal });
+        let text = '';
+        let objectInput = '';
+        let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+        let finishReason = 'stop';
+        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.contentBlockDelta?.delta?.toolUse?.input) {
+                objectInput += event.contentBlockDelta.delta.toolUse.input;
+                yield { kind: 'partial', partial: safePartialJson(objectInput) };
+            }
+            if (event.metadata?.usage) {
+                usage = toUsage(event.metadata.usage.inputTokens, event.metadata.usage.outputTokens);
+            }
+            if (event.messageStop?.stopReason) {
+                finishReason = toFinishReason(event.messageStop.stopReason);
+            }
+        }
+        const object = parseJson(objectInput || text || '{}', req, 'objectStream');
+        yield { kind: 'finish', object, usage, finishReason };
+    }
+}
+function toClientOptions(options) {
+    const { client: _client, harnessLogger: _harnessLogger, telemetry: _telemetry, harnessTimeoutMs: _harnessTimeoutMs, ...clientOptions } = options;
+    return clientOptions;
+}
+function toConverseInput(req, forceObject) {
+    const providerOptions = {
+        ...(req.defaults?.providerOptions ?? {}),
+        ...(req.call?.providerOptions ?? {})
+    };
+    const { system, messages } = toBedrockMessages(req.messages);
+    const tools = forceObject ? [toObjectTool(req)] : toTools(req.tools);
+    return {
+        modelId: req.model,
+        messages,
+        ...(system.length > 0 ? { system } : {}),
+        ...(tools ? { toolConfig: { tools, ...(forceObject ? { toolChoice: { tool: { name: 'harness_response' } } } : {}) } } : {}),
+        inferenceConfig: {
+            ...(req.call?.maxTokens ?? req.defaults?.maxTokens !== undefined ? { maxTokens: req.call?.maxTokens ?? req.defaults?.maxTokens } : {}),
+            ...(req.call?.temperature ?? req.defaults?.temperature !== undefined ? { temperature: req.call?.temperature ?? req.defaults?.temperature } : {}),
+            ...(req.call?.topP ?? req.defaults?.topP !== undefined ? { topP: req.call?.topP ?? req.defaults?.topP } : {}),
+            ...(req.call?.stopSequences ?? req.defaults?.stopSequences ? { stopSequences: req.call?.stopSequences ?? req.defaults?.stopSequences } : {})
+        },
+        ...providerOptions
+    };
+}
+function toBedrockMessages(messages) {
+    const system = messages.filter((message) => message.role === 'system').map((message) => ({ text: message.content }));
+    const converted = messages.filter((message) => message.role !== 'system').map((message) => {
+        if (message.role === 'tool') {
+            return {
+                role: 'user',
+                content: [{ toolResult: { toolUseId: message.toolCallId, content: [{ text: message.content }] } }]
+            };
+        }
+        if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
+            return {
+                role: 'assistant',
+                content: [
+                    ...(typeof message.content === 'string' && message.content ? [{ text: message.content }] : []),
+                    ...message.toolCalls.map((call) => ({ toolUse: { toolUseId: call.id, name: call.name, input: call.arguments } }))
+                ]
+            };
+        }
+        return {
+            role: message.role,
+            content: typeof message.content === 'string' ? [{ text: message.content }] : message.content.map(toContentBlock)
+        };
+    });
+    return { system, messages: converted };
+}
+function toContentBlock(part) {
+    if (part.kind === 'text')
+        return { text: part.text };
+    if (part.kind === 'image') {
+        const format = part.mimeType.split('/')[1] ?? 'png';
+        return { image: { format, source: { bytes: Buffer.from(part.dataBase64, 'base64') } } };
+    }
+    return { text: `[unsupported ${part.kind} content omitted]` };
+}
+function toTools(tools) {
+    if (!tools || tools.length === 0)
+        return undefined;
+    return tools.map((tool) => ({
+        toolSpec: {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: { json: tool.parameters }
+        }
+    }));
+}
+function toObjectTool(req) {
+    return {
+        toolSpec: {
+            name: 'harness_response',
+            description: 'Return the structured response object.',
+            inputSchema: { json: req.schema }
+        }
+    };
+}
+function outputText(response) {
+    return response.output?.message?.content?.filter((block) => typeof block.text === 'string').map((block) => block.text).join('') ?? '';
+}
+function extractToolCalls(response, req, method) {
+    const calls = response.output?.message?.content?.map((block) => block.toolUse).filter(Boolean);
+    if (!calls || calls.length === 0)
+        return undefined;
+    return calls.map((call) => ({
+        id: String(call.toolUseId),
+        name: String(call.name),
+        arguments: typeof call.input === 'string' ? parseJson(call.input, req, method) : call.input ?? {}
+    }));
+}
+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 };
+}
+function toFinishReason(value) {
+    switch (value) {
+        case 'end_turn':
+        case 'stop_sequence':
+            return 'stop';
+        case 'max_tokens':
+            return 'length';
+        case 'tool_use':
+            return 'tool_calls';
+        case 'content_filtered':
+        case 'guardrail_intervened':
+            return 'content_filter';
+        default:
+            return 'error';
+    }
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@purista/harness-bedrock",
+  "version": "1.0.0",
+  "description": "Amazon Bedrock model provider adapter for @purista/harness.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/puristajs/harness",
+    "directory": "packages/harness-bedrock"
+  },
+  "bugs": {
+    "url": "https://github.com/puristajs/harness/issues"
+  },
+  "homepage": "https://github.com/puristajs/harness#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "test": "vitest run",
+    "lint": "echo 'no lint configured for @purista/harness-bedrock'"
+  },
+  "dependencies": {
+    "@aws-sdk/client-bedrock-runtime": "^3.1045.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.1.5",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "peerDependencies": {
+    "@purista/harness": "*"
+  },
+  "engines": {
+    "node": ">=24.15.0"
+  }
+}