@ebowwa/coder 0.7.63 → 0.7.64

package/dist/core/image.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Image Processing Module
+ */
+import type { MediaType, ImageBlock } from "../types/index.js";
+/**
+ * Supported image extensions
+ */
+export declare const IMAGE_EXTENSIONS: Set<string>;
+/**
+ * Binary file exclusions (CI8 set in binary)
+ * These are NOT processed as images - treated as binary
+ */
+export declare const BINARY_EXCLUSIONS: Set<string>;
+/**
+ * Size limits (from binary)
+ */
+export declare const MAX_IMAGE_TOKENS = 25000;
+export declare const MAX_FILE_SIZE = 5242880;
+export declare const MAX_DIMENSION = 3932160;
+/**
+ * Resize fallback settings (from binary)
+ */
+export declare const FALLBACK_MAX_DIMENSION = 400;
+export declare const FALLBACK_JPEG_QUALITY = 20;
+/**
+ * Detect MIME type from file magic bytes (ObT function in binary)
+ * Not just extension-based - inspects file header
+ */
+export declare function detectMimeType(bytes: Buffer): MediaType | null;
+export interface ImageFileResult {
+    type: "image";
+    base64: string;
+    mediaType: MediaType;
+    originalSize: number;
+    dimensions?: {
+        originalWidth?: number;
+        originalHeight?: number;
+        displayWidth?: number;
+        displayHeight?: number;
+    };
+}
+/**
+ * Read and process an image file (bwA function in binary)
+ *
+ * Flow:
+ * 1. Read file as bytes
+ * 2. Detect MIME type from magic bytes
+ * 3. Process with sharp library
+ * 4. Check token limit and resize if needed
+ * 5. Return base64-encoded result
+ */
+export declare function readImageFile(filePath: string, maxTokens?: number, signal?: AbortSignal): Promise<ImageFileResult>;
+/**
+ * Check if a file extension is a supported image
+ */
+export declare function isImageExtension(extension: string): boolean;
+/**
+ * Check if a file extension should be treated as binary (not image)
+ */
+export declare function isBinaryExclusion(extension: string): boolean;
+/**
+ * Convert ImageFileResult to API ImageBlock format
+ */
+export declare function toImageBlock(result: ImageFileResult): ImageBlock;
+/**
+ * Format image result for tool output
+ */
+export declare function formatImageResult(result: ImageFileResult): string;
+//# sourceMappingURL=image.d.ts.map

package/dist/core/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../packages/src/core/image.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAM/D;;GAEG;AACH,eAAO,MAAM,gBAAgB,aAAiD,CAAC;AAE/E;;;GAGG;AACH,eAAO,MAAM,iBAAiB,aAsB5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAAQ,CAAC;AACtC,eAAO,MAAM,aAAa,UAAU,CAAC;AACrC,eAAO,MAAM,aAAa,UAAU,CAAC;AAErC;;GAEG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAoBxC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CA0B9D;AAMD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE;QACX,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;CACH;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,MAAyB,EACpC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,eAAe,CAAC,CAmI1B;AAwCD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAG3D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAG5D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,UAAU,CAShE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAOjE"}

package/dist/core/image.js

