81 lines
2.9 KiB
JavaScript
81 lines
2.9 KiB
JavaScript
import Anthropic from '@anthropic-ai/sdk';
|
|
import { resolveSecret } from './secret.js';
|
|
|
|
export const DEFAULT_MODEL = process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-6';
|
|
|
|
/**
|
|
* Build an Anthropic client, resolving the API key via the secret resolver.
|
|
* Key reference can be overridden with ANTHROPIC_API_KEY_REF env var.
|
|
*/
|
|
export function getAnthropicClient() {
|
|
const key = resolveSecret(process.env.ANTHROPIC_API_KEY_REF || 'env:ANTHROPIC_API_KEY');
|
|
if (!key) {
|
|
throw new Error(
|
|
'Anthropic API key not configured (set ANTHROPIC_API_KEY or ANTHROPIC_API_KEY_REF)'
|
|
);
|
|
}
|
|
return new Anthropic({ apiKey: key });
|
|
}
|
|
|
|
/**
|
|
* Factory that returns a callModel function bound to a specific client + model.
|
|
*
|
|
* @param {object} opts
|
|
* @param {object} opts.client - Anthropic client (or fake for tests)
|
|
* @param {string} [opts.model] - Model ID (default: DEFAULT_MODEL)
|
|
* @param {number} [opts.maxTokens] - max_tokens (default: 1024)
|
|
* @returns {Function} callModel({ system, messages, tools, onTextDelta })
|
|
*
|
|
* callModel returns a stable shape:
|
|
* { text: string, toolUses: [{id, name, input}], stopReason: string, usage: object }
|
|
*
|
|
* Text deltas are streamed via onTextDelta(chunk) as they arrive.
|
|
* Tool-use blocks are collected from the final assembled message.
|
|
*/
|
|
export function makeCallModel({ client, model = DEFAULT_MODEL, maxTokens = 1024 }) {
|
|
return async function callModel({ system, messages, tools, onTextDelta }) {
|
|
// client.messages.stream returns a MessageStream: AsyncIterable<MessageStreamEvent>
|
|
// with a finalMessage() method that resolves to the assembled Message.
|
|
const stream = client.messages.stream({
|
|
model,
|
|
max_tokens: maxTokens,
|
|
...(system !== undefined && { system }),
|
|
messages,
|
|
...(tools !== undefined && tools !== null && { tools }),
|
|
});
|
|
|
|
// Iterate events; fire onTextDelta for text_delta events only.
|
|
// RawContentBlockDeltaEvent: { type: 'content_block_delta', index, delta }
|
|
// TextDelta: { type: 'text_delta', text }
|
|
for await (const event of stream) {
|
|
if (
|
|
event.type === 'content_block_delta' &&
|
|
event.delta?.type === 'text_delta'
|
|
) {
|
|
onTextDelta?.(event.delta.text);
|
|
}
|
|
}
|
|
|
|
// finalMessage() resolves to the fully assembled Message object.
|
|
const final = await stream.finalMessage();
|
|
|
|
// Collect text from all text blocks (typically just one, but join defensively).
|
|
const text = final.content
|
|
.filter((b) => b.type === 'text')
|
|
.map((b) => b.text)
|
|
.join('');
|
|
|
|
// Collect tool_use blocks, normalising to a stable {id, name, input} shape.
|
|
const toolUses = final.content
|
|
.filter((b) => b.type === 'tool_use')
|
|
.map((b) => ({ id: b.id, name: b.name, input: b.input }));
|
|
|
|
return {
|
|
text,
|
|
toolUses,
|
|
stopReason: final.stop_reason,
|
|
usage: final.usage,
|
|
};
|
|
};
|
|
}
|