@dan-ai-studio/dshopencodego 0.1.43 → 0.1.45

package/lib/types/conversion/context.js

@@ -1,212 +0,0 @@
-/**
- * Harness request history converted into pi-ai's request vocabulary.
- *
- * Three shapes need care:
- *
- * - The system prompt has one home in pi-ai. `normalizeContext()` folds
- *   `Context.systemPrompt` and `Context.tools` into a leading system message,
- *   so this module only has to decide *which* text that is.
- * - Tool results are their own message role and must carry the tool's *name*,
- *   which the Harness records only on the preceding assistant tool call — so
- *   names are recovered by walking the history.
- * - Images go through the durable attachment service under the route's pixel
- *   and encoded-byte budgets, and follow the host's offload protocol instead of
- *   dropping content locally.
- *
- * The image helpers are reached through a namespace import on purpose: they are
- * newer additions to the LLM seam, and a named import of one that a host build
- * does not export fails at module instantiation — taking the whole plugin down
- * before it can report anything. A namespace read fails only when the feature is
- * actually used.
- *
- * @module @dan-ai-studio/dshopencodego/conversion/context
- */
-import { brandString } from '@deepseek-ai/dsh-brand';
-import * as llm from '@deepseek-ai/dsh-llm';
-import { contentHasImage, LlmError, requestImageHandleText } from '@deepseek-ai/dsh-llm';
-import { requestImageDimensions } from '@deepseek-ai/dsh-attachment';
-import { toPiAssistant } from './replay.js';
-/** Join the text blocks of one Harness message. */
-function flattenText(message) {
-    return message.content.filter(block => block.type === 'text').map(block => block.text).join('');
-}
-/** DSH carries tool results under their own role. */
-function toolMessage(message) {
-    return message.role === 'tool' ? message : undefined;
-}
-/** pi-ai cannot replay an image attached to an assistant or system message. */
-function assertSupportedImageRoles(messages) {
-    for (const message of messages) {
-        if (message.role !== 'user' && toolMessage(message) === undefined && contentHasImage(message.content)) {
-            throw new LlmError(`pi-ai cannot represent an image in an in-history ${message.role} message`, 'UNSUPPORTED_CONTENT');
-        }
-    }
-}
-/**
- * Every tool declaration this request carries.
- *
- * `GenerateOptions.toolHistory` is deliberately not projected: projecting it
- * requires the route to declare a `toolUpdate` mode, and no source states one
- * for this gateway's models (models.dev describes tools only as callable). A
- * route that claims a mode the provider does not implement would silently
- * change what the model sees, so every request sends the complete current tool
- * list — the documented behavior when a route declares no mode.
- */
-function toolsOf(options) {
-    return options.tools?.map(tool => ({
-        name: tool.name,
-        description: tool.description,
-        // ToolSchema.parameters is a JSON Schema object; pi-ai's TSchema is
-        // structurally JSON Schema, so it assigns directly.
-        parameters: tool.parameters,
-    }));
-}
-/**
- * Select the system prompt for pi-ai.
- *
- * `options.system` wins when defined; otherwise a leading `system` message
- * supplies it and leaves the converted history. An empty leading message sends
- * no prompt at all.
- */
-function splitSystemPrompt(options) {
-    if (options.system !== undefined)
-        return { systemPrompt: options.system, messages: options.messages };
-    const [first, ...rest] = options.messages;
-    if (first?.role !== 'system')
-        return { systemPrompt: undefined, messages: options.messages };
-    const text = flattenText(first);
-    return { systemPrompt: text.length > 0 ? text : undefined, messages: rest };
-}
-/** Every image occurrence this request will actually send. */
-function collectImageRefs(blocks, refs) {
-    for (const block of blocks) {
-        // An occurrence the surface already offloaded is a placeholder, not an image.
-        if (block.type === 'image' && block.offloaded !== true)
-            refs.set(block.attachment.attachmentId, block.attachment);
-    }
-}
-async function prepareRequestImages(messages, attachments, policy, signal) {
-    const refs = new Map();
-    for (const message of messages)
-        collectImageRefs(message.content, refs);
-    const ordered = [...refs.values()];
-    const prepared = await Promise.all(ordered.map(ref => attachments.readImageRequest(ref, { ...requestImageDimensions(ref.width, ref.height, policy.maxPixels), maxBytes: policy.maxBytes }, signal)));
-    const versions = new Map();
-    for (const [index, ref] of ordered.entries())
-        versions.set(ref.attachmentId, prepared[index]);
-    return versions;
-}
-/** Convert one message's content into pi-ai user content. */
-async function userContent(blocks, requestImages, resolveImageAccess) {
-    const content = [];
-    for (const block of blocks) {
-        if (block.type === 'text') {
-            if (block.text.length > 0)
-                content.push({ type: 'text', text: block.text });
-            continue;
-        }
-        if (block.type === 'image') {
-            const version = requestImages.get(block.attachment.attachmentId);
-            if (version === undefined) {
-                throw new LlmError('dshopencodego: an image in this request has no prepared bytes; image input requires the attachment service', 'UNSUPPORTED_CONTENT');
-            }
-            content.push({
-                type: 'text',
-                text: requestImageHandleText(block.attachment, version, resolveImageAccess(block.attachment)),
-            });
-            content.push({ type: 'image', data: Buffer.from(version.data).toString('base64'), mimeType: version.mediaType });
-        }
-        // Other block types are not user-input vocabulary for pi-ai.
-    }
-    return content.every(block => block.type === 'text')
-        ? content.map(block => block.text).join('')
-        : content;
-}
-/**
- * Apply the host's image offload protocol to a request history.
- *
- * The host marks what the surface already offloaded. When the retained
- * occurrences still exceed the base64 bound, the request fails with
- * `IMAGE_OFFLOAD_REQUIRED` naming how many more must go — the host's retry
- * protocol, not a local decision to drop content.
- */
-function projectImagesForRequest(messages, images, requestImages) {
-    const offloadedImageText = llm.offloadedImageText;
-    const placeholder = (ref) => offloadedImageText(ref, images.resolveImageAccess(ref));
-    if (images.maxRequestImageBytes !== undefined) {
-        const over = llm.requiredImageOffload(messages, { representation: 'base64', maxBytes: images.maxRequestImageBytes, byteQuantum: 1 }, block => requestImages.get(block.attachment.attachmentId).bytes);
-        if (over > 0) {
-            throw new LlmError(`request images exceed the ${images.maxRequestImageBytes}-byte base64 bound;`
-                + ` ${over} more oldest occurrence(s) must be offloaded`, llm.IMAGE_OFFLOAD_REQUIRED_CODE, { offloadImages: over });
-        }
-    }
-    return llm.projectOffloadedImages(messages, placeholder);
-}
-/**
- * Convert Harness history into a pi-ai request context.
- *
- * The result is a plain `Context`; the adapter normalizes it into the branded
- * transcript pi-ai's providers accept.
- * @param options - the assembled request.
- * @param images - attachment access; omitted selects the text-only conversion,
- *   which refuses any image rather than silently dropping it.
- * @param onReplayDegrade - called when stored replay metadata is unusable.
- * @returns the pi-ai context.
- * @throws {LlmError} `UNSUPPORTED_CONTENT` for an image this request cannot
- *   carry, and `IMAGE_OFFLOAD_REQUIRED` when retained images still exceed the
- *   base64 bound.
- */
-export async function toPiContext(options, images, onReplayDegrade) {
-    assertSupportedImageRoles(options.messages);
-    const split = splitSystemPrompt(options);
-    const resolveImageAccess = images?.resolveImageAccess ?? (() => undefined);
-    const policy = images?.requestImagePolicy ?? { maxPixels: 1_440_000, maxBytes: 400_000 };
-    const requestImages = images === undefined
-        ? new Map()
-        : await prepareRequestImages(split.messages, images.attachments, policy, options.signal);
-    const history = images === undefined
-        ? split.messages
-        : projectImagesForRequest(split.messages, images, requestImages);
-    const toolNames = new Map();
-    const messages = [];
-    for (const message of history) {
-        const tool = toolMessage(message);
-        if (tool !== undefined) {
-            const content = await userContent(tool.content, requestImages, resolveImageAccess);
-            messages.push({
-                role: 'toolResult',
-                toolCallId: tool.toolCallId,
-                toolName: toolNames.get(tool.toolCallId) ?? 'unknown',
-                content: typeof content === 'string'
-                    ? [{ type: 'text', text: content.length > 0 ? content : '(no output)' }]
-                    : content,
-                isError: tool.isError ?? false,
-                timestamp: 0,
-            });
-            continue;
-        }
-        if (message.role === 'system') {
-            // pi-ai keeps one leading system message; a later one folds into a user
-            // message so its position in the history survives.
-            messages.push({ role: 'user', content: flattenText(message), timestamp: 0 });
-            continue;
-        }
-        if (message.role === 'assistant') {
-            const assistant = toPiAssistant(message, onReplayDegrade);
-            for (const block of assistant.content) {
-                if (block.type === 'toolCall')
-                    toolNames.set(brandString(block.id), block.name);
-            }
-            messages.push(assistant);
-            continue;
-        }
-        const content = await userContent(message.content, requestImages, resolveImageAccess);
-        messages.push({ role: 'user', content, timestamp: 0 });
-    }
-    const tools = toolsOf(options);
-    return {
-        ...split.systemPrompt === undefined ? {} : { systemPrompt: split.systemPrompt },
-        messages,
-        ...tools === undefined || tools.length === 0 ? {} : { tools },
-    };
-}

