dsh-plugin-subscriptions 0.1.0

package/lib/tools/x-search.js

@@ -0,0 +1,195 @@
+/**
+ * `x_search` tool: run xAI's hosted X (Twitter) search through the grok
+ * subscription's OAuth session. The wire call is a non-streaming Responses
+ * request carrying the built-in `x_search` tool definition; the canonical
+ * output is `{ answer, citations }`.
+ */
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { httpLlmError, TokenManager } from '../providers/common.js';
+/** Endpoint the search request is posted to. */
+export const X_SEARCH_URL = 'https://api.x.ai/v1/responses';
+/** Grok model the search runs on (a catalog model of the grok provider). */
+export const X_SEARCH_MODEL = 'grok-4';
+/** xAI caps each handle filter list at ten entries. */
+const MAX_HANDLES = 10;
+/**
+ * Validate and assemble the request facts from tool arguments. Throws plain
+ * Errors for argument problems the schema DSL cannot express (non-empty
+ * query, handle caps, mutually exclusive filters).
+ */
+export function buildXSearchRequest(args) {
+    const query = args.query.trim();
+    if (query.length === 0)
+        throw new Error('x_search: query must be a non-empty string');
+    const allowed = normalizeHandles(args.allowed_x_handles, 'allowed_x_handles');
+    const excluded = normalizeHandles(args.excluded_x_handles, 'excluded_x_handles');
+    if (allowed.length > 0 && excluded.length > 0) {
+        throw new Error('x_search: allowed_x_handles and excluded_x_handles cannot be used together');
+    }
+    const tool = { type: 'x_search' };
+    if (allowed.length > 0)
+        tool.allowed_x_handles = allowed;
+    if (excluded.length > 0)
+        tool.excluded_x_handles = excluded;
+    if (args.from_date !== undefined && args.from_date.trim().length > 0)
+        tool.from_date = args.from_date.trim();
+    if (args.to_date !== undefined && args.to_date.trim().length > 0)
+        tool.to_date = args.to_date.trim();
+    if (args.enable_image_understanding === true)
+        tool.enable_image_understanding = true;
+    if (args.enable_video_understanding === true)
+        tool.enable_video_understanding = true;
+    return { query, tool };
+}
+/** Strip `@` prefixes, drop blanks, and enforce the provider's handle cap. */
+function normalizeHandles(value, field) {
+    if (value === undefined)
+        return [];
+    const handles = value.map(handle => handle.trim().replace(/^@+/, '')).filter(handle => handle.length > 0);
+    if (handles.length > MAX_HANDLES)
+        throw new Error(`x_search: ${field} supports at most ${MAX_HANDLES} handles`);
+    return handles;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Extract the answer text and citation URLs from a Responses payload: the
+ * `output_text` shortcut or message output parts for the answer, and both
+ * top-level `citations` and inline `url_citation` annotations for sources.
+ */
+export function parseXSearchResponse(payload) {
+    const body = isRecord(payload) ? payload : {};
+    let answer = typeof body.output_text === 'string' ? body.output_text.trim() : '';
+    const citations = [];
+    const push = (url) => {
+        if (typeof url === 'string' && url.length > 0 && !citations.includes(url))
+            citations.push(url);
+    };
+    if (Array.isArray(body.citations)) {
+        for (const citation of body.citations)
+            push(citation);
+    }
+    const parts = [];
+    if (Array.isArray(body.output)) {
+        for (const item of body.output) {
+            if (!isRecord(item) || item.type !== 'message' || !Array.isArray(item.content))
+                continue;
+            for (const part of item.content) {
+                if (!isRecord(part))
+                    continue;
+                if ((part.type === 'output_text' || part.type === 'text')
+                    && typeof part.text === 'string' && part.text.trim().length > 0) {
+                    parts.push(part.text.trim());
+                }
+                if (Array.isArray(part.annotations)) {
+                    for (const annotation of part.annotations) {
+                        if (isRecord(annotation) && annotation.type === 'url_citation')
+                            push(annotation.url);
+                    }
+                }
+            }
+        }
+    }
+    if (answer.length === 0)
+        answer = parts.join('\n\n');
+    return { answer, citations };
+}
+/** Bound a call-card title's query. */
+function truncate(text, max = 60) {
+    return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+/**
+ * Build the `x_search` tool definition.
+ * @param options - grok session source and fetch implementation.
+ * @returns the tool to register on `ctx.tools`.
+ */
+export function createXSearchTool(options) {
+    return defineTool({
+        name: 'x_search',
+        description: "Search X (Twitter) posts, profiles, and threads using the grok subscription's hosted xAI x_search. "
+            + 'Use this for current discussion, reactions, or claims on X rather than general web pages.',
+        parameters: {
+            query: { type: 'string', required: true, description: 'What to look up on X.' },
+            allowed_x_handles: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'X handles to include exclusively (max 10).',
+            },
+            excluded_x_handles: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'X handles to exclude (max 10).',
+            },
+            from_date: { type: 'string', description: 'Optional start date in YYYY-MM-DD format.' },
+            to_date: { type: 'string', description: 'Optional end date in YYYY-MM-DD format.' },
+            enable_image_understanding: {
+                type: 'boolean',
+                description: 'Whether xAI should analyze images attached to matching posts.',
+            },
+            enable_video_understanding: {
+                type: 'boolean',
+                description: 'Whether xAI should analyze videos attached to matching posts.',
+            },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                properties: {
+                    answer: { type: 'string', required: true },
+                    citations: { type: 'array', items: { type: 'string' }, required: true },
+                },
+                additionalProperties: false,
+            },
+            render: (_args, value) => [{
+                    type: 'text',
+                    text: value.citations.length > 0
+                        ? `${value.answer}\n\nSources:\n${value.citations.map(citation => `- ${citation}`).join('\n')}`
+                        : value.answer,
+                }],
+            presentationMeta: (_args, value) => ({ answer: value.answer, citations: value.citations }),
+        },
+        presentCall: args => ({
+            card: 'generic',
+            title: `x_search: ${truncate(args.query)}`,
+            kind: 'search',
+        }),
+        presentResult: (_args, result) => {
+            if (result.isError || !isRecord(result.meta))
+                return undefined;
+            const citations = Array.isArray(result.meta.citations) ? result.meta.citations : [];
+            return {
+                card: 'web',
+                kind: 'search',
+                sources: citations.filter((citation) => typeof citation === 'string')
+                    .map(url => ({ url })),
+                ...typeof result.meta.answer === 'string' && result.meta.answer.length > 0
+                    ? { answer: result.meta.answer }
+                    : {},
+                truncated: false,
+            };
+        },
+        async execute(args, exec) {
+            const request = buildXSearchRequest(args);
+            const session = await options.tokens.session();
+            const response = await (options.fetchFn ?? fetch)(X_SEARCH_URL, {
+                method: 'POST',
+                headers: {
+                    'authorization': `Bearer ${session.accessToken}`,
+                    'content-type': 'application/json',
+                    'accept': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: X_SEARCH_MODEL,
+                    input: [{ role: 'user', content: request.query }],
+                    tools: [request.tool],
+                    store: false,
+                }),
+                signal: exec.signal,
+            });
+            if (!response.ok)
+                throw await httpLlmError(response, 'x_search');
+            return parseXSearchResponse(await response.json());
+        },
+    });
+}

