@aryee337/aery-ai 0.1.148 → 0.2.10

package/dist/types/provider-models/special.d.ts

@@ -0,0 +1,16 @@
+import type { ModelManagerOptions } from "../model-manager";
+export interface OpenAICodexModelManagerConfig {
+    accessToken?: string;
+    accountId?: string;
+    clientVersion?: string;
+}
+export declare function openaiCodexModelManagerOptions(config?: OpenAICodexModelManagerConfig): ModelManagerOptions<"openai-codex-responses">;
+export interface CursorModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    clientVersion?: string;
+}
+export declare function cursorModelManagerOptions(config?: CursorModelManagerConfig): ModelManagerOptions<"cursor-agent">;
+export interface ZaiModelManagerConfig {
+}
+export declare function zaiModelManagerOptions(_config?: ZaiModelManagerConfig): ModelManagerOptions<"anthropic-messages">;

package/dist/types/providers/aery-native-client.d.ts

@@ -0,0 +1,13 @@
+import type { Api, AssistantMessageEventStream as AssistantMessageEventStreamType, Context, Model, SimpleStreamOptions } from "../types";
+/**
+ * Stream a turn through an `aery auth-gateway over the aery-native protocol.
+ *
+ * The returned {@link AssistantMessageEventStream} receives each parsed
+ * `AssistantMessageEvent` verbatim from the gateway; the terminal `done` /
+ * `error` event resolves `.result()` automatically via the base class's
+ * completion check. Non-streaming consumers just call `.result()` and pay
+ * for SSE framing they don't use — that overhead is dominated by provider
+ * latency, so we always stream rather than maintaining a parallel
+ * non-streaming path.
+ */
+export declare function streamAeryNative<TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStreamType;

