@compresr/sdk 1.3.1 → 1.5.0

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

@@ -1,6 +1,3 @@
-/**
- * Schema exports
- */
 export { BaseResponseSchema, StreamChunkSchema, HealthResponseSchema, type BaseResponse, type StreamChunk, type HealthResponse, } from './common.js';
-export { CompressRequestSchema, AgnosticBatchInputSchema, AgnosticBatchRequestSchema, CompressBatchInputSchema, CompressBatchRequestSchema, CompressResultSchema, CompressBatchItemResultSchema, CompressBatchResultSchema, CompressResponseSchema, CompressBatchResponseSchema, type CompressRequest, type AgnosticBatchInput, type AgnosticBatchRequest, type CompressBatchInput, type CompressBatchRequest, type CompressResult, type CompressBatchItemResult, type CompressBatchResult, type CompressResponse, type CompressBatchResponse, } from './compression.js';
+export { CompressRequestSchema, CompressBatchInputSchema, CompressBatchRequestSchema, CompressResultSchema, CompressBatchItemResultSchema, CompressBatchResultSchema, CompressResponseSchema, CompressBatchResponseSchema, type CompressRequest, type CompressBatchInput, type CompressBatchRequest, type CompressResult, type CompressBatchItemResult, type CompressBatchResult, type CompressResponse, type CompressBatchResponse, } from './compression.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/schemas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,cAAc,GACpB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,0BAA0B,EAC1B,wBAAwB,EACxB,0BAA0B,EAC1B,oBAAoB,EACpB,6BAA6B,EAC7B,yBAAyB,EACzB,sBAAsB,EACtB,2BAA2B,EAC3B,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,cAAc,GACpB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,0BAA0B,EAC1B,oBAAoB,EACpB,6BAA6B,EAC7B,yBAAyB,EACzB,sBAAsB,EACtB,2BAA2B,EAC3B,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC"}

package/dist/cjs/schemas/index.js

@@ -1,19 +1,12 @@
 "use strict";
-/**
- * Schema exports
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompressBatchResponseSchema = exports.CompressResponseSchema = exports.CompressBatchResultSchema = exports.CompressBatchItemResultSchema = exports.CompressResultSchema = exports.CompressBatchRequestSchema = exports.CompressBatchInputSchema = exports.AgnosticBatchRequestSchema = exports.AgnosticBatchInputSchema = exports.CompressRequestSchema = exports.HealthResponseSchema = exports.StreamChunkSchema = exports.BaseResponseSchema = void 0;
-// Common
+exports.CompressBatchResponseSchema = exports.CompressResponseSchema = exports.CompressBatchResultSchema = exports.CompressBatchItemResultSchema = exports.CompressResultSchema = exports.CompressBatchRequestSchema = exports.CompressBatchInputSchema = exports.CompressRequestSchema = exports.HealthResponseSchema = exports.StreamChunkSchema = exports.BaseResponseSchema = void 0;
 var common_js_1 = require("./common.js");
 Object.defineProperty(exports, "BaseResponseSchema", { enumerable: true, get: function () { return common_js_1.BaseResponseSchema; } });
 Object.defineProperty(exports, "StreamChunkSchema", { enumerable: true, get: function () { return common_js_1.StreamChunkSchema; } });
 Object.defineProperty(exports, "HealthResponseSchema", { enumerable: true, get: function () { return common_js_1.HealthResponseSchema; } });
-// Compression
 var compression_js_1 = require("./compression.js");
 Object.defineProperty(exports, "CompressRequestSchema", { enumerable: true, get: function () { return compression_js_1.CompressRequestSchema; } });
-Object.defineProperty(exports, "AgnosticBatchInputSchema", { enumerable: true, get: function () { return compression_js_1.AgnosticBatchInputSchema; } });
-Object.defineProperty(exports, "AgnosticBatchRequestSchema", { enumerable: true, get: function () { return compression_js_1.AgnosticBatchRequestSchema; } });
 Object.defineProperty(exports, "CompressBatchInputSchema", { enumerable: true, get: function () { return compression_js_1.CompressBatchInputSchema; } });
 Object.defineProperty(exports, "CompressBatchRequestSchema", { enumerable: true, get: function () { return compression_js_1.CompressBatchRequestSchema; } });
 Object.defineProperty(exports, "CompressResultSchema", { enumerable: true, get: function () { return compression_js_1.CompressResultSchema; } });

package/dist/cjs/schemas/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/schemas/index.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,SAAS;AACT,yCAOqB;AANnB,+GAAA,kBAAkB,OAAA;AAClB,8GAAA,iBAAiB,OAAA;AACjB,iHAAA,oBAAoB,OAAA;AAMtB,cAAc;AACd,mDAqB0B;AApBxB,uHAAA,qBAAqB,OAAA;AACrB,0HAAA,wBAAwB,OAAA;AACxB,4HAAA,0BAA0B,OAAA;AAC1B,0HAAA,wBAAwB,OAAA;AACxB,4HAAA,0BAA0B,OAAA;AAC1B,sHAAA,oBAAoB,OAAA;AACpB,+HAAA,6BAA6B,OAAA;AAC7B,2HAAA,yBAAyB,OAAA;AACzB,wHAAA,sBAAsB,OAAA;AACtB,6HAAA,2BAA2B,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/schemas/index.ts"],"names":[],"mappings":";;;AAAA,yCAOqB;AANnB,+GAAA,kBAAkB,OAAA;AAClB,8GAAA,iBAAiB,OAAA;AACjB,iHAAA,oBAAoB,OAAA;AAMtB,mDAiB0B;AAhBxB,uHAAA,qBAAqB,OAAA;AACrB,0HAAA,wBAAwB,OAAA;AACxB,4HAAA,0BAA0B,OAAA;AAC1B,sHAAA,oBAAoB,OAAA;AACpB,+HAAA,6BAA6B,OAAA;AAC7B,2HAAA,yBAAyB,OAAA;AACzB,wHAAA,sBAAsB,OAAA;AACtB,6HAAA,2BAA2B,OAAA"}

package/dist/cjs/version.d.ts

@@ -2,5 +2,5 @@
  * SDK Version - Single source of truth
  * Update this when bumping the version
  */
