@qorejs/qore 0.7.1 → 0.7.2

package/dist/src/providers/openai.js

@@ -0,0 +1,96 @@
+import { createSSEAdapter, readEnv } from './sse.js';
+const DEFAULT_BASE_URL = 'https://api.openai.com/v1';
+const DEFAULT_MODEL = 'gpt-5';
+// Treat plain chat text as one user message so callers can start from a single string.
+function normalizeChatInput(input) {
+    if (typeof input === 'string') {
+        return [{ role: 'user', content: input }];
+    }
+    if (Array.isArray(input)) {
+        return input;
+    }
+    if (input && typeof input === 'object' && 'role' in input) {
+        return [input];
+    }
+    return input;
+}
+// Keep provider setup explicit because real API keys should stay off the client.
+export function createOpenAI(options = {}) {
+    const { apiKey, baseURL = DEFAULT_BASE_URL, model = DEFAULT_MODEL, headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch } = options;
+    const resolvedApiKey = apiKey ?? readEnv('OPENAI_API_KEY');
+    if (!resolvedApiKey) {
+        throw new Error('Qore OpenAI adapter requires an API key. Pass apiKey or set OPENAI_API_KEY.');
+    }
+    const transport = createSSEAdapter({
+        name: 'OpenAI',
+        url: `${baseURL}/responses`,
+        headers: {
+            Authorization: `Bearer ${resolvedApiKey}`,
+            'Content-Type': 'application/json',
+            ...defaultHeaders
+        },
+        fetch: fetchImpl,
+        buildRequest(request, requestOptions = {}) {
+            const { signal, headers = {}, ...overrides } = requestOptions;
+            const config = {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    model,
+                    stream: true,
+                    ...request,
+                    ...overrides
+                })
+            };
+            if (signal) {
+                config.signal = signal;
+            }
+            return config;
+        },
+        parse: (data) => JSON.parse(data),
+        isError: (event) => event.data?.type === 'error',
+        getError: (event) => {
+            const errorEvent = event.data;
+            return errorEvent.error?.message ?? 'OpenAI streaming error';
+        },
+        eventToText: (event) => event.data?.type === 'response.output_text.delta'
+            && typeof event.data.delta === 'string'
+            ? event.data.delta
+            : undefined
+    });
+    async function* streamEvents(request, requestOptions = {}) {
+        for await (const event of transport.stream(request, requestOptions)) {
+            yield event.data;
+        }
+    }
+    async function* streamText(input, requestOptions = {}) {
+        const request = input && typeof input === 'object' && 'input' in input
+            ? input
+            : { input };
+        for await (const chunk of transport.streamText(request, requestOptions)) {
+            yield chunk;
+        }
+    }
+    return {
+        // Stream typed semantic events from the Responses API.
+        responses: {
+            stream: streamEvents
+        },
+        // Stream only text deltas for the common chat-response case.
+        streamText(input, requestOptions = {}) {
+            return streamText(input, requestOptions);
+        },
+        // Match the Qore narrative directly: stream(openai.chat(prompt)).
+        chat(input, requestOptions = {}) {
+            const { signal, headers, ...rest } = requestOptions;
+            const request = { ...rest };
+            if (!('input' in request)) {
+                request.input = normalizeChatInput(input);
+            }
+            return streamText(request, {
+                ...(signal ? { signal } : {}),
+                ...(headers ? { headers } : {})
+            });
+        }
+    };
+}

package/dist/src/providers/sse-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { SSEAdapter, SSEAdapterOptions } from './types.js';
+export declare function createSSEAdapter<TRequest = Record<string, unknown>, TChatInput = unknown, TData = unknown>(options?: SSEAdapterOptions<TRequest, TChatInput, TData>): SSEAdapter<TRequest, TChatInput, TData>;

package/dist/src/providers/sse-adapter.js