package/lib/translate/anthropic.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Translate between the harness message vocabulary and the Anthropic Messages
+ * API wire format used by the claude provider: request message assembly, tool
+ * schema mapping, and a push-model SSE-event → StreamChunk state machine
+ * ({@link AnthropicStreamTranslator}) so tests need no streams.
+ */
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import type { StreamChunk, ToolSchema } from '@deepseek-ai/dsh-llm';
+import type { TranslatableMessage } from './resolved.js';
+/**
+ * The Claude Code identity block. The subscription endpoint rejects requests
+ * that do not present as Claude Code, so this block is REQUIRED as the first
+ * system entry on every request.
+ */
+export declare const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
+/** One Anthropic request message. */
+export interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: Record<string, unknown>[];
+}
+/**
+ * Convert harness messages into Anthropic messages. Consecutive same-role
+ * messages merge into one message with multiple content blocks; tool results
+ * arrive as user messages with `tool_result` blocks; system-role messages are
+ * handled by {@link toAnthropicSystem} and skipped here. Reasoning blocks are
+ * not replayed (v1). Images must arrive pre-resolved
+ * ({@link TranslatableMessage}); an unresolved ImageBlock is skipped because
+ * its bytes are unreachable here.
+ * @param messages - ordered conversation messages with resolved images.
+ * @returns Anthropic messages in conversation order.
+ */
+export declare function toAnthropicMessages(messages: readonly TranslatableMessage[]): AnthropicMessage[];
+/**
+ * Build the Anthropic `system` array: the mandatory Claude Code identity
+ * block, then the explicit system prompt, then any system-role messages.
+ * @param system - explicit system prompt, when set.
+ * @param messages - conversation messages; their system-role text is appended.
+ * @returns the system content blocks.
+ */
+export declare function toAnthropicSystem(system?: string, messages?: readonly TranslatableMessage[]): Record<string, unknown>[];
+/**
+ * Map harness tool schemas to Anthropic tools.
+ * @param tools - tool schemas from the request.
+ * @returns Anthropic `tools` array entries.
+ */
+export declare function toAnthropicTools(tools: readonly ToolSchema[]): Record<string, unknown>[];
+/** The subset of Anthropic SSE event shapes this translator reads. */
+export interface AnthropicStreamEvent {
+    type: string;
+    index?: number;
+    message?: {
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_read_input_tokens?: number;
+            cache_creation_input_tokens?: number;
+        };
+    };
+    content_block?: {
+        type?: string;
+        id?: string;
+        name?: string;
+    };
+    delta?: {
+        type?: string;
+        text?: string;
+        thinking?: string;
+        partial_json?: string;
+        stop_reason?: string;
+    };
+    usage?: {
+        output_tokens?: number;
+    };
+    error?: {
+        type?: string;
+        message?: string;
+    };
+}
+/**
+ * Classify an Anthropic `error` event into a thrown LlmError.
+ * @param error - the wire error object.
+ * @returns the mapped error.
+ */
+export declare function anthropicFailure(error: {
+    type?: string;
+    message?: string;
+} | undefined): LlmError;
+/**
+ * Push-model Anthropic SSE translator: feed each parsed event object to
+ * {@link push} and collect the emitted harness StreamChunks. Block indexes
+ * are allocated in first-seen order; `usage` is emitted before the terminal
+ * `finish`, and nothing is emitted after it. `error` events throw
+ * {@link LlmError}.
+ */
+export declare class AnthropicStreamTranslator {
+    private blocks;
+    private nextIndex;
+    private sawAnyBlock;
+    private pendingUsage;
+    private outputTokens;
+    private stopReason;
+    private usageEmitted;
+    /** Set once `message_stop` produced the terminal finish chunk. */
+    terminated: boolean;
+    private open;
+    private emitUsage;
+    /**
+     * Process one parsed Anthropic SSE event.
+     * @param event - the parsed event object.
+     * @returns the StreamChunks this event produced (possibly none).
+     */
+    push(event: AnthropicStreamEvent): StreamChunk[];
+}
+/**
+ * Consume an Anthropic SSE byte stream and yield harness StreamChunks.
+ * @param stream - raw response body.
+ * @param onActivity - transport-activity callback for the idle watchdog.
+ * @returns the chunk stream; throws when the stream ends before `message_stop`.
+ */
+export declare function streamAnthropic(stream: ReadableStream<Uint8Array>, onActivity?: () => void): AsyncGenerator<StreamChunk>;

