@jaypie/llm 1.3.0 → 1.3.2

package/dist/cjs/observability/llmobs.d.ts

@@ -0,0 +1,72 @@
+/**
+ * LLM Observability span kinds supported by Datadog's `llmobs` SDK.
+ * @see https://docs.datadoghq.com/llm_observability/setup/sdk/nodejs/
+ */
+export type LlmObsSpanKind = "agent" | "embedding" | "llm" | "retrieval" | "task" | "tool" | "workflow";
+export interface LlmObsSpanOptions {
+    kind: LlmObsSpanKind;
+    modelName?: string;
+    modelProvider?: string;
+    name: string;
+}
+export interface LlmObsAnnotation {
+    inputData?: unknown;
+    metadata?: Record<string, unknown>;
+    metrics?: Record<string, number>;
+    outputData?: unknown;
+    tags?: Record<string, unknown>;
+}
+/** Manual span handle for streaming, where a callback cannot enclose the work. */
+export interface LlmObsSpanHandle {
+    annotate: (annotation: LlmObsAnnotation) => void;
+    finish: () => void;
+}
+/** Minimal shape of the dd-trace `llmobs` SDK surface this module uses. */
+interface LlmObsSdk {
+    annotate: (span: unknown, annotation: LlmObsAnnotation) => void;
+    trace: (options: LlmObsSpanOptions, fn: (span: unknown) => unknown) => unknown;
+}
+/** Reset the cached SDK resolution. Exposed for tests. */
+export declare function _resetLlmObs(): void;
+/**
+ * Inject an SDK to bypass dd-trace resolution. Test-only: dd-trace is not a
+ * dependency, so the enabled path cannot otherwise be exercised in unit tests.
+ */
+export declare function _setLlmObs(sdk: LlmObsSdk | null): void;
+/**
+ * True when LLM Observability emission is opted in via `DD_LLMOBS_ENABLED`.
+ * Accepts any truthy value except "false"/"0".
+ */
+export declare function isLlmObsEnabled(): boolean;
+/**
+ * Run `fn` inside an LLM Observability span. When emission is disabled or
+ * dd-trace is absent, `fn` is invoked directly with no overhead. The active
+ * span is established for the duration of `fn`, so nested `withLlmObsSpan`
+ * calls (and `annotateLlmObs`) attach as children/annotations automatically.
+ */
+export declare function withLlmObsSpan<T>(options: LlmObsSpanOptions, fn: () => Promise<T>): Promise<T>;
+/**
+ * Annotate the currently active LLM Observability span. No-op when disabled.
+ */
+export declare function annotateLlmObs(annotation: LlmObsAnnotation): void;
+/**
+ * Open a manual span that is finished later. Used by streaming, where work is
+ * yielded incrementally and cannot be enclosed in a single callback. The span
+ * is kept open via a deferred promise resolved by `finish()`. Returns null when
+ * emission is disabled or dd-trace is absent.
+ *
+ * Note: because the span is held open across `yield` boundaries (outside the
+ * SDK's AsyncLocalStorage scope), manual spans are emitted flat rather than
+ * nested. Annotations are applied to the explicit span reference.
+ */
+export declare function openLlmObsSpan(options: LlmObsSpanOptions): LlmObsSpanHandle | null;
+/**
+ * Sum an `LlmUsage` array into LLM Observability metric keys. Returns undefined
+ * when there is no usage data so callers can omit the `metrics` field.
+ */
+export declare function usageToLlmObsMetrics(usage?: Array<{
+    input?: number;
+    output?: number;
+    total?: number;
+}>): Record<string, number> | undefined;
+export {};

package/dist/cjs/operate/OperateLoop.d.ts

@@ -10,6 +10,7 @@ export interface OperateLoopConfig {
     inputProcessor?: InputProcessor;
     retryPolicy?: RetryPolicy;
 }
