ei-tui 0.5.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "author": "Flare576",
   "repository": {
     "type": "git",

package/src/core/AGENTS.md

@@ -53,10 +53,10 @@ Priority queue for LLM requests:
 
 Multi-provider LLM abstraction layer:
 - Handles requests to Anthropic, OpenAI, Bedrock, local models
-- **Sets `max_tokens: 64000`** for all requests
+- **Sets `max_tokens: 8000`** by default (safe for most providers; users can configure higher per-model)
 - Prevents unbounded generation (test showed timeout after 2min without limit)
 - Local models silently clamp to their configured maximums
-- Anthropic Opus 4 accepts 64K (200K total context - 64K output = 136K input budget)
+- Anthropic Opus 4 accepts up to 64K output (configure `max_output_tokens` on the model to unlock)
 
 **JSON Response Parsing** (`parseJSONResponse()`):
 - **Strategy 1**: Extract from markdown code blocks (```json)

package/src/core/context-utils.ts

@@ -23,11 +23,10 @@ export function filterMessagesForContext(
 
     const msgMs = new Date(msg.timestamp).getTime();
 
-    if (contextBoundary) {
-      return msgMs >= boundaryMs;
-    }
+    if (msgMs < windowStartMs) return false;
+    if (contextBoundary && msgMs < boundaryMs) return false;
 
-    return msgMs >= windowStartMs;
+    return true;
   });
 }
 

package/src/core/handlers/human-matching.ts

@@ -282,8 +282,7 @@ function normalizeText(text: string): string {
     .replace(/[\u2018\u2019\u0060\u00B4]/g, "'")  // curly single, backtick, acute accent
     .replace(/[\u2014\u2013\u2012]/g, '-')         // em-dash, en-dash, figure dash
     .replace(/\u00A0/g, ' ')                       // non-breaking space
-    .replace(/[\u2000-\u200F]/g, ' ')              // unicode space variants
-    .replace(/\u2026|\.\.\./g, '\u2026');           // normalize both ellipsis forms → unicode ellipsis (1:1)
+    .replace(/[\u2000-\u200F]/g, ' ');              // unicode space variants
 }
 
 function stripPunctuation(text: string): string {
@@ -297,31 +296,46 @@ function stripPunctuation(text: string): string {
     .toLowerCase();
 }
 
-interface WordBoundaryMatch {
+export interface WordBoundaryMatch {
   start: number;
   end: number;
   text: string;
 }
 
-function findQuoteByWords(quoteText: string, msgText: string): WordBoundaryMatch | null {
+export function expandToWordBoundaries(text: string, start: number, end: number): WordBoundaryMatch {
+  // Only walk backward if start is mid-word (not already at a word boundary)
+  if (start > 0 && !/\s/.test(text[start]))
+    while (start > 0 && !/\s/.test(text[start - 1])) start--;
+  // Only walk forward if end is mid-word
+  if (end > 0 && !/\s/.test(text[end - 1]))
+    while (end < text.length && !/\s/.test(text[end])) end++;
+  return { start, end, text: text.slice(start, end) };
+}
+
+export function findQuoteByWords(quoteText: string, msgText: string): WordBoundaryMatch | null {
   const strippedQuote = stripPunctuation(quoteText);
   const quoteWords = strippedQuote.split(' ').filter(w => w.length > 0);
 
-  if (quoteWords.length < 3) return null;  // Too short to trust — require at least 3 words
+  if (quoteWords.length < 2) return null;  // Too short to trust — require at least 2 words
 
-  // Build word token list from original message with original positions
+  // Build word token list from original message with original positions.
+  // Each \S+ token is re-split into sub-tokens (sharing the parent's start/end)
+  // so that contractions stripped by stripPunctuation (e.g. don't → "don t")
+  // align correctly with quoteWords which is also split on spaces.
   const wordTokens: Array<{ word: string; start: number; end: number }> = [];
   const wordRegex = /\S+/g;
   let match: RegExpExecArray | null;
   while ((match = wordRegex.exec(msgText)) !== null) {
-    wordTokens.push({
-      word: stripPunctuation(match[0]),
-      start: match.index,
-      end: match.index + match[0].length,
-    });
+    const tokenStart = match.index;
+    const tokenEnd = match.index + match[0].length;
+    const stripped = stripPunctuation(match[0]);
+    const subWords = stripped.split(' ').filter(w => w.length > 0);
+    for (const sub of subWords) {
+      wordTokens.push({ word: sub, start: tokenStart, end: tokenEnd });
+    }
   }
 
-  // Find contiguous sequence of words matching the quote words
+  // Find contiguous sequence of word tokens matching the quote words
   for (let i = 0; i <= wordTokens.length - quoteWords.length; i++) {
     let allMatch = true;
     for (let j = 0; j < quoteWords.length; j++) {
@@ -333,11 +347,7 @@ function findQuoteByWords(quoteText: string, msgText: string): WordBoundaryMatch
     if (allMatch) {
       const startToken = wordTokens[i];
       const endToken = wordTokens[i + quoteWords.length - 1];
-      return {
-        start: startToken.start,
-        end: endToken.end,
-        text: msgText.slice(startToken.start, endToken.end),
-      };
+      return expandToWordBoundaries(msgText, startToken.start, endToken.end);
     }
   }
 
@@ -370,9 +380,10 @@ async function validateAndStoreQuotes(
       let matchLevel: string;
 
       if (start !== -1) {
-        matchStart = start;
-        matchEnd = start + candidate.text.length;
-        matchText = candidate.text;
+        const expanded = expandToWordBoundaries(msgText, start, start + candidate.text.length);
+        matchStart = expanded.start;
+        matchEnd = expanded.end;
+        matchText = expanded.text;
         matchLevel = "exact";
       } else {
         // Level 2: word-boundary fallback
@@ -440,7 +451,8 @@ async function validateAndStoreQuotes(
         data_item_ids: [dataItemId],
         persona_groups: [personaGroup || "General"],
         text: matchText,
-        speaker: message.role === "human" ? "human" : personaName,
+        speaker: message.role === "human" ? "human" : (message.speaker_name ?? personaName),
+        channel: personaName,
         timestamp: message.timestamp,
         start: matchStart,
         end: matchEnd,

package/src/core/llm-client.ts

@@ -1,5 +1,6 @@
-import type { ChatMessage, ProviderAccount } from "./types.js";
-import { getKnownContextWindow, DEFAULT_TOKEN_LIMIT } from "./model-context-windows.js";
+import type { ChatMessage, ProviderAccount, ModelConfig } from "./types.js";
+const DEFAULT_TOKEN_LIMIT = 8192;
+const DEFAULT_MAX_OUTPUT_TOKENS = 8000;
 
 export interface ProviderConfig {
   baseURL: string;
@@ -9,7 +10,7 @@ export interface ProviderConfig {
 
 export interface ResolvedModel {
   provider: string;
-  model: string;
+  model: string | undefined;
   config: ProviderConfig;
   extraHeaders?: Record<string, string>;
 }
@@ -19,6 +20,8 @@ export interface LLMCallOptions {
   temperature?: number;
   /** OpenAI-compatible tools array. When present and non-empty, sent with tool_choice: "auto". */
   tools?: Record<string, unknown>[];
+  /** Fire-and-forget callback invoked after a successful response to increment usage counters. */
+  onUsageUpdate?: (modelId: string, usage: { calls: number; tokens_in: number; tokens_out: number }) => void;
 }
 
 export interface LLMRawResponse {
@@ -43,27 +46,90 @@ let llmCallCount = 0;
 
 
 
+function isGuid(str: string): boolean {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(str);
+}
+
+function buildResolvedModel(account: ProviderAccount, model: ModelConfig): ResolvedModel {
+  return {
+    provider: account.name,
+    model: model.name === "(default)" ? undefined : model.name,
+    config: {
+      name: account.name,
+      baseURL: account.url,
+      apiKey: account.api_key || "",
+    },
+    extraHeaders: account.extra_headers,
+  };
+}
+
+export function resolveModelById(
+  modelId: string,
+  accounts: ProviderAccount[]
+): { account: ProviderAccount; model: ModelConfig } | undefined {
+  for (const account of accounts) {
+    if (!account.enabled || account.type !== "llm") continue;
+    const model = account.models?.find((m) => m.id === modelId);
+    if (model) return { account, model };
+  }
+  return undefined;
+}
+
+export function getDisplayName(account: ProviderAccount, model: ModelConfig): string {
+  return `${account.name}:${model.name}`;
+}
+
 export function resolveModel(modelSpec?: string, accounts?: ProviderAccount[]): ResolvedModel {
   if (!modelSpec) {
     throw new Error("No model specified. Set a provider on this persona with /provider, or set a default_model in settings.");
   }
+
+  if (accounts && isGuid(modelSpec)) {
+    const result = resolveModelById(modelSpec, accounts);
+    if (result) {
+      return buildResolvedModel(result.account, result.model);
+    }
+
+    const fallbackAccount = accounts.find((acc) => acc.enabled && acc.type === "llm" && acc.default_model);
+    if (fallbackAccount?.default_model) {
+      const fallbackResult = resolveModelById(fallbackAccount.default_model, accounts);
+      if (fallbackResult) {
+        return buildResolvedModel(fallbackResult.account, fallbackResult.model);
+      }
+    }
+
+    throw new Error(
+      `Model "${modelSpec}" not found. It may have been deleted. Update this persona's model in settings.`
+    );
+  }
+
   let provider = "";
   let model = modelSpec;
