@fgv/ts-extras 5.1.0-16 → 5.1.0-17

package/lib/packlets/ai-assist/registry.d.ts

@@ -3,7 +3,7 @@
  * @packageDocumentation
  */
 import { Result } from '@fgv/ts-utils';
-import { type AiProviderId, type IAiProviderDescriptor } from './model';
+import { type AiProviderId, type IAiModelCapabilityConfig, type IAiProviderDescriptor } from './model';
 /**
  * All valid provider ID values, in the same order as the registry.
  * @public
@@ -22,4 +22,13 @@ export declare function getProviderDescriptors(): ReadonlyArray<IAiProviderDescr
  * @public
  */
 export declare function getProviderDescriptor(id: string): Result<IAiProviderDescriptor>;
+/**
+ * Default capability config used by `callProviderListModels` when callers
+ * don't supply their own. Patterns are intentionally narrow — false
+ * positives are worse than missing a model. Caller can override per call
+ * via {@link IProviderListModelsParams.capabilityConfig}.
+ *
+ * @public
+ */
+export declare const DEFAULT_MODEL_CAPABILITY_CONFIG: IAiModelCapabilityConfig;
 //# sourceMappingURL=registry.d.ts.map

package/lib/packlets/ai-assist/registry.js

@@ -19,7 +19,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.allProviderIds = void 0;
+exports.DEFAULT_MODEL_CAPABILITY_CONFIG = exports.allProviderIds = void 0;
 exports.getProviderDescriptors = getProviderDescriptors;
 exports.getProviderDescriptor = getProviderDescriptor;
 /**
@@ -44,7 +44,9 @@ const BUILTIN_PROVIDERS = [
         baseUrl: '',
         defaultModel: '',
         supportedTools: [],
-        corsRestricted: false
+        corsRestricted: false,
+        streamingCorsRestricted: false,
+        acceptsImageInput: false
     },
     {
         id: 'anthropic',
@@ -55,7 +57,9 @@ const BUILTIN_PROVIDERS = [
         baseUrl: 'https://api.anthropic.com/v1',
         defaultModel: 'claude-sonnet-4-5-20250929',
         supportedTools: ['web_search'],
-        corsRestricted: false
+        corsRestricted: false,
+        streamingCorsRestricted: false,
+        acceptsImageInput: true
     },
     {
         id: 'google-gemini',
@@ -64,9 +68,12 @@ const BUILTIN_PROVIDERS = [
         needsSecret: true,
         apiFormat: 'gemini',
         baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
-        defaultModel: 'gemini-2.5-flash',
+        defaultModel: { base: 'gemini-2.5-flash', image: 'imagen-3.0-generate-002' },
         supportedTools: ['web_search'],
-        corsRestricted: false
+        corsRestricted: false,
+        streamingCorsRestricted: false,
+        acceptsImageInput: true,
+        imageApiFormat: 'gemini-imagen'
     },
     {
         id: 'groq',
@@ -77,7 +84,9 @@ const BUILTIN_PROVIDERS = [
         baseUrl: 'https://api.groq.com/openai/v1',
         defaultModel: 'llama-3.3-70b-versatile',
         supportedTools: [],
-        corsRestricted: false
+        corsRestricted: false,
+        streamingCorsRestricted: false,
+        acceptsImageInput: false
     },
     {
         id: 'mistral',
@@ -88,7 +97,9 @@ const BUILTIN_PROVIDERS = [
         baseUrl: 'https://api.mistral.ai/v1',
         defaultModel: 'mistral-large-latest',
         supportedTools: [],
-        corsRestricted: false
+        corsRestricted: false,
+        streamingCorsRestricted: false,
+        acceptsImageInput: false
     },
     {
         id: 'openai',
@@ -97,9 +108,12 @@ const BUILTIN_PROVIDERS = [
         needsSecret: true,
         apiFormat: 'openai',
         baseUrl: 'https://api.openai.com/v1',
-        defaultModel: 'gpt-4o',
+        defaultModel: { base: 'gpt-4o', image: 'dall-e-3' },
         supportedTools: ['web_search'],
-        corsRestricted: false
+        corsRestricted: false,
+        streamingCorsRestricted: false,
+        acceptsImageInput: true,
+        imageApiFormat: 'openai-images'
     },
     {
         id: 'xai-grok',
@@ -108,9 +122,16 @@ const BUILTIN_PROVIDERS = [
         needsSecret: true,
         apiFormat: 'openai',
         baseUrl: 'https://api.x.ai/v1',
-        defaultModel: { base: 'grok-4-1-fast', tools: 'grok-4-1-fast-reasoning' },
+        defaultModel: {
+            base: 'grok-4-1-fast',
+            tools: 'grok-4-1-fast-reasoning',
+            image: 'grok-2-image-1212'
+        },
         supportedTools: ['web_search'],
-        corsRestricted: true
+        corsRestricted: true,
+        streamingCorsRestricted: true,
+        acceptsImageInput: true,
+        imageApiFormat: 'xai-images'
     }
 ];
 /**
@@ -147,4 +168,39 @@ function getProviderDescriptor(id) {
     }
     return (0, ts_utils_1.succeed)(descriptor);
 }
+// ============================================================================
+// Default model capability config
+// ============================================================================
+/**
+ * Default capability config used by `callProviderListModels` when callers
+ * don't supply their own. Patterns are intentionally narrow — false
+ * positives are worse than missing a model. Caller can override per call
+ * via {@link IProviderListModelsParams.capabilityConfig}.
+ *
+ * @public
+ */
+exports.DEFAULT_MODEL_CAPABILITY_CONFIG = {
+    perProvider: {
+        openai: [
+            { idPattern: /^dall-e/, capabilities: ['image-generation'] },
+            { idPattern: /^gpt-image/, capabilities: ['image-generation'] },
+            { idPattern: /^gpt-4/, capabilities: ['chat', 'tools', 'vision'] },
+            { idPattern: /^gpt-3\.5/, capabilities: ['chat'] },
+            { idPattern: /^o\d/, capabilities: ['chat', 'tools'] }
+        ],
+        'xai-grok': [
+            { idPattern: /-image/, capabilities: ['image-generation'] },
+            { idPattern: /^grok-4/, capabilities: ['chat', 'tools', 'vision'] },
+            { idPattern: /^grok-3/, capabilities: ['chat', 'tools'] },
+            { idPattern: /^grok-2/, capabilities: ['chat', 'vision'] }
+        ],
+        'google-gemini': [
+            { idPattern: /^imagen/, capabilities: ['image-generation'] },
+            { idPattern: /^gemini-/, capabilities: ['chat', 'tools', 'vision'] }
+        ],
+        anthropic: [{ idPattern: /^claude-/, capabilities: ['chat', 'tools', 'vision'] }],
+        groq: [{ idPattern: /./, capabilities: ['chat'] }],
+        mistral: [{ idPattern: /./, capabilities: ['chat'] }]
+    }
+};
 //# sourceMappingURL=registry.js.map

