c0de-agent 0.0.0 → 1.0.0

package/dist/llm/routing.js

@@ -0,0 +1,53 @@
+import { resolveRoute } from './registry.js';
+import { withRetry } from './retry.js';
+import { isLLMError } from './schema/errors.js';
+/**
+ * Run `run` against the primary route first. If it throws a retryable error
+ * that exhausts retries, try each fallback in order. Non-retryable errors
+ * (context overflow, auth, invalid request) propagate immediately without
+ * trying fallbacks.
+ */
+const runWithFallback = async (registry, chain, run) => {
+    const targets = [chain.primary, ...chain.fallbacks];
+    let lastError;
+    for (let i = 0; i < targets.length; i += 1) {
+        const target = targets[i];
+        if (target === undefined)
+            continue;
+        // Validate the route exists before attempting (fails fast with NoRoute).
+        resolveRoute(registry, target.provider, target.model);
+        try {
+            const result = await withRetry(() => run(target.provider, target.model), {
+                maxRetries: chain.maxRetries,
+                sleep: chain.sleep,
+            });
+            return { result, provider: target.provider, model: target.model };
+        }
+        catch (error) {
+            lastError = error;
+            // Non-retryable errors do not fall through to fallback.
+            if (!shouldFallOver(error))
+                throw error;
+        }
+    }
+    throw lastError;
+};
+/**
+ * Whether an error should trigger a fallback after retries are exhausted.
+ * Per spec §7.6: RateLimit (after retries), ProviderInternal, and Authentication
+ * fall over to the next route. Context-overflow, invalid request, and transport
+ * errors propagate without trying fallbacks.
+ */
+const shouldFallOver = (error) => {
+    if (!isLLMError(error))
+        return false;
+    const reason = error.reason;
+    if (reason._tag === 'ProviderInternal')
+        return true;
+    if (reason._tag === 'RateLimit')
+        return true;
+    if (reason._tag === 'Authentication')
+        return true;
+    return false;
+};
+export { runWithFallback, shouldFallOver };

package/dist/llm/schema/errors.d.ts

@@ -0,0 +1,88 @@
+type HttpContext = {
+    request: {
+        method: string;
+        url: string;
+        headers: Record<string, string>;
+    };
+    response?: {
+        status: number;
+        headers: Record<string, string>;
+    };
+    body?: string;
+    requestId?: string;
+};
+type LLMErrorReason = {
+    _tag: 'InvalidRequest';
+    message: string;
+    parameter?: string;
+    classification?: 'context-overflow';
+    http?: HttpContext;
+} | {
+    _tag: 'NoRoute';
+    route: string;
+    provider: string;
+    model: string;
+} | {
+    _tag: 'Authentication';
+    message: string;
+    kind: 'missing' | 'invalid' | 'expired' | 'insufficient-permissions' | 'unknown';
+    http?: HttpContext;
+} | {
+    _tag: 'RateLimit';
+    message: string;
+    retryAfterMs?: number;
+    http?: HttpContext;
+} | {
+    _tag: 'QuotaExceeded';
+    message: string;
+    http?: HttpContext;
+} | {
+    _tag: 'ContentPolicy';
+    message: string;
+    http?: HttpContext;
+} | {
+    _tag: 'ProviderInternal';
+    message: string;
+    status: number;
+    retryAfterMs?: number;
+    http?: HttpContext;
+} | {
+    _tag: 'Transport';
+    message: string;
+    kind?: string;
+    url?: string;
+    http?: HttpContext;
+} | {
+    _tag: 'InvalidProviderOutput';
+    message: string;
+    raw?: string;
+} | {
+    _tag: 'UnknownProvider';
+    message: string;
+    status?: number;
+    http?: HttpContext;
+};
+/** Human-readable message extracted from any reason. */
+declare const reasonMessage: (reason: LLMErrorReason) => string;
+/** Whether a reason is retryable (RateLimit / ProviderInternal). */
+declare const reasonRetryable: (reason: LLMErrorReason) => boolean;
+/** Retry-after delay in ms for reasons that carry one. */
+declare const reasonRetryAfterMs: (reason: LLMErrorReason) => number | undefined;
+type LLMError = {
+    _tag: 'LLMError';
+    module: string;
+    method: string;
+    reason: LLMErrorReason;
+    message: string;
+};
+declare const llmError: (module: string, method: string, reason: LLMErrorReason) => LLMError;
+declare const isLLMError: (e: unknown) => e is LLMError;
+type ToolFailure = {
+    _tag: 'ToolFailure';
+    message: string;
+    metadata?: Record<string, unknown>;
+};
+declare const toolFailure: (message: string, metadata?: Record<string, unknown>) => ToolFailure;
+declare const isToolFailure: (e: unknown) => e is ToolFailure;
+export type { HttpContext, LLMError, LLMErrorReason, ToolFailure };
+export { isLLMError, isToolFailure, llmError, reasonMessage, reasonRetryAfterMs, reasonRetryable, toolFailure, };

