@aryee337/aery-ai 0.1.148 → 0.2.10

package/dist/types/providers/openai-responses-shared.d.ts

@@ -0,0 +1,100 @@
+import type OpenAI from "openai";
+import type { ResponseInput, ResponseInputContent, ResponseOutputItem } from "openai/resources/responses/responses";
+import { type Api, type AssistantMessage, type ImageContent, type Model, type ServiceTier, type StopReason, type StreamOptions, type TextContent, type TextSignatureV1, type ToolResultMessage } from "../types";
+import type { AssistantMessageEventStream } from "../utils/event-stream";
+export declare const OPENAI_RESPONSES_PROGRESS_EVENT_TYPES: ReadonlySet<string>;
+export declare function isOpenAIResponsesProgressEvent(event: unknown): boolean;
+export declare function encodeTextSignatureV1(id: string, phase?: TextSignatureV1["phase"]): string;
+export declare function parseTextSignature(signature: string | undefined): {
+    id: string;
+    phase?: TextSignatureV1["phase"];
+} | undefined;
+export declare function encodeResponsesToolCallId(callId: string, itemId: string | null | undefined): string;
+export declare function normalizeResponsesToolCallIdForTransform(id: string, model?: Model<Api>, source?: AssistantMessage): string;
+export declare function collectKnownCallIds(messages: ResponseInput): Set<string>;
+/** Scan replay items for call_ids that were originally custom tool calls. */
+export declare function collectCustomCallIds(messages: ResponseInput): Set<string>;
+/**
+ * Convert orphan `function_call_output` / `custom_tool_call_output` items —
+ * those whose `call_id` has no matching preceding `function_call` /
+ * `custom_tool_call` in the same input — into assistant text notes.
+ *
+ * The Responses API rejects unpaired outputs with
+ * `400 No tool call found for function call output with call_id …`. Orphans
+ * sneak in through two paths today:
+ *
+ * - A previous turn's `providerPayload` snapshot replaces the input array via
+ *   the `dt: false` splice (see {@link convertConversationMessages}), wiping
+ *   the matching `function_call` while leaving the matching
+ *   `function_call_output` queued in a later `toolResult`.
+ * - A locally-rejected tool call (argument-validation failure, hook reject,
+ *   aborted turn before the call streamed) produces a tool result without a
+ *   `function_call` ever landing in any persisted provider payload.
+ *
+ * Dropping the result loses information the model needs to recover; sending
+ * it as-is 400s the request. Folding it into an assistant `message` preserves
+ * the payload (call_id + truncated output) while staying within the Responses
+ * input grammar. Matches the behavior of {@link transformRequestBody} in the
+ * codex provider — issue #1351 / regression of #472.
+ */
+export declare function repairOrphanResponsesToolOutputs(input: ResponseInput): ResponseInput;
+export declare function convertResponsesInputContent(content: string | Array<TextContent | ImageContent>, supportsImages: boolean): ResponseInputContent[] | undefined;
+export declare function convertResponsesAssistantMessage<TApi extends Api>(assistantMsg: AssistantMessage, model: Model<TApi>, msgIndex: number, knownCallIds: Set<string>, includeThinkingSignatures?: boolean, customCallIds?: Set<string>): ResponseInput;
+export declare function appendResponsesToolResultMessages<TApi extends Api>(messages: ResponseInput, toolResult: ToolResultMessage, model: Model<TApi>, strictResponsesPairing: boolean, knownCallIds: ReadonlySet<string>, customCallIds?: ReadonlySet<string>): void;
+export interface ProcessResponsesStreamOptions {
+    onFirstToken?: () => void;
+    onOutputItemDone?: (item: ResponseOutputItem) => void;
+}
+export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: ProcessResponsesStreamOptions): Promise<void>;
+export declare function mapOpenAIResponsesStopReason(status: OpenAI.Responses.ResponseStatus | undefined): StopReason;
+/** Initial empty `AssistantMessage` that streaming providers accumulate into. */
+export declare function createInitialResponsesAssistantMessage(api: Api, provider: string, modelId: string): AssistantMessage;
+/** Extension fields we add on top of `ResponseCreateParamsStreaming` across the Responses-family providers. */
+export type ResponsesSamplingParamsExtras = {
+    top_p?: number;
+    top_k?: number;
+    min_p?: number;
+    presence_penalty?: number;
+    repetition_penalty?: number;
+};
+type CommonResponsesParams = OpenAI.Responses.ResponseCreateParamsStreaming & ResponsesSamplingParamsExtras;
+type CommonSamplingOptions = Pick<StreamOptions, "temperature" | "topP" | "topK" | "minP" | "presencePenalty" | "repetitionPenalty" | "maxTokens"> & {
+    serviceTier?: ServiceTier;
+};
+/**
+ * Apply the common `StreamOptions` → Responses sampling-parameter mapping (max output tokens,
+ * temperature, top-p/k, min-p, presence/repetition penalties, service tier). Mutates `params`.
+ */
+export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, provider: string): void;
+type ReasoningOptions = {
+    reasoning?: string;
+    reasoningSummary?: "auto" | "detailed" | "concise" | null;
+};
+/**
+ * Apply reasoning-related Responses parameters: enable encrypted reasoning content for replay,
+ * set effort/summary when requested, and otherwise inject the GPT-5 "Juice: 0" no-reasoning hack.
+ * Mutates `params` and may push a developer message into `messages`.
+ *
+ * @param omitReasoningEffort - When `true`, suppresses `params.reasoning.effort` from the wire
+ *   body. Set by `xai-responses.ts` via {@link OpenAIResponsesOptions.omitReasoningEffort} for
+ *   xAI Grok models that return HTTP 400 on any `reasoning.effort` value (e.g. grok-build,
+ *   grok-4.20-0309-reasoning). When `true` and `options.reasoning` is set but
+ *   `options.reasoningSummary` is absent, `params.reasoning` is intentionally omitted from the
+ *   wire body entirely — these models reason natively at their own internal default effort level
+ *   without needing explicit activation. Callers that pass `options.reasoning` for such models
+ *   should expect this documented downgrade: the model will reason, but at its default effort.
+ */
+export declare function applyResponsesReasoningParams<P extends OpenAI.Responses.ResponseCreateParamsStreaming>(params: P, model: Model<Api>, options: ReasoningOptions | undefined, messages: ResponseInput, mapEffort?: (effort: string) => string, includeEncryptedReasoning?: boolean, omitReasoningEffort?: boolean): void;
+/** Populate `output.usage` from a Responses-API `response.usage` payload. Does not invoke `calculateCost`. */
+export declare function populateResponsesUsageFromResponse(output: AssistantMessage, usage: {
+    input_tokens?: number | null;
+    output_tokens?: number | null;
+    total_tokens?: number | null;
+    input_tokens_details?: {
+        cached_tokens?: number | null;
+    } | null;
+    output_tokens_details?: {
+        reasoning_tokens?: number | null;
+    } | null;
+} | null | undefined): void;
+export {};