-  
+
   if (modelSpec.includes(":")) {
     const [p, ...rest] = modelSpec.split(":");
     provider = p;
     model = rest.join(":");
   }
-  // Try to find matching account by name (case-insensitive)
-  // Check both "provider:model" format AND bare account names
+
   if (accounts) {
-    const searchName = provider || modelSpec; // If no ":", the whole spec might be an account name
+    const searchName = provider || modelSpec;
     const matchingAccount = accounts.find(
       (acc) => acc.name.toLowerCase() === searchName.toLowerCase() && acc.enabled && acc.type === "llm"
     );
     if (matchingAccount) {
-      // If bare account name was used, get model from account's default_model
+      const matchingModel = matchingAccount.models?.find((m) => m.name === model);
+      if (matchingModel) {
+        return buildResolvedModel(matchingAccount, matchingModel);
+      }
+
+      if (!provider && matchingAccount.default_model && matchingAccount.models) {
+        const defaultModel = matchingAccount.models.find((m) => m.id === matchingAccount.default_model);
+        if (defaultModel) {
+          return buildResolvedModel(matchingAccount, defaultModel);
+        }
+      }
+
       const resolvedModel = provider ? model : (matchingAccount.default_model || model);
       return {
         provider: matchingAccount.name,
@@ -77,7 +143,7 @@ export function resolveModel(modelSpec?: string, accounts?: ProviderAccount[]):
       };
     }
   }