package/lib/packlets/ai-assist/sseParser.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Server-Sent Events (SSE) parser primitives shared by the streaming format
+ * adapters in `streamingClient.ts`. Implements the subset of the SSE wire
+ * format that LLM providers actually emit: optional `event:` line, one or
+ * more `data:` lines per message, messages separated by a blank line.
+ *
+ * @packageDocumentation
+ */
+/**
+ * One parsed SSE message (the SSE spec calls each blank-line-terminated
+ * record an "event").
+ *
+ * @internal
+ */
+export interface ISseEvent {
+    /** The `event:` field, if present (some providers omit it). */
+    readonly event?: string;
+    /** Concatenated contents of the message's `data:` lines. */
+    readonly data: string;
+}
+/**
+ * Parses a single SSE message (the text between blank-line separators) into
+ * an {@link ISseEvent}. Returns undefined for messages with no `data:` lines
+ * (comments, heartbeats).
+ *
+ * @internal
+ */
+export declare function parseSseEvent(chunk: string): ISseEvent | undefined;
+/**
+ * Reads an SSE response body and yields parsed events. Buffers across read()
+ * boundaries so a message split mid-chunk still parses cleanly. Terminates
+ * when the stream closes (normal EOF or aborted fetch).
+ *
+ * @internal
+ */
+export declare function readSseEvents(body: ReadableStream<Uint8Array>): AsyncGenerator<ISseEvent>;
+/**
+ * Parses the `data` payload of an SSE event as JSON. Returns undefined for
+ * the OpenAI `[DONE]` sentinel and for any payload that fails to parse —
+ * adapters treat both as "skip this event."
+ *
+ * @internal
+ */
+export declare function parseSseEventJson(data: string): unknown | undefined;
+//# sourceMappingURL=sseParser.d.ts.map