package/dist/types/providers/aery-native-server.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Aery-native wire format for the auth-gateway.
+ *
+ * Where the OpenAI / Anthropic / Responses route modules translate foreign
+ * wire shapes through aery-ai's canonical {@link Context}, this module accepts
+ * the canonical shape *directly* — for clients that already speak aery-ai
+ * (containerized aery, the swarm extension, robaery's sidecar auth-gateway).
+ * Skipping the wire-format → Context → wire-format round-trip cuts
+ * per-request CPU but, more importantly, avoids the quantization that those
+ * translations impose on first-class aery-ai fields (service tier, cache
+ * markers, thinking budgets, tool-choice variants, …).
+ *
+ * The streaming wire is {@link AssistantMessageEvent} serialized verbatim and
+ * SSE-framed. Same type aery-ai already produces internally; the client feeds
+ * each parsed event straight into `AssistantMessageEventStream.push()` with
+ * no translation. Including `partial: AssistantMessage` on every delta is
+ * O(N²) in turn length on the wire — acceptable for the loopback / sidecar
+ * topology this transport is designed for; provider latency dominates the
+ * actual cost.
+ *
+ * Endpoint contract:
+ *   POST /v1/aery/stream
+ *   body:    { modelId, context, options?, stream? }   // `stream` defaults to true
+ *   200 SSE: stream of `AssistantMessageEvent` (terminated by `data: [DONE]`)
+ *   200 JSON (stream=false): { message: AssistantMessage }
+ *   4xx/5xx: { error: { type, message } }
+ */
+import type { AssistantMessageEventStream, Context, SimpleStreamOptions } from "../types";
+export interface AeryNativeParsedRequest {
+    modelId: string;
+    context: Context;
+    options: SimpleStreamOptions;
+    stream: boolean;
+}
+/**
+ * Parse an aery-native request body. Validation is intentionally minimal — only
+ * the shape the gateway itself reads is checked (`modelId`, `context.messages`
+ * array, options is an object). Everything downstream is the canonical aery-ai
+ * type surface; mis-shaped values surface as a `502 upstream_error` from
+ * `streamSimple` rather than being re-validated here.
+ *
+ * Accepts both `{ modelId: string }` and `{ model: { id: string } }` so the
+ * existing `streamProxy` client (which sends the full Model object) can target
+ * the gateway with only a URL swap.
+ */
+export declare function parseRequest(body: unknown, _headers?: Headers): AeryNativeParsedRequest;
+/**
+ * Ship every {@link AssistantMessageEvent} verbatim, SSE-framed.
+ *
+ * No per-event re-shaping: the aery-native client is aery-ai itself, so the
+ * canonical event type IS the wire type. Including the rolling
+ * `partial: AssistantMessage` on every delta is quadratic in turn length
+ * on the wire, but for the loopback / sidecar topology this transport
+ * targets (containerized aery → host gateway, robaery slot → aery-auth-gateway
+ * sidecar) the bandwidth cost is negligible compared to provider latency —
+ * and the client gets to feed the events straight into its existing
+ * `AssistantMessageEventStream.push()` plumbing with zero translation.
+ */
+export declare function encodeStream(events: AssistantMessageEventStream): ReadableStream<Uint8Array>;
+/**
+ * Aery-native error envelope:
+ *   `{ error: { type, message } }`
+ *
+ * Mirrors OpenAI's outer shape (which clients/SDKs already parse) without the
+ * provider-specific status taxonomy — aery-native callers consume `type`
+ * directly.
+ */
+export declare function formatError(status: number, type: string, message: string): Response;

package/dist/types/providers/amazon-bedrock.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Amazon Bedrock Converse Stream provider.
+ *
+ * Talks directly to `bedrock-runtime.{region}.amazonaws.com` over HTTPS with
+ * SigV4 signing and decodes the `application/vnd.amazon.eventstream` response.
+ * No `@aws-sdk/*`, no `@smithy/*`, no `proxy-agent`. Proxies are honored via
+ * Bun's native `HTTPS_PROXY` support.
+ */
+import type { Effort } from "../model-thinking";
+import type { StreamFunction, StreamOptions, ThinkingBudgets } from "../types";
+export type BedrockThinkingDisplay = "summarized" | "omitted";
+export interface BedrockOptions extends StreamOptions {
+    region?: string;
+    profile?: string;
+    /** Amazon Bedrock API key sent as `Authorization: Bearer`, ahead of SigV4 credential resolution. */
+    bearerToken?: string;
+    toolChoice?: "auto" | "any" | "none" | {
+        type: "tool";
+        name: string;
+    };
+    reasoning?: Effort;
+    thinkingBudgets?: ThinkingBudgets;
+    interleavedThinking?: boolean;
+    /**
+     * Controls how Claude returns thinking content in Bedrock responses.
+     * - `"summarized"`: thinking blocks include human-readable summaries (default here).
+     * - `"omitted"`: thinking content is suppressed; the encrypted signature still
+     *   travels back for multi-turn continuity.
+     *
+     * Starting with Claude Opus 4.7 the Anthropic API default is `"omitted"`, which
+     * leaves callers waiting on a silent stream during long reasoning runs (issue
+     * #1373). We default to `"summarized"` so adaptive-thinking models that accept
+     * the field keep producing visible thinking deltas. Older adaptive-thinking
+     * models (Opus 4.6, Sonnet 4.6+) reject the field, so we omit it for them.
+     */
+    thinkingDisplay?: BedrockThinkingDisplay;
+}
+export declare const streamBedrock: StreamFunction<"bedrock-converse-stream">;

package/dist/types/providers/anthropic-client.d.ts

@@ -0,0 +1,99 @@
+import type { FetchImpl } from "../types";
+import type { MessageCreateParamsStreaming } from "./anthropic-wire";
+/** Per-request options accepted by {@link AnthropicMessages.create}. */
+export interface AnthropicRequestOptions {
+    signal?: AbortSignal;
+    /** Pre-response timeout in milliseconds. */
+    timeout?: number;
+    /** Per-request retry budget override. */
+    maxRetries?: number;
+}
+/**
+ * Extra `RequestInit` fields merged into every fetch call. Bun extends
+ * `RequestInit` with a `tls` option used for the Claude Code TLS profile and
+ * Foundry mTLS.
+ */
+export type AnthropicFetchOptions = RequestInit & {
+    tls?: {
+        rejectUnauthorized?: boolean;
+        serverName?: string;
+        ciphers?: string;
+        ca?: string | string[];
+        cert?: string;
+        key?: string;
+    };
+};
+export interface AnthropicClientOptions {
+    /** Sent as `X-Api-Key` unless the header is already present in `defaultHeaders`. */
+    apiKey?: string | null;
+    /** Sent as `Authorization: Bearer <token>` unless the header is already present in `defaultHeaders`. */
+    authToken?: string | null;
+    baseURL?: string | null;
+    maxRetries?: number;
+    /** Pre-response timeout in milliseconds. Defaults to 10 minutes. */
+    timeout?: number;
+    defaultHeaders?: Record<string, string>;
+    fetch?: FetchImpl;
+    fetchOptions?: AnthropicFetchOptions;
+}
+/** Non-2xx response from the Anthropic API. */
+export declare class AnthropicApiError extends Error {
+    readonly status: number;
+    readonly headers: Headers;
+    readonly requestId: string | null;
+    constructor(status: number, message: string, headers: Headers);
+    static fromResponse(response: Response): Promise<AnthropicApiError>;
+}
+/** Network-level failure (DNS, TLS, socket reset) after retries were exhausted. */
+export declare class AnthropicConnectionError extends Error {
+    constructor(cause: unknown);
+}
+/** No response headers arrived within the configured request timeout. */
+export declare class AnthropicConnectionTimeoutError extends Error {
+    constructor();
+}
+/**
+ * Lazy in-flight request handle. The HTTP request starts on the first
+ * `asResponse()` call; subsequent calls return the same promise.
+ *
+ * Shape-compatible with the SDK's `APIPromise.asResponse()` so
+ * `getAnthropicStreamResponse` treats internal and injected clients uniformly.
+ */
+export declare class AnthropicApiRequest {
+    #private;
+    constructor(start: () => Promise<Response>);
+    asResponse(): Promise<Response>;
+}
+/**
+ * `messages` resource. `create` lives on the prototype so tests can intercept
+ * every outgoing request with `vi.spyOn(AnthropicMessages.prototype, "create")`.
+ */
+export declare class AnthropicMessages {
+    #private;
+    constructor(client: AnthropicMessagesClient, path: string);
+    create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): AnthropicApiRequest;
+}
+/**
+ * Structural interface satisfied by both {@link AnthropicMessagesClient} and
+ * SDK-style clients (e.g. `AnthropicVertex`), so callers can inject an
+ * alternative Messages-API client via `AnthropicOptions.client`.
+ */
+export interface AnthropicMessagesClientLike {
+    messages: {
+        create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): unknown;
+    };
+    beta?: {
+        messages: {
+            create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): unknown;
+        };
+    };
+}
+export declare class AnthropicMessagesClient implements AnthropicMessagesClientLike {
+    #private;
+    readonly messages: AnthropicMessages;
+    readonly beta: {
+        readonly messages: AnthropicMessages;
+    };
+    constructor(options: AnthropicClientOptions);
+    request(path: string, params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): AnthropicApiRequest;
+}