@@ -0,0 +1,290 @@
+/**
+ * Image Processing Module
+ */
+import sharp from "sharp";
+// ============================================
+// CONSTANTS
+// ============================================
+/**
+ * Supported image extensions
+ */
+export const IMAGE_EXTENSIONS = new Set(["png", "jpg", "jpeg", "gif", "webp"]);
+/**
+ * Binary file exclusions (CI8 set in binary)
+ * These are NOT processed as images - treated as binary
+ */
+export const BINARY_EXCLUSIONS = new Set([
+    // Audio/Video
+    "mp3", "wav", "flac", "ogg", "aac", "m4a", "wma", "aiff", "opus",
+    "mp4", "avi", "mov", "wmv", "flv", "mkv", "webm", "m4v", "mpeg", "mpg",
+    // Archives
+    "zip", "rar", "tar", "gz", "bz2", "7z", "xz", "z", "tgz", "iso",
+    // Executables
+    "exe", "dll", "so", "dylib", "app", "msi", "deb", "rpm", "bin",
+    // Databases
+    "dat", "db", "sqlite", "sqlite3", "mdb", "idx",
+    // Documents
+    "doc", "docx", "xls", "xlsx", "ppt", "pptx", "odt", "ods", "odp",
+    // Fonts
+    "ttf", "otf", "woff", "woff2", "eot",
+    // Design files
+    "psd", "ai", "eps", "sketch", "fig", "xd",
+    // 3D
+    "blend", "obj", "3ds", "max",
+    // Compiled code
+    "class", "jar", "war", "pyc", "pyo", "rlib",
+    // Other
+    "swf", "fla"
+]);
+/**
+ * Size limits (from binary)
+ */
+export const MAX_IMAGE_TOKENS = 25000; // muA() default
+export const MAX_FILE_SIZE = 5242880; // 5MB a2T
+export const MAX_DIMENSION = 3932160; // MP total pixels
+/**
+ * Resize fallback settings (from binary)
+ */
+export const FALLBACK_MAX_DIMENSION = 400;
+export const FALLBACK_JPEG_QUALITY = 20;
+// ============================================
+// MIME TYPE DETECTION (ObT function in binary)
+// ============================================
+/**
+ * Magic byte signatures for image formats
+ */
+const MAGIC_SIGNATURES = [
+    // PNG: 89 50 4E 47
+    { signature: [0x89, 0x50, 0x4E, 0x47], mimeType: "image/png" },
+    // JPEG: FF D8 FF
+    { signature: [0xFF, 0xD8, 0xFF], mimeType: "image/jpeg" },
+    // GIF: 47 49 46 38
+    { signature: [0x47, 0x49, 0x46, 0x38], mimeType: "image/gif" },
+    // WEBP: 52 49 46 46 ... 57 45 42 50 (at offset 8)
+    { signature: [0x52, 0x49, 0x46, 0x46], mimeType: "image/webp" },
+];
+/**
+ * Detect MIME type from file magic bytes (ObT function in binary)
+ * Not just extension-based - inspects file header
+ */
+export function detectMimeType(bytes) {
+    if (bytes.length < 4)
+        return null;
+    for (const { signature, mimeType } of MAGIC_SIGNATURES) {
+        let matches = true;
+        for (let i = 0; i < signature.length; i++) {
+            if (bytes[i] !== signature[i]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches) {
+            // Special case for WEBP - verify RIFF...WEBP pattern
+            if (mimeType === "image/webp") {
+                if (bytes.length >= 12 &&
+                    bytes[8] === 0x57 && bytes[9] === 0x45 &&
+                    bytes[10] === 0x42 && bytes[11] === 0x50) {
+                    return "image/webp";
+                }
+                continue;
+            }
+            return mimeType;
+        }
+    }
+    return null;
+}
+/**
+ * Read and process an image file (bwA function in binary)
+ *
+ * Flow:
+ * 1. Read file as bytes
+ * 2. Detect MIME type from magic bytes
+ * 3. Process with sharp library
+ * 4. Check token limit and resize if needed
+ * 5. Return base64-encoded result
+ */
+export async function readImageFile(filePath, maxTokens = MAX_IMAGE_TOKENS, signal) {
+    // 1. Read file as bytes
+    const file = Bun.file(filePath);
+    const bytes = Buffer.from(await file.arrayBuffer());
+    if (bytes.length === 0) {
+        throw new Error(`Image file is empty: ${filePath}`);
+    }
+    // Check file size limit
+    if (bytes.length > MAX_FILE_SIZE) {
+        throw new Error(`Image file too large: ${filePath} (${(bytes.length / 1024 / 1024).toFixed(2)}MB > 5MB limit)`);
+    }
+    // 2. Detect MIME type from magic bytes (ObT function)
+    const detectedMimeType = detectMimeType(bytes);
+    if (!detectedMimeType) {
+        throw new Error(`Unsupported image format: ${filePath}`);
+    }
+    // 3. Process with sharp library
+    let image = sharp(bytes);
+    const metadata = await image.metadata();
+    const dimensions = {
+        originalWidth: metadata.width,
+        originalHeight: metadata.height,
+    };
+    // Check dimension limits
+    const totalPixels = (metadata.width || 0) * (metadata.height || 0);
+    if (totalPixels > MAX_DIMENSION) {
+        // Need to resize
+        const scale = Math.sqrt(MAX_DIMENSION / totalPixels);
+        const newWidth = Math.round((metadata.width || 1) * scale);
+        const newHeight = Math.round((metadata.height || 1) * scale);
+        image = sharp(bytes).resize(newWidth, newHeight, {
+            fit: "inside",
+            withoutEnlargement: true,
+        });
+    }
+    // 4. Get processed buffer
+    let outputFormat = metadata.format || "jpeg";
+    let outputBuffer;
+    // Determine output format based on input
+    if (outputFormat === "png") {
+        outputBuffer = await image.png().toBuffer();
+    }
+    else if (outputFormat === "webp") {
+        outputBuffer = await image.webp().toBuffer();
+    }
+    else if (outputFormat === "gif") {
+        outputBuffer = await image.gif().toBuffer();
+    }
+    else {
+        // Default to JPEG for everything else
+        outputBuffer = await image.jpeg({ quality: 85 }).toBuffer();
+        outputFormat = "jpeg";
+    }
+    // 5. Check token limit and resize if needed
+    const base64 = outputBuffer.toString("base64");
+    const estimatedTokens = Math.ceil(base64.length * 0.125);
+    if (estimatedTokens > maxTokens) {
+        // Resize to fit within token limit
+        try {
+            const resizedBuffer = await resizeForTokenLimit(bytes, maxTokens);
+            const resizedBase64 = resizedBuffer.toString("base64");
+            // Get final dimensions
+            const finalMeta = await sharp(resizedBuffer).metadata();
+            return {
+                type: "image",
+                base64: resizedBase64,
+                mediaType: "image/jpeg", // Resized images are always JPEG
+                originalSize: bytes.length,
+                dimensions: {
+                    originalWidth: metadata.width,
+                    originalHeight: metadata.height,
+                    displayWidth: finalMeta.width,
+                    displayHeight: finalMeta.height,
+                },
+            };
+        }
+        catch (resizeErr) {
+            // Final fallback: aggressive resize with sharp
+            const smallImage = await sharp(bytes)
+                .resize(FALLBACK_MAX_DIMENSION, FALLBACK_MAX_DIMENSION, {
+                fit: "inside",
+                withoutEnlargement: true,
+            })
+                .jpeg({ quality: FALLBACK_JPEG_QUALITY })
+                .toBuffer();
+            const finalMeta = await sharp(smallImage).metadata();
+            return {
+                type: "image",
+                base64: smallImage.toString("base64"),
+                mediaType: "image/jpeg",
+                originalSize: bytes.length,
+                dimensions: {
+                    originalWidth: metadata.width,
+                    originalHeight: metadata.height,
+                    displayWidth: finalMeta.width,
+                    displayHeight: finalMeta.height,
+                },
+            };
+        }
+    }
+    // Map format to MediaType
+    const mediaType = outputFormat === "jpeg" ? "image/jpeg" :
+        outputFormat === "png" ? "image/png" :
+            outputFormat === "gif" ? "image/gif" :
+                outputFormat === "webp" ? "image/webp" :
+                    "image/jpeg";
+    return {
+        type: "image",
+        base64,
+        mediaType,
+        originalSize: bytes.length,
+        dimensions: {
+            originalWidth: metadata.width,
+            originalHeight: metadata.height,
+            displayWidth: metadata.width,
+            displayHeight: metadata.height,
+        },
+    };
+}
+/**
+ * Resize image to fit within token limit
+ */
+async function resizeForTokenLimit(bytes, maxTokens) {
+    // Target ~80% of max tokens for safety margin
+    const targetBase64Length = Math.floor((maxTokens * 0.8) / 0.125);
+    const targetBufferSize = Math.floor(targetBase64Length * 0.75); // base64 is ~4/3 of binary
+    const image = sharp(bytes);
+    const metadata = await image.metadata();
+    // Calculate scale factor needed
+    const currentSize = bytes.length;
+    if (currentSize <= targetBufferSize) {
+        return bytes;
+    }
+    const scaleFactor = Math.sqrt(targetBufferSize / currentSize);
+    const newWidth = Math.round((metadata.width || 1) * scaleFactor);
+    const newHeight = Math.round((metadata.height || 1) * scaleFactor);
+    // Resize and convert to JPEG
+    return sharp(bytes)
+        .resize(newWidth, newHeight, {
+        fit: "inside",
+        withoutEnlargement: true,
+    })
+        .jpeg({ quality: 70 })
+        .toBuffer();
+}
+// ============================================
+// HELPER FUNCTIONS
+// ============================================
+/**
+ * Check if a file extension is a supported image
+ */
+export function isImageExtension(extension) {
+    const ext = extension.toLowerCase().replace(/^\./, "");
+    return IMAGE_EXTENSIONS.has(ext);
+}
+/**
+ * Check if a file extension should be treated as binary (not image)
+ */
+export function isBinaryExclusion(extension) {
+    const ext = extension.toLowerCase().replace(/^\./, "");
+    return BINARY_EXCLUSIONS.has(ext);
+}
+/**
+ * Convert ImageFileResult to API ImageBlock format
+ */
+export function toImageBlock(result) {
+    return {
+        type: "image",
+        source: {
+            type: "base64",
+            data: result.base64,
+            media_type: result.mediaType,
+        },
+    };
+}
+/**
+ * Format image result for tool output
+ */
+export function formatImageResult(result) {
+    const dims = result.dimensions;
+    const dimStr = dims?.originalWidth && dims?.originalHeight
+        ? ` (${dims.originalWidth}x${dims.originalHeight}${dims.displayWidth !== dims.originalWidth ? ` → ${dims.displayWidth}x${dims.displayHeight}` : ''})`
+        : '';
+    return `[Image: ${result.mediaType}${dimStr}, ${(result.originalSize / 1024).toFixed(1)}KB original]`;
+}

package/dist/core/image.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=image.test.d.ts.map

package/dist/core/image.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.test.d.ts","sourceRoot":"","sources":["../../packages/src/core/image.test.ts"],"names":[],"mappings":""}

package/dist/core/image.test.js

@@ -0,0 +1,149 @@
+import { test, expect, describe } from "bun:test";
+import { IMAGE_EXTENSIONS, BINARY_EXCLUSIONS, detectMimeType, isImageExtension, isBinaryExclusion, readImageFile, toImageBlock, formatImageResult, } from "./image.js";
+describe("Image Extensions", () => {
+    test("IMAGE_EXTENSIONS contains supported formats", () => {
+        expect(IMAGE_EXTENSIONS.has("png")).toBe(true);
+        expect(IMAGE_EXTENSIONS.has("jpg")).toBe(true);
+        expect(IMAGE_EXTENSIONS.has("jpeg")).toBe(true);
+        expect(IMAGE_EXTENSIONS.has("gif")).toBe(true);
+        expect(IMAGE_EXTENSIONS.has("webp")).toBe(true);
+    });
+    test("IMAGE_EXTENSIONS does not contain unsupported formats", () => {
+        expect(IMAGE_EXTENSIONS.has("bmp")).toBe(false);
+        expect(IMAGE_EXTENSIONS.has("svg")).toBe(false);
+        expect(IMAGE_EXTENSIONS.has("pdf")).toBe(false);
+    });
+});
+describe("Binary Exclusions", () => {
+    test("BINARY_EXCLUSIONS contains common binary formats", () => {
+        expect(BINARY_EXCLUSIONS.has("exe")).toBe(true);
+        expect(BINARY_EXCLUSIONS.has("zip")).toBe(true);
+        expect(BINARY_EXCLUSIONS.has("mp4")).toBe(true);
+        expect(BINARY_EXCLUSIONS.has("doc")).toBe(true);
+    });
+    test("PDF is NOT in binary exclusions (handled separately)", () => {
+        // PDF files can be read with page limits, not in exclusions
+        expect(BINARY_EXCLUSIONS.has("pdf")).toBe(false);
+    });
+});
+describe("isImageExtension", () => {
+    test("returns true for image extensions", () => {
+        expect(isImageExtension("png")).toBe(true);
+        expect(isImageExtension("jpg")).toBe(true);
+        expect(isImageExtension(".jpeg")).toBe(true);
+        expect(isImageExtension("GIF")).toBe(true);
+    });
+    test("returns false for non-image extensions", () => {
+        expect(isImageExtension("txt")).toBe(false);
+        expect(isImageExtension("pdf")).toBe(false);
+        expect(isImageExtension("exe")).toBe(false);
+    });
+});
+describe("isBinaryExclusion", () => {
+    test("returns true for binary exclusions", () => {
+        expect(isBinaryExclusion("exe")).toBe(true);
+        expect(isBinaryExclusion("zip")).toBe(true);
+        expect(isBinaryExclusion("mp4")).toBe(true);
+    });
+    test("returns false for text files", () => {
+        expect(isBinaryExclusion("txt")).toBe(false);
+        expect(isBinaryExclusion("md")).toBe(false);
+    });
+});
+describe("detectMimeType", () => {
+    test("detects PNG magic bytes", () => {
+        // PNG magic bytes: 89 50 4E 47
+        const pngHeader = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]);
+        expect(detectMimeType(pngHeader)).toBe("image/png");
+    });
+    test("detects JPEG magic bytes", () => {
+        // JPEG magic bytes: FF D8 FF
+        const jpegHeader = Buffer.from([0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10]);
+        expect(detectMimeType(jpegHeader)).toBe("image/jpeg");
+    });
+    test("detects GIF magic bytes", () => {
+        // GIF magic bytes: 47 49 46 38
+        const gifHeader = Buffer.from([0x47, 0x49, 0x46, 0x38, 0x39, 0x61]);
+        expect(detectMimeType(gifHeader)).toBe("image/gif");
+    });
+    test("detects WEBP magic bytes", () => {
+        // WEBP: RIFF....WEBP
+        const webpHeader = Buffer.from([
+            0x52, 0x49, 0x46, 0x46, // RIFF
+            0x00, 0x00, 0x00, 0x00, // size
+            0x57, 0x45, 0x42, 0x50, // WEBP
+        ]);
+        expect(detectMimeType(webpHeader)).toBe("image/webp");
+    });
+    test("returns null for unknown data", () => {
+        const unknownData = Buffer.from([0x00, 0x01, 0x02, 0x03]);
+        expect(detectMimeType(unknownData)).toBe(null);
+    });
+    test("returns null for empty buffer", () => {
+        expect(detectMimeType(Buffer.alloc(0))).toBe(null);
+    });
+});
+describe("toImageBlock", () => {
+    test("converts ImageFileResult to ImageBlock", () => {
+        const result = {
+            type: "image",
+            base64: "dGVzdCBkYXRh", // "test data" in base64
+            mediaType: "image/png",
+            originalSize: 1000,
+            dimensions: {
+                originalWidth: 100,
+                originalHeight: 100,
+                displayWidth: 100,
+                displayHeight: 100,
+            },
+        };
+        const block = toImageBlock(result);
+        expect(block.type).toBe("image");
+        expect(block.source.type).toBe("base64");
+        expect(block.source.data).toBe("dGVzdCBkYXRh");
+        expect(block.source.media_type).toBe("image/png");
+    });
+});
+describe("formatImageResult", () => {
+    test("formats image result with dimensions", () => {
+        const result = {
+            type: "image",
+            base64: "dGVzdA==",
+            mediaType: "image/png",
+            originalSize: 1024,
+            dimensions: {
+                originalWidth: 100,
+                originalHeight: 200,
+                displayWidth: 100,
+                displayHeight: 200,
+            },
+        };
+        const formatted = formatImageResult(result);
+        expect(formatted).toContain("image/png");
+        expect(formatted).toContain("100x200");
+        expect(formatted).toContain("1.0KB");
+    });
+    test("formats image result without dimensions", () => {
+        const result = {
+            type: "image",
+            base64: "dGVzdA==",
+            mediaType: "image/jpeg",
+            originalSize: 2048,
+            dimensions: {},
+        };
+        const formatted = formatImageResult(result);
+        expect(formatted).toContain("image/jpeg");
+        expect(formatted).toContain("2.0KB");
+    });
+});
+describe("readImageFile", () => {
+    test("throws error for non-existent file", async () => {
+        try {
+            await readImageFile("/non/existent/file.png");
+            expect(true).toBe(false); // Should not reach here
+        }
+        catch (error) {
+            expect(error).toBeDefined();
+        }
+    });
+});