package/lib/types/conversion/index.js

@@ -1,7 +0,0 @@
-/**
- * Harness ⇄ pi-ai conversion.
- * @module @dan-ai-studio/dshopencodego/conversion
- */
-export { toPiContext } from './context.js';
-export { classifyPiAiError, mapStopReason, mapUsage, toStreamChunks } from './stream.js';
-export { toPiAssistant, toPiReplayState } from './replay.js';

package/lib/types/conversion/replay.js

@@ -1,242 +0,0 @@
-/**
- * Durable pi-ai replay metadata and assistant-history reconstruction.
- *
- * Harness content is the durable source of truth for text and tool calls; this
- * module stores only the provider-native metadata needed to rebuild a pi-ai
- * assistant message on a later request (signatures, response ids, native
- * thinking level). When that metadata is unusable — another adapter wrote it, a
- * future version wrote it, or it no longer matches the content — the message
- * degrades to provider-neutral history instead of failing the request.
- *
- * @module @dan-ai-studio/dshopencodego/conversion/replay
- */
-import { LlmError } from '@deepseek-ai/dsh-llm';
-/** Tool arguments arrive as raw JSON strings; a malformed one becomes `{}`. */
-function parseArguments(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-            return parsed;
-        }
-    }
-    catch {
-        // Malformed arguments are the model's fault, not a reason to fail replay.
-    }
-    return {};
-}
-/** Historical pi-ai messages require a usage value; none of it is replayed. */
-function emptyPiUsage() {
-    return {
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        totalTokens: 0,
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    };
-}
-/**
- * Project a successful pi-ai response into the minimal durable replay state.
- * @param message - the completed native response.
- * @param requestedModel - request identity stored on the assistant source.
- * @returns the versioned lossless-JSON envelope; `blocks` is index-aligned with
- *   the streamed blocks, so assembly prunes an entry with its block.
- */
-export function toPiReplayState(message, requestedModel = message.model) {
-    const responseModel = message.api === 'anthropic-messages' && message.model !== requestedModel
-        ? message.model
-        : message.responseModel;
-    const response = {
-        kind: 'pi-ai',
-        version: 2,
-        api: message.api,
-        provider: message.provider,
-        model: requestedModel,
-        ...responseModel === undefined ? {} : { responseModel },
-        ...message.responseId === undefined ? {} : { responseId: message.responseId },
-        ...message.providerThinkingLevel === undefined ? {} : { providerThinkingLevel: message.providerThinkingLevel },
-        stopReason: message.stopReason,
-    };
-    return {
-        response,
-        blocks: message.content.map((block) => {
-            switch (block.type) {
-                case 'text': return {
-                    type: 'text',
-                    ...block.textSignature === undefined ? {} : { textSignature: block.textSignature },
-                };
-                case 'thinking': return {
-                    type: 'reasoning',
-                    ...block.thinkingSignature === undefined ? {} : { thinkingSignature: block.thinkingSignature },
-                    ...block.redacted === undefined ? {} : { redacted: block.redacted },
-                };
-                case 'toolCall': return {
-                    type: 'tool-call',
-                    ...block.thoughtSignature === undefined ? {} : { thoughtSignature: block.thoughtSignature },
-                };
-            }
-        }),
-    };
-}
-function invalidReplay(message) {
-    throw new LlmError(`invalid pi-ai replay state: ${message}`, 'INVALID_REPLAY_STATE');
-}
-/** Validate a durable envelope before any of it reaches pi-ai. */
-function readReplayState(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return invalidReplay('expected a replay envelope');
-    const envelope = value;
-    const rawResponse = envelope['response'];
-    if (typeof rawResponse !== 'object' || rawResponse === null || Array.isArray(rawResponse)) {
-        return invalidReplay('expected a response object');
-    }
-    const response = rawResponse;
-    if (response['kind'] !== 'pi-ai')
-        return invalidReplay('unknown state kind');
-    if (response['version'] !== 2)
-        return invalidReplay(`unsupported version ${String(response['version'])}`);
-    for (const key of ['api', 'provider', 'model']) {
-        if (typeof response[key] !== 'string' || response[key].length === 0)
-            return invalidReplay(`${key} must be a non-empty string`);
-    }
-    if (!['stop', 'length', 'toolUse', 'error', 'aborted'].includes(String(response['stopReason']))) {
-        return invalidReplay('unknown stopReason');
-    }
-    for (const key of ['responseModel', 'responseId', 'providerThinkingLevel']) {
-        if (response[key] !== undefined && typeof response[key] !== 'string')
-            return invalidReplay(`${key} must be a string`);
-    }
-    const blocks = envelope['blocks'];
-    if (!Array.isArray(blocks))
-        return invalidReplay('blocks must be an array');
-    for (const [index, value] of blocks.entries()) {
-        if (typeof value !== 'object' || value === null || Array.isArray(value))
-            return invalidReplay(`block ${index} must be an object`);
-        const block = value;
-        if (!['text', 'reasoning', 'tool-call'].includes(String(block['type']))) {
-            return invalidReplay(`block ${index} has an unknown type`);
-        }
-        for (const signature of ['textSignature', 'thinkingSignature', 'thoughtSignature']) {
-            if (block[signature] !== undefined && typeof block[signature] !== 'string') {
-                return invalidReplay(`block ${index} ${signature} must be a string`);
-            }
-        }
-        if (block['redacted'] !== undefined && typeof block['redacted'] !== 'boolean') {
-            return invalidReplay(`block ${index} redacted must be boolean`);
-        }
-    }
-    return { response: response, blocks: blocks };
-}
-/** Convert provider-neutral blocks without claiming same-model fidelity. */
-function foreignAssistant(message) {
-    const source = message.source.kind === 'model' ? message.source : undefined;
-    const content = [];
-    for (const block of message.content) {
-        switch (block.type) {
-            case 'text':
-                content.push({ type: 'text', text: block.text });
-                break;
-            case 'reasoning':
-                content.push({ type: 'thinking', thinking: block.text });
-                break;
-            case 'tool-call':
-                content.push({
-                    type: 'toolCall', id: block.id, name: block.name, arguments: parseArguments(block.arguments),
-                });
-                break;
-            case 'image':
-                throw new LlmError('pi-ai chat history cannot represent structured assistant image output', 'UNSUPPORTED_CONTENT');
-            default:
-                // Plugin-added block types have no pi-ai representation.
-                break;
-        }
-    }
-    return {
-        role: 'assistant',
-        content,
-        // Deliberately never equals a catalog API: absent replay state is foreign
-        // even when the source names this same provider and model.
-        api: 'dsh-foreign',
-        provider: source?.provider ?? 'dsh-foreign',
-        model: source?.model ?? 'dsh-foreign',
-        usage: emptyPiUsage(),
-        stopReason: content.some(piece => piece.type === 'toolCall') ? 'toolUse' : 'stop',
-        timestamp: 0,
-    };
-}
-/** Recombine durable content with validated replay metadata. */
-function replayedAssistant(message, source, rawState) {
-    const state = readReplayState(rawState);
-    if (state.response.provider !== source.provider)
-        return invalidReplay('provider does not match assistant source');
-    if (state.response.model !== source.model)
-        return invalidReplay('model does not match assistant source');
-    if (state.blocks.length !== message.content.length)
-        return invalidReplay('block count does not match assistant content');
-    const content = message.content.map((block, index) => {
-        const replay = state.blocks[index];
-        if (replay === undefined || replay.type !== block.type)
-            return invalidReplay(`block ${index} does not match assistant content`);
-        switch (block.type) {
-            case 'text': return {
-                type: 'text',
-                text: block.text,
-                ...replay.type === 'text' && replay.textSignature !== undefined ? { textSignature: replay.textSignature } : {},
-            };
-            case 'reasoning': return {
-                type: 'thinking',
-                thinking: block.text,
-                ...replay.type === 'reasoning' && replay.thinkingSignature !== undefined
-                    ? { thinkingSignature: replay.thinkingSignature } : {},
-                ...replay.type === 'reasoning' && replay.redacted !== undefined ? { redacted: replay.redacted } : {},
-            };
-            case 'tool-call': return {
-                type: 'toolCall',
-                id: block.id,
-                name: block.name,
-                arguments: parseArguments(block.arguments),
-                ...replay.type === 'tool-call' && replay.thoughtSignature !== undefined
-                    ? { thoughtSignature: replay.thoughtSignature } : {},
-            };
-            default: return invalidReplay(`block ${index} has an unsupported Harness type`);
-        }
-    });
-    return {
-        role: 'assistant',
-        content,
-        api: state.response.api,
-        provider: state.response.provider,
-        // Anthropic reports aliases and fallbacks as `model`, unlike Completions'
-        // informational `responseModel`.
-        model: state.response.api === 'anthropic-messages'
-            ? state.response.responseModel ?? state.response.model
-            : state.response.model,
-        ...state.response.responseModel === undefined ? {} : { responseModel: state.response.responseModel },
-        ...state.response.responseId === undefined ? {} : { responseId: state.response.responseId },
-        ...state.response.providerThinkingLevel === undefined
-            ? {} : { providerThinkingLevel: state.response.providerThinkingLevel },
-        usage: emptyPiUsage(),
-        stopReason: state.response.stopReason,
-        timestamp: 0,
-    };
-}
-/**
- * Convert one durable assistant message into pi-ai history.
- * @param message - assistant content with its model source and optional replay metadata.
- * @param onDegrade - called with the reason when unusable metadata falls back.
- * @returns the native assistant message, or a provider-neutral reconstruction.
- */
-export function toPiAssistant(message, onDegrade) {
-    const source = message.source;
-    if (source.kind !== 'model' || source.replayState === undefined)
-        return foreignAssistant(message);
-    try {
-        return replayedAssistant(message, source, source.replayState);
-    }
-    catch (error) {
-        if (!(error instanceof LlmError) || error.code !== 'INVALID_REPLAY_STATE')
-            throw error;
-        onDegrade?.(error.message);
-        return foreignAssistant(message);
-    }
-}

