ei-tui 0.5.1 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "0.5.1",
+  "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/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();

package/src/core/state-manager.ts

@@ -50,15 +50,20 @@ export class StateManager {
       this.queueState.load(state.queue);
       this.tools = state.tools ?? [];
       this.providers = state.providers ?? [];
-      this.migrateLearnedByToIds();
-      this.migrateFactValidation();
-      this.migrateMessageFlags();
-      this.migrateInterestedPersonas();
+      this.runMigrations();
     } else {
       this.humanState.load(createDefaultHumanEntity());
     }
   }
 
+  private runMigrations(): void {
+    this.migrateLearnedByToIds();
+    this.migrateFactValidation();
+    this.migrateMessageFlags();
+    this.migrateInterestedPersonas();
+    this.migrateProviderModel();
+  }
+
   /**
    * Migration: learned_by used to store display names; now stores persona IDs.
    * On load, attempt to resolve display names -> IDs using current persona map.
@@ -222,6 +227,162 @@ export class StateManager {
     }
   }
 
+  private migrateProviderModel(): void {
+    const human = this.humanState.get();
+    const settings = human.settings;
+    if (!settings?.accounts?.length) return;
+
+    const modelLookup = new Map<string, string>();
+
+    // Helper: ensure a model exists in an account and register it in modelLookup.
+    // ref must be in "ProviderName:model-name" format.
+    const ensureModelInAccount = (ref: string): void => {
+      const colonIdx = ref.indexOf(":");
+      if (colonIdx === -1) return;
+      const providerName = ref.substring(0, colonIdx);
+      const modelName = ref.substring(colonIdx + 1);
+      const account = settings.accounts!.find((a) => a.name === providerName);
+      if (!account) return;
+
+      if (!account.models) account.models = [];
+
+      const existing = account.models.find((m) => m.name === modelName);
+      if (existing) {
+        modelLookup.set(ref, existing.id);
+      } else {
+        const newModel = {
+          id: crypto.randomUUID(),
+          name: modelName,
+        };
+        account.models.push(newModel);
+        modelLookup.set(ref, newModel.id);
+      }
+    };
+
+    const isProviderRef = (val: string): boolean => {
+      const colonIdx = val.indexOf(":");
+      if (colonIdx === -1) return false;
+      const providerName = val.substring(0, colonIdx);
+      return settings.accounts!.some((a) => a.name === providerName);
+    };
+
+    // Phase 1: Collect ALL model refs from everywhere they can appear.
+    const allRefs: string[] = [];
+    const pushRef = (ref: string | undefined): void => {
+      if (ref && isProviderRef(ref)) allRefs.push(ref);
+    };
+
+    pushRef(settings.default_model);
+    pushRef(settings.oneshot_model);
+    pushRef(settings.rewrite_model);
+    pushRef(settings.opencode?.extraction_model);
+    pushRef(settings.claudeCode?.extraction_model);
+
+    const personas = this.personaState.getAll();
+    for (const persona of personas) {
+      pushRef(persona.model);
+    }
+
+    // Also include account.default_model values (legacy strings, not yet GUIDs)
+    for (const account of settings.accounts) {
+      if (account.default_model && isProviderRef(account.default_model)) {
+        allRefs.push(account.default_model);
+      }
+    }
+
+    // Phase 2: For each ref, ensure model exists in the matching account.
+    for (const ref of allRefs) {
+      ensureModelInAccount(ref);
+    }
+
+    // Helper: check if a value looks like a UUID (already migrated)
+    const isUUID = (val: string): boolean =>
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val);
+
+    // Phase 3: Ensure every account has a models array and default_model is a GUID.
+    for (const account of settings.accounts) {
+      if (!account.models) {
+        account.models = [];
+      }
+
+      // Handle account.default_model - could be:
+      // 1. Already a GUID (already migrated) - leave it
+      // 2. A "Provider:model" ref - look up in modelLookup
+      // 3. A plain model name like "claude-haiku-4-5-20251001" - add to models[] and convert
+      if (account.default_model) {
+        if (isUUID(account.default_model)) {
+          // Already migrated, nothing to do
+        } else if (isProviderRef(account.default_model)) {
+          // It's a "Provider:model" ref - should be in modelLookup from Phase 2
+          const guid = modelLookup.get(account.default_model);
+          if (guid) account.default_model = guid;
+        } else {
+          // Plain model name - check if it exists in models[], add if not, convert to GUID
+          const existing = account.models.find((m) => m.name === account.default_model);
+          if (existing) {
+            account.default_model = existing.id;
+          } else {
+            const model = {
+              id: crypto.randomUUID(),
+              name: account.default_model,
+              token_limit: (account as any).token_limit as number | undefined,
+              max_output_tokens: undefined as number | undefined,
+            };
+            account.models.push(model);
+            modelLookup.set(`${account.name}:${model.name}`, model.id);
+            account.default_model = model.id;
+          }
+        }
+      }
+
+      // If still no models, create a placeholder
+      if (account.models.length === 0) {
+        const model = { id: crypto.randomUUID(), name: "(default)" };
+        account.models.push(model);
+        modelLookup.set(`${account.name}:(default)`, model.id);
+        account.default_model = model.id;
+      }
+
+      delete (account as any).token_limit;
+    }
+
+    const resolveRef = (ref: string | undefined): string | undefined => {
+      if (!ref) return ref;
+      const guid = modelLookup.get(ref);
+      if (guid) return guid;
+      const colonIdx = ref.indexOf(":");
+      if (colonIdx === -1) return ref;
+      return undefined;
+    };
+
+    settings.default_model = resolveRef(settings.default_model);
+    settings.oneshot_model = resolveRef(settings.oneshot_model);
+    settings.rewrite_model = resolveRef(settings.rewrite_model);
+
+    if (settings.opencode) {
+      settings.opencode.extraction_model = resolveRef(settings.opencode.extraction_model);
+      delete (settings.opencode as any).extraction_token_limit;
+    }
+
+    if (settings.claudeCode) {
+      settings.claudeCode.extraction_model = resolveRef(settings.claudeCode.extraction_model);
+      delete (settings.claudeCode as any).extraction_token_limit;
+    }
+
+    for (const persona of personas) {
+      if (persona.model) {
+        const resolved = resolveRef(persona.model);
+        const colonIdx = (resolved ?? persona.model).indexOf(":");
+        const finalModel = colonIdx !== -1 ? undefined : (resolved ?? persona.model);
+        this.personaState.update(persona.id, { model: finalModel });
+      }
+    }
+
+    this.humanState.set(human);
+    this.scheduleSave();
+    console.log("[StateManager] Migrated provider/model references to GUID-based ModelConfig system");
+  }
+
   /**
    * Returns true if value looks like a persona ID (UUID or the special "ei" id).
    * Display names are free-form strings that won't match UUID format.
@@ -621,6 +782,12 @@ export class StateManager {
     return result;
   }
 
+  queue_deleteItems(ids: string[]): number {
+    const result = this.queueState.deleteItems(ids);
+    if (result > 0) this.scheduleSave();
+    return result;
+  }
+
   queue_dlqLength(): number {
     return this.queueState.dlqLength();
   }
@@ -764,6 +931,67 @@ export class StateManager {
     return result;
   }
 
+  deleteModel(providerId: string, modelId: string): { success: boolean; error?: string; cleared: string[] } {
+    const human = this.humanState.get();
+    const settings = human.settings;
+    if (!settings?.accounts?.length) {
+      return { success: false, error: `Provider not found: ${providerId}`, cleared: [] };
+    }
+
+    const provider = settings.accounts.find(a => a.id === providerId);
+    if (!provider) {
+      return { success: false, error: `Provider not found: ${providerId}`, cleared: [] };
+    }
+
+    if (!provider.models?.find(m => m.id === modelId)) {
+      return { success: false, error: `Model not found: ${modelId}`, cleared: [] };
+    }
+
+    if ((provider.models?.length ?? 0) <= 1) {
+      return { success: false, error: `Cannot delete the last model on a provider`, cleared: [] };
+    }
+
+    const cleared: string[] = [];
+
+    if (settings.default_model === modelId) {
+      settings.default_model = undefined;
+      cleared.push("settings.default_model");
+    }
+    if (settings.oneshot_model === modelId) {
+      settings.oneshot_model = undefined;
+      cleared.push("settings.oneshot_model");
+    }
+    if (settings.rewrite_model === modelId) {
+      settings.rewrite_model = undefined;
+      cleared.push("settings.rewrite_model");
+    }
+    if (settings.opencode?.extraction_model === modelId) {
+      settings.opencode.extraction_model = undefined;
+      cleared.push("settings.opencode.extraction_model");
+    }
+    if (settings.claudeCode?.extraction_model === modelId) {
+      settings.claudeCode.extraction_model = undefined;
+      cleared.push("settings.claudeCode.extraction_model");
+    }
+    if (provider.default_model === modelId) {
+      provider.default_model = undefined;
+      cleared.push("provider.default_model");
+    }
+
+    provider.models = provider.models!.filter(m => m.id !== modelId);
+    this.humanState.set(human);
+
+    for (const persona of this.personaState.getAll()) {
+      if (persona.model === modelId) {
+        this.personaState.update(persona.id, { model: undefined });
+        cleared.push(`persona:${persona.display_name}`);
+      }
+    }
+
+    this.scheduleSave();
+    return { success: true, cleared };
+  }
+
   async flush(): Promise<void> {
     await this.persistenceState.flush();
   }
@@ -788,6 +1016,7 @@ export class StateManager {
     this.providers = state.providers ?? [];
     this.tools = state.tools ?? [];
     this.persistenceState.markExistingData();
+    this.runMigrations();
     this.scheduleSave();
   }
 

package/src/core/tools/index.ts

@@ -81,7 +81,7 @@ export function toOpenAITools(tools: ToolDefinition[]): Record<string, unknown>[
       name: t.name,
       description: t.description,
       parameters: t.input_schema,
-      ...(t.is_submit ? { strict: true } : {}),
+
     },
   }));
 }