package/dist/llm/schema/errors.js

@@ -0,0 +1,33 @@
+/** Human-readable message extracted from any reason. */
+const reasonMessage = (reason) => {
+    switch (reason._tag) {
+        case 'NoRoute':
+            return `No LLM route for model "${reason.model}" using provider "${reason.provider}" (route "${reason.route}")`;
+        default:
+            return reason.message;
+    }
+};
+/** Whether a reason is retryable (RateLimit / ProviderInternal). */
+const reasonRetryable = (reason) => reason._tag === 'RateLimit' || reason._tag === 'ProviderInternal';
+/** Retry-after delay in ms for reasons that carry one. */
+const reasonRetryAfterMs = (reason) => {
+    if (reason._tag === 'RateLimit' || reason._tag === 'ProviderInternal') {
+        return reason.retryAfterMs;
+    }
+    return undefined;
+};
+const llmError = (module, method, reason) => ({
+    _tag: 'LLMError',
+    module,
+    method,
+    reason,
+    message: `${module}.${method}: ${reasonMessage(reason)}`,
+});
+const isLLMError = (e) => typeof e === 'object' && e !== null && e._tag === 'LLMError';
+const toolFailure = (message, metadata) => ({
+    _tag: 'ToolFailure',
+    message,
+    metadata,
+});
+const isToolFailure = (e) => typeof e === 'object' && e !== null && e._tag === 'ToolFailure';
+export { isLLMError, isToolFailure, llmError, reasonMessage, reasonRetryAfterMs, reasonRetryable, toolFailure, };

package/dist/llm/schema/events.d.ts

