bioscode 0.1.5

package/dist/session/context-optimization.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Context Optimization Module
+ *
+ * Handles context overflow detection, pruning, and auto-compaction.
+ * Based on code-cli/opencode methodology:
+ * - Overflow: triggers when tokens > (context_limit - output_max)
+ * - Pruning: removes old tool outputs (20k min savings, 40k protected)
+ * - Compaction: generates summary to reduce context
+ */
+export interface TokenUsage {
+    input: number;
+    output: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+}
+export interface OverflowCheckOptions {
+    tokens: TokenUsage;
+    contextLimit: number;
+    outputLimit?: number;
+    autoEnabled: boolean;
+}
+export interface ContextPercentageOptions {
+    tokens: TokenUsage;
+    contextLimit: number;
+}
+export interface ToolResultPart {
+    type: "tool-result";
+    id: string;
+    messageId: string;
+    sessionId: string;
+    toolCallId: string;
+    toolName?: string;
+    output: string;
+    metadata?: {
+        tokenEstimate?: number;
+        [key: string]: unknown;
+    };
+}
+export interface PrunablePartInfo {
+    part: ToolResultPart;
+    tokens: number;
+}
+export interface PruningAnalysis {
+    prunableParts: PrunablePartInfo[];
+    potentialSavings: number;
+    totalTokens: number;
+}
+export interface CompactionCheckOptions {
+    isOverflow: boolean;
+    potentialPruneSavings: number;
+}
+export interface SimpleMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+}
+export interface CompactedMessage {
+    role: "user";
+    content: string;
+    isCompacted: true;
+}
+/**
+ * Context Optimization - Static utilities for managing context window
+ */
+export declare const ContextOptimization: {
+    /**
+     * Minimum token savings required to trigger pruning
+     * Must save at least 20,000 tokens to be worth pruning
+     */
+    PRUNE_MINIMUM: number;
+    /**
+     * Token threshold for protecting recent content from pruning
+     * Last 40,000 tokens are protected from removal
+     */
+    PRUNE_PROTECT: number;
+    /**
+     * Maximum output tokens to reserve for model response
+     * Matches Claude's typical max output
+     */
+    OUTPUT_TOKEN_MAX: number;
+    /**
+     * Tools whose outputs should never be pruned
+     * Skills are protected because they may contain important state
+     */
+    PROTECTED_TOOLS: readonly ["skill"];
+    /**
+     * Warning threshold percentage (60%)
+     */
+    WARNING_THRESHOLD: number;
+    /**
+     * Critical threshold percentage (80%)
+     */
+    CRITICAL_THRESHOLD: number;
+    /**
+     * Check if context is overflowing
+     * Overflow occurs when total tokens exceed usable context
+     * (context_limit - output_reserved)
+     */
+    isOverflow(options: OverflowCheckOptions): boolean;
+    /**
+     * Calculate usable context after reserving space for output
+     * Uses the smaller of OUTPUT_TOKEN_MAX or model's output limit
+     */
+    calculateUsableContext(contextLimit: number, outputLimit?: number): number;
+    /**
+     * Calculate percentage of context window used
+     */
+    getContextPercentage(options: ContextPercentageOptions): number;
+    /**
+     * Check if we should show a warning (60%+ usage)
+     */
+    shouldWarn(percentage: number): boolean;
+    /**
+     * Check if we should show critical warning (80%+ usage)
+     */
+    shouldShowCritical(percentage: number): boolean;
+    /**
+     * Check if pruning would be worthwhile
+     * Only prune if we can save at least PRUNE_MINIMUM tokens
+     */
+    shouldPrune(potentialSavings: number): boolean;
+    /**
+     * Check if a tool's output should be protected from pruning
+     */
+    isProtectedTool(toolName: string): boolean;
+    /**
+     * Calculate total tokens from usage object
+     * Includes input, output, and cache tokens
+     */
+    calculateTotalTokens(tokens: TokenUsage): number;
+    /**
+     * Estimate tokens from text content
+     * Uses ~4 characters per token as a rough estimate
+     */
+    estimateTokens(text: string): number;
+    /**
+     * Analyze parts to find prunable tool results
+     * Protects recent content (within PRUNE_PROTECT threshold)
+     * and outputs from protected tools
+     */
+    analyzePrunableParts(parts: ToolResultPart[]): PruningAnalysis;
+    /**
+     * Prune content by truncating long outputs
+     * Keeps first few and last few lines for context
+     */
+    pruneContent(output: string, maxLength?: number): string;
+    /**
+     * Determine if compaction is needed
+     * Returns true if overflow and pruning won't save enough
+     */
+    shouldCompact(options: CompactionCheckOptions): boolean;
+    /**
+     * Generate the prompt for creating a conversation summary
+     */
+    getCompactionPrompt(messages: SimpleMessage[]): string;
+    /**
+     * Create a compacted message from a summary
+     */
+    createCompactedMessage(summary: string): CompactedMessage;
+    /**
+     * Generate a summary of messages using LLM
+     * Always uses Sonnet 4.5 for cost efficiency
+     */
+    compact(messages: SimpleMessage[]): Promise<CompactedMessage>;
+};
+export type { OverflowCheckOptions as ContextOverflowOptions };