package/lib/packlets/ai-assist/sseParser.js

@@ -0,0 +1,127 @@
+"use strict";
+// Copyright (c) 2026 Erik Fortune
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSseEvent = parseSseEvent;
+exports.readSseEvents = readSseEvents;
+exports.parseSseEventJson = parseSseEventJson;
+/**
+ * Parses a single SSE message (the text between blank-line separators) into
+ * an {@link ISseEvent}. Returns undefined for messages with no `data:` lines
+ * (comments, heartbeats).
+ *
+ * @internal
+ */
+function parseSseEvent(chunk) {
+    let event;
+    const dataLines = [];
+    for (const line of chunk.split('\n')) {
+        if (line.startsWith('event:')) {
+            event = line.slice(6).trim();
+        }
+        else if (line.startsWith('data:')) {
+            // Per the SSE spec the value starts after the colon, with one optional leading space stripped.
+            const value = line.slice(5);
+            dataLines.push(value.startsWith(' ') ? value.slice(1) : value);
+        }
+    }
+    if (dataLines.length === 0) {
+        return undefined;
+    }
+    return event !== undefined ? { event, data: dataLines.join('\n') } : { data: dataLines.join('\n') };
+}
+/**
+ * Reads an SSE response body and yields parsed events. Buffers across read()
+ * boundaries so a message split mid-chunk still parses cleanly. Terminates
+ * when the stream closes (normal EOF or aborted fetch).
+ *
+ * @internal
+ */
+function readSseEvents(body) {
+    return __asyncGenerator(this, arguments, function* readSseEvents_1() {
+        var _a;
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            let streaming = true;
+            while (streaming) {
+                const { value, done } = yield __await(reader.read());
+                if (done) {
+                    streaming = false;
+                    if (buffer.length > 0) {
+                        const tail = parseSseEvent(buffer.replace(/\r\n/g, '\n'));
+                        if (tail) {
+                            yield yield __await(tail);
+                        }
+                    }
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                // SSE messages are separated by a blank line; some servers use \r\n.
+                const normalized = buffer.replace(/\r\n/g, '\n');
+                const parts = normalized.split('\n\n');
+                // Last element is the partial chunk (no terminating blank line yet); buffer it.
+                buffer = (_a = parts.pop()) !== null && _a !== void 0 ? _a : '';
+                for (const chunk of parts) {
+                    const event = parseSseEvent(chunk);
+                    if (event) {
+                        yield yield __await(event);
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    });
+}
+/**
+ * Parses the `data` payload of an SSE event as JSON. Returns undefined for
+ * the OpenAI `[DONE]` sentinel and for any payload that fails to parse —
+ * adapters treat both as "skip this event."
+ *
+ * @internal
+ */
+function parseSseEventJson(data) {
+    if (data === '[DONE]') {
+        return undefined;
+    }
+    try {
+        return JSON.parse(data);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+//# sourceMappingURL=sseParser.js.map

package/lib/packlets/ai-assist/streamingAdapters/anthropic.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Streaming adapter for the Anthropic Messages API. Surfaces server tool
+ * use (e.g. `web_search`) as unified `tool-event` markers based on the
+ * `content_block_start` / `content_block_stop` lifecycle.
+ *
+ * @packageDocumentation
+ */
+import { type Logging, Result } from '@fgv/ts-utils';
+import { AiPrompt, type AiServerToolConfig, type IAiStreamEvent, type IChatMessage } from '../model';
+import { IStreamApiConfig } from './common';
+/**
+ * Issues a streaming Anthropic Messages request and returns the
+ * unified-event iterable on success.
+ *
+ * @internal
+ */
+export declare function callAnthropicStream(config: IStreamApiConfig, prompt: AiPrompt, messagesBefore: ReadonlyArray<IChatMessage> | undefined, temperature: number, tools: ReadonlyArray<AiServerToolConfig> | undefined, logger?: Logging.ILogger, signal?: AbortSignal): Promise<Result<AsyncIterable<IAiStreamEvent>>>;
+//# sourceMappingURL=anthropic.d.ts.map

package/lib/packlets/ai-assist/streamingAdapters/anthropic.js

@@ -0,0 +1,195 @@
+"use strict";
+// Copyright (c) 2026 Erik Fortune
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAnthropicStream = callAnthropicStream;
+/**
+ * Streaming adapter for the Anthropic Messages API. Surfaces server tool
+ * use (e.g. `web_search`) as unified `tool-event` markers based on the
+ * `content_block_start` / `content_block_stop` lifecycle.
+ *
+ * @packageDocumentation
+ */
+const ts_utils_1 = require("@fgv/ts-utils");
+const chatRequestBuilders_1 = require("../chatRequestBuilders");
+const sseParser_1 = require("../sseParser");
+const toolFormats_1 = require("../toolFormats");
+const common_1 = require("./common");
+const anthropicContentBlockInner = ts_utils_1.Validators.object({
+    type: ts_utils_1.Validators.string.optional(),
+    name: ts_utils_1.Validators.string.optional()
+}, { options: { optionalFields: ['type', 'name'] } });
+const anthropicContentBlockStartPayload = ts_utils_1.Validators.object({
+    content_block: anthropicContentBlockInner
+});
+const anthropicContentBlockDeltaInner = ts_utils_1.Validators.object({
+    type: ts_utils_1.Validators.string.optional(),
+    text: ts_utils_1.Validators.string.optional()
+}, { options: { optionalFields: ['type', 'text'] } });
+const anthropicContentBlockDeltaPayload = ts_utils_1.Validators.object({
+    delta: anthropicContentBlockDeltaInner
+});
+const anthropicMessageDeltaInner = ts_utils_1.Validators.object({ stop_reason: ts_utils_1.Validators.string.optional() }, { options: { optionalFields: ['stop_reason'] } });
+const anthropicMessageDeltaPayload = ts_utils_1.Validators.object({
+    delta: anthropicMessageDeltaInner
+});
+const anthropicErrorInner = ts_utils_1.Validators.object({ message: ts_utils_1.Validators.string.optional() }, { options: { optionalFields: ['message'] } });
+const anthropicErrorPayload = ts_utils_1.Validators.object({ error: anthropicErrorInner.optional() }, { options: { optionalFields: ['error'] } });
+// ============================================================================
+// Stream translator
+// ============================================================================
+/**
+ * Translates an Anthropic Messages API SSE stream into unified events.
+ *
+ * @internal
+ */
+function translateAnthropicStream(response) {
+    return __asyncGenerator(this, arguments, function* translateAnthropicStream_1() {
+        var _a, e_1, _b, _c;
+        var _d, _e;
+        let fullText = '';
+        let truncated = false;
+        let stopped = false;
+        try {
+            /* c8 ignore next - body is non-null at this point per openSseConnection */
+            if (!response.body)
+                return yield __await(void 0);
+            try {
+                for (var _f = true, _g = __asyncValues((0, sseParser_1.readSseEvents)(response.body)), _h; _h = yield __await(_g.next()), _a = _h.done, !_a; _f = true) {
+                    _c = _h.value;
+                    _f = false;
+                    const message = _c;
+                    const eventName = message.event;
+                    if (eventName === 'content_block_start') {
+                        const payload = (0, common_1.validateEventPayload)((0, sseParser_1.parseSseEventJson)(message.data), anthropicContentBlockStartPayload);
+                        const block = payload === null || payload === void 0 ? void 0 : payload.content_block;
+                        if ((block === null || block === void 0 ? void 0 : block.type) === 'server_tool_use' && block.name === 'web_search') {
+                            yield yield __await({ type: 'tool-event', toolType: 'web_search', phase: 'started' });
+                        }
+                        else if ((block === null || block === void 0 ? void 0 : block.type) === 'web_search_tool_result') {
+                            yield yield __await({ type: 'tool-event', toolType: 'web_search', phase: 'completed' });
+                        }
+                    }
+                    else if (eventName === 'content_block_delta') {
+                        const payload = (0, common_1.validateEventPayload)((0, sseParser_1.parseSseEventJson)(message.data), anthropicContentBlockDeltaPayload);
+                        if ((payload === null || payload === void 0 ? void 0 : payload.delta.type) === 'text_delta' && typeof payload.delta.text === 'string') {
+                            const delta = payload.delta.text;
+                            if (delta.length > 0) {
+                                fullText += delta;
+                                yield yield __await({ type: 'text-delta', delta });
+                            }
+                        }
+                    }
+                    else if (eventName === 'message_delta') {
+                        const payload = (0, common_1.validateEventPayload)((0, sseParser_1.parseSseEventJson)(message.data), anthropicMessageDeltaPayload);
+                        if ((payload === null || payload === void 0 ? void 0 : payload.delta.stop_reason) === 'max_tokens') {
+                            truncated = true;
+                        }
+                    }
+                    else if (eventName === 'message_stop') {
+                        stopped = true;
+                    }
+                    else if (eventName === 'error') {
+                        const payload = (0, common_1.validateEventPayload)((0, sseParser_1.parseSseEventJson)(message.data), anthropicErrorPayload);
+                        yield yield __await({
+                            type: 'error',
+                            message: (_e = (_d = payload === null || payload === void 0 ? void 0 : payload.error) === null || _d === void 0 ? void 0 : _d.message) !== null && _e !== void 0 ? _e : 'Anthropic stream returned an error event'
+                        });
+                        return yield __await(void 0);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_f && !_a && (_b = _g.return)) yield __await(_b.call(_g));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        catch (err) {
+            yield yield __await({ type: 'error', message: err instanceof Error ? err.message : String(err) });
+            return yield __await(void 0);
+        }
+        if (stopped) {
+            yield yield __await({ type: 'done', truncated, fullText });
+        }
+        else {
+            yield yield __await({ type: 'error', message: 'Anthropic stream ended without a message_stop event' });
+        }
+    });
+}
+// ============================================================================
+// Per-format request caller
+// ============================================================================
+/**
+ * Issues a streaming Anthropic Messages request and returns the
+ * unified-event iterable on success.
+ *
+ * @internal
+ */
+async function callAnthropicStream(config, prompt, messagesBefore, temperature, tools, logger, signal) {
+    const url = `${config.baseUrl}/messages`;
+    const messages = (0, chatRequestBuilders_1.buildAnthropicMessages)(prompt, { head: messagesBefore });
+    const body = {
+        model: config.model,
+        system: prompt.system,
+        messages,
+        max_tokens: 4096,
+        temperature,
+        stream: true
+    };
+    if (tools && tools.length > 0) {
+        body.tools = (0, toolFormats_1.toAnthropicTools)(tools);
+    }
+    const headers = {
+        'x-api-key': config.apiKey,
+        'anthropic-version': '2023-06-01',
+        'anthropic-dangerous-direct-browser-access': 'true'
+    };
+    /* c8 ignore next 3 - optional logger diagnostic output */
+    if (logger) {
+        const toolTypes = tools && tools.length > 0 ? tools.map((t) => t.type).join(',') : 'none';
+        logger.info(`Anthropic streaming: model=${config.model}, tools=${toolTypes}`);
+    }
+    const conn = await (0, common_1.openSseConnection)(url, headers, body, logger, signal);
+    return conn.onSuccess((response) => (0, ts_utils_1.succeed)(translateAnthropicStream(response)));
+}
+//# sourceMappingURL=anthropic.js.map

package/lib/packlets/ai-assist/streamingAdapters/common.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Shared infrastructure for the per-format streaming adapters: HTTP connection
+ * helper, common config and request-params types, and a typed-validation
+ * helper for SSE event payloads.
+ *
+ * @packageDocumentation
+ */
+import { type Logging, Result, type Validator } from '@fgv/ts-utils';
+import { AiPrompt, type AiServerToolConfig, type IAiProviderDescriptor, type IChatMessage, type ModelSpec } from '../model';
+/**
+ * Parameters for a streaming completion request. Structurally identical to
+ * the non-streaming `IProviderCompletionParams`; kept as its own interface
+ * so callers can be explicit about which path they're invoking.
+ *
+ * @public
+ */
+export interface IProviderCompletionStreamParams {
+    /** The provider descriptor */
+    readonly descriptor: IAiProviderDescriptor;
+    /** API key for authentication */
+    readonly apiKey: string;
+    /** The structured prompt to send */
+    readonly prompt: AiPrompt;
+    /**
+     * Prior conversation history to insert between the system prompt and the
+     * prompt's user message. The new user turn (carried by `prompt.user`) is
+     * always sent last, so the wire shape becomes
+     * `[system, ...messagesBefore, user=prompt.user]`.
+     */
+    readonly messagesBefore?: ReadonlyArray<IChatMessage>;
+    /** Sampling temperature (default: 0.7) */
+    readonly temperature?: number;
+    /** Optional model override — string or context-aware map. */
+    readonly modelOverride?: ModelSpec;
+    /** Optional logger for request/response observability. */
+    readonly logger?: Logging.ILogger;
+    /** Server-side tools to include in the request. */
+    readonly tools?: ReadonlyArray<AiServerToolConfig>;
+    /** Optional abort signal for cancelling the in-flight stream. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Configuration for a single per-format streaming call: where to POST, what
+ * key to authenticate with, and which model to request.
+ *
+ * @internal
+ */
+export interface IStreamApiConfig {
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly model: string;
+}
+/**
+ * Opens an SSE-style POST connection. Returns the underlying Response on a
+ * 2xx; failures (network, non-2xx, missing body) surface as Result.fail
+ * carrying the body text.
+ *
+ * @internal
+ */
+export declare function openSseConnection(url: string, headers: Record<string, string>, body: unknown, logger?: Logging.ILogger, signal?: AbortSignal): Promise<Result<Response>>;
+/**
+ * Validates a parsed SSE event payload against a typed shape, returning the
+ * validated value or `undefined` if validation fails. Adapters use the
+ * `undefined` return to skip unrecognized event shapes — the same lenient
+ * behavior the inline casts had, but with a real type-checked path on the
+ * happy case.
+ *
+ * @internal
+ */
+export declare function validateEventPayload<T>(json: unknown, validator: Validator<T>): T | undefined;
+//# sourceMappingURL=common.d.ts.map