@@ -0,0 +1,135 @@
+import type { ContentBlockID, FinishReason, ProtocolID, ProviderMetadata, ResponseID, RouteID, ToolCallID } from './ids.js';
+import type { ToolResultValue } from './messages.js';
+import type { Model } from './options.js';
+type Usage = {
+    inputTokens?: number;
+    outputTokens?: number;
+    nonCachedInputTokens?: number;
+    cacheReadInputTokens?: number;
+    cacheWriteInputTokens?: number;
+    reasoningTokens?: number;
+    totalTokens?: number;
+    providerMetadata?: ProviderMetadata;
+};
+type UsageInput = Partial<Usage>;
+declare const usageFrom: (input: UsageInput) => Usage;
+/** Visible (non-reasoning) output tokens: max(0, output - reasoning). */
+declare const visibleOutputTokens: (u: Usage) => number;
+type StepStart = {
+    type: 'step-start';
+    index: number;
+};
+type TextStart = {
+    type: 'text-start';
+    id: ContentBlockID;
+    providerMetadata?: ProviderMetadata;
+};
+type TextDelta = {
+    type: 'text-delta';
+    id: ContentBlockID;
+    text: string;
+    providerMetadata?: ProviderMetadata;
+};
+type TextEnd = {
+    type: 'text-end';
+    id: ContentBlockID;
+    providerMetadata?: ProviderMetadata;
+};
+type ReasoningStart = {
+    type: 'reasoning-start';
+    id: ContentBlockID;
+    providerMetadata?: ProviderMetadata;
+};
+type ReasoningDelta = {
+    type: 'reasoning-delta';
+    id: ContentBlockID;
+    text: string;
+    providerMetadata?: ProviderMetadata;
+};
+type ReasoningEnd = {
+    type: 'reasoning-end';
+    id: ContentBlockID;
+    providerMetadata?: ProviderMetadata;
+};
+type ToolInputStart = {
+    type: 'tool-input-start';
+    id: ToolCallID;
+    name: string;
+    providerMetadata?: ProviderMetadata;
+};
+type ToolInputDelta = {
+    type: 'tool-input-delta';
+    id: ToolCallID;
+    name: string;
+    text: string;
+    providerMetadata?: ProviderMetadata;
+};
+type ToolInputEnd = {
+    type: 'tool-input-end';
+    id: ToolCallID;
+    name: string;
+    providerMetadata?: ProviderMetadata;
+};
+type ToolCallEvent = {
+    type: 'tool-call';
+    id: ToolCallID;
+    name: string;
+    input: unknown;
+    providerExecuted?: boolean;
+    providerMetadata?: ProviderMetadata;
+};
+type ToolResultEvent = {
+    type: 'tool-result';
+    id: ToolCallID;
+    name: string;
+    result: ToolResultValue;
+    providerExecuted?: boolean;
+    providerMetadata?: ProviderMetadata;
+};
+type ToolErrorEvent = {
+    type: 'tool-error';
+    id: ToolCallID;
+    name: string;
+    message: string;
+    providerMetadata?: ProviderMetadata;
+};
+type StepFinish = {
+    type: 'step-finish';
+    index: number;
+    reason: FinishReason;
+    usage?: Usage;
+    providerMetadata?: ProviderMetadata;
+};
+type FinishEvent = {
+    type: 'finish';
+    reason: FinishReason;
+    usage?: Usage;
+    providerMetadata?: ProviderMetadata;
+    responseId?: ResponseID;
+};
+type ProviderErrorEvent = {
+    type: 'provider-error';
+    message: string;
+    classification?: 'context-overflow';
+    retryable?: boolean;
+    providerMetadata?: ProviderMetadata;
+};
+type StreamEvent = StepStart | TextStart | TextDelta | TextEnd | ReasoningStart | ReasoningDelta | ReasoningEnd | ToolInputStart | ToolInputDelta | ToolInputEnd | ToolCallEvent | ToolResultEvent | ToolErrorEvent | StepFinish | FinishEvent | ProviderErrorEvent;
+type PreparedRequest = {
+    id: string;
+    route: RouteID;
+    protocol: ProtocolID;
+    model: Model;
+    body: unknown;
+};
+type LLMResponse = {
+    events: StreamEvent[];
+    usage?: Usage;
+};
+/** Fold a list of events into an LLMResponse (used by non-streaming chat). */
+declare const foldResponse: (events: StreamEvent[]) => LLMResponse;
+declare const responseText: (res: LLMResponse) => string;
+declare const responseReasoning: (res: LLMResponse) => string;
+declare const responseToolCalls: (res: LLMResponse) => ToolCallEvent[];
+export type { FinishEvent, LLMResponse, PreparedRequest, ProviderErrorEvent, ReasoningDelta, ReasoningEnd, ReasoningStart, StepFinish, StepStart, StreamEvent, TextDelta, TextEnd, TextStart, ToolCallEvent, ToolErrorEvent, ToolInputDelta, ToolInputEnd, ToolInputStart, ToolResultEvent, Usage, UsageInput, };
+export { foldResponse, responseReasoning, responseText, responseToolCalls, usageFrom, visibleOutputTokens, };

package/dist/llm/schema/events.js

@@ -0,0 +1,35 @@
+const usageFrom = (input) => {
+    const inputTokens = input.inputTokens;
+    const outputTokens = input.outputTokens;
+    const total = input.totalTokens ??
+        (inputTokens !== undefined || outputTokens !== undefined
+            ? (inputTokens ?? 0) + (outputTokens ?? 0)
+            : undefined);
+    return { ...input, totalTokens: total };
+};
+/** Visible (non-reasoning) output tokens: max(0, output - reasoning). */
+const visibleOutputTokens = (u) => {
+    const out = u.outputTokens ?? 0;
+    const reasoning = u.reasoningTokens ?? 0;
+    return Math.max(0, out - reasoning);
+};
+/** Fold a list of events into an LLMResponse (used by non-streaming chat). */
+const foldResponse = (events) => {
+    let usage;
+    for (const event of events) {
+        if ((event.type === 'finish' || event.type === 'step-finish') && event.usage !== undefined) {
+            usage = event.usage;
+        }
+    }
+    return { events, usage };
+};
+const responseText = (res) => res.events
+    .filter((e) => e.type === 'text-delta')
+    .map((e) => e.text)
+    .join('');
+const responseReasoning = (res) => res.events
+    .filter((e) => e.type === 'reasoning-delta')
+    .map((e) => e.text)
+    .join('');
+const responseToolCalls = (res) => res.events.filter((e) => e.type === 'tool-call');
+export { foldResponse, responseReasoning, responseText, responseToolCalls, usageFrom, visibleOutputTokens, };