-export declare const SDK_VERSION = "1.2.0";
+export declare const SDK_VERSION = "1.5.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/cjs/version.js

@@ -5,5 +5,5 @@ exports.SDK_VERSION = void 0;
  * SDK Version - Single source of truth
  * Update this when bumping the version
  */
-exports.SDK_VERSION = '1.2.0';
+exports.SDK_VERSION = '1.5.0';
 //# sourceMappingURL=version.js.map

package/dist/esm/agents/engine.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Provider-agnostic agent engine — TypeScript port of Wave 2A.
+ *
+ * ``CompresrEngine`` wraps LangChain.js's ``initChatModel`` + ``createAgent``
+ * with Compresr's ``compresrToolMiddleware`` and normalizes the final
+ * ``AIMessage`` into a provider-shape-free :class:`NormalizedResult` that
+ * facades will remap back into provider-native shapes.
+ *
+ * Mirrors Python ``compresr/agents/engine.py``.
+ */
+import type { CompressionClient } from '../clients/compression.js';
+import { type ErrorPolicy } from '../integrations/_shared/index.js';
+import { type NormalizedResult } from './normalized.js';
+/**
+ * Immutable bundle of compression knobs forwarded to the tool middleware.
+ *
+ * Mirrors Python ``compresr.integrations._shared.CompressionPolicy``.
+ */
+export interface CompressionPolicyOptions {
+    targetCompressionRatio?: number;
+    compressionModelName?: string;
+    coarse?: boolean;
+    minTokens?: number;
+    onError?: ErrorPolicy;
+    allowTools?: Iterable<string>;
+    ignoreTools?: Iterable<string>;
+}
+/**
+ * Parse an LLM spec into ``{ provider, modelName }``.
+ *
+ * Accepted forms:
+ *  - Bare provider: ``"anthropic"`` -> ``{ provider, modelName: undefined }``.
+ *    The model must then be supplied at the call site.
+ *  - LangChain-style colon: ``"anthropic:claude-opus-4-8"``.
+ *  - Vercel-style slash: ``"anthropic/claude-opus-4-8"`` — normalized to the
+ *    colon form to match LangChain.js's ``initChatModel`` convention.
+ */
+export declare function parseLlmSpec(llm: string): {
+    provider: string;
+    modelName: string | undefined;
+};
+export interface CompresrEngineOptions {
+    compresrClient: CompressionClient;
+    llm: string;
+    llmApiKey?: string;
+    policy?: CompressionPolicyOptions;
+}
+export interface RunOptions {
+    messages: ReadonlyArray<unknown>;
+    tools?: ReadonlyArray<unknown>;
+    system?: string;
+    maxTokens?: number;
+    config?: Record<string, unknown>;
+    /**
+     * Per-call model name. If omitted, falls back to the engine's default
+     * (the model encoded in ``llm: 'provider:model'`` at construction).
+     * When neither is provided, ``run`` throws ``CompresrError("missing_model")``.
+     */
+    model?: string;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    /** Gemini-native alias of ``maxTokens``. The engine aliases when needed. */
+    maxOutputTokens?: number;
+    stop?: string[];
+    stopSequences?: string[];
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    seed?: number;
+    logprobs?: boolean;
+    topLogprobs?: number;
+}
+interface LangChainBindings {
+    initChatModel: (modelStr: string, kwargs?: Record<string, unknown>) => unknown;
+    createAgent: (params: Record<string, unknown>) => unknown;
+}
+/**
+ * Test seam — lets vitest stub LangChain without monkey-patching
+ * ``node_modules``.
+ *
+ * @internal — not a stable public API; reserved for SDK tests only.
+ */
+export declare function _setLangChainBindings(b: LangChainBindings | undefined): void;
+export declare class CompresrEngine {
+    readonly provider: string;
+    /**
+     * Default model bound to the engine, parsed from the constructor's ``llm``
+     * spec. ``undefined`` when the spec is a bare provider — in that case the
+     * model must be supplied per-call on :meth:`run`.
+     */
+    readonly defaultModelName: string | undefined;
+    private readonly compresrClient;
+    private readonly llmApiKey?;
+    private readonly policy;
+    private readonly chatModels;
+    constructor(options: CompresrEngineOptions);
+    /**
+     * Back-compat alias for ``defaultModelName`` — returns the constructor
+     * default and may be ``undefined`` when the engine was built with a bare
+     * provider ``llm`` spec.
+     */
+    get modelName(): string | undefined;
+    private getChatModel;
+    private buildMiddleware;
+    private buildAgent;
+    /**
+     * Pull every option whose key lives in :data:`LLM_BIND_OPTIONS` and return a
+     * fresh object — the caller passes it to ``chat.bind(...)``. Non-LLM keys
+     * are silently ignored, which keeps the public ``RunOptions`` interface
+     * forgiving when callers mix in custom config.
+     *
+     * Gemini quirk: LangChain.js's ``ChatGoogleGenerativeAI`` uses
+     * ``maxOutputTokens`` instead of ``maxTokens``. We alias when the caller
+     * provided ``maxTokens`` without an explicit ``maxOutputTokens``.
+     */
+    private extractBindOptions;
+    run(options: RunOptions): Promise<NormalizedResult>;
+    private normalize;
+}
+export {};
+//# sourceMappingURL=engine.d.ts.map