package/dist/types/providers/openai-responses.d.ts

@@ -0,0 +1,66 @@
+import type { Tool as OpenAITool } from "openai/resources/responses/responses";
+import type { Model, ServiceTier, StreamFunction, StreamOptions, Tool, ToolChoice } from "../types";
+import { type OpenAIResponsesToolChoice } from "../utils/tool-choice";
+export declare function normalizeOpenAIResponsesPromptCacheKey(sessionId: string | undefined): string | undefined;
+export interface OpenAIResponsesOptions extends StreamOptions {
+    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoningSummary?: "auto" | "detailed" | "concise" | null;
+    serviceTier?: ServiceTier;
+    toolChoice?: ToolChoice;
+    /**
+     * Enforce strict tool call/result pairing when building Responses API inputs.
+     * Azure OpenAI and GitHub Copilot Responses paths require tool results to match prior tool calls.
+     */
+    strictResponsesPairing?: boolean;
+    /**
+     * Pass `include: ["reasoning.encrypted_content"]` on requests when the
+     * model supports reasoning. Default: true (preserves current behavior).
+     * Set to false when the upstream Responses endpoint rejects replayed
+     * encrypted reasoning (e.g., xAI Grok under SuperGrok OAuth).
+     */
+    includeEncryptedReasoning?: boolean;
+    /**
+     * Strip `type: "reasoning"` items from replayed conversation history
+     * before they hit the wire. Default: false (preserves current behavior).
+     * Set to true when the upstream rejects replayed reasoning wrappers.
+     */
+    filterReasoningHistory?: boolean;
+    /**
+     * Suppress the `reasoning.effort` wire param when set, even if
+     * `options.reasoning` is requested. Default: false. xAI Grok models
+     * outside the effort-capable allowlist 400 with "Model X does not
+     * support parameter reasoningEffort" — the xAI Responses adapter sets
+     * this when the target model is not in GROK_EFFORT_CAPABLE_PREFIXES.
+     */
+    omitReasoningEffort?: boolean;
+    /**
+     * Extra request headers merged onto the underlying client's
+     * defaultHeaders. Used by adapter wrappers to inject provider-specific
+     * routing or cache hints.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Extra body fields merged into the Responses request payload. Used by
+     * adapter wrappers to inject provider-specific body keys (e.g.,
+     * prompt_cache_key for prompt-cache routing).
+     */
+    extraBody?: Record<string, unknown>;
+}
+/**
+ * Generate function for OpenAI Responses API
+ */
+export declare const streamOpenAIResponses: StreamFunction<"openai-responses">;
+export declare function getOpenAIResponsesCacheSessionId(options: Pick<OpenAIResponsesOptions, "cacheRetention" | "sessionId" | "promptCacheKey"> | undefined): string | undefined;
+export declare function supportsDeveloperRole(modelOrBaseUrl: Pick<Model, "provider" | "baseUrl"> | string): boolean;
+/**
+ * Whether this model should get the OpenAI custom-tool grammar variant
+ * for `apply_patch`. The generated model catalog sets
+ * `model.applyPatchToolType` for first-party GPT-5 Responses models; this
+ * runtime path only consumes that metadata.
+ * @internal Exported for tests.
+ */
+export declare function supportsFreeformApplyPatch(model: Model<"openai-responses">): boolean;
+/** @internal Exported for tests. */
+export declare function mapOpenAIResponsesToolChoiceForTools(choice: ToolChoice | undefined, tools: Tool[], model: Model<"openai-responses">): OpenAIResponsesToolChoice;
+/** @internal Exported for tests. */
+export declare function convertTools(tools: Tool[], strictMode: boolean, model: Model<"openai-responses">): OpenAITool[];