@@ -0,0 +1,83 @@
+import { normalizeError } from '../shared/utils.js';
+import { mergeHeaders, readErrorBody } from './sse-env.js';
+import { getErrorMessage, isErrorEvent, parseEventData, readSSE } from './sse-parser.js';
+function isRequestConfig(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+// Expose a generic SSE adapter so Qore can integrate with any token-streaming endpoint.
+export function createSSEAdapter(options = {}) {
+    const { name = 'SSE', url: defaultURL, method: defaultMethod = 'POST', headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch, buildRequest = null, buildChatRequest = null, parse = parseEventData, isError = isErrorEvent, getError = getErrorMessage, eventToText = (event) => typeof event.data === 'string' ? event.data : undefined } = options;
+    if (typeof fetchImpl !== 'function') {
+        throw new Error(`Qore ${name} adapter requires fetch in the current runtime`);
+    }
+    async function* stream(request = {}, requestOptions = {}) {
+        const builtRequest = buildRequest
+            ? await buildRequest(request, requestOptions)
+            : request;
+        const requestConfig = isRequestConfig(builtRequest)
+            ? builtRequest
+            : { body: builtRequest };
+        const { url = defaultURL, method = defaultMethod, headers: requestHeaders = {}, signal: requestSignal, ...init } = requestConfig;
+        const { signal: overrideSignal, headers: overrideHeaders = {} } = requestOptions;
+        const signal = requestSignal ?? overrideSignal;
+        if (!url) {
+            throw new Error(`Qore ${name} adapter requires a request URL`);
+        }
+        const initConfig = {
+            method,
+            headers: mergeHeaders(defaultHeaders, mergeHeaders(requestHeaders, overrideHeaders)),
+            ...init
+        };
+        if (signal) {
+            initConfig.signal = signal;
+        }
+        const response = await fetchImpl(url, initConfig);
+        if (!response.ok) {
+            throw new Error(await readErrorBody(response));
+        }
+        if (!response.body) {
+            throw new Error(`${name} streaming response did not include a readable body`);
+        }
+        for await (const rawEvent of readSSE(response.body)) {
+            if (!rawEvent.data || rawEvent.data === '[DONE]') {
+                continue;
+            }
+            let parsedEvent;
+            try {
+                parsedEvent = await parse(rawEvent.data, rawEvent);
+            }
+            catch (error) {
+                throw normalizeError(error);
+            }
+            const nextEvent = {
+                ...rawEvent,
+                data: parsedEvent
+            };
+            if (await isError(nextEvent)) {
+                throw new Error(await getError(nextEvent, name));
+            }
+            yield nextEvent;
+        }
+    }
+    async function* streamText(request = {}, requestOptions = {}) {
+        for await (const event of stream(request, requestOptions)) {
+            const nextText = await eventToText(event, request, requestOptions);
+            if (typeof nextText === 'string') {
+                yield nextText;
+            }
+        }
+    }
+    return {
+        // Stream parsed SSE events from an arbitrary HTTP endpoint.
+        stream,
+        // Stream only the text payload selected by the adapter's eventToText mapping.
+        streamText,
+        // Offer the same narrative shape as provider SDKs when buildChatRequest is supplied.
+        chat(input, requestOptions = {}) {
+            if (typeof buildChatRequest !== 'function') {
+                throw new Error(`Qore ${name} adapter does not define chat(). Use stream() or streamText() instead.`);
+            }
+            return streamText(buildChatRequest(input, requestOptions), requestOptions);
+        }
+    };
+}

package/dist/src/providers/sse-env.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderHeaders } from './types.js';
+export declare function readEnv(name: string): string | undefined;
+export declare function readErrorBody(response: Response): Promise<string>;
+export declare function mergeHeaders(baseHeaders?: ProviderHeaders, nextHeaders?: ProviderHeaders): ProviderHeaders;

package/dist/src/providers/sse-env.js

@@ -0,0 +1,33 @@
+// Read environment variables without assuming a Node-only runtime.
+export function readEnv(name) {
+    return typeof process !== 'undefined' && process?.env
+        ? process.env[name]
+        : undefined;
+}
+// Read one JSON or text error body so adapter failures surface clearly.
+export async function readErrorBody(response) {
+    const contentType = response.headers.get('content-type') ?? '';
+    if (contentType.includes('application/json')) {
+        try {
+            const body = await response.json();
+            return body?.error?.message ?? body?.message ?? JSON.stringify(body);
+        }
+        catch {
+            return `${response.status} ${response.statusText}`.trim();
+        }
+    }
+    try {
+        const text = await response.text();
+        return text || `${response.status} ${response.statusText}`.trim();
+    }
+    catch {
+        return `${response.status} ${response.statusText}`.trim();
+    }
+}
+// Merge headers while allowing per-request overrides.
+export function mergeHeaders(baseHeaders = {}, nextHeaders = {}) {
+    return {
+        ...baseHeaders,
+        ...nextHeaders
+    };
+}

package/dist/src/providers/sse-parser.d.ts

@@ -0,0 +1,5 @@
+import type { SSEEvent } from './types.js';
+export declare function readSSE(body: ReadableStream<Uint8Array>): AsyncIterable<SSEEvent<string>>;
+export declare function parseEventData(data: string): unknown;
+export declare function isErrorEvent(event: SSEEvent<unknown>): boolean;
+export declare function getErrorMessage(event: SSEEvent<unknown>, name: string): string;