package/dist/session/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export { Session } from "./session";
+export { LLM } from "./llm";
+export { ContextOptimization } from "./context-optimization";
+export { TitleGenerator } from "./title-generator";

package/dist/session/llm.d.ts

@@ -0,0 +1,68 @@
+import { streamText, type ModelMessage, type Tool } from "ai";
+import { type OperationMode } from "../prompt";
+import type { ModelInfo } from "../provider/types";
+export declare namespace LLM {
+    interface StreamOptions {
+        sessionId: string;
+        model: ModelInfo;
+        messages: ModelMessage[];
+        system?: string[];
+        tools?: Record<string, Tool>;
+        temperature?: number;
+        maxTokens?: number;
+        signal?: AbortSignal;
+        mode?: OperationMode;
+    }
+    interface StreamResult {
+        stream: AsyncIterable<any>;
+        response: Promise<any>;
+    }
+    /**
+     * Stream a response from the LLM
+     */
+    function stream(options: StreamOptions): Promise<ReturnType<typeof streamText>>;
+    /**
+     * Token usage breakdown including cache-specific counts
+     */
+    interface TokenUsage {
+        /** Regular input tokens (not from cache) */
+        input: number;
+        /** Output tokens generated */
+        output: number;
+        /** Tokens read from cache (cache hits) */
+        cacheRead: number;
+        /** Tokens written to cache (cache creation) */
+        cacheWrite: number;
+        /** Total tokens (input + output + cache operations) */
+        total: number;
+    }
+    /**
+     * Count tokens including cache-specific breakdown
+     */
+    function countTokens(usage: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cachedInputTokens?: number;
+        cacheCreationInputTokens?: number;
+    }): TokenUsage;
+    /**
+     * Count only cached tokens (reads and writes)
+     */
+    function countCachedTokens(usage: {
+        cachedInputTokens?: number;
+        cacheCreationInputTokens?: number;
+    }): {
+        read: number;
+        write: number;
+        total: number;
+    };
+    /**
+     * Calculate token usage cost including cache tokens
+     */
+    function calculateCost(model: ModelInfo, usage: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cachedInputTokens?: number;
+        cacheCreationInputTokens?: number;
+    }): number;
+}

package/dist/session/message-optimizer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Message Optimization Module
+ *
+ * Optimizes messages before sending to LLM:
+ * - Merges consecutive tool_results to reduce message count
+ * - Filters out progress messages that add noise
+ */
+import type { ModelMessage } from "ai";
+/**
+ * Merge consecutive tool result messages
+ */
+export declare function mergeToolResults(messages: ModelMessage[]): ModelMessage[];
+/**
+ * Filter out progress messages
+ */
+export declare function filterProgressMessages(messages: ModelMessage[]): ModelMessage[];
+/**
+ * Optimize messages for LLM
+ */
+export declare function optimizeMessages(messages: ModelMessage[], options?: {
+    mergeToolResults?: boolean;
+    filterProgress?: boolean;
+}): ModelMessage[];
+/**
+ * Statistics about message optimization
+ */
+export declare function getOptimizationStats(original: ModelMessage[], optimized: ModelMessage[]): {
+    originalCount: number;
+    optimizedCount: number;
+    reduction: number;
+    reductionPercent: number;
+};