@kkeve/suite 0.0.1 → 0.0.2

package/dist/agent-loop/runtime.js

@@ -1,163 +0,0 @@
-"use strict";
-/**
- * RuntimeEnvironment — runtime environment detection
- *
- * Detects available system binaries (git/codegraph/playwright/node),
- * and provides config paths (env).
- *
- * Tools (core/tools/*) get paths via ToolExecutionContext.runtime,
- * instead of resolving binaries themselves.
- *
- * Design decisions:
- * D02: Layer 1: RuntimeEnvironment provides binary paths
- *      Layer 2: Tool execute() gets paths from runtime
- *      Layer 3: Skill only ctx.tools.call(), no path awareness
- * D04: Business-specific paths (keveWikiDir/reposBaseDir) removed from core.
- *      Agent package can add them in its own runtime extension.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectRuntimeEnvironment = detectRuntimeEnvironment;
-const path = __importStar(require("node:path"));
-const fs = __importStar(require("node:fs"));
-const node_child_process_1 = require("node:child_process");
-// ===== Detection =====
-/**
- * Find a binary on the system PATH.
- * Returns the absolute path or the binary name if not found (will fail at exec time).
- */
-function findBinary(name) {
-    try {
-        return (0, node_child_process_1.execSync)(`which ${name} 2>/dev/null`, { encoding: 'utf-8' }).trim();
-    }
-    catch {
-        return name;
-    }
-}
-/**
- * Detect package manager from lockfile
- */
-function detectPackageManager(projectDir) {
-    if (fs.existsSync(path.join(projectDir, 'pnpm-lock.yaml')))
-        return 'pnpm';
-    if (fs.existsSync(path.join(projectDir, 'yarn.lock')))
-        return 'yarn';
-    if (fs.existsSync(path.join(projectDir, 'package-lock.json')))
-        return 'npm';
-    return 'pnpm';
-}
-/**
- * Load environment variables from .env file (if present)
- */
-function loadEnvFile(envPath) {
-    const env = {};
-    if (!fs.existsSync(envPath))
-        return env;
-    try {
-        const content = fs.readFileSync(envPath, 'utf-8');
-        for (const line of content.split('\n')) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#'))
-                continue;
-            const eqIndex = trimmed.indexOf('=');
-            if (eqIndex > 0) {
-                const key = trimmed.slice(0, eqIndex).trim();
-                let value = trimmed.slice(eqIndex + 1).trim();
-                if ((value.startsWith('"') && value.endsWith('"')) ||
-                    (value.startsWith("'") && value.endsWith("'"))) {
-                    value = value.slice(1, -1);
-                }
-                env[key] = value;
-            }
-        }
-    }
-    catch {
-        // Ignore .env read errors
-    }
-    return env;
-}
-/**
- * Detect the runtime environment.
- *
- * Scans for binaries, loads env vars.
- * Called once at startup (entry.ts) and passed to Pipeline → SkillContext.
- *
- * @param cwd - Starting directory (defaults to process.cwd())
- * @param agentDir - Agent package directory for finding node_modules binaries
- */
-function detectRuntimeEnvironment(cwd, agentDir) {
-    const startDir = cwd ?? process.cwd();
-    const pkgDir = agentDir ?? findPkgDir(startDir);
-    // Find playwright binary: prefer agent's node_modules, fallback to global
-    const localPlaywright = path.join(pkgDir, 'node_modules', '.bin', 'playwright');
-    const playwrightBin = fs.existsSync(localPlaywright)
-        ? localPlaywright
-        : findBinary('playwright');
-    // Load .env from agent/pkg dir
-    const env = {
-        ...loadEnvFile(path.join(pkgDir, '.env')),
-    };
-    // Also inherit relevant process.env
-    for (const key of ['GITLAB_TOKEN', 'HOME', 'PATH', 'NODE_ENV']) {
-        if (process.env[key])
-            env[key] = process.env[key];
-    }
-    return {
-        gitBin: findBinary('git'),
-        codegraphBin: findBinary('codegraph'),
-        playwrightBin,
-        nodeBin: process.execPath,
-        packageManager: detectPackageManager(pkgDir),
-        env,
-    };
-}
-/**
- * Walk up from startDir to find the nearest package directory
- * (contains package.json with node_modules)
- */
-function findPkgDir(startDir) {
-    let dir = startDir;
-    for (let i = 0; i < 15; i++) {
-        const pkgPath = path.join(dir, 'package.json');
-        if (fs.existsSync(pkgPath) && fs.existsSync(path.join(dir, 'node_modules'))) {
-            return dir;
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return startDir;
-}

package/dist/agent-loop/types.d.ts

@@ -1,161 +0,0 @@
-/**
- * Agent Loop Core Types
- *
- * Reference: gemini-cli LocalAgentExecutor + AgentProtocol
- * Adapted for OpenAI-compatible API (internal proxy at xxx)
- *
- * Key differences from gemini-cli:
- * - LLM calls use OpenAIClient instead of GeminiChat
- * - Tool definitions reuse core/llm/types.ts Tool interface
- * - No Gemini-specific Content/Part types — use OpenAI Message format
- * - Simplified timeout (no DeadlineTimer pause/resume — we don't wait for user confirmation)
- */
-import type { LLMClient, Tool } from '../llm/types';
-import type { RuntimeEnvironment } from './runtime';
-/** Default maximum number of conversational turns for an agent. */
-export declare const DEFAULT_MAX_TURNS = 30;
-/** Default maximum execution time for an agent in minutes. */
-export declare const DEFAULT_MAX_TIME_MINUTES = 10;
-/** Tool name for signaling task completion (reference: gemini-cli CompleteTaskTool) */
-export declare const COMPLETE_TASK_TOOL_NAME = "complete_task";
-/**
- * Definition of an agent to execute via the loop.
- * Reference: gemini-cli LocalAgentDefinition (agents/types.ts L214-285)
- *
- * Simplified from gemini-cli: removed kind, promptConfig, modelConfig, runConfig,
- * workspaceDirectories, memoryInboxAccess, mcpServers, processOutput, onBeforeTurn.
- * These features can be added incrementally as needed.
- */
-export interface AgentDefinition {
-    /** Unique identifier for the agent. */
-    name: string;
-    /** Human-readable description. */
-    description: string;
-    /** System prompt injected as the first message. Can include SKILL.md content. */
-    systemPrompt?: string;
-    /** The initial user query/message. Defaults to 'Get Started!' if not provided. */
-    query?: string;
-    /** Maximum number of conversational turns. Defaults to DEFAULT_MAX_TURNS (30). */
-    maxTurns?: number;
-    /** Maximum execution time in minutes. Defaults to DEFAULT_MAX_TIME_MINUTES (10). */
-    maxTimeMinutes?: number;
-    /** Tool names to restrict to. If omitted, all registered tools are available. */
-    toolNames?: string[];
-    /** Paths that are read-only — bash tool will block write operations targeting these directories */
-    readOnlyPaths?: string[];
-    /** Working directory for tool execution. Defaults to process.cwd() */
-    cwd?: string;
-}
-/**
- * Execution context for the agent loop.
- * Provides the LLM client, tool registry, and config needed to run an agent.
- */
-export interface AgentLoopContext {
-    /** LLM client for calling the model. Uses core/llm/OpenAIClient. */
-    llmClient: LLMClient;
-    /** Tool registry for executing tool calls from the model. */
-    toolRegistry: ToolRegistry;
-    /** Application configuration. */
-    config: Record<string, unknown>;
-}
-/**
- * Callback for receiving agent events during execution.
- * Events are emitted at key points: start, tool calls, thoughts, end, errors.
- */
-export type AgentEventCallback = (event: AgentEvent) => void;
-/**
- * Events emitted during agent execution.
- * Reference: gemini-cli AgentEvents (agent/types.ts L104-131) and SubagentActivityEvent (agents/types.ts L84-89)
- *
- * Simplified from gemini-cli: merged multiple event interfaces into one,
- * removed display-specific fields (DisplayContent, ToolDisplayFormat).
- */
-export interface AgentEvent {
-    type: 'agent_start' | 'tool_call_start' | 'tool_call_end' | 'thought_chunk' | 'agent_end' | 'agent_error';
-    /** Stream identifier (typically the agent name). */
-    streamId: string;
-    /** Event-specific data. */
-    data: Record<string, unknown>;
-}
-/**
- * Describes how an agent's execution ended.
- * Reference: gemini-cli AgentTerminateMode (agents/types.ts L24-31)
- */
-export declare const TM_GOAL = "GOAL";
-export declare const TM_TIMEOUT = "TIMEOUT";
-export declare const TM_MAX_TURNS = "MAX_TURNS";
-export declare const TM_ABORTED = "ABORTED";
-export declare const TM_ERROR = "ERROR";
-export declare const TM_ERROR_NO_COMPLETE_TASK = "ERROR_NO_COMPLETE_TASK";
-export type AgentTerminateMode = typeof TM_GOAL | typeof TM_TIMEOUT | typeof TM_MAX_TURNS | typeof TM_ABORTED | typeof TM_ERROR | typeof TM_ERROR_NO_COMPLETE_TASK;
-/**
- * The final result of an agent's execution.
- * Reference: gemini-cli OutputObject (agents/types.ts L36-41)
- */
-export interface AgentResult {
-    /** Whether the agent completed successfully (GOAL termination). */
-    success: boolean;
-    /** The final output string from complete_task, if available. */
-    output?: string;
-    /** How the agent's execution ended. */
-    terminateReason: AgentTerminateMode;
-    /** Number of conversational turns completed. */
-    turnCount: number;
-    /** Total execution time in milliseconds. */
-    durationMs: number;
-    /** Error message if the agent failed. */
-    error?: string;
-}
-export interface ToolExecutionContext {
-    /** Runtime environment (binary paths, config dirs, env vars) */
-    runtime: RuntimeEnvironment;
-    /** Working directory for command execution */
-    cwd: string;
-    /** Timeout in milliseconds */
-    timeout?: number;
-    /** 🆕 Paths that are read-only — bash tool will block write operations to these directories */
-    readOnlyPaths?: string[];
-}
-/**
- * A tool definition for the agent loop's registry.
- * Compatible with core/llm/types.ts Tool interface.
- */
-export interface ToolDefinition {
-    /** Tool name (used as the key in OpenAI function_call). */
-    name: string;
-    /** Human-readable description sent to the LLM. */
-    description: string;
-    /** Zod schema for input validation and OpenAI parameter generation. */
-    inputSchema: z.ZodType<any>;
-    /** Execute the tool with validated arguments. */
-    execute: (args: any, context?: ToolExecutionContext) => Promise<any>;
-    /** Custom JSON Schema for the LLM (overrides zod conversion). */
-    customJsonSchema?: Record<string, any>;
-}
-import type * as z from 'zod/v4';
-/**
- * Tool registry for managing and executing tools during agent execution.
- * Reference: gemini-cli ToolRegistry (tools/tool-registry.ts)
- *
- * Simplified: no message bus, no confirmation policy, no sort, no MCP integration.
- * These can be added incrementally.
- */
-export declare class ToolRegistry {
-    private tools;
-    /** Register a tool definition. */
-    register(tool: ToolDefinition): void;
-    /** Unregister a tool by name. */
-    unregister(name: string): void;
-    /** Get all registered tool names. */
-    getAllToolNames(): string[];
-    /** Convert registered tools to the core/llm/types.ts Tool map format for LLM calls. */
-    getToolsMap(): Record<string, Tool>;
-    /** Get a subset of tools by name (for agent's toolNames restriction). */
-    getToolsMapSubset(names: string[]): Record<string, Tool>;
-    /** Execute a registered tool by name with the given arguments and optional context. */
-    execute(name: string, args: any, context?: ToolExecutionContext): Promise<any>;
-    /** Check if a tool is registered. */
-    has(name: string): boolean;
-    /** Get a tool definition by name. */
-    get(name: string): ToolDefinition | undefined;
-}

package/dist/agent-loop/types.js

@@ -1,105 +0,0 @@
-"use strict";
-/**
- * Agent Loop Core Types
- *
- * Reference: gemini-cli LocalAgentExecutor + AgentProtocol
- * Adapted for OpenAI-compatible API (internal proxy at xxx)
- *
- * Key differences from gemini-cli:
- * - LLM calls use OpenAIClient instead of GeminiChat
- * - Tool definitions reuse core/llm/types.ts Tool interface
- * - No Gemini-specific Content/Part types — use OpenAI Message format
- * - Simplified timeout (no DeadlineTimer pause/resume — we don't wait for user confirmation)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolRegistry = exports.TM_ERROR_NO_COMPLETE_TASK = exports.TM_ERROR = exports.TM_ABORTED = exports.TM_MAX_TURNS = exports.TM_TIMEOUT = exports.TM_GOAL = exports.COMPLETE_TASK_TOOL_NAME = exports.DEFAULT_MAX_TIME_MINUTES = exports.DEFAULT_MAX_TURNS = void 0;
-// ===== Constants (reference: gemini-cli DEFAULT_MAX_TURNS/DEFAULT_MAX_TIME_MINUTES) =====
-/** Default maximum number of conversational turns for an agent. */
-exports.DEFAULT_MAX_TURNS = 30;
-/** Default maximum execution time for an agent in minutes. */
-exports.DEFAULT_MAX_TIME_MINUTES = 10;
-/** Tool name for signaling task completion (reference: gemini-cli CompleteTaskTool) */
-exports.COMPLETE_TASK_TOOL_NAME = 'complete_task';
-// ===== Termination Modes =====
-/**
- * Describes how an agent's execution ended.
- * Reference: gemini-cli AgentTerminateMode (agents/types.ts L24-31)
- */
-// Inline termination mode constants (vite tree-shaking removes cross-module const objects)
-exports.TM_GOAL = 'GOAL';
-exports.TM_TIMEOUT = 'TIMEOUT';
-exports.TM_MAX_TURNS = 'MAX_TURNS';
-exports.TM_ABORTED = 'ABORTED';
-exports.TM_ERROR = 'ERROR';
-exports.TM_ERROR_NO_COMPLETE_TASK = 'ERROR_NO_COMPLETE_TASK';
-/**
- * Tool registry for managing and executing tools during agent execution.
- * Reference: gemini-cli ToolRegistry (tools/tool-registry.ts)
- *
- * Simplified: no message bus, no confirmation policy, no sort, no MCP integration.
- * These can be added incrementally.
- */
-class ToolRegistry {
-    tools = new Map();
-    /** Register a tool definition. */
-    register(tool) {
-        this.tools.set(tool.name, tool);
-    }
-    /** Unregister a tool by name. */
-    unregister(name) {
-        this.tools.delete(name);
-    }
-    /** Get all registered tool names. */
-    getAllToolNames() {
-        return Array.from(this.tools.keys());
-    }
-    /** Convert registered tools to the core/llm/types.ts Tool map format for LLM calls. */
-    getToolsMap() {
-        const result = {};
-        for (const [name, def] of this.tools) {
-            result[name] = {
-                description: def.description,
-                inputSchema: def.inputSchema,
-                execute: def.execute,
-                customJsonSchema: def.customJsonSchema,
-            };
-        }
-        return result;
-    }
-    /** Get a subset of tools by name (for agent's toolNames restriction). */
-    getToolsMapSubset(names) {
-        const result = {};
-        for (const name of names) {
-            const def = this.tools.get(name);
-            if (def) {
-                result[name] = {
-                    description: def.description,
-                    inputSchema: def.inputSchema,
-                    execute: def.execute,
-                    customJsonSchema: def.customJsonSchema,
-                };
-            }
-        }
-        return result;
-    }
-    /** Execute a registered tool by name with the given arguments and optional context. */
-    async execute(name, args, context) {
-        const tool = this.tools.get(name);
-        if (!tool) {
-            throw new Error(`Tool not found: ${name}`);
-        }
-        // Validate args with zod schema
-        const validation = tool.inputSchema.safeParse(args);
-        const validatedArgs = validation.success ? validation.data : args;
-        return tool.execute(validatedArgs, context);
-    }
-    /** Check if a tool is registered. */
-    has(name) {
-        return this.tools.has(name);
-    }
-    /** Get a tool definition by name. */
-    get(name) {
-        return this.tools.get(name);
-    }
-}
-exports.ToolRegistry = ToolRegistry;

package/dist/context/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * @ks-data/agent-core — context module entry point.
- *
- * Provides truncation and token estimation utilities for managing
- * LLM input size within token budgets.
- */
-export { ASCII_TOKENS_PER_CHAR, NON_ASCII_TOKENS_PER_CHAR, MSG_OVERHEAD_TOKENS, DEFAULT_CHARS_PER_TOKEN, estimateTextTokens, estimateTokenCountSync, estimateTokenCountForText, calculateTokenCount, type TokenEstimationPart, } from './tokenCalculation';
-export { MIN_TARGET_TOKENS, MIN_CHARS_FOR_TRUNCATION, TEXT_TRUNCATION_PREFIX, TOOL_TRUNCATION_PREFIX, estimateCharsFromTokens, truncateProportionally, normalizeFunctionResponse, truncateToTokenBudget, } from './truncation';

package/dist/context/index.js

@@ -1,29 +0,0 @@
-"use strict";
-/**
- * @ks-data/agent-core — context module entry point.
- *
- * Provides truncation and token estimation utilities for managing
- * LLM input size within token budgets.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.truncateToTokenBudget = exports.normalizeFunctionResponse = exports.truncateProportionally = exports.estimateCharsFromTokens = exports.TOOL_TRUNCATION_PREFIX = exports.TEXT_TRUNCATION_PREFIX = exports.MIN_CHARS_FOR_TRUNCATION = exports.MIN_TARGET_TOKENS = exports.calculateTokenCount = exports.estimateTokenCountForText = exports.estimateTokenCountSync = exports.estimateTextTokens = exports.DEFAULT_CHARS_PER_TOKEN = exports.MSG_OVERHEAD_TOKENS = exports.NON_ASCII_TOKENS_PER_CHAR = exports.ASCII_TOKENS_PER_CHAR = void 0;
-var tokenCalculation_1 = require("./tokenCalculation");
-// Token calculation
-Object.defineProperty(exports, "ASCII_TOKENS_PER_CHAR", { enumerable: true, get: function () { return tokenCalculation_1.ASCII_TOKENS_PER_CHAR; } });
-Object.defineProperty(exports, "NON_ASCII_TOKENS_PER_CHAR", { enumerable: true, get: function () { return tokenCalculation_1.NON_ASCII_TOKENS_PER_CHAR; } });
-Object.defineProperty(exports, "MSG_OVERHEAD_TOKENS", { enumerable: true, get: function () { return tokenCalculation_1.MSG_OVERHEAD_TOKENS; } });
-Object.defineProperty(exports, "DEFAULT_CHARS_PER_TOKEN", { enumerable: true, get: function () { return tokenCalculation_1.DEFAULT_CHARS_PER_TOKEN; } });
-Object.defineProperty(exports, "estimateTextTokens", { enumerable: true, get: function () { return tokenCalculation_1.estimateTextTokens; } });
-Object.defineProperty(exports, "estimateTokenCountSync", { enumerable: true, get: function () { return tokenCalculation_1.estimateTokenCountSync; } });
-Object.defineProperty(exports, "estimateTokenCountForText", { enumerable: true, get: function () { return tokenCalculation_1.estimateTokenCountForText; } });
-Object.defineProperty(exports, "calculateTokenCount", { enumerable: true, get: function () { return tokenCalculation_1.calculateTokenCount; } });
-var truncation_1 = require("./truncation");
-// Truncation
-Object.defineProperty(exports, "MIN_TARGET_TOKENS", { enumerable: true, get: function () { return truncation_1.MIN_TARGET_TOKENS; } });
-Object.defineProperty(exports, "MIN_CHARS_FOR_TRUNCATION", { enumerable: true, get: function () { return truncation_1.MIN_CHARS_FOR_TRUNCATION; } });
-Object.defineProperty(exports, "TEXT_TRUNCATION_PREFIX", { enumerable: true, get: function () { return truncation_1.TEXT_TRUNCATION_PREFIX; } });
-Object.defineProperty(exports, "TOOL_TRUNCATION_PREFIX", { enumerable: true, get: function () { return truncation_1.TOOL_TRUNCATION_PREFIX; } });
-Object.defineProperty(exports, "estimateCharsFromTokens", { enumerable: true, get: function () { return truncation_1.estimateCharsFromTokens; } });
-Object.defineProperty(exports, "truncateProportionally", { enumerable: true, get: function () { return truncation_1.truncateProportionally; } });
-Object.defineProperty(exports, "normalizeFunctionResponse", { enumerable: true, get: function () { return truncation_1.normalizeFunctionResponse; } });
-Object.defineProperty(exports, "truncateToTokenBudget", { enumerable: true, get: function () { return truncation_1.truncateToTokenBudget; } });

package/dist/context/tokenCalculation.d.ts

@@ -1,55 +0,0 @@
-/**
- * Token estimation constants — ported from gemini-cli (Apache-2.0).
- *
- * ASCII characters (0-127) are roughly 3-4 chars per token.
- * We use 0.33 (~3 chars/token) as a conservative baseline for mixed text and code.
- */
-export declare const ASCII_TOKENS_PER_CHAR = 0.33;
-/**
- * Non-ASCII characters (including CJK) are often 1-2 tokens per char.
- * We use 1.5 as a conservative estimate to avoid underestimation.
- */
-export declare const NON_ASCII_TOKENS_PER_CHAR = 1.5;
-/** Structural overhead per message turn (role prefixes, separators). */
-export declare const MSG_OVERHEAD_TOKENS = 5;
-/** Default chars-per-token ratio used as fallback. */
-export declare const DEFAULT_CHARS_PER_TOKEN = 4;
-/**
- * Heuristic estimation of tokens for a text string.
- * Uses char-by-char scan for strings ≤ 100K chars, length/charsPerToken for larger strings.
- */
-export declare function estimateTextTokens(text: string, charsPerToken?: number): number;
-/**
- * Synchronous token-count estimation for an array of message-like parts.
- * Adapted from gemini-cli's `estimateTokenCountSync`, but uses our own
- * message-part representation instead of Gemini's `Part` type.
- *
- * Each "part" can be:
- *   - `{ text: string }`          → text token estimation
- *   - `{ functionResponse: ... }` → tool response estimation
- *   - other objects               → JSON string length / charsPerToken fallback
- */
-export interface TokenEstimationPart {
-    text?: string;
-    functionResponse?: {
-        name?: string;
-        response?: unknown;
-    };
-    [key: string]: unknown;
-}
-export declare function estimateTokenCountSync(parts: TokenEstimationPart[], charsPerToken?: number): number;
-/**
- * Asynchronous token count calculation for a text string or message array.
- * For text-only content, this simply delegates to `estimateTokenCountSync`.
- * For content with media references (future: image/PDF), we would call
- * an external tokenizer — but for now, everything is text-only estimation.
- *
- * This replaces gemini-cli's `calculateRequestTokenCount` which uses
- * the Gemini `countTokens` API. We don't have an equivalent API for
- * our internal OpenAI-compatible proxy, so we rely on heuristic estimation.
- */
-export declare function calculateTokenCount(content: string | TokenEstimationPart[], charsPerToken?: number): Promise<number>;
-/**
- * Convenience: estimate token count for a single text string.
- */
-export declare function estimateTokenCountForText(text: string, charsPerToken?: number): number;

package/dist/context/tokenCalculation.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CHARS_PER_TOKEN = exports.MSG_OVERHEAD_TOKENS = exports.NON_ASCII_TOKENS_PER_CHAR = exports.ASCII_TOKENS_PER_CHAR = void 0;
-exports.estimateTextTokens = estimateTextTokens;
-exports.estimateTokenCountSync = estimateTokenCountSync;
-exports.calculateTokenCount = calculateTokenCount;
-exports.estimateTokenCountForText = estimateTokenCountForText;
-/**
- * Token estimation constants — ported from gemini-cli (Apache-2.0).
- *
- * ASCII characters (0-127) are roughly 3-4 chars per token.
- * We use 0.33 (~3 chars/token) as a conservative baseline for mixed text and code.
- */
-exports.ASCII_TOKENS_PER_CHAR = 0.33;
-/**
- * Non-ASCII characters (including CJK) are often 1-2 tokens per char.
- * We use 1.5 as a conservative estimate to avoid underestimation.
- */
-exports.NON_ASCII_TOKENS_PER_CHAR = 1.5;
-/** Structural overhead per message turn (role prefixes, separators). */
-exports.MSG_OVERHEAD_TOKENS = 5;
-/** Default chars-per-token ratio used as fallback. */
-exports.DEFAULT_CHARS_PER_TOKEN = 4;
-/**
- * Maximum number of characters to process with the full character-by-character heuristic.
- * Above this, we use a faster approximation to avoid performance bottlenecks.
- */
-const MAX_CHARS_FOR_FULL_HEURISTIC = 100_000;
-/**
- * Heuristic estimation of tokens for a text string.
- * Uses char-by-char scan for strings ≤ 100K chars, length/charsPerToken for larger strings.
- */
-function estimateTextTokens(text, charsPerToken = exports.DEFAULT_CHARS_PER_TOKEN) {
-    if (text.length > MAX_CHARS_FOR_FULL_HEURISTIC) {
-        return text.length / charsPerToken;
-    }
-    let tokens = 0;
-    const asciiTokensPerChar = 1 / charsPerToken;
-    for (let i = 0; i < text.length; i++) {
-        if (text.charCodeAt(i) <= 127) {
-            tokens += asciiTokensPerChar;
-        }
-        else {
-            tokens += exports.NON_ASCII_TOKENS_PER_CHAR;
-        }
-    }
-    return tokens;
-}
-function estimateTokenCountSync(parts, charsPerToken = exports.DEFAULT_CHARS_PER_TOKEN) {
-    let totalTokens = 0;
-    for (const part of parts) {
-        if (typeof part.text === 'string') {
-            totalTokens += estimateTextTokens(part.text, charsPerToken);
-        }
-        else if (part.functionResponse) {
-            const fr = part.functionResponse;
-            let frTokens = (fr.name?.length ?? 0) / charsPerToken;
-            const response = fr.response;
-            if (typeof response === 'string') {
-                frTokens += response.length / charsPerToken;
-            }
-            else if (response !== undefined && response !== null) {
-                frTokens += JSON.stringify(response).length / charsPerToken;
-            }
-            totalTokens += frTokens;
-        }
-        else {
-            // Fallback: JSON-serialize the whole part and estimate by length.
-            totalTokens += JSON.stringify(part).length / charsPerToken;
-        }
-    }
-    return Math.floor(totalTokens);
-}
-/**
- * Asynchronous token count calculation for a text string or message array.
- * For text-only content, this simply delegates to `estimateTokenCountSync`.
- * For content with media references (future: image/PDF), we would call
- * an external tokenizer — but for now, everything is text-only estimation.
- *
- * This replaces gemini-cli's `calculateRequestTokenCount` which uses
- * the Gemini `countTokens` API. We don't have an equivalent API for
- * our internal OpenAI-compatible proxy, so we rely on heuristic estimation.
- */
-async function calculateTokenCount(content, charsPerToken = exports.DEFAULT_CHARS_PER_TOKEN) {
-    if (typeof content === 'string') {
-        return estimateTokenCountSync([{ text: content }], charsPerToken);
-    }
-    return estimateTokenCountSync(content, charsPerToken);
-}
-/**
- * Convenience: estimate token count for a single text string.
- */
-function estimateTokenCountForText(text, charsPerToken = exports.DEFAULT_CHARS_PER_TOKEN) {
-    return Math.floor(estimateTextTokens(text, charsPerToken));
-}