@askalf/dario 5.5.86 → 5.5.88

package/README.md

@@ -18,7 +18,7 @@
 
 <p><strong>One local endpoint. Every AI tool you own. The subscription you already pay for.</strong></p>
 
-<sub><code>npm i -g @askalf/dario</code> · <strong>0</strong> runtime deps · <a href="https://www.npmjs.com/package/@askalf/dario">SLSA-attested</a> every release · nothing phones home · ~26k lines you can read in a weekend · independent, unofficial, third-party (<a href="DISCLAIMER.md">DISCLAIMER.md</a>)</sub>
+<sub><code>npm i -g @askalf/dario</code> · <strong>0</strong> runtime deps · <a href="https://www.npmjs.com/package/@askalf/dario">SLSA-attested</a> every release · nothing phones home · ~28k lines you can read in a weekend · independent, unofficial, third-party (<a href="DISCLAIMER.md">DISCLAIMER.md</a>)</sub>
 
 <sub>Part of <a href="#own-your-stack"><strong>Own Your Stack</strong></a> — 12 open tools for owning your AI infra: <a href="https://github.com/askalf/truecopy">truecopy</a> · <a href="https://github.com/askalf/strongroom">strongroom</a> · <a href="https://github.com/askalf/fieldpass">fieldpass</a> · <a href="https://github.com/askalf/plumbline">plumbline</a> · <a href="#own-your-stack">full family ↓</a></sub>
 

package/dist/anthropic-responses-translate.d.ts

