@purista/harness-anthropic 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,25 @@
+# @purista/harness-anthropic
+
+Anthropic model provider adapter for `@purista/harness`.
+
+## Install
+
+```bash
+npm install @purista/harness @purista/harness-anthropic
+```
+
+Configure the provider with an Anthropic API key in your application
+environment. The adapter is designed for use through the typed
+`@purista/harness` model provider port.
+
+```ts
+import { anthropic } from '@purista/harness-anthropic'
+
+anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
+```
+
+## 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,30 @@
+import type { BaseModelProviderOptions, ModelProvider } from '@purista/harness';
+import { type ClientOptions } from '@anthropic-ai/sdk';
+export interface AnthropicFactoryOptions extends ClientOptions {
+    /** Optional injected client for tests or custom transport behavior. */
+    client?: AnthropicClient;
+    /** 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 Anthropic-backed harness `ModelProvider`.
+ *
+ * @example
+ * ```ts
+ * import { anthropic } from '@purista/harness-anthropic'
+ *
+ * const provider = anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
+ * ```
+ */
+export declare function anthropic(options?: AnthropicFactoryOptions): ModelProvider;
+export type AnthropicClient = {
+    messages: {
+        create(payload: unknown, options?: {
+            signal?: AbortSignal;
+        }): Promise<any>;
+    };
+};

package/dist/index.js

@@ -0,0 +1,263 @@
+import { BaseModelProvider, ModelError } from '@purista/harness';
+import Anthropic, {} from '@anthropic-ai/sdk';
+/**
+ * Creates an Anthropic-backed harness `ModelProvider`.
+ *
+ * @example
+ * ```ts
+ * import { anthropic } from '@purista/harness-anthropic'
+ *
+ * const provider = anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
+ * ```
+ */
+export function anthropic(options = {}) {
+    return new AnthropicModelProvider(options);
+}
+class AnthropicModelProvider extends BaseModelProvider {
+    options;
+    client;
+    constructor(options) {
+        super({
+            id: 'anthropic',
+            genAiSystem: 'anthropic',
+            ...(options.harnessLogger ? { logger: options.harnessLogger } : {}),
+            ...(options.telemetry ? { telemetry: options.telemetry } : {}),
+            ...(options.harnessTimeoutMs !== undefined ? { timeoutMs: options.harnessTimeoutMs } : options.timeout !== undefined ? { timeoutMs: options.timeout } : {})
+        });
+        this.options = options;
+        this.client = options.client ?? new Anthropic(toClientOptions(options));
+    }
+    async doText(req) {
+        req.signal.throwIfAborted();
+        const response = await createMessage(this.client, req, false);
+        const toolCalls = extractToolCalls(response, req, 'text');
+        return {
+            content: response.content?.filter((block) => block.type === 'text').map((block) => block.text).join('') ?? '',
+            ...(toolCalls ? { toolCalls } : {}),
+            usage: toUsage(response.usage?.input_tokens, response.usage?.output_tokens),
+            finishReason: toFinishReason(response.stop_reason),
+            raw: response
+        };
+    }
+    async *doTextStream(req) {
+        req.signal.throwIfAborted();
+        const stream = await createMessage(this.client, req, true);
+        const toolState = new Map();
+        let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+        let finishReason = 'stop';
+        for await (const event of stream) {
+            req.signal.throwIfAborted();
+            if (event.type === 'message_start') {
+                usage = toUsage(event.message?.usage?.input_tokens, event.message?.usage?.output_tokens);
+            }
+            else if (event.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                toolState.set(event.index, {
+                    id: String(event.content_block.id),
+                    name: String(event.content_block.name),
+                    input: JSON.stringify(event.content_block.input ?? {})
+                });
+            }
+            else if (event.type === 'content_block_delta') {
+                if (event.delta?.type === 'text_delta') {
+                    yield { kind: 'delta', text: event.delta.text };
+                }
+                else if (event.delta?.type === 'input_json_delta') {
+                    const state = toolState.get(event.index);
+                    if (state)
+                        state.input += event.delta.partial_json;
+                }
+            }
+            else if (event.type === 'content_block_stop') {
+                const state = toolState.get(event.index);
+                if (state) {
+                    yield { kind: 'tool_call', call: { id: state.id, name: state.name, arguments: parseJson(state.input, req, 'textStream') } };
+                    toolState.delete(event.index);
+                }
+            }
+            else if (event.type === 'message_delta') {
+                finishReason = toFinishReason(event.delta?.stop_reason);
+                usage = toUsage(usage.inputTokens, event.usage?.output_tokens ?? usage.outputTokens);
+            }
+        }
+        yield { kind: 'finish', usage, finishReason };
+    }
+    async doObject(req) {
+        req.signal.throwIfAborted();
+        const response = await createMessage(this.client, req, false, true);
+        const toolUse = response.content?.find((block) => block.type === 'tool_use' && block.name === 'harness_response');
+        const object = (toolUse?.input ?? parseJson(response.content?.filter((block) => block.type === 'text').map((block) => block.text).join('') || '{}', req, 'object'));
+        return {
+            object,
+            usage: toUsage(response.usage?.input_tokens, response.usage?.output_tokens),
+            finishReason: toFinishReason(response.stop_reason),
+            raw: response
+        };
+    }
+    async *doObjectStream(req) {
+        req.signal.throwIfAborted();
+        const stream = await createMessage(this.client, req, true, true);
+        let text = '';
+        let objectInput = '';
+        let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+        let finishReason = 'stop';
+        for await (const event of stream) {
+            req.signal.throwIfAborted();
+            if (event.type === 'message_start') {
+                usage = toUsage(event.message?.usage?.input_tokens, event.message?.usage?.output_tokens);
+            }
+            else if (event.type === 'content_block_start' && event.content_block?.type === 'tool_use' && event.content_block.name === 'harness_response') {
+                objectInput = JSON.stringify(event.content_block.input ?? {});
+            }
+            else if (event.type === 'content_block_delta') {
+                if (event.delta?.type === 'text_delta') {
+                    text += event.delta.text;
+                    yield { kind: 'partial', partial: safePartialJson(text) };
+                }
+                else if (event.delta?.type === 'input_json_delta') {
+                    objectInput += event.delta.partial_json;
+                    yield { kind: 'partial', partial: safePartialJson(objectInput) };
+                }
+            }
+            else if (event.type === 'message_delta') {
+                finishReason = toFinishReason(event.delta?.stop_reason);
+                usage = toUsage(usage.inputTokens, event.usage?.output_tokens ?? usage.outputTokens);
+            }
+        }
+        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;
+}
+async function createMessage(client, req, stream, forceObject = false) {
+    const providerOptions = {
+        ...(req.defaults?.providerOptions ?? {}),
+        ...(req.call?.providerOptions ?? {})
+    };
+    const { requestOptions, ...bodyOptions } = providerOptions;
+    const { system, messages } = toAnthropicMessages(req.messages);
+    const tools = forceObject ? [toObjectTool(req)] : toTools(req.tools);
+    return client.messages.create({
+        model: req.model,
+        messages,
+        stream,
+        max_tokens: req.call?.maxTokens ?? req.defaults?.maxTokens ?? 1024,
+        ...(system ? { system } : {}),
+        ...(tools ? { tools } : {}),
+        ...(forceObject ? { tool_choice: { type: 'tool', name: 'harness_response' } } : {}),
+        ...(req.call?.temperature ?? req.defaults?.temperature !== undefined ? { temperature: req.call?.temperature ?? req.defaults?.temperature } : {}),
+        ...(req.call?.topP ?? req.defaults?.topP !== undefined ? { top_p: req.call?.topP ?? req.defaults?.topP } : {}),
+        ...(req.call?.stopSequences ?? req.defaults?.stopSequences ? { stop_sequences: req.call?.stopSequences ?? req.defaults?.stopSequences } : {}),
+        ...bodyOptions
+    }, { ...requestOptions, signal: req.signal });
+}
+function toAnthropicMessages(messages) {
+    const system = messages.filter((message) => message.role === 'system').map((message) => message.content).join('\n\n');
+    const converted = messages.filter((message) => message.role !== 'system').map((message) => {
+        if (message.role === 'tool') {
+            return {
+                role: 'user',
+                content: [{ type: 'tool_result', tool_use_id: message.toolCallId, content: message.content }]
+            };
+        }
+        if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
+            return {
+                role: 'assistant',
+                content: [
+                    ...(typeof message.content === 'string' && message.content ? [{ type: 'text', text: message.content }] : []),
+                    ...message.toolCalls.map((call) => ({ type: 'tool_use', id: call.id, name: call.name, input: call.arguments }))
+                ]
+            };
+        }
+        return {
+            role: message.role,
+            content: typeof message.content === 'string' ? message.content : message.content.map(toContentBlock)
+        };
+    });
+    return {
+        ...(system ? { system } : {}),
+        messages: converted
+    };
+}
+function toContentBlock(part) {
+    if (part.kind === 'text')
+        return { type: 'text', text: part.text };
+    if (part.kind === 'image') {
+        return { type: 'image', source: { type: 'base64', media_type: part.mimeType, data: part.dataBase64 } };
+    }
+    if (part.kind === 'image_url') {
+        return { type: 'image', source: { type: 'url', url: part.url } };
+    }
+    return { type: 'text', text: `[unsupported ${part.kind} content omitted]` };
+}
+function toTools(tools) {
+    if (!tools || tools.length === 0)
+        return undefined;
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters
+    }));
+}
+function toObjectTool(req) {
+    return {
+        name: 'harness_response',
+        description: 'Return the structured response object.',
+        input_schema: req.schema
+    };
+}
+function extractToolCalls(response, req, method) {
+    const calls = response.content?.filter((block) => block.type === 'tool_use' && block.name && block.id);
+    if (!calls || calls.length === 0)
+        return undefined;
+    return calls.map((call) => ({
+        id: String(call.id),
+        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, 'Anthropic returned malformed structured JSON.', content, error);
+    }
+}
+function malformedResponseError(req, method, message, body, cause) {
+    return new ModelError(message, {
+        provider: 'anthropic',
+        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';
+        default:
+            return 'error';
+    }
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@purista/harness-anthropic",
+  "version": "1.0.0",
+  "description": "Anthropic 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-anthropic"
+  },
+  "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-anthropic'"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.95.1"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.1.5",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "peerDependencies": {
+    "@purista/harness": "*"
+  },
+  "engines": {
+    "node": ">=24.15.0"
+  }
+}