package/dist/llm/schema/ids.d.ts

@@ -0,0 +1,22 @@
+/** Opaque-brand helper: a value of type T carrying a phantom brand B. */
+type Brand<T, B> = T & {
+    readonly _brand?: B;
+};
+type ProtocolID = string;
+type RouteID = string;
+type ModelID = Brand<string, 'ModelID'>;
+type ProviderID = Brand<string, 'ProviderID'>;
+type ResponseID = string;
+type ContentBlockID = string;
+type ToolCallID = string;
+type ReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+type TextVerbosity = 'low' | 'medium' | 'high';
+type FinishReason = 'stop' | 'length' | 'tool-calls' | 'content-filter' | 'error' | 'unknown';
+/** Loose JSON schema (provider passthrough; not validated structurally here). */
+type JsonSchema = Record<string, unknown>;
+/** Per-provider raw payload passthrough, keyed by provider id. */
+type ProviderMetadata = Record<string, Record<string, unknown>>;
+declare const modelId: (value: string) => ModelID;
+declare const providerId: (value: string) => ProviderID;
+export type { Brand, ContentBlockID, FinishReason, JsonSchema, ModelID, ProtocolID, ProviderID, ProviderMetadata, ReasoningEffort, ResponseID, RouteID, TextVerbosity, ToolCallID, };
+export { modelId, providerId };

package/dist/llm/schema/ids.js

@@ -0,0 +1,3 @@
+const modelId = (value) => value;
+const providerId = (value) => value;
+export { modelId, providerId };

package/dist/llm/schema/index.d.ts

@@ -0,0 +1,5 @@
+export * from './errors.js';
+export * from './events.js';
+export * from './ids.js';
+export * from './messages.js';
+export * from './options.js';

package/dist/llm/schema/index.js

@@ -0,0 +1,5 @@
+export * from './errors.js';
+export * from './events.js';
+export * from './ids.js';
+export * from './messages.js';
+export * from './options.js';

package/dist/llm/schema/messages.d.ts

@@ -0,0 +1,97 @@
+import type { JsonSchema, ProviderMetadata, ToolCallID } from './ids.js';
+import type { CacheHint, GenerationOptions, HttpOptions, Model, ProviderOptions } from './options.js';
+type SystemPart = {
+    type: 'text';
+    text: string;
+    cache?: CacheHint;
+    metadata?: Record<string, unknown>;
+};
+type TextPart = {
+    type: 'text';
+    text: string;
+    cache?: CacheHint;
+    providerMetadata?: ProviderMetadata;
+};
+type ReasoningPart = {
+    type: 'reasoning';
+    text: string;
+    encrypted?: string;
+    providerMetadata?: ProviderMetadata;
+};
+type ToolCallPart = {
+    type: 'tool-call';
+    id: ToolCallID;
+    name: string;
+    input: unknown;
+    providerExecuted?: boolean;
+    providerMetadata?: ProviderMetadata;
+};
+type ToolResultValue = {
+    type: 'json';
+    value: unknown;
+} | {
+    type: 'text';
+    value: unknown;
+} | {
+    type: 'error';
+    value: unknown;
+};
+type ToolResultPart = {
+    type: 'tool-result';
+    id: ToolCallID;
+    name: string;
+    result: ToolResultValue;
+    providerExecuted?: boolean;
+    cache?: CacheHint;
+    providerMetadata?: ProviderMetadata;
+};
+type ContentPart = TextPart | ReasoningPart | ToolCallPart | ToolResultPart;
+type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+type Message = {
+    id?: string;
+    role: MessageRole;
+    content: ContentPart[];
+    metadata?: Record<string, unknown>;
+};
+declare const messageUser: (text: string) => Message;
+declare const messageAssistant: (text: string) => Message;
+declare const messageSystem: (text: string) => Message;
+type ToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: JsonSchema;
+    outputSchema?: JsonSchema;
+    cache?: CacheHint;
+};
+type ToolChoice = {
+    type: 'auto';
+} | {
+    type: 'none';
+} | {
+    type: 'required';
+} | {
+    type: 'tool';
+    name: string;
+};
+type ResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json';
+    schema: JsonSchema;
+};
+type InternalRequest = {
+    id?: string;
+    model: Model;
+    system: SystemPart[];
+    messages: Message[];
+    tools: ToolDefinition[];
+    toolChoice?: ToolChoice;
+    generation?: GenerationOptions;
+    providerOptions?: ProviderOptions;
+    http?: HttpOptions;
+    responseFormat?: ResponseFormat;
+};
+/** Immutable patch of an InternalRequest. */
+declare const requestUpdate: (req: InternalRequest, patch: Partial<InternalRequest>) => InternalRequest;
+export type { ContentPart, InternalRequest, Message, MessageRole, ReasoningPart, ResponseFormat, SystemPart, TextPart, ToolCallPart, ToolChoice, ToolDefinition, ToolResultPart, ToolResultValue, };
+export { messageAssistant, messageSystem, messageUser, requestUpdate };

