portercode 0.1.0

package/dist/provider/types.d.ts

@@ -0,0 +1,328 @@
+import z from "zod";
+/**
+ * Model capabilities and configuration types
+ */
+export declare const ModelCapabilities: z.ZodObject<{
+    temperature: z.ZodDefault<z.ZodBoolean>;
+    reasoning: z.ZodDefault<z.ZodBoolean>;
+    vision: z.ZodDefault<z.ZodBoolean>;
+    toolUse: z.ZodDefault<z.ZodBoolean>;
+    streaming: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    temperature: boolean;
+    reasoning: boolean;
+    vision: boolean;
+    toolUse: boolean;
+    streaming: boolean;
+}, {
+    temperature?: boolean | undefined;
+    reasoning?: boolean | undefined;
+    vision?: boolean | undefined;
+    toolUse?: boolean | undefined;
+    streaming?: boolean | undefined;
+}>;
+export type ModelCapabilities = z.infer<typeof ModelCapabilities>;
+export declare const ModelCost: z.ZodObject<{
+    input: z.ZodNumber;
+    output: z.ZodNumber;
+    cacheRead: z.ZodOptional<z.ZodNumber>;
+    cacheWrite: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    input: number;
+    output: number;
+    cacheRead?: number | undefined;
+    cacheWrite?: number | undefined;
+}, {
+    input: number;
+    output: number;
+    cacheRead?: number | undefined;
+    cacheWrite?: number | undefined;
+}>;
+export type ModelCost = z.infer<typeof ModelCost>;
+export declare const ModelLimits: z.ZodObject<{
+    context: z.ZodNumber;
+    output: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    output: number;
+    context: number;
+}, {
+    output: number;
+    context: number;
+}>;
+export type ModelLimits = z.infer<typeof ModelLimits>;
+export declare const ModelInfo: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    provider: z.ZodString;
+    family: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodObject<{
+        temperature: z.ZodDefault<z.ZodBoolean>;
+        reasoning: z.ZodDefault<z.ZodBoolean>;
+        vision: z.ZodDefault<z.ZodBoolean>;
+        toolUse: z.ZodDefault<z.ZodBoolean>;
+        streaming: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        temperature: boolean;
+        reasoning: boolean;
+        vision: boolean;
+        toolUse: boolean;
+        streaming: boolean;
+    }, {
+        temperature?: boolean | undefined;
+        reasoning?: boolean | undefined;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+        streaming?: boolean | undefined;
+    }>;
+    cost: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodOptional<z.ZodNumber>;
+        cacheWrite: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        input: number;
+        output: number;
+        cacheRead?: number | undefined;
+        cacheWrite?: number | undefined;
+    }, {
+        input: number;
+        output: number;
+        cacheRead?: number | undefined;
+        cacheWrite?: number | undefined;
+    }>;
+    limits: z.ZodObject<{
+        context: z.ZodNumber;
+        output: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        output: number;
+        context: number;
+    }, {
+        output: number;
+        context: number;
+    }>;
+    status: z.ZodDefault<z.ZodEnum<["active", "beta", "deprecated"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "active" | "beta" | "deprecated";
+    id: string;
+    name: string;
+    provider: string;
+    capabilities: {
+        temperature: boolean;
+        reasoning: boolean;
+        vision: boolean;
+        toolUse: boolean;
+        streaming: boolean;
+    };
+    cost: {
+        input: number;
+        output: number;
+        cacheRead?: number | undefined;
+        cacheWrite?: number | undefined;
+    };
+    limits: {
+        output: number;
+        context: number;
+    };
+    family?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    provider: string;
+    capabilities: {
+        temperature?: boolean | undefined;
+        reasoning?: boolean | undefined;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+        streaming?: boolean | undefined;
+    };
+    cost: {
+        input: number;
+        output: number;
+        cacheRead?: number | undefined;
+        cacheWrite?: number | undefined;
+    };
+    limits: {
+        output: number;
+        context: number;
+    };
+    status?: "active" | "beta" | "deprecated" | undefined;
+    family?: string | undefined;
+}>;
+export type ModelInfo = z.infer<typeof ModelInfo>;
+export declare const ProviderInfo: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    envKeys: z.ZodArray<z.ZodString, "many">;
+    models: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        provider: z.ZodString;
+        family: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodObject<{
+            temperature: z.ZodDefault<z.ZodBoolean>;
+            reasoning: z.ZodDefault<z.ZodBoolean>;
+            vision: z.ZodDefault<z.ZodBoolean>;
+            toolUse: z.ZodDefault<z.ZodBoolean>;
+            streaming: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            temperature: boolean;
+            reasoning: boolean;
+            vision: boolean;
+            toolUse: boolean;
+            streaming: boolean;
+        }, {
+            temperature?: boolean | undefined;
+            reasoning?: boolean | undefined;
+            vision?: boolean | undefined;
+            toolUse?: boolean | undefined;
+            streaming?: boolean | undefined;
+        }>;
+        cost: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodOptional<z.ZodNumber>;
+            cacheWrite: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }>;
+        limits: z.ZodObject<{
+            context: z.ZodNumber;
+            output: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            output: number;
+            context: number;
+        }, {
+            output: number;
+            context: number;
+        }>;
+        status: z.ZodDefault<z.ZodEnum<["active", "beta", "deprecated"]>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "active" | "beta" | "deprecated";
+        id: string;
+        name: string;
+        provider: string;
+        capabilities: {
+            temperature: boolean;
+            reasoning: boolean;
+            vision: boolean;
+            toolUse: boolean;
+            streaming: boolean;
+        };
+        cost: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        };
+        limits: {
+            output: number;
+            context: number;
+        };
+        family?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        provider: string;
+        capabilities: {
+            temperature?: boolean | undefined;
+            reasoning?: boolean | undefined;
+            vision?: boolean | undefined;
+            toolUse?: boolean | undefined;
+            streaming?: boolean | undefined;
+        };
+        cost: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        };
+        limits: {
+            output: number;
+            context: number;
+        };
+        status?: "active" | "beta" | "deprecated" | undefined;
+        family?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    envKeys: string[];
+    models: Record<string, {
+        status: "active" | "beta" | "deprecated";
+        id: string;
+        name: string;
+        provider: string;
+        capabilities: {
+            temperature: boolean;
+            reasoning: boolean;
+            vision: boolean;
+            toolUse: boolean;
+            streaming: boolean;
+        };
+        cost: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        };
+        limits: {
+            output: number;
+            context: number;
+        };
+        family?: string | undefined;
+    }>;
+}, {
+    id: string;
+    name: string;
+    envKeys: string[];
+    models: Record<string, {
+        id: string;
+        name: string;
+        provider: string;
+        capabilities: {
+            temperature?: boolean | undefined;
+            reasoning?: boolean | undefined;
+            vision?: boolean | undefined;
+            toolUse?: boolean | undefined;
+            streaming?: boolean | undefined;
+        };
+        cost: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        };
+        limits: {
+            output: number;
+            context: number;
+        };
+        status?: "active" | "beta" | "deprecated" | undefined;
+        family?: string | undefined;
+    }>;
+}>;
+export type ProviderInfo = z.infer<typeof ProviderInfo>;
+/**
+ * Provider configuration from user config
+ */
+export declare const ProviderConfig: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    options?: Record<string, any> | undefined;
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+}, {
+    options?: Record<string, any> | undefined;
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+}>;
+export type ProviderConfig = z.infer<typeof ProviderConfig>;

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

@@ -0,0 +1,160 @@
+/**
+ * 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;
+};
+export type { OverflowCheckOptions as ContextOverflowOptions };

package/dist/session/index.d.ts

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

package/dist/session/llm.d.ts

@@ -0,0 +1,29 @@
+import { streamText, type ModelMessage, type Tool } from "ai";
+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;
+    }
+    interface StreamResult {
+        stream: AsyncIterable<any>;
+        response: Promise<any>;
+    }
+    /**
+     * Stream a response from the LLM
+     */
+    function stream(options: StreamOptions): Promise<ReturnType<typeof streamText>>;
+    /**
+     * Calculate token usage cost
+     */
+    function calculateCost(model: ModelInfo, usage: {
+        inputTokens?: number;
+        outputTokens?: number;
+    }): number;
+}