package/dist/core/models.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Model Configuration - Single Source of Truth
+ * Consolidates all model-related constants, types, and utilities
+ */
+export interface ModelDefinition {
+    /** Model ID (e.g., "claude-opus-4-6") */
+    id: string;
+    /** Short display name (e.g., "Opus 4.6") */
+    name: string;
+    /** Full display name (e.g., "Claude Opus 4.6") - for /models command */
+    fullName: string;
+    /** Context window in tokens */
+    contextWindow: number;
+    /** Maximum output tokens (optional, defaults to contextWindow/4) */
+    maxOutput?: number;
+    /** Pricing per 1M tokens in USD */
+    pricing: {
+        input: number;
+        output: number;
+        cacheWrite: number;
+        cacheRead: number;
+    };
+    /** Whether model supports extended thinking */
+    supportsThinking: boolean;
+    /** Model provider */
+    provider: "anthropic" | "zhipu" | "openai" | "other";
+    /** Whether model supports vision/images */
+    supportsVision: boolean;
+}
+/**
+ * All available models with complete configuration
+ */
+export declare const MODELS: Record<string, ModelDefinition>;
+/** Models available for interactive use (shown in /models command) */
+export declare const AVAILABLE_MODELS: readonly [ModelDefinition, ModelDefinition, ModelDefinition, ModelDefinition];
+/** Model aliases for subagent tasks */
+export declare const MODEL_ALIASES: {
+    readonly haiku: "claude-haiku-4-5";
+    readonly sonnet: "claude-sonnet-4-6";
+    readonly opus: "claude-opus-4-6";
+    readonly fast: "glm-4.5-air";
+    readonly default: "claude-sonnet-4-6";
+};
+/** Default model for interactive use */
+export declare const DEFAULT_MODEL = "claude-sonnet-4-6";
+/** Default model for summarization (fast/cheap) */
+export declare const SUMMARIZATION_MODEL: string;
+/** Default context window if model not found */
+export declare const DEFAULT_CONTEXT_WINDOW = 200000;
+/** Default max output tokens if not specified */
+export declare const DEFAULT_MAX_OUTPUT = 4096;
+/**
+ * Get model definition by ID
+ */
+export declare function getModel(modelId: string): ModelDefinition | undefined;
+/**
+ * Get model or throw if not found
+ */
+export declare function requireModel(modelId: string): ModelDefinition;
+/**
+ * Get context window for a model
+ * Falls back to fuzzy matching and then default
+ */
+export declare function getContextWindow(modelId: string): number;
+/**
+ * Get max output tokens for a model
+ */
+export declare function getMaxOutput(modelId: string): number;
+/**
+ * Get display name for a model
+ */
+export declare function getModelDisplayName(modelId: string): string;
+/**
+ * Check if model supports extended thinking
+ */
+export declare function supportsExtendedThinking(modelId: string): boolean;
+/**
+ * Check if model supports vision
+ */
+export declare function supportsVision(modelId: string): boolean;
+/**
+ * Get pricing for a model
+ */
+export declare function getModelPricing(modelId: string): {
+    input: number;
+    output: number;
+    cacheWrite: number;
+    cacheRead: number;
+};
+/**
+ * Calculate cost for API usage
+ */
+export declare function calculateCost(modelId: string, usage: {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+}): {
+    costUSD: number;
+    estimatedSavingsUSD: number;
+};
+/**
+ * Format cost for display
+ */
+export declare function formatCost(costUSD: number): string;
+/**
+ * Resolve model alias to model ID
+ */
+export declare function resolveModelAlias(alias: string): string;
+/** Claude model type (for TypeScript type checking) */
+export type ClaudeModel = "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-sonnet-4-5" | "claude-3-5-sonnet" | "claude-3-5-haiku" | "claude-3-opus" | "claude-3-sonnet" | "claude-3-haiku" | "glm-5" | "glm-4.5-air" | string;
+/** @deprecated Use getModelPricing() instead */
+export declare const MODEL_PRICING: Record<string, {
+    input: number;
+    output: number;
+    cache_write: number;
+    cache_read: number;
+}>;
+/** @deprecated Use getContextWindow() instead */
+export declare const MODEL_CONTEXT_WINDOWS: Record<string, number>;
+/** @deprecated Use getModelDisplayName() instead */
+export declare const MODEL_DISPLAY_NAMES: Record<string, string>;
+//# sourceMappingURL=models.d.ts.map

package/dist/core/models.d.ts.map

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