package/lib/translate/anthropic.js

@@ -0,0 +1,370 @@
+/**
+ * Translate between the harness message vocabulary and the Anthropic Messages
+ * API wire format used by the claude provider: request message assembly, tool
+ * schema mapping, and a push-model SSE-event → StreamChunk state machine
+ * ({@link AnthropicStreamTranslator}) so tests need no streams.
+ */
+import { CallId, CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, LlmError, } from '@deepseek-ai/dsh-llm';
+import { parseSse } from './sse.js';
+/**
+ * The Claude Code identity block. The subscription endpoint rejects requests
+ * that do not present as Claude Code, so this block is REQUIRED as the first
+ * system entry on every request.
+ */
+export const CLAUDE_CODE_IDENTITY = 'You are Claude Code, Anthropic\'s official CLI for Claude.';
+/** Flatten a tool result's content to plain text for `tool_result`. */
+function toolResultText(block) {
+    return block.content.map(part => (part.type === 'text' ? part.text : '')).join('');
+}
+/** Parse a tool call's raw JSON arguments into Anthropic's object-shaped `input`. */
+function parseToolInput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return {};
+    }
+    catch {
+        // The model produced malformed JSON; an empty object keeps the request valid.
+        return {};
+    }
+}
+/**
+ * Convert harness messages into Anthropic messages. Consecutive same-role
+ * messages merge into one message with multiple content blocks; tool results
+ * arrive as user messages with `tool_result` blocks; system-role messages are
+ * handled by {@link toAnthropicSystem} and skipped here. Reasoning blocks are
+ * not replayed (v1). Images must arrive pre-resolved
+ * ({@link TranslatableMessage}); an unresolved ImageBlock is skipped because
+ * its bytes are unreachable here.
+ * @param messages - ordered conversation messages with resolved images.
+ * @returns Anthropic messages in conversation order.
+ */
+export function toAnthropicMessages(messages) {
+    const out = [];
+    for (const message of messages) {
+        if (message.role === 'system')
+            continue;
+        const role = message.role;
+        const blocks = [];
+        for (const block of message.content) {
+            switch (block.type) {
+                case 'text':
+                    blocks.push({ type: 'text', text: block.text });
+                    break;
+                case 'tool-call':
+                    blocks.push({
+                        type: 'tool_use',
+                        id: String(block.id),
+                        name: block.name,
+                        input: parseToolInput(block.arguments),
+                    });
+                    break;
+                case 'tool-result':
+                    blocks.push({
+                        type: 'tool_result',
+                        tool_use_id: String(block.toolCallId),
+                        content: toolResultText(block),
+                        ...block.isError === true ? { is_error: true } : {},
+                    });
+                    break;
+                case 'image':
+                    if ('dataBase64' in block) {
+                        blocks.push({
+                            type: 'image',
+                            source: { type: 'base64', media_type: block.mediaType, data: block.dataBase64 },
+                        });
+                    }
+                    // An unresolved ImageBlock carries only an attachment reference; the
+                    // adapter resolves images before translation, so this is skipped.
+                    break;
+                default:
+                    // reasoning (not replayed), unknown blocks.
+                    break;
+            }
+        }
+        if (blocks.length === 0)
+            continue;
+        const last = out[out.length - 1];
+        if (last !== undefined && last.role === role)
+            last.content.push(...blocks);
+        else
+            out.push({ role, content: blocks });
+    }
+    return out;
+}
+/**
+ * Build the Anthropic `system` array: the mandatory Claude Code identity
+ * block, then the explicit system prompt, then any system-role messages.
+ * @param system - explicit system prompt, when set.
+ * @param messages - conversation messages; their system-role text is appended.
+ * @returns the system content blocks.
+ */
+export function toAnthropicSystem(system, messages) {
+    const blocks = [{ type: 'text', text: CLAUDE_CODE_IDENTITY }];
+    if (system !== undefined && system.length > 0)
+        blocks.push({ type: 'text', text: system });
+    for (const message of messages ?? []) {
+        if (message.role !== 'system')
+            continue;
+        for (const block of message.content) {
+            if (block.type === 'text')
+                blocks.push({ type: 'text', text: block.text });
+        }
+    }
+    return blocks;
+}
+/**
+ * Map harness tool schemas to Anthropic tools.
+ * @param tools - tool schemas from the request.
+ * @returns Anthropic `tools` array entries.
+ */
+export function toAnthropicTools(tools) {
+    return tools.map(tool => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters,
+    }));
+}
+/** Assemble the final ContentBlock for one open block. */
+function closeBlock(block) {
+    switch (block.kind) {
+        case 'text':
+            return { type: 'text', text: block.text };
+        case 'reasoning':
+            return { type: 'reasoning', text: block.text };
+        case 'tool-call':
+            return {
+                type: 'tool-call',
+                id: CallId(block.callId),
+                name: block.name ?? '',
+                arguments: block.text,
+            };
+    }
+}
+/**
+ * Classify an Anthropic `error` event into a thrown LlmError.
+ * @param error - the wire error object.
+ * @returns the mapped error.
+ */
+export function anthropicFailure(error) {
+    const type = error?.type ?? 'unknown_error';
+    const message = error?.message ?? `Anthropic reported ${type}`;
+    if (type === 'invalid_request_error' && /prompt is too long/i.test(message)) {
+        return new LlmError(message, CONTEXT_WINDOW_EXCEEDED_CODE);
+    }
+    if (type === 'rate_limit_error')
+        return new LlmError(message, 'RATE_LIMIT');
+    if (type === 'authentication_error')
+        return new LlmError(message, 'AUTH');
+    return new LlmError(message, 'SERVER');
+}
+/**
+ * Push-model Anthropic SSE translator: feed each parsed event object to
+ * {@link push} and collect the emitted harness StreamChunks. Block indexes
+ * are allocated in first-seen order; `usage` is emitted before the terminal
+ * `finish`, and nothing is emitted after it. `error` events throw
+ * {@link LlmError}.
+ */
+export class AnthropicStreamTranslator {
+    blocks = new Map();
+    nextIndex = 0;
+    sawAnyBlock = false;
+    pendingUsage;
+    outputTokens;
+    stopReason = 'stop';
+    usageEmitted = false;
+    /** Set once `message_stop` produced the terminal finish chunk. */
+    terminated = false;
+    open(wireIndex, kind, chunks, callId = '', name) {
+        const block = {
+            index: this.nextIndex++,
+            kind,
+            text: '',
+            callId,
+            ...name === undefined ? {} : { name },
+        };
+        this.blocks.set(wireIndex, block);
+        this.sawAnyBlock = true;
+        chunks.push({ type: 'block-start', index: block.index, blockType: kind });
+        return block;
+    }
+    emitUsage(chunks) {
+        if (this.usageEmitted)
+            return;
+        this.usageEmitted = true;
+        const usage = {
+            inputTokens: this.pendingUsage?.inputTokens ?? 0,
+            outputTokens: this.outputTokens ?? 0,
+            ...this.pendingUsage?.cacheReadTokens !== undefined
+                ? { cacheReadTokens: this.pendingUsage.cacheReadTokens }
+                : {},
+            ...this.pendingUsage?.cacheWriteTokens !== undefined
+                ? { cacheWriteTokens: this.pendingUsage.cacheWriteTokens }
+                : {},
+        };
+        chunks.push({ type: 'usage', usage });
+    }
+    /**
+     * Process one parsed Anthropic SSE event.
+     * @param event - the parsed event object.
+     * @returns the StreamChunks this event produced (possibly none).
+     */
+    push(event) {
+        if (this.terminated)
+            return [];
+        const chunks = [];
+        switch (event.type) {
+            case 'message_start': {
+                const usage = event.message?.usage;
+                if (usage !== undefined) {
+                    this.pendingUsage = {
+                        inputTokens: usage.input_tokens ?? 0,
+                        ...usage.cache_read_input_tokens !== undefined
+                            ? { cacheReadTokens: usage.cache_read_input_tokens }
+                            : {},
+                        ...usage.cache_creation_input_tokens !== undefined
+                            ? { cacheWriteTokens: usage.cache_creation_input_tokens }
+                            : {},
+                    };
+                    this.outputTokens = usage.output_tokens ?? this.outputTokens;
+                }
+                return chunks;
+            }
+            case 'content_block_start': {
+                const wireIndex = event.index ?? 0;
+                const block = event.content_block;
+                switch (block?.type) {
+                    case 'text':
+                        this.open(wireIndex, 'text', chunks);
+                        break;
+                    case 'thinking':
+                        this.open(wireIndex, 'reasoning', chunks);
+                        break;
+                    case 'tool_use': {
+                        const opened = this.open(wireIndex, 'tool-call', chunks, block.id ?? '', block.name);
+                        chunks.push({
+                            type: 'tool-call-delta',
+                            index: opened.index,
+                            id: CallId(opened.callId),
+                            ...block.name === undefined ? {} : { name: block.name },
+                            argumentsDelta: '',
+                        });
+                        break;
+                    }
+                    default:
+                        break;
+                }
+                return chunks;
+            }
+            case 'content_block_delta': {
+                const wireIndex = event.index ?? 0;
+                const block = this.blocks.get(wireIndex);
+                const delta = event.delta;
+                if (block === undefined || delta === undefined)
+                    return chunks;
+                switch (delta.type) {
+                    case 'text_delta':
+                        block.text += delta.text ?? '';
+                        chunks.push({ type: 'text-delta', index: block.index, text: delta.text ?? '' });
+                        break;
+                    case 'thinking_delta':
+                        block.text += delta.thinking ?? '';
+                        chunks.push({ type: 'reasoning-delta', index: block.index, text: delta.thinking ?? '' });
+                        break;
+                    case 'input_json_delta':
+                        block.text += delta.partial_json ?? '';
+                        chunks.push({
+                            type: 'tool-call-delta',
+                            index: block.index,
+                            id: CallId(block.callId),
+                            ...block.name === undefined ? {} : { name: block.name },
+                            argumentsDelta: delta.partial_json ?? '',
+                        });
+                        break;
+                    default:
+                        // signature_delta and future deltas carry no harness content.
+                        break;
+                }
+                return chunks;
+            }
+            case 'content_block_stop': {
+                const wireIndex = event.index ?? 0;
+                const block = this.blocks.get(wireIndex);
+                if (block === undefined)
+                    return chunks;
+                this.blocks.delete(wireIndex);
+                chunks.push({ type: 'block-end', index: block.index, block: closeBlock(block) });
+                return chunks;
+            }
+            case 'message_delta': {
+                if (event.usage?.output_tokens !== undefined)
+                    this.outputTokens = event.usage.output_tokens;
+                switch (event.delta?.stop_reason) {
+                    case 'end_turn':
+                    case 'stop_sequence':
+                        this.stopReason = 'stop';
+                        break;
+                    case 'tool_use':
+                        this.stopReason = 'tool-calls';
+                        break;
+                    case 'max_tokens':
+                        this.stopReason = 'max-tokens';
+                        break;
+                    default:
+                        break;
+                }
+                return chunks;
+            }
+            case 'message_stop': {
+                this.terminated = true;
+                for (const [wireIndex, block] of [...this.blocks]) {
+                    this.blocks.delete(wireIndex);
+                    chunks.push({ type: 'block-end', index: block.index, block: closeBlock(block) });
+                }
+                this.emitUsage(chunks);
+                if (this.stopReason === 'stop' && !this.sawAnyBlock) {
+                    chunks.push({
+                        type: 'finish',
+                        reason: {
+                            kind: 'error',
+                            failure: { message: 'model returned a completed response with no content', code: EMPTY_RESPONSE_CODE },
+                        },
+                    });
+                }
+                else {
+                    chunks.push({ type: 'finish', reason: { kind: this.stopReason } });
+                }
+                return chunks;
+            }
+            case 'error':
+                throw anthropicFailure(event.error);
+            default:
+                // ping and future event types carry no harness content.
+                return chunks;
+        }
+    }
+}
+/**
+ * Consume an Anthropic SSE byte stream and yield harness StreamChunks.
+ * @param stream - raw response body.
+ * @param onActivity - transport-activity callback for the idle watchdog.
+ * @returns the chunk stream; throws when the stream ends before `message_stop`.
+ */
+export async function* streamAnthropic(stream, onActivity) {
+    const translator = new AnthropicStreamTranslator();
+    for await (const sseEvent of parseSse(stream, onActivity)) {
+        let event;
+        try {
+            event = JSON.parse(sseEvent.data);
+        }
+        catch {
+            throw new LlmError(`malformed SSE payload: ${sseEvent.data.slice(0, 120)}`, 'MALFORMED_RESPONSE');
+        }
+        yield* translator.push(event);
+        if (translator.terminated)
+            return;
+    }
+    throw new LlmError('Anthropic SSE stream ended before message_stop', 'STREAM_CLOSED');
+}