package/dist/llm/schema/messages.js

@@ -0,0 +1,18 @@
+const messageUser = (text) => ({
+    role: 'user',
+    content: [{ type: 'text', text }],
+});
+const messageAssistant = (text) => ({
+    role: 'assistant',
+    content: [{ type: 'text', text }],
+});
+const messageSystem = (text) => ({
+    role: 'system',
+    content: [{ type: 'text', text }],
+});
+/** Immutable patch of an InternalRequest. */
+const requestUpdate = (req, patch) => ({
+    ...req,
+    ...patch,
+});
+export { messageAssistant, messageSystem, messageUser, requestUpdate };

package/dist/llm/schema/options.d.ts

@@ -0,0 +1,54 @@
+import type { JsonSchema, ModelID, ProviderID } from './ids.js';
+type HttpOptions = {
+    body?: JsonSchema;
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+};
+type GenerationOptions = {
+    maxTokens?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    seed?: number;
+    stop?: string[];
+};
+type ModelLimits = {
+    context?: number;
+    output?: number;
+};
+type Model = {
+    readonly id: ModelID;
+    readonly provider: ProviderID;
+    readonly limits?: ModelLimits;
+};
+declare const model: (id: string, provider: string, limits?: ModelLimits) => Model;
+/** Immutable patch of a Model. */
+declare const modelUpdate: (m: Model, patch: Partial<ModelLimits>) => Model;
+type CacheHint = {
+    type: 'ephemeral' | 'persistent';
+    ttlSeconds?: number;
+};
+type CachePolicyObject = {
+    tools?: boolean;
+    system?: boolean;
+    messages?: 'latest-user-message' | 'latest-assistant' | {
+        tail: number;
+    };
+    ttlSeconds?: number;
+};
+type CachePolicy = 'auto' | 'none' | CachePolicyObject;
+type ProviderOptions = Record<string, Record<string, unknown>>;
+type RouteDefaults = {
+    headers?: Record<string, string>;
+    limits?: ModelLimits;
+    generation?: GenerationOptions;
+    providerOptions?: ProviderOptions;
+    http?: HttpOptions;
+};
+declare const mergeGenerationOptions: (...opts: (GenerationOptions | undefined)[]) => GenerationOptions | undefined;
+declare const mergeHttpOptions: (...opts: (HttpOptions | undefined)[]) => HttpOptions | undefined;
+declare const mergeProviderOptions: (...opts: (ProviderOptions | undefined)[]) => ProviderOptions | undefined;
+export type { CacheHint, CachePolicy, CachePolicyObject, GenerationOptions, HttpOptions, Model, ModelLimits, ProviderOptions, RouteDefaults, };
+export { mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, model, modelUpdate };

package/dist/llm/schema/options.js

