@jaypie/llm 1.3.13 → 1.3.15

package/dist/esm/observability/exchangeStore.d.ts

@@ -0,0 +1,20 @@
+import { LlmExchangeEnvelope } from "../types/LlmProvider.interface.js";
+/** Minimal shape of the @jaypie/dynamodb surface this module uses. */
+interface ExchangeStoreSdk {
+    storeExchange: (envelope: LlmExchangeEnvelope) => Promise<unknown>;
+}
+/** Reset the cached resolution. Exposed for tests. */
+export declare function _resetExchangeStore(): void;
+/**
+ * Inject a store to bypass @jaypie/dynamodb resolution. Test-only: the peer
+ * is optional, so the enabled path cannot otherwise be exercised in unit
+ * tests without it installed.
+ */
+export declare function _setExchangeStore(sdk: ExchangeStoreSdk | null): void;
+/**
+ * Persist an exchange envelope via @jaypie/dynamodb when
+ * LLM_EXCHANGE_ENABLED is set. Silent no-op when the flag is unset or the
+ * peer is absent; persister failures are logged and never thrown.
+ */
+export declare function persistExchange(envelope: LlmExchangeEnvelope): Promise<void>;
+export {};

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

@@ -52,11 +52,17 @@ export declare class BedrockAdapter extends BaseProviderAdapter {
     readonly defaultModel: "amazon.nova-pro-v1:0";
     private _modelsFallbackToStructuredOutputTool;
     private _modelsWithoutTemperature;
+    private _modelsWithoutCachePoint;
+    private rememberModelRejectsCachePoint;
+    private supportsCachePoint;
     private rememberModelRejectsOutputConfig;
     private useFakeToolForStructuredOutput;
     private rememberModelRejectsTemperature;
     private supportsTemperature;
     buildRequest(request: OperateRequest): BedrockRequest;
+    /** Remove any cachePoint blocks so the request can be retried unsupported. */
+    private stripCachePoints;
+    private requestHasCachePoints;
     formatTools(toolkit: Toolkit): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
     executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<AnnotatedBedrockResponse>;

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

@@ -21,6 +21,11 @@ export declare class OpenAiAdapter extends BaseProviderAdapter {
     private supportsTemperature;
     /** Whether `reasoning.effort` may be sent for this model. Overridden by xAI. */
     protected supportsReasoningEffort(model: string): boolean;
+    /**
+     * Whether to emit `prompt_cache_key` (OpenAI Responses API). Overridable by
+     * OpenAI-compatible subclasses whose backend rejects the field.
+     */
+    protected supportsPromptCacheKey(): boolean;
     /** Translate a normalized effort to this provider's `reasoning.effort` value. */
     protected mapReasoningEffort(effort: LlmEffort, model: string): LlmEffortMapping;
     buildRequest(request: OperateRequest): unknown;

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

@@ -42,6 +42,13 @@ interface OpenRouterUsage {
     completionTokensDetails?: {
         reasoningTokens?: number;
     };
+    promptTokensDetails?: {
+        cachedTokens?: number;
+        cached_tokens?: number;
+    };
+    prompt_tokens_details?: {
+        cached_tokens?: number;
+    };
 }
 interface OpenRouterResponse {
     id: string;
@@ -95,6 +102,10 @@ interface OpenRouterRequest {
 type OpenRouterContentPart = {
     type: "text";
     text: string;
+    cache_control?: {
+        type: "ephemeral";
+        ttl?: "5m" | "1h";
+    };
 } | {
     type: "image_url";
     imageUrl: {

package/dist/esm/operate/exchange/buildExchangeEnvelope.d.ts

@@ -0,0 +1,16 @@
+import { LlmExchangeEnvelope, LlmHistory, LlmInputMessage, LlmOperateInput, LlmOperateOptions, LlmOperateResponse } from "../../types/LlmProvider.interface.js";
+import { OperateLoopState } from "../types.js";
+/**
+ * Assemble the serializable exchange envelope for one operate() settlement.
+ * The `resolution` block is stamped by the Llm facade, which is the layer
+ * that knows fallback outcome; the loop fills provider/model best-effort.
+ */
+export declare function buildExchangeEnvelope({ duration, initialHistoryLength, input, options, response, startedAt, state, }: {
+    duration: number;
+    initialHistoryLength: number;
+    input: string | LlmHistory | LlmInputMessage | LlmOperateInput;
+    options: LlmOperateOptions;
+    response: LlmOperateResponse;
+    startedAt: string;
+    state: OperateLoopState;
+}): LlmExchangeEnvelope;

package/dist/esm/operate/exchange/emitExchange.d.ts

@@ -0,0 +1,20 @@
+import { LlmExchangeCallback, LlmExchangeEnvelope } from "../../types/LlmProvider.interface.js";
+/**
+ * Truthy-except-"false"/"0" gate on LLM_EXCHANGE_ENABLED, matching the
+ * DD_LLMOBS_ENABLED convention in observability/llmobs.ts.
+ */
+export declare function isExchangeStoreEnabled(): boolean;
+/**
+ * Whether the loop should assemble an exchange envelope at settlement.
+ */
+export declare function isExchangeRequested({ onExchange, }: {
+    onExchange?: LlmExchangeCallback;
+}): boolean;
+/**
+ * Deliver an exchange envelope to a callback. Errors thrown by the callback
+ * are logged and swallowed — exchange capture must never interrupt the call.
+ */
+export declare function emitExchange({ envelope, onExchange, }: {
+    envelope: LlmExchangeEnvelope;
+    onExchange?: LlmExchangeCallback;
+}): Promise<void>;

package/dist/esm/operate/exchange/index.d.ts

@@ -0,0 +1,2 @@
+export { buildExchangeEnvelope } from "./buildExchangeEnvelope.js";
+export { emitExchange, isExchangeRequested, isExchangeStoreEnabled, } from "./emitExchange.js";

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

@@ -1,6 +1,6 @@
 import { JsonObject } from "@jaypie/types";
 import { type LlmEffort } from "../constants.js";
-import { LlmHistory, LlmMessageType, LlmOperateOptions, LlmUsageItem } from "../types/LlmProvider.interface.js";
+import { LlmCache, LlmHistory, LlmMessageType, LlmOperateOptions, LlmUsageItem } from "../types/LlmProvider.interface.js";
 import { Toolkit } from "../tools/Toolkit.class.js";
 /**
  * Standardized tool call representation across providers
@@ -73,6 +73,11 @@ export interface OperateRequest {
     effort?: LlmEffort;
     /** Provider-specific options */
     providerOptions?: JsonObject;
+    /**
+     * Prompt-caching control for the stable prefix (system + tools). `true`/
+     * omitted = enabled@5m, `false`/`0` = disabled, `"5m"`/`"1h"` = enabled@ttl.
+     */
+    cache?: LlmCache;
     /** Whether the request will execute over a streaming transport */
     stream?: boolean;
     /** Sampling temperature (0-2 for most providers) */
@@ -150,6 +155,10 @@ export interface OperateLoopState {
     currentTurn: number;
     /** Formatted output schema for structured output */
     formattedFormat?: JsonObject;
+    /** Stop reason from the most recent model response */
+    lastStopReason?: string;
+    /** Model-request retries across all turns (exchange envelope) */
+    retries: number;
     /** Formatted tools for the provider */
     formattedTools?: ProviderToolDefinition[];
     /** Maximum allowed turns */

package/dist/esm/providers/anthropic/types.d.ts

@@ -2,10 +2,20 @@ import { JsonObject } from "@jaypie/types";
 import { LlmMessageRole } from "../../types/LlmProvider.interface.js";
 export declare const ROLE_MAP: Record<LlmMessageRole, string>;
 export declare namespace Anthropic {
+    interface CacheControlEphemeral {
+        type: "ephemeral";
+        ttl?: "5m" | "1h";
+    }
     interface TextBlock {
         type: "text";
         text: string;
     }
+    /** Top-level `system` block form that can carry a cache breakpoint */
+    interface SystemTextBlockParam {
+        type: "text";
+        text: string;
+        cache_control?: CacheControlEphemeral;
+    }
     interface ToolUseBlock {
         type: "tool_use";
         id: string;
@@ -63,17 +73,20 @@ export declare namespace Anthropic {
         description?: string;
         input_schema: Messages.Tool.InputSchema;
         type?: "custom";
+        cache_control?: CacheControlEphemeral;
     }
     interface Usage {
         input_tokens: number;
         output_tokens: number;
         thinking_tokens?: number;
+        cache_read_input_tokens?: number;
+        cache_creation_input_tokens?: number;
     }
     interface MessageCreateParams {
         model: string;
         messages: MessageParam[];
         max_tokens: number;
-        system?: string;
+        system?: string | SystemTextBlockParam[];
         tools?: Tool[];
         tool_choice?: {
             type: "auto" | "any" | "tool";

package/dist/esm/types/LlmProvider.interface.d.ts

@@ -26,7 +26,7 @@ export declare enum LlmResponseStatus {
     Incomplete = "incomplete",
     InProgress = "in_progress"
 }
-interface LlmError {
+export interface LlmError {
     detail?: string;
     status: number | string;
     title: string;
@@ -212,7 +212,97 @@ export interface LlmProgressEvent {
     usage?: LlmUsage;
 }
 export type LlmProgressCallback = (event: LlmProgressEvent) => unknown | Promise<unknown>;
+/**
+ * Serializable snapshot of the request side of one operate() call.
+ * `input` is the raw, pre-interpolation input with multimodal parts preserved.
+ */
+export interface LlmExchangeRequest {
+    cache?: LlmCache;
+    data?: NaturalMap;
+    effort?: LlmEffort;
+    explain?: boolean;
+    /** Format normalized to JSON Schema (Zod/Natural already rendered) */
+    format?: JsonObject;
+    input: string | LlmHistory | LlmInputMessage | LlmOperateInput;
+    instructions?: string;
+    /** Requested model (pre-fallback) */
+    model?: string;
+    placeholders?: {
+        input?: boolean;
+        instructions?: boolean;
+        system?: boolean;
+    };
+    providerOptions?: JsonObject;
+    system?: string;
+    temperature?: number;
+    /** Names of tools offered to the model */
+    tools?: string[];
+    turns?: boolean | number;
+    user?: string;
+}
+/**
+ * Serializable snapshot of the response side of one operate() call.
+ */
+export interface LlmExchangeResponse {
+    content?: string | JsonObject;
+    error?: LlmError;
+    /** Turns this call added to history (tool calls/results included); never the resent history */
+    historyDelta: LlmHistory;
+    reasoning?: string[];
+    status: LlmResponseStatus;
+    stopReason?: string;
+    /** Per-model-call usage items (provider/model on each item) */
+    usage: LlmUsage;
+    /** Cumulative usage keyed `provider:model` */
+    usageTotals?: Record<string, LlmUsageItem>;
+}
+/**
+ * How the call was actually served after fallback and retry resolution.
+ */
+export interface LlmExchangeResolution {
+    fallbackAttempts?: number;
+    fallbackUsed?: boolean;
+    /** Served model */
+    model?: string;
+    /** Served provider */
+    provider?: string;
+    /** Model-request retries within the served attempt */
+    retries?: number;
+}
+export interface LlmExchangeTiming {
+    /** Milliseconds from start to settlement */
+    duration: number;
+    /** ISO 8601 */
+    startedAt: string;
+}
+/**
+ * One serializable request/response envelope per operate() settlement
+ * (success or failure). Contains no functions.
+ */
+export interface LlmExchangeEnvelope {
+    /** Provider response id(s) per model turn, when available */
+    ids?: string[];
+    request: LlmExchangeRequest;
+    resolution: LlmExchangeResolution;
+    response: LlmExchangeResponse;
+    timing: LlmExchangeTiming;
+}
+export type LlmExchangeCallback = (envelope: LlmExchangeEnvelope) => unknown | Promise<unknown>;
+/**
+ * Prompt-caching control for operate()/stream().
+ * - `true` / omitted → caching enabled at the default `"5m"` TTL
+ * - `false` / `0` → caching disabled
+ * - `"5m"` / `"1h"` → enabled at that TTL (TTL honored by Anthropic/OpenRouter;
+ *   other providers ignore it and cache with their own defaults)
+ */
+export type LlmCache = boolean | 0 | "5m" | "1h";
 export interface LlmOperateOptions {
+    /**
+     * Prompt caching for the stable request prefix (system prompt + tools).
+     * Enabled by default; pass `false`/`0` to opt out, or `"5m"`/`"1h"` to set
+     * the TTL. See {@link LlmCache}.
+     */
+    cache?: LlmCache;
     data?: NaturalMap;
     /**
      * Provider-neutral reasoning effort (lowest | low | medium | high | highest).
@@ -276,6 +366,12 @@ export interface LlmOperateOptions {
     };
     instructions?: string;
     model?: string;
+    /**
+     * Fires once per operate() settlement (success or failure) with a fully
+     * serializable request/response envelope. Errors thrown by the callback
+     * are logged and never interrupt the call.
+     */
+    onExchange?: LlmExchangeCallback;
     /**
      * Receives lightweight progress events as the operate loop runs:
      * start, model_request, model_response, tool_call, tool_result,
@@ -315,6 +411,10 @@ export interface LlmUsageItem {
     output: number;
     reasoning: number;
     total: number;
+    /** Prompt-cache tokens served from cache this call (billed at ~0.1x input) */
+    cacheRead?: number;
+    /** Prompt-cache tokens written to cache this call (billed at ~1.25x input) */
+    cacheWrite?: number;
     provider?: string;
     model?: string;
 }
@@ -322,6 +422,11 @@ export type LlmUsage = LlmUsageItem[];
 export interface LlmOperateResponse {
     content?: string | JsonObject;
     error?: LlmError;
+    /**
+     * Serializable exchange envelope for this call. Present only when
+     * `onExchange` was passed or exchange persistence is enabled.
+     */
+    exchange?: LlmExchangeEnvelope;
     /** Number of providers attempted (1 = primary only, >1 = fallback(s) used) */
     fallbackAttempts?: number;
     /** Whether a fallback provider was used instead of the primary */

package/dist/esm/util/cacheControl.d.ts

@@ -0,0 +1,21 @@
+import { type LlmCache } from "../types/LlmProvider.interface.js";
+export declare const CACHE_TTL_DEFAULT: "5m";
+export type CacheTtl = "5m" | "1h";
+export interface ResolvedCache {
+    enabled: boolean;
+    ttl: CacheTtl;
+}
+/**
+ * Normalize the caller-facing `cache` option into a concrete decision.
+ * - `undefined` / `true` → enabled at the default TTL
+ * - `false` / `0` → disabled
+ * - `"5m"` / `"1h"` → enabled at that TTL
+ */
+export declare function resolveCache(cache: LlmCache | undefined): ResolvedCache;
+/**
+ * Deterministic short key for providers with automatic, prefix-based caching
+ * (e.g. OpenAI `prompt_cache_key`). Derived from the stable prefix so the same
+ * system prompt + tools + model always routes to the same cache. Dependency-
+ * free FNV-1a; not cryptographic.
+ */
+export declare function promptCacheKey(seed: string): string;

package/dist/esm/util/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./cacheControl.js";
 export * from "./determineModelProvider.js";
 export * from "./extractReasoning.js";
 export * from "./fillFormatArrays.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaypie/llm",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "description": "Large language model utilities",
   "repository": {
     "type": "git",
@@ -55,12 +55,16 @@
   },
   "peerDependencies": {
     "@aws-sdk/client-bedrock-runtime": "^3.1045.0",
+    "@jaypie/dynamodb": "*",
     "@jaypie/kit": "*",
     "@jaypie/logger": "*"
   },
   "peerDependenciesMeta": {
     "@aws-sdk/client-bedrock-runtime": {
       "optional": true
+    },
+    "@jaypie/dynamodb": {
+      "optional": true
     }
   },
   "publishConfig": {