package/dist/types/providers/register-builtins.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Lazy provider module loading.
+ *
+ * Each provider module is loaded only when its stream function is first called.
+ * This avoids eagerly importing heavy SDK dependencies (e.g., openai) at
+ * startup. The loaded module promise is cached so subsequent calls
+ * reuse the same import.
+ *
+ * NOTE: stream.ts currently imports providers directly, so this file is not yet
+ * wired into the main streaming path. It provides the infrastructure for lazy
+ * loading that can be integrated when stream.ts is refactored.
+ */
+import type { AssistantMessageEventStream, Context, Model, OptionsForApi } from "../types";
+import { AssistantMessageEventStream as EventStreamImpl } from "../utils/event-stream";
+import type { BedrockOptions } from "./amazon-bedrock";
+interface BedrockProviderModule {
+    streamBedrock: (model: Model<"bedrock-converse-stream">, context: Context, options: BedrockOptions) => AssistantMessageEventStream;
+}
+export declare function setBedrockProviderModule(module: BedrockProviderModule): void;
+export declare const streamAnthropic: (model: Model<"anthropic-messages">, context: Context, options: OptionsForApi<"anthropic-messages">) => EventStreamImpl;
+export declare const streamAzureOpenAIResponses: (model: Model<"azure-openai-responses">, context: Context, options: OptionsForApi<"azure-openai-responses">) => EventStreamImpl;
+export declare const streamGoogle: (model: Model<"google-generative-ai">, context: Context, options: OptionsForApi<"google-generative-ai">) => EventStreamImpl;
+export declare const streamGoogleGeminiCli: (model: Model<"google-gemini-cli">, context: Context, options: OptionsForApi<"google-gemini-cli">) => EventStreamImpl;
+export declare const streamGoogleVertex: (model: Model<"google-vertex">, context: Context, options: OptionsForApi<"google-vertex">) => EventStreamImpl;
+export declare const streamOpenAICodexResponses: (model: Model<"openai-codex-responses">, context: Context, options: OptionsForApi<"openai-codex-responses">) => EventStreamImpl;
+export declare const streamOpenAICompletions: (model: Model<"openai-completions">, context: Context, options: OptionsForApi<"openai-completions">) => EventStreamImpl;
+export declare const streamOpenAIResponses: (model: Model<"openai-responses">, context: Context, options: OptionsForApi<"openai-responses">) => EventStreamImpl;
+export declare const streamCursor: (model: Model<"cursor-agent">, context: Context, options: OptionsForApi<"cursor-agent">) => EventStreamImpl;
+export declare const streamOllama: (model: Model<"ollama-chat">, context: Context, options: OptionsForApi<"ollama-chat">) => EventStreamImpl;
+export declare const streamBedrock: (model: Model<"bedrock-converse-stream">, context: Context, options: OptionsForApi<"bedrock-converse-stream">) => EventStreamImpl;
+export {};

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

