@askalf/dario 6.3.0 → 6.4.0

package/README.md

@@ -269,6 +269,8 @@ The tool doesn't know. The backend doesn't know. dario is the seam.
 
 A ChatGPT Plus or Pro plan is served on **all three** of dario's endpoints: any client that speaks `/v1/chat/completions` or `/v1/responses` can use it (Codex CLI, the OpenAI SDKs, the Agents SDK, your scripts), and so can any client that speaks `/v1/messages` (Claude Code, the Anthropic SDKs, agent runtimes). The harness never needs to know which subscription is behind it — and the symmetry holds: Codex CLI runs on a Claude plan the same way.
 
+An Anthropic-shape client that declares Anthropic's hosted `web_search_20260209` tool gets **real web search on the ChatGPT plan** (since 6.4): the plan's own search runs, and the client sees Anthropic's own blocks — `server_tool_use` with the query, `web_search_tool_result` listing the pages searched, the answer with `web_search_result_location` citations. `allowed_domains` and `user_location` carry over, and so does forcing the search with `tool_choice`; `blocked_domains` and `max_uses` do not.
+
 ```bash
 dario add altman            # prints an authorize URL; paste the redirect URL back
 dario codex list

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

@@ -216,9 +216,33 @@ export interface ResponsesFunctionTool {
     parameters: Record<string, unknown>;
     strict?: boolean | null;
 }
+/**
+ * The Responses hosted web-search tool (v6.4). `filters.allowed_domains` and
+ * `user_location` are the two Anthropic web-search options it can carry;
+ * `blocked_domains` and `max_uses` have no equivalent and are dropped.
+ */
+export interface ResponsesWebSearchTool {
+    type: 'web_search';
+    filters?: {
+        allowed_domains?: string[];
+    };
+    user_location?: {
+        type: 'approximate';
+        city?: string;
+        region?: string;
+        country?: string;
+        timezone?: string;
+    };
+    search_context_size?: 'low' | 'medium' | 'high';
+}
+export type ResponsesTool = ResponsesFunctionTool | ResponsesWebSearchTool;
 export type ResponsesToolChoice = 'auto' | 'none' | 'required' | {
     type: 'function';
     name: string;
+}
+/** Force the hosted web search (the backend accepts `web_search` here, not a function name). */
+ | {
+    type: 'web_search';
 };
 export interface ResponsesReasoningConfig {
     /**
@@ -235,7 +259,9 @@ export interface ResponsesRequest {
     model: string;
     input: ResponsesInputItem[];
     instructions?: string;
-    tools?: ResponsesFunctionTool[];
+    tools?: ResponsesTool[];
+    /** `web_search_call.action.sources` — the searched URLs, which the Anthropic result block needs. */
+    include?: string[];
     tool_choice?: ResponsesToolChoice;
     parallel_tool_calls?: boolean;
     reasoning?: ResponsesReasoningConfig;
@@ -292,7 +318,29 @@ export interface ResponsesReasoningItem {
     encrypted_content?: string | null;
     status?: string;
 }
-export type ResponsesOutputItem = ResponsesMessageItem | ResponsesResponseFunctionCall | ResponsesReasoningItem | {
+/**
+ * A hosted web-search step as the backend reports it. `action.type` is
+ * `search` (with `query` and, when `include: web_search_call.action.sources`
+ * was asked for, `sources`), `open_page` (`url`) or `find_in_page`
+ * (`url`, `pattern`) — probed 2026-09-12 on the ChatGPT backend.
+ */
+export interface ResponsesWebSearchCallItem {
+    type: 'web_search_call';
+    id?: string;
+    status?: string;
+    action?: {
+        type?: string;
+        query?: string;
+        queries?: string[];
+        url?: string;
+        pattern?: string;
+        sources?: Array<{
+            type?: string;
+            url?: string;
+        }>;
+    };
+}
+export type ResponsesOutputItem = ResponsesMessageItem | ResponsesResponseFunctionCall | ResponsesReasoningItem | ResponsesWebSearchCallItem | {
     type: string;
     [key: string]: unknown;
 };
@@ -429,6 +477,15 @@ export type ResponsesAnthropicStreamEvent = {
         id: string;
         name: string;
         input: Record<string, unknown>;
+    } | {
+        type: 'server_tool_use';
+        id: string;
+        name: 'web_search';
+        input: Record<string, unknown>;
+    } | {
+        type: 'web_search_tool_result';
+        tool_use_id: string;
+        content: AnthropicWebSearchResult[];
     };
 } | {
     type: 'content_block_delta';
@@ -442,6 +499,9 @@ export type ResponsesAnthropicStreamEvent = {
     } | {
         type: 'input_json_delta';
         partial_json: string;
+    } | {
+        type: 'citations_delta';
+        citation: AnthropicWebSearchCitation;
     };
 } | {
     type: 'content_block_stop';
@@ -461,6 +521,22 @@ export type ResponsesAnthropicStreamEvent = {
 } | {
     type: 'message_stop';
 };
+/** One searched page, as Anthropic's `web_search_tool_result` lists them. */
+export interface AnthropicWebSearchResult {
+    type: 'web_search_result';
+    url: string;
+    title: string;
+    encrypted_content: string;
+    page_age: string | null;
+}
+/** A citation on a text block, as Anthropic's `citations_delta` carries it. */
+export interface AnthropicWebSearchCitation {
+    type: 'web_search_result_location';
+    url: string;
+    title: string;
+    cited_text: string;
+    encrypted_index: string;
+}
 /**
  * One parsed Responses SSE event — a typed superset of the fields this
  * translator consumes. Every event carries a `type`; the rest are present
@@ -480,6 +556,14 @@ export interface ResponsesStreamEvent {
     summary_index?: number;
     /** Text / argument / reasoning fragment on `*.delta` events. */
     delta?: string;
+    /** `output_text.annotation.added`: a url_citation over the item's text. */
+    annotation?: {
+        type?: string;
+        url?: string;
+        title?: string;
+        start_index?: number;
+        end_index?: number;
+    };
     /** error event fields. */
     code?: string | null;
     message?: string;

package/dist/anthropic-responses-translate.js

@@ -288,7 +288,7 @@ function translateAssistantBlocks(blocks) {
         out.push(call);
     return out;
 }
-function translateToolChoice(choice) {
+function translateToolChoice(choice, webSearchName) {
     if (!choice || typeof choice !== 'object')
         return undefined;
     switch (choice.type) {
@@ -299,7 +299,12 @@ function translateToolChoice(choice) {
         case 'any':
             return 'required';
         case 'tool':
-            // Responses forced form is FLATTENED: {type:'function', name}.
+            // Responses forced form is FLATTENED: {type:'function', name}. Forcing
+            // the hosted web search is its own shape — `{type:'function', name:
+            // 'web_search'}` names a function the request never declared and the
+            // backend 400s ("Tool choice 'function' not found in 'tools'").
+            if (typeof choice.name === 'string' && choice.name === webSearchName)
+                return { type: 'web_search' };
             return typeof choice.name === 'string'
                 ? { type: 'function', name: choice.name }
                 : 'required';
@@ -361,11 +366,37 @@ export function anthropicToResponsesRequest(body, targetModel, options = {}) {
     const instructions = flattenSystem(body.system);
     if (instructions.length > 0)
         out.instructions = instructions;
+    // The client's name for the hosted web search, once one is declared, so a
+    // forced tool_choice on it translates to the hosted-tool choice.
+    let webSearchName;
     if (Array.isArray(body.tools)) {
         const tools = [];
+        let webSearch = false;
         for (const tool of body.tools) {
             if (!tool || typeof tool.name !== 'string')
                 continue;
+            // Anthropic's hosted web search → the backend's hosted web search. The
+            // two options both sides speak travel; the rest is dropped. Asking for
+            // `action.sources` is what lets the result block name the pages it
+            // searched rather than come back empty.
+            const t = tool;
+            if (typeof t.type === 'string' && t.type.startsWith('web_search') && !webSearch) {
+                webSearch = true;
+                webSearchName = tool.name;
+                const ws = { type: 'web_search' };
+                if (Array.isArray(t.allowed_domains) && t.allowed_domains.length > 0)
+                    ws.filters = { allowed_domains: t.allowed_domains.filter((d) => typeof d === 'string') };
+                const loc = t.user_location;
+                if (loc && typeof loc === 'object') {
+                    const l = { type: 'approximate' };
+                    for (const k of ['city', 'region', 'country', 'timezone'])
+                        if (typeof loc[k] === 'string')
+                            l[k] = loc[k];
+                    ws.user_location = l;
+                }
+                tools.push(ws);
+                continue;
+            }
             if (!tool.input_schema || typeof tool.input_schema !== 'object')
                 continue;
             const fn = {
@@ -379,8 +410,10 @@ export function anthropicToResponsesRequest(body, targetModel, options = {}) {
         }
         if (tools.length > 0)
             out.tools = tools;
+        if (webSearch)
+            out.include = ['web_search_call.action.sources'];
     }
-    const toolChoice = translateToolChoice(body.tool_choice);
+    const toolChoice = translateToolChoice(body.tool_choice, webSearchName);
     if (toolChoice !== undefined && out.tools)
         out.tool_choice = toolChoice;
     if (body.tool_choice?.disable_parallel_tool_use === true && out.tools) {
@@ -579,6 +612,10 @@ export function responsesStreamToAnthropicSSE(options = {}) {
     const blockByOutputIndex = new Map();
     let sawToolCall = false;
     let syntheticToolSeq = 0;
+    /** Text streamed per message item, so a url_citation's indices can be turned into cited_text. */
+    const textByOutputIndex = new Map();
+    /** server_tool_use ids per web_search_call output index, for the result block. */
+    const searchIdByOutputIndex = new Map();
     function ensureStarted(event, events) {
         if (started)
             return;
@@ -620,6 +657,46 @@ export function responsesStreamToAnthropicSSE(options = {}) {
         });
         return index;
     }
+    /**
+     * A hosted web-search step: a `server_tool_use` block opened at
+     * output_item.added, its input (query or url) written at output_item.done
+     * when the backend reveals the action, then a `web_search_tool_result`
+     * block listing the pages the step touched — the searched sources when the
+     * request asked for them, the opened page otherwise.
+     */
+    function openSearchBlock(item, outputIndex, events) {
+        const index = nextIndex++;
+        open = { kind: 'search', index, outputIndex };
+        blockByOutputIndex.set(outputIndex, { kind: 'search', index });
+        const id = strOr(item?.id) || `srvtoolu_responses_${syntheticToolSeq++}`;
+        searchIdByOutputIndex.set(outputIndex, id);
+        events.push({ type: 'content_block_start', index, content_block: { type: 'server_tool_use', id, name: 'web_search', input: {} } });
+        return index;
+    }
+    function finishSearchBlock(item, outputIndex, events) {
+        const ws = (item ?? {});
+        const action = ws.action ?? {};
+        const input = action.type === 'search' || action.query
+            ? { query: strOr(action.query) || (Array.isArray(action.queries) ? strOr(action.queries[0]) : '') }
+            : action.url ? { url: strOr(action.url), ...(action.pattern ? { pattern: strOr(action.pattern) } : {}) } : {};
+        const blk = blockByOutputIndex.get(outputIndex);
+        if (blk && blk.kind === 'search') {
+            events.push({ type: 'content_block_delta', index: blk.index, delta: { type: 'input_json_delta', partial_json: JSON.stringify(input) } });
+        }
+        closeOpenBlock(events);
+        const results = [];
+        const seen = new Set();
+        const urls = Array.isArray(action.sources) ? action.sources.map((s) => strOr(s?.url)).filter(Boolean) : action.url ? [strOr(action.url)] : [];
+        for (const url of urls) {
+            if (seen.has(url))
+                continue;
+            seen.add(url);
+            results.push({ type: 'web_search_result', url, title: '', encrypted_content: '', page_age: null });
+        }
+        const index = nextIndex++;
+        events.push({ type: 'content_block_start', index, content_block: { type: 'web_search_tool_result', tool_use_id: searchIdByOutputIndex.get(outputIndex) ?? '', content: results } });
+        events.push({ type: 'content_block_stop', index });
+    }
     function openThinkingBlock(outputIndex, events) {
         const index = nextIndex++;
         open = { kind: 'thinking', index, outputIndex };
@@ -719,12 +796,16 @@ export function responsesStreamToAnthropicSSE(options = {}) {
                         openToolBlock(event.item, outputIndex, events);
                     else if (itemType === 'reasoning')
                         openThinkingBlock(outputIndex, events);
+                    else if (itemType === 'web_search_call')
+                        openSearchBlock(event.item, outputIndex, events);
                     // message → nothing; the text block opens on the first delta.
                     break;
                 }
                 case 'response.output_text.delta': {
                     if (typeof event.delta === 'string' && event.delta.length > 0) {
-                        const index = ensureTextBlock(numOr(event.output_index, 0), events);
+                        const oi = numOr(event.output_index, 0);
+                        const index = ensureTextBlock(oi, events);
+                        textByOutputIndex.set(oi, (textByOutputIndex.get(oi) ?? '') + event.delta);
                         events.push({
                             type: 'content_block_delta',
                             index,
@@ -733,6 +814,24 @@ export function responsesStreamToAnthropicSSE(options = {}) {
                     }
                     break;
                 }
+                case 'response.output_text.annotation.added': {
+                    // A url_citation over the message text → a citation on the text
+                    // block, with the cited span cut from what has streamed so far.
+                    const a = event.annotation;
+                    if (a && a.type === 'url_citation' && typeof a.url === 'string') {
+                        const oi = numOr(event.output_index, 0);
+                        const index = ensureTextBlock(oi, events);
+                        const text = textByOutputIndex.get(oi) ?? '';
+                        const from = numOr(a.start_index, 0);
+                        const to = numOr(a.end_index, from);
+                        events.push({
+                            type: 'content_block_delta',
+                            index,
+                            delta: { type: 'citations_delta', citation: { type: 'web_search_result_location', url: a.url, title: strOr(a.title), cited_text: text.slice(Math.max(0, from), Math.max(from, to)), encrypted_index: '' } },
+                        });
+                    }
+                    break;
+                }
                 case 'response.function_call_arguments.delta': {
                     if (typeof event.delta === 'string' && event.delta.length > 0) {
                         const index = resolveBlock(numOr(event.output_index, 0), 'tool', events);
@@ -758,6 +857,11 @@ export function responsesStreamToAnthropicSSE(options = {}) {
                 }
                 case 'response.output_item.done': {
                     const outputIndex = numOr(event.output_index, 0);
+                    const itemType = event.item && typeof event.item === 'object' ? event.item.type : undefined;
+                    if (itemType === 'web_search_call') {
+                        finishSearchBlock(event.item, outputIndex, events);
+                        break;
+                    }
                     if (open && open.outputIndex === outputIndex)
                         closeOpenBlock(events);
                     break;
@@ -861,7 +965,7 @@ export function createAnthropicMessageAssembler() {
                 }
                 else if (e.type === 'content_block_start') {
                     blocks[e.index] = { ...e.content_block };
-                    if (e.content_block.type === 'tool_use')
+                    if (e.content_block.type === 'tool_use' || e.content_block.type === 'server_tool_use')
                         partialJson.set(e.index, '');
                 }
                 else if (e.type === 'content_block_delta') {
@@ -873,6 +977,8 @@ export function createAnthropicMessageAssembler() {
                         b.thinking = String(b.thinking ?? '') + d.thinking;
                     else if (d.type === 'input_json_delta')
                         partialJson.set(e.index, (partialJson.get(e.index) ?? '') + d.partial_json);
+                    else if (d.type === 'citations_delta')
+                        (b.citations = (Array.isArray(b.citations) ? b.citations : [])).push(d.citation);
                 }
                 else if (e.type === 'message_delta') {
                     if (msg) {
@@ -894,7 +1000,7 @@ export function createAnthropicMessageAssembler() {
         message(fallbackModel) {
             for (const [i, raw] of partialJson) {
                 const b = blocks[i];
-                if (!b || b.type !== 'tool_use')
+                if (!b || (b.type !== 'tool_use' && b.type !== 'server_tool_use'))
                     continue;
                 b.input = safeParseArguments(raw);
             }

package/dist/codex-backend.js

@@ -717,6 +717,9 @@ export function createResponsesTranslator(model) {
 export const CODEX_SUPPORTED_FIELDS = [
     'model', 'input', 'stream', 'store', 'instructions',
     'tools', 'tool_choice', 'parallel_tool_calls', 'reasoning',
+    // `web_search_call.action.sources` (v6.4): accepted by the backend, probed
+    // 2026-09-12 — the searched URLs the Anthropic result block lists.
+    'include',
     // Sent by the Codex CLI on every request (codex-rs ResponsesApiRequest), so
     // accepted by construction; see codexPromptCacheKey.
     'prompt_cache_key',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.3.0",
+  "version": "6.4.0",
   "description": "Use your Claude and ChatGPT subscriptions in Cursor, Cline, Aider, Claude Code and the Agent SDK — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint: either plan answers either wire shape, with automatic failover when one hits its limit.",
   "type": "module",
   "bin": {