@ebowwa/coder 0.7.64 → 0.7.66

package/packages/src/core/context/index.ts

@@ -0,0 +1,66 @@
+/**
+ * Context Module - Context compaction for conversation management
+ *
+ * When the context window fills up, we need to compact messages to continue.
+ * This module provides token estimation, summarization, and compaction utilities.
+ *
+ * @example
+ * ```ts
+ * import { compactMessages, needsCompaction, estimateMessagesTokens } from "./context/index.js";
+ *
+ * // Check if compaction is needed
+ * if (needsCompaction(messages, maxTokens)) {
+ *   const result = await compactMessages(messages, maxTokens);
+ *   console.log(`Saved ${result.tokensBefore - result.tokensAfter} tokens`);
+ * }
+ * ```
+ */
+
+// Types
+export type {
+  LLMSummarizationOptions,
+  CompactionOptions,
+  CompactionResult,
+  CompactionStats,
+  ToolPair,
+} from "./types.js";
+
+// Constants
+export {
+  CHARS_PER_TOKEN,
+  DEFAULT_KEEP_LAST,
+  DEFAULT_KEEP_FIRST,
+  MIN_MESSAGES_FOR_COMPACTION,
+  DEFAULT_COMPACTION_THRESHOLD,
+  MAX_SUMMARY_LENGTH,
+  SUMMARY_MAX_TOKENS,
+} from "./constants.js";
+
+// Token Estimation
+export {
+  estimateTokens,
+  estimateBlockTokens,
+  estimateMessageTokens,
+  estimateMessagesTokens,
+} from "./token-estimation.js";
+
+// Extraction
+export {
+  extractTextFromMessage,
+  extractToolPairs,
+  extractToolNames,
+} from "./extraction.js";
+
+// Summarization
+export {
+  summarizeMessages,
+  summarizeWithLLM,
+  compactContentNative,
+} from "./summarization.js";
+
+// Compaction
+export {
+  compactMessages,
+  needsCompaction,
+  getCompactionStats,
+} from "./compaction.js";

package/packages/src/core/context/summarization.ts