package/dist/src/providers/sse-parser.js

@@ -0,0 +1,99 @@
+// Parse server-sent events without adding any transport dependency.
+export async function* readSSE(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let eventName = 'message';
+    let eventId = null;
+    let retry = null;
+    let data = [];
+    const flushEvent = () => {
+        if (data.length === 0) {
+            eventName = 'message';
+            eventId = null;
+            retry = null;
+            return null;
+        }
+        const nextEvent = {
+            event: eventName,
+            id: eventId,
+            retry,
+            data: data.join('\n')
+        };
+        eventName = 'message';
+        eventId = null;
+        retry = null;
+        data = [];
+        return nextEvent;
+    };
+    while (true) {
+        const { value, done } = await reader.read();
+        buffer += decoder.decode(value ?? new Uint8Array(), { stream: !done });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            if (!line) {
+                const nextEvent = flushEvent();
+                if (nextEvent) {
+                    yield nextEvent;
+                }
+                continue;
+            }
+            if (line.startsWith(':')) {
+                continue;
+            }
+            const separator = line.indexOf(':');
+            const field = separator === -1 ? line : line.slice(0, separator);
+            const rawValue = separator === -1 ? '' : line.slice(separator + 1).replace(/^ /, '');
+            switch (field) {
+                case 'event':
+                    eventName = rawValue || 'message';
+                    break;
+                case 'data':
+                    data.push(rawValue);
+                    break;
+                case 'id':
+                    eventId = rawValue;
+                    break;
+                case 'retry': {
+                    const parsedRetry = Number.parseInt(rawValue, 10);
+                    retry = Number.isNaN(parsedRetry) ? null : parsedRetry;
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        if (done) {
+            break;
+        }
+    }
+    const finalEvent = flushEvent();
+    if (finalEvent) {
+        yield finalEvent;
+    }
+}
+// Default to JSON payloads when possible, otherwise preserve the raw text event body.
+export function parseEventData(data) {
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return data;
+    }
+}
+// Surface provider-side SSE error objects through one shared fallback.
+export function isErrorEvent(event) {
+    return Boolean(event.data
+        && typeof event.data === 'object'
+        && 'type' in event.data
+        && event.data.type === 'error');
+}
+// Pull a human-readable message from common SSE error shapes.
+export function getErrorMessage(event, name) {
+    if (event.data && typeof event.data === 'object') {
+        const errorRecord = event.data;
+        return errorRecord.error?.message ?? errorRecord.message ?? `${name} streaming error`;
+    }
+    return `${name} streaming error`;
+}

package/dist/src/providers/sse.d.ts

@@ -0,0 +1,4 @@
+export { createSSEAdapter } from './sse-adapter.js';
+export { readEnv, readErrorBody, mergeHeaders } from './sse-env.js';
+export { readSSE, parseEventData, isErrorEvent, getErrorMessage } from './sse-parser.js';
+export type { AnthropicAdapter, AnthropicChatInput, AnthropicEvent, AnthropicMessage, AnthropicOptions, AnthropicRequest, FetchLike, OpenAIAdapter, OpenAIChatInput, OpenAIEvent, OpenAIMessage, OpenAIOptions, OpenAIRequest, ProviderHeaders, ProviderRequestOptions, SSEAdapter, SSEAdapterOptions, SSEEvent, SSERequestConfig } from './types.js';

package/dist/src/providers/sse.js

@@ -0,0 +1,3 @@
+export { createSSEAdapter } from './sse-adapter.js';
+export { readEnv, readErrorBody, mergeHeaders } from './sse-env.js';
+export { readSSE, parseEventData, isErrorEvent, getErrorMessage } from './sse-parser.js';

package/dist/src/providers/types.d.ts

@@ -0,0 +1,94 @@
+import type { GlobalAbortSignal, MaybePromise } from '../core/response.js';
+export type ProviderHeaders = Record<string, string>;
+export interface ProviderRequestOptions {
+    signal?: GlobalAbortSignal;
+    headers?: ProviderHeaders;
+    [key: string]: unknown;
+}
+export interface SSEEvent<TData = unknown> {
+    event: string;
+    id: string | null;
+    retry: number | null;
+    data: TData;
+}
+export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export interface SSERequestConfig {
+    url?: string;
+    method?: string;
+    headers?: ProviderHeaders;
+    signal?: GlobalAbortSignal;
+    body?: BodyInit | null;
+    [key: string]: unknown;
+}
+export interface SSEAdapterOptions<TRequest = Record<string, unknown>, TChatInput = unknown, TData = unknown> {
+    name?: string;
+    url?: string;
+    method?: string;
+    headers?: ProviderHeaders;
+    fetch?: FetchLike;
+    buildRequest?: (request: TRequest, requestOptions?: ProviderRequestOptions) => MaybePromise<TRequest | string | SSERequestConfig>;
+    buildChatRequest?: (input: TChatInput, requestOptions?: ProviderRequestOptions) => TRequest;
+    parse?: (data: string, event: SSEEvent<string>) => MaybePromise<TData>;
+    isError?: (event: SSEEvent<TData>) => MaybePromise<boolean>;
+    getError?: (event: SSEEvent<TData>, name: string) => MaybePromise<string>;
+    eventToText?: (event: SSEEvent<TData>, request: TRequest, requestOptions?: ProviderRequestOptions) => MaybePromise<string | undefined>;
+}
+export interface SSEAdapter<TRequest = Record<string, unknown>, TChatInput = unknown, TData = unknown> {
+    stream(request?: TRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<SSEEvent<TData>>;
+    streamText(request?: TRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+    chat(input: TChatInput, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+}
+export interface OpenAIEvent {
+    type: string;
+    [key: string]: unknown;
+}
+export type OpenAIMessage = Record<string, unknown> & {
+    role?: string;
+    content?: unknown;
+};
+export type OpenAIChatInput = string | OpenAIMessage | OpenAIMessage[] | Record<string, unknown>;
+export type OpenAIRequest = Record<string, unknown> & {
+    input?: OpenAIChatInput;
+};
+export interface OpenAIOptions {
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    headers?: ProviderHeaders;
+    fetch?: FetchLike;
+}
+export interface OpenAIAdapter {
+    responses: {
+        stream(request: OpenAIRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<OpenAIEvent>;
+    };
+    streamText(input: string | OpenAIRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+    chat(input: OpenAIChatInput, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+}
+export interface AnthropicEvent {
+    type: string;
+    [key: string]: unknown;
+}
+export type AnthropicMessage = Record<string, unknown> & {
+    role?: string;
+    content?: unknown;
+};
+export type AnthropicChatInput = string | AnthropicMessage | AnthropicMessage[] | Record<string, unknown>;
+export type AnthropicRequest = Record<string, unknown> & {
+    messages?: AnthropicChatInput;
+};
+export interface AnthropicOptions {
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    version?: string;
+    maxTokens?: number;
+    headers?: ProviderHeaders;
+    fetch?: FetchLike;
+}
+export interface AnthropicAdapter {
+    messages: {
+        stream(request: AnthropicRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<AnthropicEvent>;
+    };
+    streamText(messages: string | AnthropicRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+    chat(input: AnthropicChatInput, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+}

package/dist/src/providers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/shared/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeError(error: unknown): Error;
+export declare function sleep(ms: number, signal?: AbortSignal | null): Promise<void>;

package/dist/src/shared/utils.js

@@ -0,0 +1,32 @@
+// Convert unknown thrown values into Error instances the runtime can reason about.
+export function normalizeError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    if (typeof error === 'string') {
+        return new Error(error);
+    }
+    return new Error('Unknown Qore error');
+}
+// Sleep for a fixed time and reject early if the surrounding operation is aborted.
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            cleanup();
+            reject(normalizeError(signal?.reason ?? 'Operation aborted'));
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+        };
+        if (signal?.aborted) {
+            onAbort();
+            return;
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}

package/package.json

@@ -1,27 +1,36 @@
 {
   "name": "@qorejs/qore",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Qore is a streaming-response framework where stream becomes signal.",
   "type": "module",
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.d.ts",
-      "import": "./src/index.js"
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
     },
     "./package.json": "./package.json"
   },
   "files": [
-    "src",
+    "dist/src",
     "README.md",
     "LICENSE"
   ],
   "sideEffects": false,
   "scripts": {
-    "test": "node --test",
-    "release:check": "npm test && npm pack --dry-run",
-    "prepublishOnly": "npm run release:check"
+    "build": "node ./scripts/build.mjs",
+    "browsers:install": "playwright install chromium",
+    "typecheck": "node ./scripts/typecheck.mjs",
+    "check:dist": "node ./scripts/check-dist-sync.mjs",
+    "test:browser": "node ./scripts/browser-smoke.mjs",
+    "smoke:package-types": "node ./scripts/package-type-smoke.mjs",
+    "smoke:package-runtime": "node ./scripts/package-runtime-smoke.mjs",
+    "test": "node ./scripts/test.mjs",
+    "release:check": "node ./scripts/release-check.mjs",
+    "publish:github": "npm publish --registry=https://npm.pkg.github.com",
+    "publish:npm": "npm publish --access public",
+    "prepublishOnly": "node ./scripts/release-check.mjs"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -39,7 +48,7 @@
     "framework",
     "async-iterable"
   ],
-  "homepage": "https://github.com/qorejs/qore#readme",
+  "homepage": "https://qorejs.dev/",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/qorejs/qore.git"
@@ -50,5 +59,10 @@
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "@playwright/test": "^1.60.0",
+    "@types/node": "^25.6.0",
+    "typescript": "^6.0.3"
+  }
 }

package/src/anthropic.js

@@ -1,122 +0,0 @@
-import { createSSEAdapter, readEnv } from './sse.js';
-
-const DEFAULT_BASE_URL = 'https://api.anthropic.com/v1';
-const DEFAULT_MODEL = 'claude-sonnet-4-20250514';
-const DEFAULT_VERSION = '2023-06-01';
-const DEFAULT_MAX_TOKENS = 1024;
-
-// Normalize single-string prompts into Anthropic's Messages API shape.
-function normalizeMessages(input) {
-  if (typeof input === 'string') {
-    return [{ role: 'user', content: input }];
-  }
-
-  if (Array.isArray(input)) {
-    return input;
-  }
-
-  if (input && typeof input === 'object' && 'role' in input) {
-    return [input];
-  }
-
-  return input;
-}
-
-// Keep provider setup explicit because real API keys should stay off the client.
-export function createAnthropic(options = {}) {
-  const {
-    apiKey,
-    baseURL = DEFAULT_BASE_URL,
-    model = DEFAULT_MODEL,
-    version = DEFAULT_VERSION,
-    maxTokens = DEFAULT_MAX_TOKENS,
-    headers: defaultHeaders = {},
-    fetch: fetchImpl = globalThis.fetch
-  } = options;
-  const resolvedApiKey = apiKey ?? readEnv('ANTHROPIC_API_KEY');
-
-  if (!resolvedApiKey) {
-    throw new Error('Qore Anthropic adapter requires an API key. Pass apiKey or set ANTHROPIC_API_KEY.');
-  }
-
-  const transport = createSSEAdapter({
-    name: 'Anthropic',
-    url: `${baseURL}/messages`,
-    headers: {
-      'content-type': 'application/json',
-      'anthropic-version': version,
-      'x-api-key': resolvedApiKey,
-      ...defaultHeaders
-    },
-    fetch: fetchImpl,
-    buildRequest(request, requestOptions = {}) {
-      const { signal, headers = {}, ...overrides } = requestOptions;
-
-      return {
-        method: 'POST',
-        signal,
-        headers,
-        body: JSON.stringify({
-          model,
-          max_tokens: maxTokens,
-          stream: true,
-          ...request,
-          ...overrides
-        })
-      };
-    },
-    parse: JSON.parse,
-    isError: (event) => event.data?.type === 'error',
-    getError: (event) => event.data?.error?.message ?? 'Anthropic streaming error',
-    eventToText: (event) => (
-      event.data?.type === 'content_block_delta'
-      && event.data.delta?.type === 'text_delta'
-      && typeof event.data.delta.text === 'string'
-    )
-      ? event.data.delta.text
-      : undefined
-  });
-
-  async function* streamEvents(request, requestOptions = {}) {
-    for await (const event of transport.stream(request, requestOptions)) {
-      yield event.data;
-    }
-  }
-
-  async function* streamText(messages, requestOptions = {}) {
-    const request = messages && typeof messages === 'object' && 'messages' in messages
-      ? messages
-      : { messages };
-
-    for await (const chunk of transport.streamText(request, requestOptions)) {
-      yield chunk;
-    }
-  }
-
-  return {
-    // Stream typed semantic events from the Messages API.
-    messages: {
-      stream: streamEvents
-    },
-
-    // Stream only text delta chunks from assistant content blocks.
-    streamText(messages, requestOptions = {}) {
-      return streamText(messages, requestOptions);
-    },
-
-    // Match the Qore narrative directly: stream(anthropic.chat(prompt)).
-    chat(input, requestOptions = {}) {
-      const {
-        signal,
-        headers,
-        ...request
-      } = requestOptions;
-
-      if (!('messages' in request)) {
-        request.messages = normalizeMessages(input);
-      }
-
-      return streamText(request, { signal, headers });
-    }
-  };
-}