package/dist/esm/agents/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/agents/engine.ts"],"names":[],"mappings":"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"}

package/dist/esm/agents/engine.js

@@ -0,0 +1,478 @@
+import { CompresrError } from '../errors/index.js';
+import { getLogger } from '../logger.js';
+import { DEFAULT_MIN_TOKENS, DEFAULT_MODEL, DEFAULT_POLICY, DEFAULT_RATIO, } from '../integrations/_shared/index.js';
+import { defaultCompresrStats, } from './normalized.js';
+const KNOWN_PROVIDERS = new Set(['anthropic', 'openai', 'google_genai']);
+/**
+ * Options that propagate to the underlying chat model via ``.bind(...)`` per call.
+ *
+ * Covers Anthropic / OpenAI / Gemini. LangChain.js normalizes most of these
+ * across providers; unsupported keys are silently ignored upstream. Binding is
+ * applied to a fresh wrapper per call so the cached chat model is never
+ * polluted across requests.
+ */
+const LLM_BIND_OPTIONS = new Set([
+    'temperature',
+    'topP',
+    'topK',
+    'maxTokens',
+    'maxOutputTokens',
+    'stop',
+    'stopSequences',
+    'presencePenalty',
+    'frequencyPenalty',
+    'seed',
+    'logprobs',
+    'topLogprobs',
+]);
+function resolvePolicy(input) {
+    const base = input ?? {};
+    const policy = {
+        targetCompressionRatio: base.targetCompressionRatio ?? DEFAULT_RATIO,
+        compressionModelName: base.compressionModelName ?? DEFAULT_MODEL,
+        minTokens: base.minTokens ?? DEFAULT_MIN_TOKENS,
+        onError: base.onError ?? DEFAULT_POLICY,
+        ...(base.coarse !== undefined ? { coarse: base.coarse } : {}),
+        ...(base.allowTools !== undefined
+            ? { allowTools: [...base.allowTools] }
+            : {}),
+        ...(base.ignoreTools !== undefined
+            ? { ignoreTools: [...base.ignoreTools] }
+            : {}),
+    };
+    return policy;
+}
+/**
+ * Parse an LLM spec into ``{ provider, modelName }``.
+ *
+ * Accepted forms:
+ *  - Bare provider: ``"anthropic"`` -> ``{ provider, modelName: undefined }``.
+ *    The model must then be supplied at the call site.
+ *  - LangChain-style colon: ``"anthropic:claude-opus-4-8"``.
+ *  - Vercel-style slash: ``"anthropic/claude-opus-4-8"`` — normalized to the
+ *    colon form to match LangChain.js's ``initChatModel`` convention.
+ */
+export function parseLlmSpec(llm) {
+    // Accept Vercel-style "anthropic/claude-..." by normalizing the first
+    // separator to a colon.
+    const normalized = llm.includes(':')
+        ? llm
+        : llm.includes('/')
+            ? llm.replace('/', ':')
+            : llm;
+    if (!normalized.includes(':')) {
+        // Bare provider — model deferred to the call site.
+        const provider = normalized.trim();
+        if (!provider) {
+            throw new CompresrError("llm must be a provider (e.g. 'anthropic') or 'provider:model' " +
+                "(e.g. 'anthropic:claude-opus-4-8')", 'invalid_llm_spec');
+        }
+        return { provider, modelName: undefined };
+    }
+    const idx = normalized.indexOf(':');
+    const provider = normalized.slice(0, idx).trim();
+    const modelName = normalized.slice(idx + 1).trim();
+    if (!provider || !modelName) {
+        throw new CompresrError("llm must be 'provider:model' (e.g. 'anthropic:claude-opus-4-8')", 'invalid_llm_spec');
+    }
+    return { provider, modelName };
+}
+let cachedLc;
+async function importLangChain() {
+    if (cachedLc)
+        return cachedLc;
+    let mod;
+    try {
+        mod = (await import('langchain'));
+    }
+    catch (exc) {
+        throw new CompresrError('CompresrEngine requires langchain>=1.0. Install with: ' +
+            'npm install langchain @langchain/core', 'missing_peer_dependency');
+    }
+    const initChatModel = mod.initChatModel;
+    const createAgent = mod.createAgent;
+    if (typeof initChatModel !== 'function' || typeof createAgent !== 'function') {
+        throw new CompresrError('langchain package is missing initChatModel / createAgent — ' +
+            'upgrade to langchain>=1.0.', 'missing_peer_dependency');
+    }
+    cachedLc = { initChatModel, createAgent };
+    return cachedLc;
+}
+/**
+ * Test seam — lets vitest stub LangChain without monkey-patching
+ * ``node_modules``.
+ *
+ * @internal — not a stable public API; reserved for SDK tests only.
+ */
+export function _setLangChainBindings(b) {
+    cachedLc = b;
+}
+// ---------------------------------------------------------------------------
+// Normalization helpers
+// ---------------------------------------------------------------------------
+function contentText(msg) {
+    const content = msg?.content;
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const block of content) {
+            if (block && typeof block === 'object') {
+                const b = block;
+                if (b.type === 'text' && typeof b.text === 'string') {
+                    parts.push(b.text);
+                }
+                else if (typeof b.text === 'string') {
+                    parts.push(b.text);
+                }
+            }
+            else if (typeof block === 'string') {
+                parts.push(block);
+            }
+        }
+        return parts.join('');
+    }
+    return '';
+}
+function normalizeContentBlocks(msg) {
+    const m = msg;
+    if (Array.isArray(m?.content_blocks) && m.content_blocks.length > 0) {
+        return [...m.content_blocks];
+    }
+    if (Array.isArray(m?.content)) {
+        return [...m.content];
+    }
+    return [];
+}
+function normalizeToolUses(msg) {
+    const tcs = msg?.tool_calls;
+    if (!Array.isArray(tcs))
+        return [];
+    const out = [];
+    for (const raw of tcs) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const tc = raw;
+        out.push({
+            ...(tc.id !== undefined ? { id: tc.id } : {}),
+            ...(tc.name !== undefined ? { name: tc.name } : {}),
+            ...(tc.args !== undefined ? { input: tc.args } : {}),
+        });
+    }
+    return out;
+}
+function extractCitations(msg) {
+    const out = [];
+    const blocks = normalizeContentBlocks(msg);
+    for (const block of blocks) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const b = block;
+        // Anthropic-style citations on text blocks
+        for (const cit of b.citations ?? []) {
+            if (!cit || typeof cit !== 'object')
+                continue;
+            const c = cit;
+            if (c.type === undefined || c.type === 'web_search_result_location') {
+                if (!c.url)
+                    continue;
+                out.push({
+                    url: c.url,
+                    ...(c.title !== undefined ? { title: c.title } : {}),
+                    ...(c.cited_text !== undefined ? { citedText: c.cited_text } : {}),
+                    providerMetadata: { ...c },
+                });
+            }
+        }
+        // OpenAI Responses: annotations with type="url_citation"
+        for (const ann of b.annotations ?? []) {
+            if (!ann || typeof ann !== 'object')
+                continue;
+            const a = ann;
+            if (a.type === 'url_citation') {
+                if (!a.url)
+                    continue;
+                out.push({
+                    url: a.url,
+                    ...(a.title !== undefined ? { title: a.title } : {}),
+                    ...(a.text !== undefined
+                        ? { citedText: a.text }
+                        : a.cited_text !== undefined
+                            ? { citedText: a.cited_text }
+                            : {}),
+                    providerMetadata: { ...a },
+                });
+            }
+        }
+    }
+    // Gemini grounding metadata
+    const responseMetadata = msg?.response_metadata ?? {};
+    const grounding = responseMetadata['grounding_metadata'] ??
+        {};
+    const chunks = grounding['grounding_chunks'];
+    if (Array.isArray(chunks)) {
+        for (const chunk of chunks) {
+            if (!chunk || typeof chunk !== 'object')
+                continue;
+            const web = (chunk.web ?? {});
+            if (!web.uri)
+                continue;
+            out.push({
+                url: web.uri,
+                ...(web.title !== undefined ? { title: web.title } : {}),
+                providerMetadata: { ...chunk },
+            });
+        }
+    }
+    return out;
+}
+function normalizeStopReason(msg) {
+    const meta = msg
+        ?.response_metadata;
+    const stop = meta?.['stop_reason'] ?? meta?.['finish_reason'];
+    if (typeof stop === 'string' && stop)
+        return stop;
+    return 'end_turn';
+}
+function normalizeUsage(msg) {
+    const direct = msg
+        ?.usage_metadata;
+    if (direct && typeof direct === 'object') {
+        return coerceUsage(direct);
+    }
+    const meta = msg
+        ?.response_metadata;
+    const u = meta?.['usage'];
+    if (u && typeof u === 'object') {
+        return coerceUsage(u);
+    }
+    return {};
+}
+function coerceUsage(raw) {
+    const out = {};
+    for (const [k, v] of Object.entries(raw)) {
+        if (typeof v === 'number')
+            out[k] = v;
+        else if (typeof v === 'string' && !Number.isNaN(Number(v))) {
+            out[k] = Number(v);
+        }
+    }
+    return out;
+}
+function lastAiMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        const ctor = msg?.constructor?.name;
+        if (ctor === 'AIMessage')
+            return msg;
+    }
+    return messages.length > 0 ? messages[messages.length - 1] : null;
+}
+// ---------------------------------------------------------------------------
+// CompresrEngine
+// ---------------------------------------------------------------------------
+export class CompresrEngine {
+    provider;
+    /**
+     * Default model bound to the engine, parsed from the constructor's ``llm``
+     * spec. ``undefined`` when the spec is a bare provider — in that case the
+     * model must be supplied per-call on :meth:`run`.
+     */
+    defaultModelName;
+    compresrClient;
+    llmApiKey;
+    policy;
+    chatModels = new Map();
+    constructor(options) {
+        const { provider, modelName } = parseLlmSpec(options.llm);
+        if (!KNOWN_PROVIDERS.has(provider)) {
+            // Warn-only — LangChain may know providers we don't.
+            getLogger().warn(`agents: unknown provider '${provider}'. ` +
+                `Supported: ${[...KNOWN_PROVIDERS].join(', ')}.`);
+        }
+        this.provider = provider;
+        this.defaultModelName = modelName;
+        this.compresrClient = options.compresrClient;
+        if (options.llmApiKey !== undefined) {
+            this.llmApiKey = options.llmApiKey;
+        }
+        this.policy = resolvePolicy(options.policy);
+    }
+    /**
+     * Back-compat alias for ``defaultModelName`` — returns the constructor
+     * default and may be ``undefined`` when the engine was built with a bare
+     * provider ``llm`` spec.
+     */
+    get modelName() {
+        return this.defaultModelName;
+    }
+    async getChatModel(modelName) {
+        const cached = this.chatModels.get(modelName);
+        if (cached !== undefined)
+            return cached;
+        const { initChatModel } = await importLangChain();
+        const kwargs = {};
+        if (this.llmApiKey !== undefined)
+            kwargs['apiKey'] = this.llmApiKey;
+        let chat;
+        if (this.provider === 'openai') {
+            try {
+                chat = initChatModel(`${this.provider}:${modelName}`, {
+                    ...kwargs,
+                    outputVersion: 'responses/v1',
+                });
+                this.chatModels.set(modelName, chat);
+                return chat;
+            }
+            catch {
+                // older @langchain/openai rejects unknown kwargs
+            }
+        }
+        chat = initChatModel(`${this.provider}:${modelName}`, kwargs);
+        this.chatModels.set(modelName, chat);
+        return chat;
+    }
+    async buildMiddleware() {
+        // Lazy-load the existing langchain middleware so importing the engine
+        // doesn't drag in @langchain/core at module load.
+        const { compresrToolMiddleware } = await import('../integrations/langchain/middleware.js');
+        const mwOpts = {
+            client: this.compresrClient,
+            targetCompressionRatio: this.policy.targetCompressionRatio,
+            compressionModel: this.policy.compressionModelName,
+            minTokens: this.policy.minTokens,
+            onError: this.policy.onError,
+        };
+        if (this.policy.coarse !== undefined)
+            mwOpts['coarse'] = this.policy.coarse;
+        if (this.policy.allowTools !== undefined) {
+            mwOpts['allowTools'] = this.policy.allowTools;
+        }
+        if (this.policy.ignoreTools !== undefined) {
+            mwOpts['ignoreTools'] = this.policy.ignoreTools;
+        }
+        return [
+            compresrToolMiddleware(mwOpts),
+        ];
+    }
+    async buildAgent(chat, tools, system) {
+        const { createAgent } = await importLangChain();
+        const middleware = await this.buildMiddleware();
+        const params = {
+            model: chat,
+            tools: [...tools],
+            middleware,
+        };
+        if (system !== undefined)
+            params['systemPrompt'] = system;
+        try {
+            return createAgent(params);
+        }
+        catch (exc) {
+            // Only retry without ``systemPrompt`` when the error clearly signals
+            // an unknown-keyword failure from an older LangChain. Otherwise
+            // re-throw so we don't mask unrelated bugs (auth, validation, etc.).
+            const message = exc instanceof Error ? exc.message : String(exc);
+            const isUnknownKwarg = /unexpected keyword|unknown (?:argument|kwarg|option)|not a known argument|systemPrompt/i.test(message);
+            if (!isUnknownKwarg || system === undefined) {
+                throw exc;
+            }
+            delete params['systemPrompt'];
+            return createAgent(params);
+        }
+    }
+    /**
+     * Pull every option whose key lives in :data:`LLM_BIND_OPTIONS` and return a
+     * fresh object — the caller passes it to ``chat.bind(...)``. Non-LLM keys
+     * are silently ignored, which keeps the public ``RunOptions`` interface
+     * forgiving when callers mix in custom config.
+     *
+     * Gemini quirk: LangChain.js's ``ChatGoogleGenerativeAI`` uses
+     * ``maxOutputTokens`` instead of ``maxTokens``. We alias when the caller
+     * provided ``maxTokens`` without an explicit ``maxOutputTokens``.
+     */
+    extractBindOptions(options) {
+        const out = {};
+        for (const [key, value] of Object.entries(options)) {
+            if (value === undefined)
+                continue;
+            if (LLM_BIND_OPTIONS.has(key)) {
+                out[key] = value;
+            }
+        }
+        if (this.provider === 'google_genai' &&
+            out['maxTokens'] !== undefined &&
+            out['maxOutputTokens'] === undefined) {
+            const { maxTokens, ...rest } = out;
+            return { ...rest, maxOutputTokens: maxTokens };
+        }
+        return out;
+    }
+    async run(options) {
+        const effectiveModel = options.model ?? this.defaultModelName;
+        if (effectiveModel === undefined) {
+            throw new CompresrError("model is required — set it on the client " +
+                "(llm: 'anthropic:claude-...') or pass it to messages.create({ model: '...' }).", 'missing_model');
+        }
+        const tools = options.tools ?? [];
+        const cachedChat = await this.getChatModel(effectiveModel);
+        const bindOptions = this.extractBindOptions(options);
+        // Bind per call so the cached chat instance stays unpolluted across
+        // concurrent requests with different temperature / maxTokens / etc.
+        let chat = cachedChat;
+        if (Object.keys(bindOptions).length > 0) {
+            const bindable = cachedChat;
+            if (typeof bindable.bind === 'function') {
+                chat = bindable.bind(bindOptions);
+            }
+        }
+        const agent = (await this.buildAgent(chat, tools, options.system));
+        let result;
+        try {
+            result = await Promise.resolve(agent.invoke({ messages: [...options.messages] }, options.config ?? {}));
+        }
+        catch (exc) {
+            // Re-wrap LangChain failures so callers always see a CompresrError
+            // (parity with Python M1). The original error is preserved via
+            // ``cause`` for debugging.
+            if (exc instanceof CompresrError)
+                throw exc;
+            const message = exc instanceof Error ? exc.message : String(exc);
+            const wrapped = new CompresrError(`Agent execution failed: ${message}`, 'agent_execution_failed');
+            // Native ``Error.cause`` is part of ES2022 — preserve the original
+            // for debugging without losing CompresrError typing.
+            wrapped.cause = exc;
+            throw wrapped;
+        }
+        return this.normalize(result);
+    }
+    normalize(agentResult) {
+        const messages = agentResult && typeof agentResult === 'object'
+            ? (agentResult.messages ?? [])
+            : [];
+        const msg = lastAiMessage(messages);
+        if (msg == null) {
+            return {
+                text: '',
+                contentBlocks: [],
+                toolUses: [],
+                citations: [],
+                stopReason: 'end_turn',
+                usage: {},
+                compresrStats: defaultCompresrStats(),
+                raw: null,
+            };
+        }
+        return {
+            text: contentText(msg),
+            contentBlocks: normalizeContentBlocks(msg),
+            toolUses: normalizeToolUses(msg),
+            citations: extractCitations(msg),
+            stopReason: normalizeStopReason(msg),
+            usage: normalizeUsage(msg),
+            compresrStats: defaultCompresrStats(),
+            raw: msg,
+        };
+    }
+}
+//# sourceMappingURL=engine.js.map