package/lib/types/conversion/stream.js

@@ -1,221 +0,0 @@
-/**
- * pi-ai assistant events translated into the Harness streaming protocol.
- *
- * pi-ai hands back parsed tool-call arguments while the Harness keeps their raw
- * JSON representation, and it reports failures as terminal stream events rather
- * than throws. Both are normalized here, together with usage and stop reasons.
- *
- * @module @dan-ai-studio/dshopencodego/conversion/stream
- */
-import { brandString } from '@deepseek-ai/dsh-brand';
-import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, isContextWindowExceededError, isQuotaExceededError, LlmError, } from '@deepseek-ai/dsh-llm';
-import { isContextOverflow } from '@earendil-works/pi-ai/utils/overflow';
-import { toPiReplayState } from './replay.js';
-/**
- * Map pi-ai usage (reasoning already folded into output).
- * @param usage - the terminal event's cumulative usage.
- * @returns Harness counts; cache fields appear only when non-zero, because
- *   pi-ai reports zeros rather than absence.
- */
-export function mapUsage(usage) {
-    return {
-        inputTokens: usage.input,
-        outputTokens: usage.output,
-        totalTokens: usage.totalTokens,
-        ...usage.cacheRead > 0 ? { cacheReadTokens: usage.cacheRead } : {},
-        ...usage.cacheWrite > 0 ? { cacheWriteTokens: usage.cacheWrite } : {},
-    };
-}
-/**
- * The account-quota failure class, written out rather than imported:
- * `dsh-llm` exports it as `ACCOUNT_QUOTA_EXCEEDED_CODE`, and the spelling is
- * the stable protocol value the host routes on, so spelling it here keeps the
- * route correct on every host this plugin supports.
- */
-const ACCOUNT_QUOTA_CODE = 'ACCOUNT_QUOTA';
-/**
- * Classify a provider error string into a Harness error code.
- *
- * pi-ai flattens a caught transport error to its `message` before this point,
- * so the actionable detail is only available as text. The patterns are ordered
- * from most specific to least, and anything unrecognized stays `PI_AI_ERROR`
- * rather than being guessed into a retryable class.
- *
- * Exhausted quota is reported as `ACCOUNT_QUOTA` rather than the generic
- * `QUOTA`: this gateway meters a prepaid balance (the usage window the plugin
- * shows is the same meter), so the remedy is topping up, not retrying — the
- * same upgrade `llm-deepseek-account` applies to its own prepaid route.
- */
-export function classifyPiAiError(message) {
-    if (/\b(?:401|403)\b/.test(message))
-        return 'AUTH';
-    if (isQuotaExceededError(message))
-        return ACCOUNT_QUOTA_CODE;
-    // A 429 typed as `server_error` is the gateway reporting an unavailable
-    // upstream, not the caller exceeding a rate limit: the remedy is waiting for
-    // the endpoint to recover rather than slowing down, so it classifies as
-    // SERVER even though the status code alone reads as a rate limit.
-    if (/server_error/i.test(message))
-        return 'SERVER';
-    if (/\b429\b|rate.?limit/i.test(message))
-        return 'RATE_LIMIT';
-    if (/\b413\b|payload too large|request body too large|length limit exceeded/i.test(message))
-        return 'INVALID_REQUEST';
-    if (/\b400\b|invalid.?request/i.test(message))
-        return 'INVALID_REQUEST';
-    if (/\b5\d\d\b/.test(message))
-        return 'SERVER';
-    if (/\btime(?:d)?\s*out\b|timeout/i.test(message))
-        return 'TIMEOUT';
-    if (/stream ended (?:before|without)\b/i.test(message))
-        return 'TRANSPORT';
-    if (/\b(?:network|connection|socket|fetch)\b|\bECONN[A-Z]+\b/i.test(message)
-        || /\b(?:other side closed|HTTP2 request did not get a response|WebSocket closed unexpectedly)\b/i.test(message)
-        || /\bterminated\b|premature close/i.test(message)) {
-        return 'TRANSPORT';
-    }
-    return 'PI_AI_ERROR';
-}
-/**
- * Map a terminal pi-ai message to the Harness finish reason.
- * @param message - the assistant message carried by `done` or `error`.
- * @param contextWindow - catalog capacity, for usage-based overflow detection.
- * @returns the finish reason; a recognized overflow, a zero-content `stop`, and
- *   the non-terminal `pending`/`deferred` states all become errors.
- */
-export function mapStopReason(message, contextWindow) {
-    const overflow = isContextOverflow(message, contextWindow)
-        || (message.stopReason === 'error'
-            && message.errorMessage !== undefined
-            && isContextWindowExceededError(message.errorMessage));
-    if (overflow) {
-        return {
-            kind: 'error',
-            failure: {
-                message: message.errorMessage ?? `pi-ai detected context overflow for model "${message.model}"`,
-                code: CONTEXT_WINDOW_EXCEEDED_CODE,
-            },
-        };
-    }
-    switch (message.stopReason) {
-        case 'stop':
-            if (message.content.length === 0) {
-                return {
-                    kind: 'error',
-                    failure: {
-                        message: `model "${message.model}" returned a completed response with no content`,
-                        code: EMPTY_RESPONSE_CODE,
-                    },
-                };
-            }
-            return { kind: 'stop' };
-        case 'length': return { kind: 'max-tokens' };
-        case 'toolUse': return { kind: 'tool-calls' };
-        case 'pending': return {
-            kind: 'error',
-            failure: { message: `pi-ai stream for model "${message.model}" ended pending`, code: 'PI_AI_ERROR' },
-        };
-        case 'deferred': return {
-            kind: 'error',
-            failure: { message: `pi-ai deferred response for model "${message.model}" is not supported`, code: 'PI_AI_ERROR' },
-        };
-        case 'aborted': return {
-            kind: 'aborted',
-            failure: { message: message.errorMessage ?? 'pi-ai stream aborted', code: 'ABORTED' },
-        };
-        case 'error': {
-            const text = message.errorMessage ?? 'pi-ai stream error';
-            return { kind: 'error', failure: { message: text, code: classifyPiAiError(text) } };
-        }
-    }
-}
-/**
- * Translate one assistant turn's pi-ai events into Harness chunks.
- * @param events - the pi-ai event stream for this turn.
- * @param contextWindow - catalog capacity, for usage-based overflow detection.
- * @param callerSignal - caller cancellation; an aborted caller turns an in-band
- *   terminal error into an aborted finish.
- * @param requestedModel - request identity recorded in the replay envelope.
- * @returns chunks ending in `usage` then `finish`.
- * @throws {LlmError} `STREAM_CLOSED` when the source ends with no terminal event.
- */
-export async function* toStreamChunks(events, contextWindow, callerSignal, requestedModel) {
-    const toolCalls = new Map();
-    for await (const event of events) {
-        switch (event.type) {
-            case 'start':
-                break;
-            case 'text_start':
-                yield { type: 'block-start', index: event.contentIndex, blockType: 'text' };
-                break;
-            case 'text_delta':
-                yield { type: 'text-delta', index: event.contentIndex, text: event.delta };
-                break;
-            case 'text_end':
-                yield { type: 'block-end', index: event.contentIndex, block: { type: 'text', text: event.content } };
-                break;
-            case 'thinking_start':
-                yield { type: 'block-start', index: event.contentIndex, blockType: 'reasoning' };
-                break;
-            case 'thinking_delta':
-                yield { type: 'reasoning-delta', index: event.contentIndex, text: event.delta };
-                break;
-            case 'thinking_end':
-                yield { type: 'block-end', index: event.contentIndex, block: { type: 'reasoning', text: event.content } };
-                break;
-            case 'toolcall_start': {
-                // The id and name live on the partial message at this index.
-                const partial = event.partial.content[event.contentIndex];
-                toolCalls.set(event.contentIndex, {
-                    id: partial?.type === 'toolCall' ? partial.id : '',
-                    name: partial?.type === 'toolCall' ? partial.name : '',
-                });
-                yield { type: 'block-start', index: event.contentIndex, blockType: 'tool-call' };
-                break;
-            }
-            case 'toolcall_delta': {
-                const known = toolCalls.get(event.contentIndex);
-                yield {
-                    type: 'tool-call-delta',
-                    index: event.contentIndex,
-                    id: brandString(known?.id ?? ''),
-                    ...known !== undefined && known.name.length > 0 ? { name: known.name } : {},
-                    argumentsDelta: event.delta,
-                };
-                break;
-            }
-            case 'toolcall_end':
-                yield {
-                    type: 'block-end',
-                    index: event.contentIndex,
-                    block: {
-                        type: 'tool-call',
-                        id: brandString(event.toolCall.id),
-                        name: event.toolCall.name,
-                        // pi-ai parses the arguments; the Harness vocabulary keeps the raw
-                        // JSON string it stores and replays.
-                        arguments: JSON.stringify(event.toolCall.arguments),
-                    },
-                };
-                break;
-            case 'done':
-                yield { type: 'usage', usage: mapUsage(event.message.usage) };
-                yield {
-                    type: 'finish',
-                    reason: mapStopReason(event.message, contextWindow),
-                    replayState: toPiReplayState(event.message, requestedModel),
-                };
-                return;
-            case 'error':
-                // pi-ai delivers failures in-band; the Harness protocol's other
-                // sanctioned error path is an error/aborted finish chunk.
-                yield { type: 'usage', usage: mapUsage(event.error.usage) };
-                yield {
-                    type: 'finish',
-                    reason: mapStopReason(callerSignal?.aborted ? { ...event.error, stopReason: 'aborted' } : event.error, contextWindow),
-                };
-                return;
-        }
-    }
-    throw new LlmError('pi-ai event stream ended without a terminal event', 'STREAM_CLOSED');
-}