@@ -0,0 +1,251 @@
+/**
+ * Summarization - Create summaries of conversation messages
+ *
+ * Strategies:
+ * 1. Native compact_content (Rust) - Fast preprocessing
+ * 2. Simple concatenation + truncation - Fallback
+ * 3. LLM-based summarization - Best quality when API available
+ */
+
+import type { Message, ToolResultBlock } from "../../types/index.js";
+import { SUMMARIZATION_MODEL } from "../models.js";
+import type { LLMSummarizationOptions } from "./types.js";
+import {
+  MAX_SUMMARY_LENGTH,
+  SUMMARY_MAX_TOKENS,
+  SUMMARIZATION_SYSTEM_PROMPT,
+  SUMMARIZATION_PROMPT,
+} from "./constants.js";
+import { extractTextFromMessage, extractToolNames } from "./extraction.js";
+
+// Lazy-load native module
+let _native: {
+  compact_content?: (
+    content: string,
+    maxTokens: number,
+    strategy?: "truncate" | "summarize" | "extract"
+  ) => string;
+} | null = null;
+let _nativeLoadAttempted = false;
+
+function getNative(): typeof _native {
+  if (_nativeLoadAttempted) return _native;
+  _nativeLoadAttempted = true;
+
+  try {
+    const nativePath = require.resolve("../../../native/index.js");
+    const nativeModule = require(nativePath);
+    _native = nativeModule.getNative?.() ?? null;
+  } catch {
+    _native = null;
+  }
+
+  return _native;
+}
+
+/**
+ * Preprocess content using native compact_content if available.
+ * Used to reduce large content before LLM summarization.
+ */
+function preprocessContent(content: string, maxTokens: number): string {
+  const native = getNative();
+
+  if (native?.compact_content) {
+    // Use native "extract" strategy for better preservation of structure
+    return native.compact_content(content, maxTokens, "extract");
+  }
+
+  // Fallback: simple truncation
+  const maxChars = maxTokens * 4;
+  if (content.length <= maxChars) return content;
+  return content.slice(0, maxChars) + "\n\n...[content truncated]";
+}
+
+/**
+ * Simple summarization that concatenates and truncates.
+ * Can be enhanced later with LLM-based summarization.
+ */
+export async function summarizeMessages(messages: Message[]): Promise<string> {
+  if (!messages || messages.length === 0) {
+    return "";
+  }
+
+  const summaryParts: string[] = [];
+  summaryParts.push(`[Context Summary: ${messages.length} messages compacted]\n`);
+
+  // Track tool operations for a cleaner summary
+  const toolOperations: string[] = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (!message) continue;
+
+    const role = message.role.toUpperCase();
+    const text = extractTextFromMessage(message);
+
+    // Track tool operations
+    toolOperations.push(...extractToolNames(message));
+
+    // Add truncated message content
+    const truncated = text.length > 300 ? `${text.slice(0, 300)}...` : text;
+    summaryParts.push(`${role}: ${truncated}\n`);
+  }
+
+  // Add tool summary
+  if (toolOperations.length > 0) {
+    const toolCounts = toolOperations.reduce((acc, tool) => {
+      acc[tool] = (acc[tool] || 0) + 1;
+      return acc;
+    }, {} as Record<string, number>);
+
+    const toolSummary = Object.entries(toolCounts)
+      .map(([name, count]) => `${name}(${count})`)
+      .join(", ");
+    summaryParts.push(`\nTools used: ${toolSummary}\n`);
+  }
+
+  let summary = summaryParts.join("");
+
+  // Truncate if too long
+  if (summary.length > MAX_SUMMARY_LENGTH) {
+    summary = summary.slice(0, MAX_SUMMARY_LENGTH) + "\n...[truncated]";
+  }
+
+  return summary;
+}
+
+/**
+ * Summarize messages using an LLM for better context preservation.
+ * Falls back to simple truncation if LLM fails or no API key provided.
+ */
+export async function summarizeWithLLM(
+  messages: Message[],
+  options: LLMSummarizationOptions = {}
+): Promise<string> {
+  const {
+    apiKey = process.env.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_API_KEY,
+    model = SUMMARIZATION_MODEL,
+    baseUrl = process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com",
+    timeout = 30000,
+  } = options;
+
+  // No API key - fall back to simple summarization
+  if (!apiKey) {
+    return summarizeMessages(messages);
+  }
+
+  try {
+    // Build the conversation text for summarization
+    let conversationText = messages.map((msg) => {
+      const role = msg.role.toUpperCase();
+      const text = extractTextFromMessage(msg);
+
+      // Extract tool info
+      const tools: string[] = [];
+      for (const block of msg.content) {
+        if (block.type === "tool_use") {
+          tools.push(`[TOOL_USE: ${block.name}]`);
+        } else if (block.type === "tool_result") {
+          const resultBlock = block as ToolResultBlock;
+          const preview = typeof resultBlock.content === "string"
+            ? resultBlock.content.slice(0, 200)
+            : "[complex result]";
+          tools.push(`[TOOL_RESULT: ${resultBlock.is_error ? "ERROR" : "OK"}] ${preview}`);
+        }
+      }
+
+      const toolsStr = tools.length > 0 ? `\n${tools.join("\n")}` : "";
+      return `${role}:\n${text.slice(0, 2000)}${toolsStr}`;
+    }).join("\n\n---\n\n");
+
+    // Preprocess with native if content is very large (reduce API costs)
+    const estimatedInputTokens = Math.ceil(conversationText.length / 4);
+    if (estimatedInputTokens > 8000) {
+      // Use native preprocessing to reduce size before LLM
+      conversationText = preprocessContent(conversationText, 6000);
+    }
+
+    // Build request
+    const requestBody = {
+      model,
+      max_tokens: SUMMARY_MAX_TOKENS,
+      system: SUMMARIZATION_SYSTEM_PROMPT,
+      messages: [{
+        role: "user" as const,
+        content: SUMMARIZATION_PROMPT.replace("{{MESSAGES}}", conversationText),
+      }],
+    };
+
+    // Make API call with timeout
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const response = await fetch(`${baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(`\x1b[33m[Compaction] LLM summarization failed: ${response.status} - ${errorText}\x1b[0m`);
+        return summarizeMessages(messages);
+      }
+
+      const data = await response.json() as {
+        content?: Array<{ type: string; text?: string }>;
+        usage?: { input_tokens: number; output_tokens: number };
+      };
+
+      // Extract text from response
+      const summaryText = data.content
+        ?.filter((block) => block.type === "text")
+        .map((block) => block.text || "")
+        .join("\n") || "";
+
+      if (!summaryText) {
+        console.error("\x1b[33m[Compaction] LLM returned empty summary\x1b[0m");
+        return summarizeMessages(messages);
+      }
+
+      // Log usage for debugging
+      if (data.usage) {
+        console.log(`\x1b[90m[Compaction] LLM summary: ${data.usage.input_tokens} in, ${data.usage.output_tokens} out\x1b[0m`);
+      }
+
+      return `[LLM Summary of ${messages.length} messages]\n\n${summaryText}`;
+
+    } finally {
+      clearTimeout(timeoutId);
+    }
+
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.error(`\x1b[33m[Compaction] LLM summarization error: ${errorMsg}\x1b[0m`);
+    // Fall back to simple summarization
+    return summarizeMessages(messages);
+  }
+}
+
+/**
+ * Compact content using native module (exposed for direct use)
+ */
+export function compactContentNative(
+  content: string,
+  maxTokens: number,
+  strategy: "truncate" | "summarize" | "extract" = "extract"
+): string | null {
+  const native = getNative();
+  if (native?.compact_content) {
+    return native.compact_content(content, maxTokens, strategy);
+  }
+  return null;
+}

package/packages/src/core/context/token-estimation.ts

@@ -0,0 +1,98 @@
+/**
+ * Token Estimation - Estimate token counts for messages
+ *
+ * Uses native Rust module for accurate, code-aware token counting.
+ * Falls back to heuristic (~4 chars/token) if native unavailable.
+ */
+
+import type { Message, ContentBlock } from "../../types/index.js";
+import { CHARS_PER_TOKEN } from "./constants.js";
+
+// Lazy-load native module to avoid circular dependencies
+let _native: { count_tokens?: (text: string) => number } | null = null;
+let _nativeLoadAttempted = false;
+
+function getNative(): { count_tokens?: (text: string) => number } | null {
+  if (_nativeLoadAttempted) return _native;
+  _nativeLoadAttempted = true;
+
+  try {
+    // Dynamic import to avoid bundling issues
+    const nativePath = require.resolve("../../../native/index.js");
+    _native = require(nativePath).getNative?.() ?? null;
+  } catch {
+    // Native module not available, use fallback
+    _native = null;
+  }
+
+  return _native;
+}
+
+/**
+ * Estimate the number of tokens in a text string.
+ * Uses native code-aware tokenizer if available, falls back to heuristic.
+ */
+export function estimateTokens(text: string): number {
+  if (!text || text.length === 0) return 0;
+
+  // Try native module first (more accurate, code-aware)
+  const native = getNative();
+  if (native?.count_tokens) {
+    return native.count_tokens(text);
+  }
+
+  // Fallback: simple heuristic
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+
+/**
+ * Estimate tokens for a single content block
+ */
+export function estimateBlockTokens(block: ContentBlock): number {
+  switch (block.type) {
+    case "text":
+      return estimateTokens(block.text);
+    case "image":
+      // Images are roughly 85-110 tokens for standard sizes
+      // Use 100 as an average estimate
+      return 100;
+    case "tool_use":
+      // Tool use: name + JSON input
+      const toolInput = JSON.stringify(block.input);
+      return estimateTokens(block.name) + estimateTokens(toolInput) + 10; // overhead
+    case "tool_result":
+      // Tool result: content + metadata
+      if (typeof block.content === "string") {
+        return estimateTokens(block.content) + 10;
+      }
+      return block.content.reduce((sum, b) => sum + estimateBlockTokens(b), 0) + 10;
+    case "thinking":
+      return estimateTokens(block.thinking);
+    default:
+      return 0;
+  }
+}
+
+/**
+ * Estimate the total number of tokens in a message
+ */
+export function estimateMessageTokens(message: Message): number {
+  // Role overhead (~4 tokens)
+  const roleOverhead = 4;
+
+  // Sum all content blocks
+  const contentTokens = message.content.reduce(
+    (sum, block) => sum + estimateBlockTokens(block),
+    0
+  );
+
+  return roleOverhead + contentTokens;
+}
+
+/**
+ * Get total estimated tokens across all messages
+ */
+export function estimateMessagesTokens(messages: Message[]): number {
+  if (!messages || messages.length === 0) return 0;
+  return messages.reduce((sum, msg) => sum + estimateMessageTokens(msg), 0);
+}

package/packages/src/core/context/types.ts

@@ -0,0 +1,59 @@
+/**
+ * Context Types - Type definitions for context compaction
+ */
+
+import type { ContentBlock, Message } from "../../types/index.js";
+
+/** Options for LLM-based summarization */
+export interface LLMSummarizationOptions {
+  /** API key for the LLM */
+  apiKey?: string;
+  /** Model to use for summarization (default: haiku) */
+  model?: string;
+  /** Base URL for API (for non-Anthropic providers) */
+  baseUrl?: string;
+  /** Timeout in ms (default: 30000) */
+  timeout?: number;
+}
+
+/** Options for message compaction */
+export interface CompactionOptions {
+  /** Number of initial messages to keep unchanged */
+  keepFirst?: number;
+  /** Number of recent messages to keep unchanged */
+  keepLast?: number;
+  /** Whether to preserve tool_use/tool_result pairs */
+  preserveToolPairs?: boolean;
+  /** Use LLM for summarization (default: true if API key available) */
+  useLLMSummarization?: boolean;
+  /** API key for LLM summarization (falls back to env) */
+  apiKey?: string;
+  /** Base URL for API (for non-Anthropic providers like Z.AI) */
+  baseUrl?: string;
+}
+
+/** Result of a compaction operation */
+export interface CompactionResult {
+  /** The compacted messages */
+  messages: Message[];
+  /** Number of messages removed */
+  messagesRemoved: number;
+  /** Estimated tokens before compaction */
+  tokensBefore: number;
+  /** Estimated tokens after compaction */
+  tokensAfter: number;
+  /** Whether compaction actually occurred */
+  didCompact: boolean;
+}
+
+/** Statistics from compaction */
+export interface CompactionStats {
+  reductionPercent: number;
+  tokensSaved: number;
+}
+
+/** Tool use/result pair for preservation */
+export interface ToolPair {
+  use: { type: "tool_use"; id: string; name: string; input: unknown };
+  result?: { type: "tool_result"; tool_use_id: string; content: string | ContentBlock[]; is_error?: boolean };
+}

package/packages/src/core/models.ts

@@ -28,7 +28,7 @@ export interface ModelDefinition {
   /** Whether model supports extended thinking */
   supportsThinking: boolean;
   /** Model provider */
-  provider: "anthropic" | "zhipu" | "openai" | "other";
+  provider: "anthropic" | "zhipu" | "minimax" | "openai" | "other";
   /** Whether model supports vision/images */
   supportsVision: boolean;
 }
@@ -164,18 +164,63 @@ export const MODELS: Record<string, ModelDefinition> = {
     supportsVision: true,
   },
 
-  // GLM Series (Zhipu AI)
+  // GLM Series (Zhipu AI - Coding Plan with Shared Quota)
+  // Note: GLM-5 consumes quota at 3x (peak) and 2x (off-peak)
   "glm-5": {
     id: "glm-5",
     name: "GLM-5",
     fullName: "GLM-5",
     contextWindow: 200_000,
     maxOutput: 128_000,
-    pricing: { input: 0.5, output: 0.5, cacheWrite: 0, cacheRead: 0 }, // GLM pricing TBD
+    pricing: { input: 0.5, output: 0.5, cacheWrite: 0, cacheRead: 0 },
     supportsThinking: true,
     provider: "zhipu",
     supportsVision: true,
   },
+  "glm-4.7": {
+    id: "glm-4.7",
+    name: "GLM-4.7",
+    fullName: "GLM-4.7",
+    contextWindow: 128_000,
+    maxOutput: 8_192,
+    pricing: { input: 0.5, output: 0.5, cacheWrite: 0, cacheRead: 0 },
+    supportsThinking: true,
+    provider: "zhipu",
+    supportsVision: true,
+  },
+  "glm-4.6": {
+    id: "glm-4.6",
+    name: "GLM-4.6",
+    fullName: "GLM-4.6",
+    contextWindow: 128_000,
+    maxOutput: 8_192,
+    pricing: { input: 0.5, output: 0.5, cacheWrite: 0, cacheRead: 0 },
+    supportsThinking: true,
+    provider: "zhipu",
+    supportsVision: true,
+  },
+  "glm-4.5v": {
+    id: "glm-4.5v",
+    name: "GLM-4.5V",
+    fullName: "GLM-4.5 Vision",
+    contextWindow: 128_000,
+    maxOutput: 4_096,
+    pricing: { input: 0.5, output: 0.5, cacheWrite: 0, cacheRead: 0 },
+    supportsThinking: false,
+    provider: "zhipu",
+    supportsVision: true,
+  },
+  "glm-4.5": {
+    id: "glm-4.5",
+    name: "GLM-4.5",
+    fullName: "GLM-4.5",
+    contextWindow: 128_000,
+    maxOutput: 4_096,
+    pricing: { input: 0.5, output: 0.5, cacheWrite: 0, cacheRead: 0 },
+    supportsThinking: false,
+    provider: "zhipu",
+    supportsVision: false,
+  },
   "glm-4.5-air": {
     id: "glm-4.5-air",
     name: "GLM-4.5 Air",
@@ -187,6 +232,19 @@ export const MODELS: Record<string, ModelDefinition> = {
     provider: "zhipu",
     supportsVision: false,
   },
+
+  // MiniMax Series
+  "minimax-m2.5": {
+    id: "MiniMax-M2.5",
+    name: "M2.5",
+    fullName: "MiniMax M2.5",
+    contextWindow: 200_000,
+    maxOutput: 32_000,
+    pricing: { input: 0.3, output: 0.9, cacheWrite: 0, cacheRead: 0 },
+    supportsThinking: false,
+    provider: "minimax",
+    supportsVision: true,
+  },
 };
 
 // ============================================
@@ -195,19 +253,38 @@ export const MODELS: Record<string, ModelDefinition> = {
 
 /** Models available for interactive use (shown in /models command) */
 export const AVAILABLE_MODELS = [
+  // Claude 4.x (Anthropic - stub)
   MODELS["claude-opus-4-6"]!,
   MODELS["claude-sonnet-4-6"]!,
   MODELS["claude-haiku-4-5"]!,
+  // GLM Series (Zhipu / Z.AI - coding plan)
   MODELS["glm-5"]!,
+  MODELS["glm-4.7"]!,
+  MODELS["glm-4.5v"]!,
+  // MiniMax Series
+  MODELS["minimax-m2.5"]!,
 ] as const;
 
 /** Model aliases for subagent tasks */
 export const MODEL_ALIASES = {
+  // Claude aliases
   haiku: "claude-haiku-4-5",
   sonnet: "claude-sonnet-4-6",
   opus: "claude-opus-4-6",
-  fast: "glm-4.5-air",
   default: "claude-sonnet-4-6",
+  // GLM aliases (Zhipu / Z.AI)
+  glm: "glm-5",
+  glm5: "glm-5",
+  glm4: "glm-4.7",
+  glm47: "glm-4.7",
+  glm46: "glm-4.6",
+  glm45v: "glm-4.5v",
+  glm45: "glm-4.5",
+  glm45air: "glm-4.5-air",
+  fast: "glm-4.5-air",
+  // MiniMax aliases
+  minimax: "minimax-m2.5",
+  m25: "minimax-m2.5",
 } as const;
 
 // ============================================

package/packages/src/core/normalizers/todo

@@ -1,4 +1,8 @@
 - channels
 - stream
 - keyboard event activity
--
+- tools/mcps
+
+
+packages/src/sandbox-body/channels/channel-command handles all this
+this si an npm package