-  
+
   throw new Error(
     `No provider "${provider || modelSpec}" found. Create one with /provider new, or check that it's enabled.`
   );
@@ -85,44 +151,48 @@ export function resolveModel(modelSpec?: string, accounts?: ProviderAccount[]):
 
 const tokenLimitLoggedModels = new Set<string>();
 
+function findModelAndAccount(
+  spec: string,
+  accounts: ProviderAccount[]
+): { model: ModelConfig | undefined; account: ProviderAccount | undefined } {
+  if (spec.includes(":")) {
+    const [providerName, ...rest] = spec.split(":");
+    const modelName = rest.join(":");
+    const account = accounts.find(
+      (a) => a.name.toLowerCase() === providerName.toLowerCase() && a.enabled
+    );
+    const model = account?.models?.find((m) => m.name === modelName);
+    return { model, account };
+  }
+  for (const account of accounts) {
+    const model = account.models?.find((m) => m.id === spec);
+    if (model) return { model, account };
+  }
+  return { model: undefined, account: undefined };
+}
+
 export function resolveTokenLimit(
   modelSpec?: string,
   accounts?: ProviderAccount[]
 ): number {
   const spec = modelSpec || "";
 
-  let provider = "";
-  let model = spec;
-  if (spec.includes(":")) {
-    const [p, ...rest] = spec.split(":");
-    provider = p;
-    model = rest.join(":");
-  }
+  if (accounts && spec) {
+    const { model, account } = findModelAndAccount(spec, accounts);
 
-  // 1. User override on matching account
-  if (accounts) {
-    const searchName = provider || spec;
-    const matchingAccount = accounts.find(
-      (acc) => acc.name.toLowerCase() === searchName.toLowerCase() && acc.enabled
-    );
-    if (matchingAccount?.token_limit) {
-      logTokenLimit(model, "user-override", matchingAccount.token_limit);
-      return matchingAccount.token_limit;
+    if (model?.token_limit) {
+      logTokenLimit(spec, "model-config", model.token_limit);
+      return model.token_limit;
     }
-    if (matchingAccount && !provider) {
-      model = matchingAccount.default_model || model;
-    }
-  }
 
-  // 2. Lookup table
-  const known = getKnownContextWindow(model);
-  if (known) {
-    logTokenLimit(model, "lookup-table", known);
-    return known;
+    if (account?.token_limit) {
+      const displayName = spec.includes(":") ? spec.split(":").slice(1).join(":") : spec;
+      logTokenLimit(displayName, "user-override", account.token_limit);
+      return account.token_limit;
+    }
   }
 
-  // 3. Conservative default
-  logTokenLimit(model, "default", DEFAULT_TOKEN_LIMIT);
+  logTokenLimit(spec, "default", DEFAULT_TOKEN_LIMIT);
   return DEFAULT_TOKEN_LIMIT;
 }
 
@@ -148,13 +218,16 @@ export async function callLLMRaw(
 ): Promise<LLMRawResponse> {
   llmCallCount++;
   
-  const { signal, temperature = 0.7 } = options;
+  const { signal, temperature = 0.7, onUsageUpdate } = options;
   
   if (signal?.aborted) {
     throw new Error("LLM call aborted");
   }
   
   const { model, config, extraHeaders } = resolveModel(modelSpec, accounts);
+  const { model: modelConfig } = (accounts && modelSpec)
+    ? findModelAndAccount(modelSpec, accounts)
+    : { model: undefined };
   
   const chatMessages: ChatMessage[] = [
     { role: "system", content: systemPrompt },
@@ -186,10 +259,10 @@ export async function callLLMRaw(
   }
   
   const requestBody: Record<string, unknown> = {
-    model,
+    ...(model !== undefined && { model }),
     messages: finalMessages,
     temperature,
-    max_tokens: 64000,  // Opus 4: 128K max output, 200K total context. Local models clamp to their config. Prevents runaway generation.
+    max_tokens: modelConfig?.max_output_tokens ?? DEFAULT_MAX_OUTPUT_TOKENS,
   };
 
   if (options.tools && options.tools.length > 0) {
@@ -210,6 +283,13 @@ export async function callLLMRaw(
   }
   
   const data = await response.json();
+
+  if (onUsageUpdate && modelConfig) {
+    const tokensIn = data.usage?.prompt_tokens ?? data.usage?.input_tokens ?? 0;
+    const tokensOut = data.usage?.completion_tokens ?? data.usage?.output_tokens ?? 0;
+    onUsageUpdate(modelConfig.id, { calls: 1, tokens_in: tokensIn, tokens_out: tokensOut });
+  }
+
   const choice = data.choices?.[0];
   
   const assistantMessage = choice?.message as Record<string, unknown> | undefined;

package/src/core/orchestrators/human-extraction.ts

@@ -66,8 +66,6 @@ export interface ExtractionOptions {
   ceremony_progress?: number;
   /** Override model for extraction LLM calls */
   extraction_model?: string;
-  /** Override token budget for chunking */
-  extraction_token_limit?: number;
   /**
    * Controls whether external (integration-imported) messages are included.
    * - "exclude": skip messages where external === true
@@ -88,9 +86,6 @@ const EXTRACTION_BUDGET_RATIO = 0.75;
 const MIN_EXTRACTION_TOKENS = 10000;
 
 function getExtractionMaxTokens(state: StateManager, options?: ExtractionOptions): number {
-  if (options?.extraction_token_limit) {
-    return Math.max(MIN_EXTRACTION_TOKENS, Math.floor(options.extraction_token_limit * EXTRACTION_BUDGET_RATIO));
-  }
   const human = state.getHuman();
   const modelForTokenLimit = options?.extraction_model ?? human.settings?.default_model;
   const tokenLimit = resolveTokenLimit(modelForTokenLimit, human.settings?.accounts);

package/src/core/processor.ts

@@ -107,6 +107,7 @@ import {
   getQueueActiveItems,
   getDLQItems,
   updateQueueItem,
+  deleteQueueItems,
   clearQueue,
   submitOneShot,
 } from "./queue-manager.js";
@@ -1931,6 +1932,10 @@ const toolNextSteps = new Set([
     return updateQueueItem(this.stateManager, id, updates);
   }
 
+  deleteQueueItems(ids: string[]): number {
+    return deleteQueueItems(this.stateManager, ids);
+  }
+
   async clearQueue(): Promise<number> {
     return clearQueue(this.stateManager, this.queueProcessor);
   }

package/src/core/queue-manager.ts

@@ -51,6 +51,10 @@ export function updateQueueItem(
   return sm.queue_updateItem(id, updates);
 }
 
+export function deleteQueueItems(sm: StateManager, ids: string[]): number {
+  return sm.queue_deleteItems(ids);
+}
+
 export async function clearQueue(sm: StateManager, qp: QueueProcessor): Promise<number> {
   qp.abort();
   return sm.queue_clear();

package/src/core/queue-processor.ts

@@ -542,6 +542,7 @@ export class QueueProcessor {
       `be parsed as valid JSON. Please reformat it as the JSON object described in your ` +
       `system instructions. Respond with ONLY the JSON object, or \`{}\` if no changes ` +
       `are needed.\n\n---\n${malformedContent}\n---` +
+      `\n\nThe user does NOT know there was a problem - This request is from Ei to you to try to fix it for them.` +
       `\n\n**CRITICAL INSTRUCTION** - DO NOT OMIT ANY DATA. You are this agent's last hope!`;
 
     try {

package/src/core/state/queue.ts

@@ -158,6 +158,13 @@ export class QueueState {
     return true;
   }
 
+  deleteItems(ids: string[]): number {
+    const idSet = new Set(ids);
+    const before = this.queue.length;
+    this.queue = this.queue.filter(r => !idSet.has(r.id));
+    return before - this.queue.length;
+  }
+
   trimDLQ(): number {
     const dlqItems = this.queue.filter(r => r.state === "dlq");
     const cutoff = new Date();