@@ -0,0 +1,26 @@
+/**
+ * Synthetic provider - wraps OpenAI or Anthropic API based on format setting.
+ *
+ * Synthetic offers both OpenAI-compatible and Anthropic-compatible APIs:
+ * - OpenAI: https://api.synthetic.new/openai/v1/chat/completions
+ * - Anthropic: https://api.synthetic.new/anthropic/v1/messages
+ *
+ * @see https://dev.synthetic.new/docs/api/overview
+ */
+import type { Api, Context, Model } from "../types";
+import type { AssistantMessageEventStream } from "../utils/event-stream";
+import { type OpenAIAnthropicApiFormat, type OpenAIAnthropicShimOptions } from "./openai-anthropic-shim";
+export type SyntheticApiFormat = OpenAIAnthropicApiFormat;
+export interface SyntheticOptions extends OpenAIAnthropicShimOptions {
+    /** API format: "openai" or "anthropic". Default: "openai" */
+    format?: SyntheticApiFormat;
+}
+/**
+ * Stream from Synthetic, routing to either OpenAI or Anthropic API based on format.
+ * Returns synchronously like other providers - async processing happens internally.
+ */
+export declare function streamSynthetic(model: Model<"openai-completions">, context: Context, options?: SyntheticOptions): AssistantMessageEventStream;
+/**
+ * Check if a model is a Synthetic model.
+ */
+export declare function isSyntheticModel(model: Model<Api>): boolean;

package/dist/{providers → types/providers}/transform-messages.d.ts

@@ -1,8 +1,12 @@
-import type { Api, AssistantMessage, Message, Model } from "../types.ts";
+import type { Api, AssistantMessage, Message, Model } from "../types";
 /**
  * Normalize tool call ID for cross-provider compatibility.
  * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.
  * Anthropic APIs require IDs matching ^[a-zA-Z0-9_-]+$ (max 64 chars).
+ *
+ * For aborted/errored turns, this function:
+ * - Preserves tool call structure (unlike converting to text summaries)
+ * - Injects synthetic "aborted" tool results
+ * - Adds a <turn-aborted> guidance marker for the model
  */
 export declare function transformMessages<TApi extends Api>(messages: Message[], model: Model<TApi>, normalizeToolCallId?: (id: string, model: Model<TApi>, source: AssistantMessage) => string): Message[];
-//# sourceMappingURL=transform-messages.d.ts.map

package/dist/types/providers/vision-guard.d.ts

@@ -0,0 +1,8 @@
+import type { ImageContent, TextContent } from "../types";
+export declare const NON_VISION_IMAGE_PLACEHOLDER = "[image omitted: model does not support vision]";
+export declare function partitionVisionContent(content: ReadonlyArray<TextContent | ImageContent>, supportsImages: boolean): {
+    textBlocks: TextContent[];
+    imageBlocks: ImageContent[];
+    omittedImages: boolean;
+};
+export declare function joinTextWithImagePlaceholder(text: string, omittedImages: boolean): string;

package/dist/types/providers/xai-responses.d.ts