@@ -0,0 +1,522 @@
+/**
+ * Anthropic Messages ⇄ OpenAI Responses translator, ported into dario so that a
+ * ChatGPT-subscription (codex) account can serve Anthropic-shape `/v1/messages`
+ * requests. It was developed and live-probe-validated outside this repo, then
+ * copied here with no change to any translation logic. The only port edits: the
+ * Anthropic-side types and the reasoning-effort thresholds it used to import
+ * from a sibling module are inlined below, making this file self-contained.
+ */
+/**
+ * Anthropic Messages ⇄ OpenAI *Responses API* translation.
+ *
+ * Targets the Responses API (not Chat Completions): the ChatGPT Codex
+ * backend speaks Responses, and reasoning models reject tools on
+ * chat/completions. This
+ * module targets the newer `/v1/responses` shape, which is REQUIRED for
+ * the reasoning-model + function-tools combination: gpt-5.6-sol (and the
+ * o-series) REJECT function tools together with reasoning on
+ * `/chat/completions`, but accept both on `/responses`. That combination
+ * is exactly Claude Code's case — CC always sends its 30+ tools and often
+ * has thinking enabled — so this is the path dario 5.1 needs to drive a
+ * reasoning model as a Claude backend.
+ *
+ * Pure data transforms — no network, no fs, no timers. A later wiring
+ * phase will translate an inbound Messages request with
+ * `anthropicToResponsesRequest`, POST it to `{baseUrl}/responses`, and
+ * translate the reply back with `responsesToAnthropicResponse`
+ * (non-streaming) — streaming is deferred (see the P0.6 stub below).
+ *
+ * The Responses shape is item-array based and sits closer to Anthropic's
+ * block model than chat completions does. Field names CONFIRMED against
+ * the OpenAI SDK type sources (openai-python `types/responses/*`); the
+ * shapes that differ from the chat-completions translator are called out
+ * where they occur:
+ *
+ *   - system  → top-level `instructions` (a string), NOT a role message.
+ *   - messages → `input[]` items. User text/images become one message
+ *     item with `input_text` / `input_image` parts (image_url is a bare
+ *     string here, not `{url}`). Assistant text replays as a message item
+ *     with a plain string. Assistant tool_use blocks become top-level
+ *     `function_call` items; user tool_result blocks become top-level
+ *     `function_call_output` items. Anthropic `tool_use_id` ↔ Responses
+ *     `call_id` threads the two.
+ *   - tools    → FLATTENED function tools `{type,name,description,
+ *     parameters}` (chat nests these under `.function`).
+ *   - tool_choice forced form → FLATTENED `{type:'function', name}`
+ *     (chat uses `{type:'function', function:{name}}`).
+ *   - thinking → `reasoning:{effort}` (+ `summary:'auto'` so a reasoning
+ *     summary comes back and can round-trip to a thinking block). Unlike
+ *     chat completions, reasoning + tools together is ALLOWED here — the
+ *     whole reason this module exists.
+ *   - max_tokens → `max_output_tokens`; `store:false` (stateless — dario
+ *     keeps no server-side conversation).
+ *
+ * Deliberate lossy edges (documented at the relevant function):
+ *   - `cache_control` is dropped silently (no Responses analog).
+ *   - Reasoning models reject sampling params: `temperature`/`top_p` are
+ *     omitted whenever reasoning is enabled.
+ *   - assistant `thinking` / `redacted_thinking` blocks are dropped from
+ *     the OUTBOUND request (no faithful inbound slot; encrypted_content
+ *     round-tripping is a later concern). Reasoning that the model
+ *     returns IS surfaced (as thinking blocks) on the response side.
+ *   - Anthropic server tools (entries without `input_schema`) are skipped.
+ *   - images inside `tool_result` content are dropped
+ *     (`function_call_output.output` is a string); sibling text survives.
+ */
+export interface AnthropicTextBlock {
+    type: 'text';
+    text: string;
+    cache_control?: unknown;
+}
+export interface AnthropicImageBlock {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    } | {
+        type: 'url';
+        url: string;
+    };
+    cache_control?: unknown;
+}
+export interface AnthropicToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+    cache_control?: unknown;
+}
+export interface AnthropicToolResultBlock {
+    type: 'tool_result';
+    tool_use_id: string;
+    content?: string | Array<Record<string, unknown>>;
+    is_error?: boolean;
+    cache_control?: unknown;
+}
+export type AnthropicContentBlock = AnthropicTextBlock | AnthropicImageBlock | AnthropicToolUseBlock | AnthropicToolResultBlock | {
+    type: string;
+    [key: string]: unknown;
+};
+export interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: string | AnthropicContentBlock[];
+}
+export interface AnthropicTool {
+    name: string;
+    description?: string;
+    input_schema?: Record<string, unknown>;
+    /** Server-tool discriminator (`bash_20250124`, …). Untranslatable. */
+    type?: string;
+    cache_control?: unknown;
+}
+export interface AnthropicToolChoice {
+    type: 'auto' | 'any' | 'tool' | 'none';
+    name?: string;
+    disable_parallel_tool_use?: boolean;
+}
+export interface AnthropicThinkingConfig {
+    type: 'enabled' | 'disabled';
+    budget_tokens?: number;
+}
+export interface AnthropicRequest {
+    model: string;
+    system?: string | AnthropicTextBlock[];
+    messages: AnthropicMessage[];
+    tools?: AnthropicTool[];
+    tool_choice?: AnthropicToolChoice;
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stop_sequences?: string[];
+    stream?: boolean;
+    thinking?: AnthropicThinkingConfig;
+    metadata?: {
+        user_id?: string | null;
+    };
+}
+export type AnthropicStopReason = 'end_turn' | 'max_tokens' | 'tool_use' | 'stop_sequence';
+export interface AnthropicUsage {
+    input_tokens: number;
+    output_tokens: number;
+}
+export interface AnthropicResponse {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    model: string;
+    content: Array<AnthropicTextBlock | AnthropicToolUseBlock>;
+    stop_reason: AnthropicStopReason | null;
+    stop_sequence: string | null;
+    usage: AnthropicUsage;
+}
+/**
+ * Thinking-budget → reasoning_effort thresholds. Claude Code's thinking
+ * tiers land at ~4k ("think"), ~10k ("think hard") and 31999
+ * ("ultrathink") budget_tokens, so the cut points sit between those
+ * tiers:
+ *
+ *   budget_tokens ≤ 4096            → 'low'
+ *   4096 < budget_tokens ≤ 16384    → 'medium'
+ *   budget_tokens > 16384           → 'high'
+ *
+ * `thinking` absent, disabled, or without a positive budget → no
+ * `reasoning_effort` in the output (upstream default applies).
+ */
+export declare const REASONING_EFFORT_LOW_MAX = 4096;
+export declare const REASONING_EFFORT_MEDIUM_MAX = 16384;
+export interface AnthropicThinkingBlock {
+    type: 'thinking';
+    thinking: string;
+}
+export type ResponsesAnthropicContentBlock = AnthropicTextBlock | AnthropicToolUseBlock | AnthropicThinkingBlock;
+/** AnthropicResponse but with a content union that admits thinking blocks. */
+export type AnthropicResponseWithThinking = Omit<AnthropicResponse, 'content'> & {
+    content: ResponsesAnthropicContentBlock[];
+};
+export interface ResponsesInputText {
+    type: 'input_text';
+    text: string;
+}
+/** Responses `input_image`: image_url is a bare string (URL or data URI). */
+export interface ResponsesInputImage {
+    type: 'input_image';
+    image_url: string;
+    detail?: 'auto' | 'low' | 'high';
+}
+export type ResponsesInputContentPart = ResponsesInputText | ResponsesInputImage;
+/** A role message input item (the "EasyInputMessage" form). */
+export interface ResponsesInputMessage {
+    role: 'user' | 'assistant' | 'system' | 'developer';
+    content: string | ResponsesInputContentPart[];
+}
+/** Assistant tool call, replayed as a top-level input item. */
+export interface ResponsesFunctionCallItem {
+    type: 'function_call';
+    call_id: string;
+    name: string;
+    arguments: string;
+    id?: string;
+}
+/** Tool result, fed back as a top-level input item (output is a string). */
+export interface ResponsesFunctionCallOutputItem {
+    type: 'function_call_output';
+    call_id: string;
+    output: string;
+}
+export type ResponsesInputItem = ResponsesInputMessage | ResponsesFunctionCallItem | ResponsesFunctionCallOutputItem;
+/** Flattened function tool — NOT nested under `.function` like chat. */
+export interface ResponsesFunctionTool {
+    type: 'function';
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
+    strict?: boolean | null;
+}
+export type ResponsesToolChoice = 'auto' | 'none' | 'required' | {
+    type: 'function';
+    name: string;
+};
+export interface ResponsesReasoningConfig {
+    effort?: 'low' | 'medium' | 'high';
+    summary?: 'auto' | 'concise' | 'detailed';
+}
+export interface ResponsesRequest {
+    model: string;
+    input: ResponsesInputItem[];
+    instructions?: string;
+    tools?: ResponsesFunctionTool[];
+    tool_choice?: ResponsesToolChoice;
+    parallel_tool_calls?: boolean;
+    reasoning?: ResponsesReasoningConfig;
+    max_output_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stream?: boolean;
+    store?: boolean;
+}
+export interface ResponsesOutputText {
+    type: 'output_text';
+    text: string;
+    annotations?: unknown[];
+}
+export interface ResponsesRefusal {
+    type: 'refusal';
+    refusal: string;
+}
+export type ResponsesMessageContentPart = ResponsesOutputText | ResponsesRefusal | {
+    type: string;
+    [key: string]: unknown;
+};
+export interface ResponsesMessageItem {
+    type: 'message';
+    id?: string;
+    role: 'assistant';
+    status?: string;
+    content?: ResponsesMessageContentPart[];
+}
+/** Response-side function_call: carries BOTH `id` (item id) and `call_id`. */
+export interface ResponsesResponseFunctionCall {
+    type: 'function_call';
+    id?: string;
+    call_id?: string;
+    name?: string;
+    arguments?: string;
+    status?: string;
+}
+export interface ResponsesReasoningSummaryPart {
+    type: 'summary_text';
+    text: string;
+}
+export interface ResponsesReasoningContentPart {
+    type: 'reasoning_text';
+    text: string;
+}
+export interface ResponsesReasoningItem {
+    type: 'reasoning';
+    id?: string;
+    summary?: ResponsesReasoningSummaryPart[];
+    content?: ResponsesReasoningContentPart[];
+    encrypted_content?: string | null;
+    status?: string;
+}
+export type ResponsesOutputItem = ResponsesMessageItem | ResponsesResponseFunctionCall | ResponsesReasoningItem | {
+    type: string;
+    [key: string]: unknown;
+};
+export interface ResponsesUsage {
+    input_tokens?: number;
+    input_tokens_details?: {
+        cached_tokens?: number;
+        cache_write_tokens?: number;
+    };
+    output_tokens?: number;
+    output_tokens_details?: {
+        reasoning_tokens?: number;
+    };
+    total_tokens?: number;
+}
+export interface ResponsesResponse {
+    id?: string;
+    object?: string;
+    model?: string;
+    /** completed | failed | in_progress | cancelled | queued | incomplete (Azure also: requires_action). */
+    status?: string;
+    output?: ResponsesOutputItem[];
+    output_text?: string;
+    incomplete_details?: {
+        reason?: string;
+    } | null;
+    error?: {
+        code?: string;
+        message?: string;
+    } | null;
+    usage?: ResponsesUsage | null;
+}
+/**
+ * Extra max_output_tokens reserved for reasoning tokens, by effort, so the
+ * client's intended visible-output budget survives on a reasoning model
+ * (max_output_tokens caps reasoning + output combined on the Responses API).
+ */
+export declare const REASONING_HEADROOM: {
+    readonly low: 12000;
+    readonly medium: 25000;
+    readonly high: 50000;
+};
+/** gpt-5.x / o-series output ceiling (tokens). */
+export declare const RESPONSES_MAX_OUTPUT_CAP = 128000;
+export interface AnthropicToResponsesOptions {
+    /**
+     * `reasoning.summary` value when reasoning is enabled. Default 'auto':
+     * without a summary, the reasoning items come back with an empty
+     * `summary[]` and there is nothing to round-trip into a thinking block.
+     * Pass `null` to omit `summary` entirely.
+     */
+    reasoningSummary?: 'auto' | 'concise' | 'detailed' | null;
+    /**
+     * `store`. Default false — dario is stateless and keeps no server-side
+     * conversation. Set true only if a caller wants OpenAI-side retention.
+     */
+    store?: boolean;
+}
+/**
+ * Translate an Anthropic Messages request into an OpenAI Responses
+ * request body for `{baseUrl}/responses`.
+ *
+ * Anthropic `input_schema` is already JSON Schema, which is what the
+ * Responses `parameters` field expects — it passes through unchanged.
+ * Tool entries without an `input_schema` (Anthropic server tools such as
+ * `web_search_20250305`) have no function-tool equivalent and are
+ * skipped. `cache_control` is dropped wherever it appears.
+ */
+export declare function anthropicToResponsesRequest(body: AnthropicRequest, targetModel: string, options?: AnthropicToResponsesOptions): ResponsesRequest;
+/**
+ * Translate a non-streaming Responses reply into an Anthropic Messages
+ * response. `requestModel` is echoed back as `model` so the client sees
+ * the model it asked for, not the upstream alias. Output items are walked
+ * in order:
+ *   - message      → its `output_text` parts become text blocks; a
+ *                    `refusal` part surfaces as a text block so the client
+ *                    sees why the turn produced no content.
+ *   - function_call → a tool_use block, id = `call_id` (Anthropic threads
+ *                    the tool_result back on this id), input = parsed
+ *                    `arguments` (bad JSON → `{}`).
+ *   - reasoning     → a thinking block IF it carries summary/reasoning
+ *                    text; an empty reasoning item is dropped.
+ * Other item types (web_search_call, code_interpreter_call, …) are
+ * dropped. If nothing produced content but `output_text` is present, it
+ * is used as a single text block fallback.
+ */
+export declare function responsesToAnthropicResponse(resp: ResponsesResponse, requestModel: string): AnthropicResponseWithThinking;
+/**
+ * Anthropic SSE event objects this translator emits. A superset of
+ * The Anthropic stream-event shape: content blocks and deltas
+ * also admit `thinking` / `thinking_delta` (the Responses API can stream
+ * reasoning, which chat completions cannot).
+ */
+export type ResponsesAnthropicStreamEvent = {
+    type: 'message_start';
+    message: AnthropicResponseWithThinking;
+} | {
+    type: 'content_block_start';
+    index: number;
+    content_block: {
+        type: 'text';
+        text: string;
+    } | {
+        type: 'thinking';
+        thinking: string;
+    } | {
+        type: 'tool_use';
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    };
+} | {
+    type: 'content_block_delta';
+    index: number;
+    delta: {
+        type: 'text_delta';
+        text: string;
+    } | {
+        type: 'thinking_delta';
+        thinking: string;
+    } | {
+        type: 'input_json_delta';
+        partial_json: string;
+    };
+} | {
+    type: 'content_block_stop';
+    index: number;
+} | {
+    type: 'message_delta';
+    delta: {
+        stop_reason: AnthropicStopReason;
+        stop_sequence: null;
+    };
+    usage: {
+        output_tokens: number;
+        input_tokens?: number;
+    };
+} | {
+    type: 'message_stop';
+};
+/**
+ * One parsed Responses SSE event — a typed superset of the fields this
+ * translator consumes. Every event carries a `type`; the rest are present
+ * only on the events that use them.
+ */
+export interface ResponsesStreamEvent {
+    type: string;
+    sequence_number?: number;
+    /** created | in_progress | completed | incomplete | failed carry a full response. */
+    response?: ResponsesResponse;
+    /** output_item.added | output_item.done carry the item. */
+    item?: ResponsesOutputItem;
+    /** Index of the item within `response.output` — the field is `output_index`. */
+    output_index?: number;
+    item_id?: string;
+    content_index?: number;
+    summary_index?: number;
+    /** Text / argument / reasoning fragment on `*.delta` events. */
+    delta?: string;
+    /** error event fields. */
+    code?: string | null;
+    message?: string;
+    param?: string | null;
+    [key: string]: unknown;
+}
+export interface ResponsesStreamTranslatorOptions {
+    /** Model echoed in message_start. Defaults to the created event's `response.model`. */
+    requestModel?: string;
+}
+export interface ResponsesStreamTranslator {
+    /** Feed one parsed Responses event; returns the Anthropic events it produced. */
+    push(event: ResponsesStreamEvent): ResponsesAnthropicStreamEvent[];
+    /** Signal end-of-stream; returns the closing events. Idempotent. */
+    end(): ResponsesAnthropicStreamEvent[];
+}
+/**
+ * Build a streaming translator from parsed OpenAI Responses events to
+ * Anthropic SSE event objects. Same interface + discipline as
+ * `openAIStreamToAnthropicSSE`: `push(event)` / `end()`, exactly one
+ * content block open at a time, strictly increasing indices, event name
+ * === data.type. Callers parse the upstream SSE themselves
+ * (`parseResponsesSSEEvent` / `createResponsesSSEParser`), push each
+ * event, and serialize the returned events (`formatResponsesAnthropicSSE`
+ * produces the wire framing).
+ *
+ *   - message_start fires once, on the first event, with an empty-content
+ *     envelope and usage 0/0 (usage is known only at response.completed).
+ *   - A `function_call` item opens a tool_use block on
+ *     output_item.added; a `reasoning` item opens a thinking block there
+ *     (eager, so block order matches upstream item order even before the
+ *     first summary fragment — a reasoning item that streams no text thus
+ *     yields an empty thinking block bracketed by start/stop, which
+ *     Anthropic clients tolerate). A `message` item opens its text block
+ *     lazily on the first output_text.delta.
+ *   - output_item.done closes that item's block; response.completed (or
+ *     .incomplete / .failed, or a stream `error`) closes any open block
+ *     and emits message_delta (stop_reason + usage) + message_stop, then
+ *     marks the stream ended.
+ *   - `end()` repeats the closing sequence only if no terminal event was
+ *     seen (a cut-off stream), and is otherwise idempotent — so callers
+ *     can always call it safely.
+ *
+ * stop_reason: a tool call anywhere → 'tool_use'; else an `incomplete`
+ * status → 'max_tokens' (content-filter incompletion → 'end_turn'); else
+ * 'end_turn' (via the shared deriveStopReason).
+ */
+export declare function responsesStreamToAnthropicSSE(options?: ResponsesStreamTranslatorOptions): ResponsesStreamTranslator;
+/**
+ * Serialize one emitted Anthropic stream event into SSE wire framing:
+ * `event: <type>\ndata: <json>\n\n` — the same `event:`/`data:` pairing
+ * dario's streaming path produces. Structural twin of
+ * Anthropic SSE formatting, widened to this module's
+ * thinking-aware event union.
+ */
+export declare function formatResponsesAnthropicSSE(event: ResponsesAnthropicStreamEvent): string;
+/**
+ * Parse one Responses SSE record's `event:` and `data:` lines into an
+ * event object. Unlike chat completions (data-only), Responses SSE pairs
+ * an `event: <type>` line with a `data: <json>` line; the JSON already
+ * carries a matching `type`, so `dataLine` alone is usually enough — the
+ * `eventLine` is used only to backfill `type` if the JSON somehow omits
+ * it. Returns null for keep-alive/comment lines, `data: [DONE]`, and
+ * unparseable payloads. Callers that own real SSE framing (multi-line
+ * buffering, CRLF, cross-chunk boundaries) should use
+ * `createResponsesSSEParser` instead.
+ */
+export declare function parseResponsesSSEEvent(eventLine: string | undefined, dataLine: string): ResponsesStreamEvent | null;
+/**
+ * Buffered Responses SSE parser: feed raw stream chunks (which do NOT
+ * align to event boundaries), get back the complete events decoded so
+ * far. Records are separated by a blank line (`\n\n` or `\r\n\r\n`);
+ * multiple `data:` lines in one record join with `\n` per the SSE spec.
+ * Call `flush()` at end-of-stream to parse any trailing record that was
+ * not blank-line terminated. Pure and offline-testable.
+ */
+export declare function createResponsesSSEParser(): {
+    push(chunk: string): ResponsesStreamEvent[];
+    flush(): ResponsesStreamEvent[];
+};