@kodax-ai/kodax 0.7.41 → 0.7.43

package/dist/types-chunks/capability.d-3C62G8Eq.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Layer A Primitive: Capability provider contract.
+ *
+ * FEATURE_082 (v0.7.24): extracted from `@kodax-ai/coding/src/extensions/types.ts`
+ * so third-party capability sources (MCP, RAG, custom indexes, …) can
+ * implement `CapabilityProvider` without importing from the coding preset.
+ *
+ * The richer "extension runtime" concept (command registration, file
+ * contributions, logger plumbing) stays in `@kodax-ai/coding/src/extensions/`
+ * because it is coupled to the coding CLI surface.
+ */
+type CapabilityKind = 'tool' | 'resource' | 'prompt';
+interface CapabilityResult {
+    kind: CapabilityKind;
+    content?: string;
+    structuredContent?: unknown;
+    evidence?: unknown[];
+    artifacts?: unknown[];
+    metadata?: Record<string, unknown>;
+}
+interface CapabilityProvider {
+    id: string;
+    kinds: CapabilityKind[];
+    search?: (query: string, options?: {
+        kind?: CapabilityKind;
+        limit?: number;
+        server?: string;
+    }) => Promise<unknown[]>;
+    describe?: (id: string) => Promise<unknown>;
+    execute?: (id: string, input: Record<string, unknown>) => Promise<CapabilityResult>;
+    read?: (id: string, options?: Record<string, unknown>) => Promise<CapabilityResult>;
+    getPrompt?: (id: string, args?: Record<string, unknown>) => Promise<unknown>;
+    getPromptContext?: () => Promise<string | undefined> | string | undefined;
+    getDiagnostics?: () => Record<string, unknown> | undefined;
+    refresh?: () => Promise<void>;
+    dispose?: () => Promise<void>;
+}
+
+export type { CapabilityKind as C, CapabilityProvider as a, CapabilityResult as b };

package/dist/types-chunks/config.d-BfJUXxC0.d.ts

@@ -0,0 +1,41 @@
+/**
+ * MCP server configuration shapes.
+ *
+ * FEATURE_082 (v0.7.24): moved from `@kodax-ai/coding/src/types.ts`. Kept as the
+ * `Mcp*` names here; the `KodaXMcp*` aliases continue to re-export from
+ * `@kodax-ai/coding` for backward compatibility.
+ */
+type McpTransportKind = 'stdio' | 'sse' | 'streamable-http';
+type McpConnectMode = 'lazy' | 'prewarm' | 'disabled';
+interface McpServerConfig {
+    /** Transport type. Defaults to 'stdio' when omitted. */
+    type?: McpTransportKind;
+    /** stdio: executable command. */
+    command?: string;
+    /** stdio: command arguments. */
+    args?: string[];
+    /** stdio: working directory for the spawned process. */
+    cwd?: string;
+    /** stdio: extra environment variables for the spawned process. */
+    env?: Record<string, string>;
+    /** sse / streamable-http: server endpoint URL. */
+    url?: string;
+    /** sse / streamable-http: extra HTTP headers (e.g. Authorization). */
+    headers?: Record<string, string>;
+    connect?: McpConnectMode;
+    startupTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    /** OAuth 2.0 configuration for authenticated MCP servers. */
+    auth?: {
+        readonly type: 'oauth2';
+        readonly clientId: string;
+        readonly authorizationUrl: string;
+        readonly tokenUrl: string;
+        readonly scopes?: readonly string[];
+        readonly redirectPort?: number;
+    };
+}
+/** Flat map of MCP server configs, keyed under `mcpServers` in config.json. */
+type McpServersConfig = Record<string, McpServerConfig>;
+
+export type { McpConnectMode as M, McpServerConfig as a, McpServersConfig as b, McpTransportKind as c };

package/dist/types-chunks/cost-tracker.d-wRtyEW9d.d.ts