@@ -0,0 +1,23 @@
+import type { StreamFunction } from "../types";
+/**
+ * xAI Grok Responses adapter (SuperGrok OAuth path).
+ *
+ * Three xAI-specific behaviors vs the generic OpenAI Responses adapter:
+ *
+ *  1. `x-grok-conv-id` header + body `prompt_cache_key` route prompt-cache
+ *     hits on xAI's edge. Hermes uses both (agent/transports/codex.py:182-193).
+ *     The header is undocumented by xAI; `previous_response_id` is the
+ *     documented alternative — switch if xAI deprecates the header.
+ *  2. includeEncryptedReasoning=false — xAI's /v1/responses rejects replayed
+ *     `encrypted_content` blobs minted under SuperGrok OAuth.
+ *  3. filterReasoningHistory=true — strip `type: "reasoning"` items from
+ *     replayed conversation history; the blob inside is non-replayable under
+ *     OAuth and the wrapper item 404s without it (store=false; server cannot
+ *     resolve by id).
+ *
+ * Everything else is the generic OpenAI Responses transport. The xAI bearer
+ * token arrives in `options.apiKey` via AuthStorage.getApiKey() upstream, and
+ * the xAI base URL (`https://api.x.ai/v1`) arrives via `model.baseUrl` from
+ * the provider registry — not routed through this wrapper.
+ */
+export declare const streamXAIResponses: StreamFunction<"openai-responses">;

package/dist/types/rate-limit-utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Rate limit reason classification and backoff calculation utilities.
+ * Ported from opencode-antigravity-auth plugin for consistency.
+ */
+export type RateLimitReason = "QUOTA_EXHAUSTED" | "RATE_LIMIT_EXCEEDED" | "MODEL_CAPACITY_EXHAUSTED" | "SERVER_ERROR" | "UNKNOWN";
+/**
+ * Classify a rate-limit error message into a reason category.
+ * Priority order: MODEL_CAPACITY > RATE_LIMIT > QUOTA > SERVER_ERROR > UNKNOWN.
+ *
+ * "resource exhausted" maps to MODEL_CAPACITY (transient, short wait)
+ * "quota exceeded" maps to QUOTA_EXHAUSTED (long wait, switch account)
+ */
+export declare function parseRateLimitReason(errorMessage: string): RateLimitReason;
+/**
+ * Calculate backoff delay in ms for a given rate limit reason.
+ * MODEL_CAPACITY gets jitter to prevent thundering herd.
+ */
+export declare function calculateRateLimitBackoffMs(reason: RateLimitReason): number;
+export declare function isUsageLimitError(errorMessage: string): boolean;

package/dist/types/stream.d.ts

@@ -0,0 +1,28 @@
+import type { Effort } from "./model-thinking";
+import type { AnthropicOptions } from "./providers/anthropic";
+import type { GoogleOptions } from "./providers/google";
+import type { GoogleGeminiCliOptions } from "./providers/google-gemini-cli";
+import type { GoogleVertexOptions } from "./providers/google-vertex";
+import type { Api, AssistantMessage, Context, Model, OptionsForApi, SimpleStreamOptions, ToolChoice } from "./types";
+import { AssistantMessageEventStream } from "./utils/event-stream";
+/**
+ * Get API key for provider from known environment variables, e.g. OPENAI_API_KEY.
+ *
+ * Will not return API keys for providers that require OAuth tokens.
+ * Checks Bun.env, then cwd/.env, then ~/.env.
+ */
+export declare function getEnvApiKey(provider: string): string | undefined;
+/**
+ * Enumerate every provider that has an env-var fallback for `getEnvApiKey`.
+ * Used by `aery auth-broker migrate --include-env` to discover env-sourced keys
+ * that should be uploaded to the broker.
+ */
+export declare function listProvidersWithEnvKey(): string[];
+export declare function stream<TApi extends Api>(model: Model<TApi>, context: Context, options?: OptionsForApi<TApi>): AssistantMessageEventStream;
+export declare function complete<TApi extends Api>(model: Model<TApi>, context: Context, options?: OptionsForApi<TApi>): Promise<AssistantMessage>;
+export declare function streamSimple<TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
+export declare function completeSimple<TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions): Promise<AssistantMessage>;
+export declare const OUTPUT_FALLBACK_BUFFER = 4000;
+export declare const ANTHROPIC_THINKING: Record<Effort, number>;
+export declare function mapAnthropicToolChoice(choice?: ToolChoice): AnthropicOptions["toolChoice"];
+export declare function mapGoogleToolChoice(choice?: ToolChoice): GoogleOptions["toolChoice"] | GoogleGeminiCliOptions["toolChoice"] | GoogleVertexOptions["toolChoice"];