+export declare const MAX_CONSECUTIVE_TOOL_ERRORS = 6;
 /**
  * OperateLoop implements the core multi-turn conversation loop.
  * It orchestrates provider adapters, retry logic, hook execution, and tool calling.
@@ -33,6 +34,12 @@ export declare class OperateLoop {
     private createContext;
     private buildInitialRequest;
     private executeOneTurn;
+    /**
+     * Backfill declared array fields when a `format` is supplied. A declared
+     * `format` is a schema contract: an empty array field should surface as `[]`
+     * rather than be dropped by a provider/model that omits empty lists.
+     */
+    private applyFormatArrayDefaults;
     /**
      * Sync the current input state from the updated provider request.
      * This is necessary because appendToolResult modifies the provider-specific request,

package/dist/cjs/operate/StreamLoop.d.ts

@@ -3,11 +3,13 @@ import { LlmStreamChunk } from "../types/LlmStreamChunk.interface.js";
 import { ProviderAdapter } from "./adapters/ProviderAdapter.interface.js";
 import { HookRunner } from "./hooks/index.js";
 import { InputProcessor } from "./input/index.js";
+import { RetryPolicy } from "./retry/index.js";
 export interface StreamLoopConfig {
     adapter: ProviderAdapter;
     client: unknown;
     hookRunner?: HookRunner;
     inputProcessor?: InputProcessor;
+    retryPolicy?: RetryPolicy;
 }
 /**
  * StreamLoop implements streaming multi-turn conversation loop.
@@ -19,6 +21,7 @@ export declare class StreamLoop {
     private readonly client;
     private readonly hookRunnerInstance;
     private readonly inputProcessorInstance;
+    private readonly retryPolicy;
     constructor(config: StreamLoopConfig);
     /**
      * Execute the streaming loop for multi-turn conversations with tool calling.

package/dist/cjs/operate/adapters/AnthropicAdapter.d.ts

@@ -6,6 +6,22 @@ import { LlmHistory, LlmOperateOptions, LlmUsageItem } from "../../types/LlmProv
 import { LlmStreamChunk } from "../../types/LlmStreamChunk.interface.js";
 import { ClassifiedError, OperateRequest, ParsedResponse, ProviderToolDefinition, StandardToolCall, StandardToolResult } from "../types.js";
 import { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
+/**
+ * Local extension of the SDK's `MessageCreateParams` to carry
+ * `output_config.format` (Anthropic native structured outputs). The SDK 0.71
+ * shipped with the older `output_format` field which the API has since
+ * deprecated in favor of `output_config.format`. We send the new shape via
+ * an untyped passthrough so callers don't need a newer SDK; remove this
+ * extension once the SDK types `output_config` directly.
+ */
+type AnthropicRequestParams = Anthropic.MessageCreateParams & {
+    output_config?: {
+        format: {
+            type: "json_schema";
+            schema: JsonObject;
+        };
+    };
+};
 /**
  * AnthropicAdapter implements the ProviderAdapter interface for Anthropic's API.
  * It handles request building, response parsing, and error classification
@@ -13,12 +29,26 @@ import { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
  */
 export declare class AnthropicAdapter extends BaseProviderAdapter {
     readonly name: "anthropic";
-    readonly defaultModel: "claude-sonnet-4-5";
-    buildRequest(request: OperateRequest): Anthropic.MessageCreateParams;
-    formatTools(toolkit: Toolkit, outputSchema?: JsonObject): ProviderToolDefinition[];
+    readonly defaultModel: "claude-sonnet-4-6";
+    private runtimeNoTemperatureModels;
+    private runtimeNoStructuredOutputModels;
+    rememberModelRejectsTemperature(model: string): void;
+    clearRuntimeNoTemperatureModels(): void;
+    rememberModelRejectsStructuredOutput(model: string): void;
+    clearRuntimeNoStructuredOutputModels(): void;
+    private supportsTemperature;
+    private supportsStructuredOutput;
+    buildRequest(request: OperateRequest): AnthropicRequestParams;
+    formatTools(toolkit: Toolkit, _outputSchema?: JsonObject): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
-    executeRequest(client: unknown, request: unknown): Promise<Anthropic.Message>;
-    executeStreamRequest(client: unknown, request: unknown): AsyncIterable<LlmStreamChunk>;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<Anthropic.Message>;
+    /**
+     * Rebuild a structured-output request without `output_format`, swapping in
+     * the legacy fake-tool emulation. Used as a runtime fallback when a model
+     * rejects native `output_config.format`.
+     */
+    private toFallbackStructuredOutputRequest;
+    executeStreamRequest(client: unknown, request: unknown, signal?: AbortSignal): AsyncIterable<LlmStreamChunk>;
     parseResponse(response: unknown, _options?: LlmOperateOptions): ParsedResponse;
     extractToolCalls(response: unknown): StandardToolCall[];
     extractUsage(response: unknown, model: string): LlmUsageItem;
@@ -32,3 +62,4 @@ export declare class AnthropicAdapter extends BaseProviderAdapter {
     private extractContent;
 }
 export declare const anthropicAdapter: AnthropicAdapter;
+export {};

package/dist/cjs/operate/adapters/BedrockAdapter.d.ts

@@ -0,0 +1,78 @@
+import type { ConverseCommandInput, ConverseCommandOutput, DocumentFormat } from "@aws-sdk/client-bedrock-runtime";
+import { JsonObject, NaturalSchema } from "@jaypie/types";
+import { z } from "zod/v4";
+import { Toolkit } from "../../tools/Toolkit.class.js";
+import { LlmHistory, LlmOperateOptions, LlmUsageItem } from "../../types/LlmProvider.interface.js";
+import { LlmStreamChunk } from "../../types/LlmStreamChunk.interface.js";
+import { ClassifiedError, OperateRequest, ParsedResponse, ProviderToolDefinition, StandardToolCall, StandardToolResult } from "../types.js";
+import { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
+type BedrockContentBlock = {
+    text: string;
+} | {
+    toolUse: {
+        toolUseId: string;
+        name: string;
+        input: JsonObject;
+    };
+} | {
+    toolResult: {
+        toolUseId: string;
+        content: Array<{
+            text: string;
+        }>;
+    };
+} | {
+    image: {
+        format: string;
+        source: {
+            bytes: Uint8Array;
+        };
+    };
+} | {
+    document: {
+        format: DocumentFormat;
+        name: string;
+        source: {
+            bytes: Uint8Array;
+        };
+    };
+};
+type BedrockMessage = {
+    role: "user" | "assistant";
+    content: BedrockContentBlock[];
+};
+type BedrockRequest = Omit<ConverseCommandInput, "messages"> & {
+    messages: BedrockMessage[];
+};
+type AnnotatedBedrockResponse = ConverseCommandOutput & {
+    __jaypieStructuredOutput?: boolean;
+};
+export declare class BedrockAdapter extends BaseProviderAdapter {
+    readonly name: "bedrock";
+    readonly defaultModel: "amazon.nova-lite-v1:0";
+    private _modelsFallbackToStructuredOutputTool;
+    private _modelsWithoutTemperature;
+    private rememberModelRejectsOutputConfig;
+    private useFakeToolForStructuredOutput;
+    private rememberModelRejectsTemperature;
+    private supportsTemperature;
+    buildRequest(request: OperateRequest): BedrockRequest;
+    formatTools(toolkit: Toolkit): ProviderToolDefinition[];
+    formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<AnnotatedBedrockResponse>;
+    private toFallbackStructuredOutputRequest;
+    executeStreamRequest(client: unknown, request: unknown, signal?: AbortSignal): AsyncIterable<LlmStreamChunk>;
+    parseResponse(response: unknown, options?: LlmOperateOptions): ParsedResponse;
+    extractToolCalls(response: unknown): StandardToolCall[];
+    extractUsage(response: unknown, model: string): LlmUsageItem;
+    formatToolResult(toolCall: StandardToolCall, result: StandardToolResult): BedrockContentBlock;
+    appendToolResult(request: unknown, toolCall: StandardToolCall, result: StandardToolResult): BedrockRequest;
+    responseToHistoryItems(response: unknown): LlmHistory;
+    classifyError(error: unknown): ClassifiedError;
+    hasStructuredOutput(response: unknown): boolean;
+    extractStructuredOutput(response: unknown): JsonObject | undefined;
+    isComplete(response: unknown): boolean;
+    private extractContentFromMessage;
+}
+export declare const bedrockAdapter: BedrockAdapter;
+export {};

package/dist/cjs/operate/adapters/{GeminiAdapter.d.ts → GoogleAdapter.d.ts}

@@ -5,20 +5,30 @@ import { LlmHistory, LlmOperateOptions, LlmUsageItem } from "../../types/LlmProv
 import { LlmStreamChunk } from "../../types/LlmStreamChunk.interface.js";
 import { ClassifiedError, OperateRequest, ParsedResponse, ProviderToolDefinition, StandardToolCall, StandardToolResult } from "../types.js";
 import { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
-import { GeminiPart, GeminiRawResponse, GeminiRequest } from "../../providers/gemini/types.js";
+import { GeminiPart, GeminiRawResponse, GeminiRequest } from "../../providers/google/types.js";
 /**
- * GeminiAdapter implements the ProviderAdapter interface for Google's Gemini API.
+ * GoogleAdapter implements the ProviderAdapter interface for Google's Gemini API.
  * It handles request building, response parsing, and error classification
  * specific to Gemini's generateContent API.
  */
-export declare class GeminiAdapter extends BaseProviderAdapter {
-    readonly name: "gemini";
-    readonly defaultModel: "gemini-3-pro-preview";
+export declare class GoogleAdapter extends BaseProviderAdapter {
+    readonly name: "google";
+    readonly defaultModel: "gemini-3.1-pro-preview";
+    private runtimeNoStructuredOutputComboModels;
+    rememberModelRejectsStructuredOutputCombo(model: string): void;
+    clearRuntimeNoStructuredOutputComboModels(): void;
+    private supportsStructuredOutputCombo;
     buildRequest(request: OperateRequest): GeminiRequest;
-    formatTools(toolkit: Toolkit, outputSchema?: JsonObject): ProviderToolDefinition[];
+    formatTools(toolkit: Toolkit, _outputSchema?: JsonObject): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
-    executeRequest(client: unknown, request: unknown): Promise<GeminiRawResponse>;
-    executeStreamRequest(client: unknown, request: unknown): AsyncIterable<LlmStreamChunk>;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<GeminiRawResponse>;
+    /**
+     * Rebuild a Gemini 3 native-combo request without `responseJsonSchema`/
+     * `responseMimeType`, swapping in the legacy fake-tool emulation. Used as
+     * a runtime fallback when a Gemini 3 model rejects the combo.
+     */
+    private toFallbackStructuredOutputRequest;
+    executeStreamRequest(client: unknown, request: unknown, signal?: AbortSignal): AsyncIterable<LlmStreamChunk>;
     parseResponse(response: unknown, options?: LlmOperateOptions): ParsedResponse;
     extractToolCalls(response: unknown): StandardToolCall[];
     extractUsage(response: unknown, model: string): LlmUsageItem;
@@ -37,4 +47,4 @@ export declare class GeminiAdapter extends BaseProviderAdapter {
     private extractContent;
     private generateCallId;
 }
-export declare const geminiAdapter: GeminiAdapter;
+export declare const googleAdapter: GoogleAdapter;

package/dist/cjs/operate/adapters/OpenAiAdapter.d.ts

@@ -12,12 +12,16 @@ import { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
  */
 export declare class OpenAiAdapter extends BaseProviderAdapter {
     readonly name: "openai";
-    readonly defaultModel: "gpt-5.2";
+    readonly defaultModel: "gpt-5.4";
+    private runtimeNoTemperatureModels;
+    rememberModelRejectsTemperature(model: string): void;
+    clearRuntimeNoTemperatureModels(): void;
+    private supportsTemperature;
     buildRequest(request: OperateRequest): unknown;
     formatTools(toolkit: Toolkit, _outputSchema?: JsonObject): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
-    executeRequest(client: unknown, request: unknown): Promise<unknown>;
-    executeStreamRequest(client: unknown, request: unknown): AsyncIterable<LlmStreamChunk>;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<unknown>;
+    executeStreamRequest(client: unknown, request: unknown, signal?: AbortSignal): AsyncIterable<LlmStreamChunk>;
     parseResponse(response: unknown, options?: LlmOperateOptions): ParsedResponse;
     extractToolCalls(response: unknown): StandardToolCall[];
     extractUsage(response: unknown, model: string): LlmUsageItem;
@@ -26,6 +30,12 @@ export declare class OpenAiAdapter extends BaseProviderAdapter {
     responseToHistoryItems(response: unknown): LlmHistory;
     classifyError(error: unknown): ClassifiedError;
     isComplete(response: unknown): boolean;
+    /**
+     * Sanitize history items for the OpenAI Responses API.
+     * Strips fields not accepted by specific item types (e.g., `name` on
+     * function_call_output items) to prevent 400 "Unknown parameter" errors.
+     */
+    private sanitizeInputItems;
     private hasToolCalls;
     private extractContent;
 }

package/dist/cjs/operate/adapters/OpenRouterAdapter.d.ts

@@ -59,22 +59,49 @@ interface OpenRouterTool {
         parameters: JsonObject;
     };
 }
+interface OpenRouterJsonSchemaConfig {
+    name: string;
+    description?: string;
+    schema: JsonObject;
+    strict?: boolean;
+}
+type OpenRouterResponseFormat = {
+    type: "json_schema";
+    json_schema: OpenRouterJsonSchemaConfig;
+} | {
+    type: "json_object";
+} | {
+    type: "text";
+};
 interface OpenRouterRequest {
     model: string;
     messages: OpenRouterMessage[];
     tools?: OpenRouterTool[];
     tool_choice?: "auto" | "none" | "required";
-    response_format?: {
-        type: "json_object" | "text";
-    };
+    response_format?: OpenRouterResponseFormat;
     user?: string;
 }
 /**
- * OpenRouter content part types (text only - images/files not supported)
+ * OpenRouter content part types. OpenRouter follows the OpenAI Chat
+ * Completions multimodal schema and forwards `image_url` and `file` parts
+ * to vision/PDF-capable backends. The SDK accepts camelCase fields at the
+ * input boundary (`imageUrl`, `fileData`) and transforms to snake_case on
+ * the wire.
  */
 type OpenRouterContentPart = {
     type: "text";
     text: string;
+} | {
+    type: "image_url";
+    imageUrl: {
+        url: string;
+    };
+} | {
+    type: "file";
+    file: {
+        filename?: string;
+        fileData: string;
+    };
 };
 /**
  * OpenRouterAdapter implements the ProviderAdapter interface for OpenRouter's API.
@@ -84,12 +111,32 @@ type OpenRouterContentPart = {
  */
 export declare class OpenRouterAdapter extends BaseProviderAdapter {
     readonly name: "openrouter";
-    readonly defaultModel: "z-ai/glm-4.7";
+    readonly defaultModel: "anthropic/claude-sonnet-4-6";
+    private runtimeNoStructuredOutputModels;
+    rememberModelRejectsStructuredOutput(model: string): void;
+    clearRuntimeNoStructuredOutputModels(): void;
+    private supportsStructuredOutput;
+    private runtimeNoTemperatureModels;
+    rememberModelRejectsTemperature(model: string): void;
+    clearRuntimeNoTemperatureModels(): void;
+    private supportsTemperature;
     buildRequest(request: OperateRequest): OpenRouterRequest;
-    formatTools(toolkit: Toolkit, outputSchema?: JsonObject): ProviderToolDefinition[];
+    formatTools(toolkit: Toolkit, _outputSchema?: JsonObject): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
-    executeRequest(client: unknown, request: unknown): Promise<OpenRouterResponse>;
-    executeStreamRequest(client: unknown, request: unknown): AsyncIterable<LlmStreamChunk>;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<OpenRouterResponse>;
+    /**
+     * Translate our internal snake_case `OpenRouterRequest` into the SDK's
+     * camelCase shape, forwarding only the fields we care about (the SDK
+     * silently strips unknown fields).
+     */
+    private toSdkChatParams;
+    /**
+     * Rebuild a structured-output request without `response_format`, swapping in
+     * the legacy fake-tool emulation. Used as a runtime fallback when a model
+     * rejects native json_schema.
+     */
+    private toFallbackStructuredOutputRequest;
+    executeStreamRequest(client: unknown, request: unknown, signal?: AbortSignal): AsyncIterable<LlmStreamChunk>;
     parseResponse(response: unknown, _options?: LlmOperateOptions): ParsedResponse;
     extractToolCalls(response: unknown): StandardToolCall[];
     extractUsage(response: unknown, model: string): LlmUsageItem;

package/dist/cjs/operate/adapters/ProviderAdapter.interface.d.ts

@@ -47,17 +47,19 @@ export interface ProviderAdapter {
      *
      * @param client - The provider's SDK client instance
      * @param request - Provider-specific request object (from buildRequest)
+     * @param signal - Optional AbortSignal to cancel the request on retry
      * @returns Raw provider response
      */
-    executeRequest(client: unknown, request: unknown): Promise<unknown>;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<unknown>;
     /**
      * Execute a streaming API request to the provider
      *
      * @param client - The provider's SDK client instance
      * @param request - Provider-specific request object (from buildRequest)
+     * @param signal - Optional AbortSignal to cancel the request on retry
      * @returns AsyncIterable of stream chunks
      */
-    executeStreamRequest?(client: unknown, request: unknown): AsyncIterable<LlmStreamChunk>;
+    executeStreamRequest?(client: unknown, request: unknown, signal?: AbortSignal): AsyncIterable<LlmStreamChunk>;
     /**
      * Parse a provider response into standardized format
      *
@@ -158,7 +160,7 @@ export declare abstract class BaseProviderAdapter implements ProviderAdapter {
     abstract buildRequest(request: OperateRequest): unknown;
     abstract formatTools(toolkit: Toolkit, outputSchema?: JsonObject): ProviderToolDefinition[];
     abstract formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
-    abstract executeRequest(client: unknown, request: unknown): Promise<unknown>;
+    abstract executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<unknown>;
     abstract parseResponse(response: unknown, options?: LlmOperateOptions): ParsedResponse;
     abstract extractToolCalls(response: unknown): StandardToolCall[];
     abstract extractUsage(response: unknown, model: string): LlmUsageItem;

package/dist/cjs/operate/adapters/XaiAdapter.d.ts

@@ -0,0 +1,14 @@
+import { ClassifiedError } from "../types.js";
+import { OpenAiAdapter } from "./OpenAiAdapter.js";
+/**
+ * XaiAdapter extends OpenAiAdapter since xAI (Grok) uses an OpenAI-compatible API.
+ * Name, default model, and transient-ingest-error detection are overridden;
+ * all request building, response parsing, tool handling, and streaming are
+ * inherited.
+ */
+export declare class XaiAdapter extends OpenAiAdapter {
+    readonly name: "xai";
+    readonly defaultModel: "grok-latest";
+    classifyError(error: unknown): ClassifiedError;
+}
+export declare const xaiAdapter: XaiAdapter;

package/dist/cjs/operate/adapters/index.d.ts

@@ -1,6 +1,8 @@
 export { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
 export type { ProviderAdapter } from "./ProviderAdapter.interface.js";
 export { AnthropicAdapter, anthropicAdapter } from "./AnthropicAdapter.js";
-export { GeminiAdapter, geminiAdapter } from "./GeminiAdapter.js";
+export { BedrockAdapter, bedrockAdapter } from "./BedrockAdapter.js";
+export { GoogleAdapter, googleAdapter } from "./GoogleAdapter.js";
 export { OpenAiAdapter, openAiAdapter } from "./OpenAiAdapter.js";
 export { OpenRouterAdapter, openRouterAdapter } from "./OpenRouterAdapter.js";
+export { XaiAdapter, xaiAdapter } from "./XaiAdapter.js";

package/dist/cjs/operate/index.d.ts

@@ -1,4 +1,4 @@
-export { AnthropicAdapter, anthropicAdapter, BaseProviderAdapter, GeminiAdapter, geminiAdapter, OpenAiAdapter, openAiAdapter, OpenRouterAdapter, openRouterAdapter, } from "./adapters/index.js";
+export { AnthropicAdapter, anthropicAdapter, BaseProviderAdapter, BedrockAdapter, bedrockAdapter, GoogleAdapter, googleAdapter, OpenAiAdapter, openAiAdapter, OpenRouterAdapter, openRouterAdapter, XaiAdapter, xaiAdapter, } from "./adapters/index.js";
 export type { ProviderAdapter } from "./adapters/index.js";
 export { createOperateLoop, OperateLoop } from "./OperateLoop.js";
 export type { OperateLoopConfig } from "./OperateLoop.js";

package/dist/cjs/operate/retry/RetryExecutor.d.ts

@@ -28,12 +28,15 @@ export declare class RetryExecutor {
     private readonly errorClassifier;
     constructor(config: RetryExecutorConfig);
     /**
-     * Execute an operation with retry logic
+     * Execute an operation with retry logic.
+     * Each attempt receives an AbortSignal. On failure, the signal is aborted
+     * before sleeping — this kills lingering socket callbacks from the previous
+     * request and prevents stale async errors from escaping the retry loop.
      *
-     * @param operation - The async operation to execute
+     * @param operation - The async operation to execute (receives AbortSignal)
      * @param options - Execution options including context and hooks
      * @returns The result of the operation
      * @throws BadGatewayError if all retries are exhausted or error is not retryable
      */
-    execute<T>(operation: () => Promise<T>, options: ExecuteOptions): Promise<T>;
+    execute<T>(operation: ((signal: AbortSignal) => Promise<T>) | (() => Promise<T>), options: ExecuteOptions): Promise<T>;
 }

package/dist/cjs/operate/retry/createStaleRejectionGuard.d.ts

@@ -0,0 +1,19 @@
+export interface StaleRejectionGuard {
+    /** Install the unhandledRejection listener (idempotent) */
+    install(): void;
+    /** Remove the listener and forget recorded errors */
+    remove(): void;
+    /** Record an error the retry loop has caught and is handling */
+    recordCaught(error: unknown): void;
+}
+/**
+ * Create a guard that suppresses unhandled rejections firing as siblings of
+ * an error the retry loop has already caught. Provider SDKs occasionally
+ * surface a single upstream failure as twin rejections — the retry layer
+ * accepts responsibility for the first; this guard prevents the second from
+ * crashing the host while the retry is in flight.
+ *
+ * The guard also continues to suppress transient socket teardown errors
+ * (e.g. undici `TypeError: terminated`) emitted between attempts.
+ */
+export declare function createStaleRejectionGuard(): StaleRejectionGuard;

package/dist/cjs/operate/retry/index.d.ts

@@ -1,4 +1,5 @@
 export { DEFAULT_BACKOFF_FACTOR, DEFAULT_INITIAL_DELAY_MS, DEFAULT_MAX_DELAY_MS, DEFAULT_MAX_RETRIES, defaultRetryPolicy, MAX_RETRIES_ABSOLUTE_LIMIT, RetryPolicy, } from "./RetryPolicy.js";
 export type { RetryPolicyConfig } from "./RetryPolicy.js";
+export { isTransientNetworkError } from "./isTransientNetworkError.js";
 export { RetryExecutor } from "./RetryExecutor.js";
 export type { ErrorClassifier, ExecuteOptions, RetryContext, RetryExecutorConfig, } from "./RetryExecutor.js";

package/dist/cjs/operate/retry/isTransientNetworkError.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Transient network error detection utility.
+ *
+ * Detects low-level Node.js/undici network errors that indicate
+ * a temporary network issue (not a provider API error).
+ * These errors should always be retried.
+ */
+/**
+ * Detect transient network errors by inspecting the error and its cause chain.
+ *
+ * Undici (Node.js fetch) wraps low-level errors like ECONNRESET inside
+ * `TypeError: terminated`. This function recursively walks `error.cause`
+ * to detect these wrapped errors.
+ *
+ * @param error - The error to inspect
+ * @returns true if the error (or any cause in its chain) is a transient network error
+ */
+export declare function isTransientNetworkError(error: unknown): boolean;

package/dist/cjs/operate/types.d.ts

@@ -117,6 +117,8 @@ import type { ResponseBuilder } from "./response/ResponseBuilder.js";
  * Internal state of the operate loop
  */
 export interface OperateLoopState {
+    /** Count of consecutive tool errors (resets on success) */
+    consecutiveToolErrors: number;
     /** Current conversation input/messages */
     currentInput: LlmHistory;
     /** Current turn number (0-indexed, incremented at start of each turn) */

package/dist/cjs/providers/anthropic/utils.d.ts

@@ -1,9 +1,10 @@
+import { createLogger } from "@jaypie/logger";
 import type Anthropic from "@anthropic-ai/sdk";
 import { LlmMessageOptions } from "../../types/LlmProvider.interface.js";
 import { z } from "zod/v4";
 import { JsonObject, NaturalSchema } from "@jaypie/types";
 export declare function loadSdk(): Promise<typeof import("@anthropic-ai/sdk")>;
-export declare const getLogger: () => any;
+export declare const getLogger: () => ReturnType<typeof createLogger>;
 export declare function initializeClient({ apiKey, }?: {
     apiKey?: string;
 }): Promise<Anthropic>;

package/dist/cjs/providers/bedrock/BedrockProvider.class.d.ts

@@ -0,0 +1,21 @@
+import { JsonObject } from "@jaypie/types";
+import { LlmHistory, LlmInputMessage, LlmMessageOptions, LlmOperateOptions, LlmOperateResponse, LlmProvider } from "../../types/LlmProvider.interface.js";
+import { LlmStreamChunk } from "../../types/LlmStreamChunk.interface.js";
+export declare class BedrockProvider implements LlmProvider {
+    private model;
+    private region?;
+    private _client?;
+    private _operateLoop?;
+    private _streamLoop?;
+    private log;
+    private conversationHistory;
+    constructor(model?: string, { region }?: {
+        region?: string;
+    });
+    private getClient;
+    private getOperateLoop;
+    private getStreamLoop;
+    send(message: string, options?: LlmMessageOptions): Promise<string | JsonObject>;
+    operate(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): Promise<LlmOperateResponse>;
+    stream(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): AsyncIterable<LlmStreamChunk>;
+}

package/dist/cjs/providers/bedrock/index.d.ts

@@ -0,0 +1 @@
+export { BedrockProvider } from "./BedrockProvider.class.js";

package/dist/cjs/providers/bedrock/utils.d.ts

@@ -0,0 +1,7 @@
+import { createLogger } from "@jaypie/logger";
+import type { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
+export declare function loadSdk(): Promise<typeof import("@aws-sdk/client-bedrock-runtime")>;
+export declare const getLogger: () => ReturnType<typeof createLogger>;
+export declare function initializeClient({ region, }?: {
+    region?: string;
+}): Promise<BedrockRuntimeClient>;

package/dist/cjs/providers/{gemini/GeminiProvider.class.d.ts → google/GoogleProvider.class.d.ts}

@@ -1,7 +1,7 @@
 import { JsonObject } from "@jaypie/types";
 import { LlmHistory, LlmInputMessage, LlmMessageOptions, LlmOperateOptions, LlmOperateResponse, LlmProvider } from "../../types/LlmProvider.interface.js";
 import { LlmStreamChunk } from "../../types/LlmStreamChunk.interface.js";
-export declare class GeminiProvider implements LlmProvider {
+export declare class GoogleProvider implements LlmProvider {
     private model;
     private _client?;
     private _operateLoop?;

package/dist/cjs/providers/google/index.d.ts

@@ -0,0 +1,3 @@
+export { GoogleProvider } from "./GoogleProvider.class.js";
+export * from "./types.js";
+export * from "./utils.js";

package/dist/{esm/providers/gemini → cjs/providers/google}/types.d.ts

@@ -72,6 +72,7 @@ export interface GeminiGenerateContentConfig {
     };
     responseMimeType?: string;
     responseJsonSchema?: JsonObject;
+    responseSchema?: JsonObject;
     temperature?: number;
     topP?: number;
     topK?: number;