@@ -0,0 +1,54 @@
+import { modelId, providerId } from './ids.js';
+const model = (id, provider, limits) => ({
+    id: modelId(id),
+    provider: providerId(provider),
+    limits,
+});
+/** Immutable patch of a Model. */
+const modelUpdate = (m, patch) => ({
+    ...m,
+    limits: { ...m.limits, ...patch },
+});
+const mergeGenerationOptions = (...opts) => {
+    const filtered = opts.filter((o) => o !== undefined);
+    if (filtered.length === 0)
+        return undefined;
+    const merged = {};
+    for (const o of filtered)
+        Object.assign(merged, o);
+    return merged;
+};
+const mergeHttpOptions = (...opts) => {
+    const filtered = opts.filter((o) => o !== undefined);
+    if (filtered.length === 0)
+        return undefined;
+    const merged = {};
+    const headers = {};
+    const query = {};
+    for (const o of filtered) {
+        if (o.body !== undefined)
+            merged.body = o.body;
+        if (o.headers !== undefined)
+            Object.assign(headers, o.headers);
+        if (o.query !== undefined)
+            Object.assign(query, o.query);
+    }
+    if (Object.keys(headers).length > 0)
+        merged.headers = headers;
+    if (Object.keys(query).length > 0)
+        merged.query = query;
+    return merged;
+};
+const mergeProviderOptions = (...opts) => {
+    const filtered = opts.filter((o) => o !== undefined);
+    if (filtered.length === 0)
+        return undefined;
+    const merged = {};
+    for (const o of filtered) {
+        for (const key of Object.keys(o)) {
+            merged[key] = { ...(merged[key] ?? {}), ...o[key] };
+        }
+    }
+    return merged;
+};
+export { mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, model, modelUpdate };

package/dist/llm/token.d.ts

@@ -0,0 +1,2 @@
+declare const estimateTokens: (text: string) => number;
+export { estimateTokens };

package/dist/llm/token.js

@@ -0,0 +1,13 @@
+/**
+ * Heuristic token estimate: ~4 characters per token for English/code text.
+ * This mirrors the common "chars / 4" approximation used by tiktoken's
+ * rough estimate mode. A real BPE tokenizer can be plugged in later without
+ * changing this signature.
+ */
+const TOKEN_CHARS_RATIO = 4;
+const estimateTokens = (text) => {
+    if (text.length === 0)
+        return 0;
+    return Math.ceil(text.length / TOKEN_CHARS_RATIO);
+};
+export { estimateTokens };

package/dist/llm/transport.d.ts

@@ -0,0 +1,31 @@
+import { llmError } from './schema/errors.js';
+/**
+ * Parse a Server-Sent Events byte stream into individual `data:` payloads.
+ * Emits the decoded data string for each event block. Skips empty data and
+ * the `[DONE]` sentinel. Works for both OpenAI (`data: {...}`) and Anthropic
+ * (`event: {type}\ndata: {...}`) framing — only the `data:` lines are emitted.
+ */
+declare const sseFraming: (stream: ReadableStream<Uint8Array>) => AsyncGenerator<string, void, unknown>;
+type StreamHTTPOptions = {
+    url: string;
+    body: unknown;
+    headers: Record<string, string>;
+    signal?: AbortSignal;
+    /** Injectable fetch (for tests). Defaults to global fetch. */
+    fetchImpl?: typeof fetch;
+};
+/**
+ * Eagerly POST a JSON body and return the response body stream for framing.
+ * Throws an LLMError (classified) on non-2xx responses or transport failure.
+ * Used when the connection must be retryable independently of frame consumption.
+ */
+declare const httpPost: (options: StreamHTTPOptions) => Promise<ReadableStream<Uint8Array>>;
+/**
+ * POST a JSON body and yield SSE data frames from the response.
+ * Throws an LLMError on non-2xx responses, classifying context-overflow.
+ */
+declare const streamHTTP: (options: StreamHTTPOptions) => AsyncGenerator<string, void, unknown>;
+/** Map an HTTP failure status + body to an LLMError. */
+declare const classifyHttpError: (status: number, body: string, url: string, headers: Headers) => ReturnType<typeof llmError>;
+export type { StreamHTTPOptions };
+export { classifyHttpError, httpPost, sseFraming, streamHTTP };