@@ -0,0 +1,110 @@
+/**
+ * KodaX Cost Rates - Multi-Provider pricing table
+ *
+ * 成本费率表 - 所有 Provider 的计费标准
+ * 支持 11 个内置 Provider 的成本追踪，用户可以覆盖默认费率
+ */
+interface CostRate {
+    readonly inputPer1M: number;
+    readonly outputPer1M: number;
+    readonly cachePer1M?: number;
+}
+declare const DEFAULT_COST_RATES: Readonly<Record<string, Readonly<Record<string, CostRate>>>>;
+declare function getCostRate(provider: string, model: string, userOverrides?: Readonly<Record<string, Readonly<Record<string, CostRate>>>>): CostRate | undefined;
+declare function calculateCost(rate: CostRate, inputTokens: number, outputTokens: number, cacheTokens?: number): number;
+
+/**
+ * KodaX Cost Tracker - Immutable session cost tracking
+ *
+ * 成本追踪器 - 不可变的会话成本追踪
+ * 使用 Immutable 模式，每次操作都返回新对象而不修改原有对象
+ */
+
+interface TokenUsageRecord {
+    readonly timestamp: number;
+    readonly provider: string;
+    readonly model: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly cost: number;
+    readonly role?: string;
+}
+interface ProviderCostSummary {
+    readonly cost: number;
+    readonly calls: number;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+}
+/**
+ * FEATURE_130 (v0.7.36) — per-retry record. Captures the wait the
+ * provider asked us to take so `/cost` can report "X retries, Ys total
+ * wait" alongside the token cost. Lives in the same tracker as token
+ * records to keep one source of truth for the session.
+ */
+interface RetryRecord {
+    readonly timestamp: number;
+    readonly provider: string;
+    readonly waitMs: number;
+    readonly reason: 'rate-limit' | 'overloaded';
+    readonly source: 'retry-after-seconds' | 'retry-after-date' | 'retry-after-ms' | 'exponential-backoff';
+}
+interface SessionCostSummary {
+    readonly totalCost: number;
+    readonly totalInputTokens: number;
+    readonly totalOutputTokens: number;
+    readonly totalCacheTokens: number;
+    /** FEATURE_116 (v0.7.37): cumulative cache-read input tokens across the
+     * session. Splits `totalCacheTokens` into the read half so the hit rate
+     * (`cacheHitRate = totalCacheReadTokens / totalCacheTokens`) is
+     * derivable for `/cost` reporting. */
+    readonly totalCacheReadTokens: number;
+    /** FEATURE_116 (v0.7.37): cumulative cache-write (creation) input tokens. */
+    readonly totalCacheWriteTokens: number;
+    /** FEATURE_116 (v0.7.37): cache-read share of all cache tokens this
+     * session, in [0, 1]. Computed as `totalCacheReadTokens /
+     * (totalCacheReadTokens + totalCacheWriteTokens)`. Returns 0 when no
+     * cache activity has been recorded — a session with zero cache
+     * activity is not "0% hit rate", just untracked. */
+    readonly cacheHitRate: number;
+    readonly callCount: number;
+    /** FEATURE_130: total retries triggered across the session. */
+    readonly retryCount: number;
+    /** FEATURE_130: cumulative milliseconds spent in retry-after sleeps. */
+    readonly retryWaitMs: number;
+    readonly byProvider: Readonly<Record<string, ProviderCostSummary>>;
+    readonly byRole: Readonly<Record<string, ProviderCostSummary>>;
+}
+interface CostTracker {
+    readonly records: readonly TokenUsageRecord[];
+    /** FEATURE_130 (v0.7.36): retry-wait records, append-only and immutable. */
+    readonly retries: readonly RetryRecord[];
+}
+declare function createCostTracker(): CostTracker;
+/**
+ * FEATURE_130 (v0.7.36): record a retry-after wait. The InkREPL spinner
+ * (or any other consumer of `KodaXEvents.onRetryAfter`) calls this so
+ * `/cost` can surface accurate session-wide retry telemetry.
+ */
+declare function recordRetry(tracker: CostTracker, entry: {
+    readonly provider: string;
+    readonly waitMs: number;
+    readonly reason: 'rate-limit' | 'overloaded';
+    readonly source: 'retry-after-seconds' | 'retry-after-date' | 'retry-after-ms' | 'exponential-backoff';
+}): CostTracker;
+declare function recordUsage(tracker: CostTracker, entry: {
+    readonly provider: string;
+    readonly model: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens?: number;
+    readonly cacheWriteTokens?: number;
+    readonly role?: string;
+}, userCostOverrides?: Readonly<Record<string, Readonly<Record<string, CostRate>>>>): CostTracker;
+declare function getSummary(tracker: CostTracker): SessionCostSummary;
+declare function formatCost(usd: number): string;
+declare function formatCostReport(summary: SessionCostSummary): string;
+
+export { DEFAULT_COST_RATES as D, createCostTracker as b, calculateCost as c, formatCostReport as d, getSummary as e, formatCost as f, getCostRate as g, recordUsage as h, recordRetry as r };
+export type { CostRate as C, ProviderCostSummary as P, RetryRecord as R, SessionCostSummary as S, TokenUsageRecord as T, CostTracker as a };