ei-tui 0.5.1 → 0.5.3

package/package.json

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

@@ -24,6 +24,7 @@ import {
   type ToolProvider,
 } from "./types.js";
 import { buildPersonaFromPersonPrompt } from "../prompts/index.js";
+import { buildSiblingAwarenessSection } from "../prompts/room/index.js";
 import type { PersonaGenerationResult } from "../prompts/generation/types.js";
 
 import type { Storage } from "../storage/interface.js";
@@ -107,6 +108,7 @@ import {
   getQueueActiveItems,
   getDLQItems,
   updateQueueItem,
+  deleteQueueItems,
   clearQueue,
   submitOneShot,
 } from "./queue-manager.js";
@@ -1023,8 +1025,9 @@ export class Processor {
         const isBackingOff = retryAfter !== null && retryAfter > new Date().toISOString();
 
         if (!isBackingOff) {
-          const request = this.stateManager.queue_claimHighest();
+          let request = this.stateManager.queue_claimHighest();
           if (request) {
+            request = this.augmentRoomRequest(request);
             const personaId = request.data.personaId as string | undefined;
             const personaDisplayName = request.data.personaDisplayName as string | undefined;
             const personaSuffix = personaDisplayName ? ` [${personaDisplayName}]` : "";
@@ -1411,6 +1414,28 @@ const toolNextSteps = new Set([
       });
   }
 
+  private augmentRoomRequest(request: LLMRequest): LLMRequest {
+    if (request.next_step !== LLMNextStep.HandleRoomResponse) return request;
+
+    const roomId = request.data.roomId as string | undefined;
+    const parentMessageId = request.data.parentMessageId as string | undefined;
+    const personaDisplayName = request.data.personaDisplayName as string | undefined;
+
+    if (!roomId || !parentMessageId || !personaDisplayName) return request;
+
+    const siblings = this.stateManager.getRoomChildren(roomId, parentMessageId)
+      .filter((m: RoomMessage) => m.role === "persona" && m.verbal_response)
+      .map((m: RoomMessage) => ({
+        name: this.stateManager.persona_getById(m.persona_id ?? "")?.display_name ?? "Participant",
+        verbal_response: m.verbal_response!,
+      }));
+
+    if (siblings.length === 0) return request;
+
+    const siblingSection = buildSiblingAwarenessSection(siblings, personaDisplayName);
+    return { ...request, system: request.system + "\n\n" + siblingSection };
+  }
+
   private classifyLLMError(error: string): string {
     const match = error.match(/\((\d{3})\)/);
     if (match) {
@@ -1931,6 +1956,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/prompt-context-builder.ts

@@ -3,7 +3,8 @@ import { StateManager } from "./state-manager.js";
 import { getEmbeddingService, findTopK } from "./embedding-service.js";
 import type { ResponsePromptData, PromptOutput } from "../prompts/index.js";
 import { buildRoomResponsePrompt } from "../prompts/room/index.js";
-import type { RoomParticipantIdentity, RoomHistoryMessage } from "../prompts/room/types.js";
+import type { RoomParticipantIdentity } from "../prompts/room/types.js";
+import { normalizeRoomMessages } from "./handlers/utils.js";
 
 const QUOTE_LIMIT = 10;
 const DATA_ITEM_LIMIT = 15;
@@ -205,6 +206,7 @@ export async function buildResponsePromptData(
       traits: persona.traits,
       topics: persona.topics,
       interested_topics: persona.topics.filter(t => t.exposure_desired - t.exposure_current > 0.2),
+      include_message_timestamps: persona.include_message_timestamps,
     },
     human: filteredHuman,
     visible_personas: visiblePersonas,
@@ -231,15 +233,7 @@ export async function buildRoomResponsePromptData(
 
   const filteredHuman = await filterHumanDataByVisibility(human, respondingPersona, currentMessage);
 
-  const history: RoomHistoryMessage[] = sourceMessages.map(m => ({
-    speaker_name: m.role === "human"
-      ? (human.settings?.name_display ?? "Human")
-      : (sm.persona_getById(m.persona_id ?? "")?.display_name ?? m.persona_id ?? "Unknown"),
-    speaker_id: m.role === "human" ? "human" : (m.persona_id ?? ""),
-    verbal_response: m.verbal_response,
-    action_response: m.action_response,
-    silence_reason: m.silence_reason,
-  }));
+  const history = normalizeRoomMessages(sourceMessages, sm);
 
   const otherParticipants: RoomParticipantIdentity[] = [];
   for (const pid of room.persona_ids) {
@@ -273,6 +267,7 @@ export async function buildRoomResponsePromptData(
       long_description: respondingPersona.long_description,
       traits: respondingPersona.traits,
       topics: respondingPersona.topics,
+      include_message_timestamps: respondingPersona.include_message_timestamps,
     },
     other_participants: otherParticipants,
     human: filteredHuman,

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/room-manager.ts

@@ -32,7 +32,11 @@ async function queueRoomPersonaResponses(
   isTUI: boolean,
   onRoomMessageQueued: (roomId: string) => void
 ): Promise<void> {
-  for (const personaId of room.persona_ids) {
+  const personaIds = room.mode === RoomMode.FreeForAll
+    ? [...room.persona_ids].sort(() => Math.random() - 0.5)
+    : room.persona_ids;
+
+  for (const personaId of personaIds) {
     const persona = sm.persona_getById(personaId);
     if (!persona || persona.is_archived || persona.is_paused) continue;
     if (room.mode === RoomMode.MessagesAgainstPersona && room.judge_persona_id === personaId) continue;
@@ -186,7 +190,9 @@ export async function sendFfaMessage(
       .map(q => q.data.personaId as string)
   );
 
-  for (const personaId of updatedRoom.persona_ids) {
+  const shuffledIds = [...updatedRoom.persona_ids].sort(() => Math.random() - 0.5);
+
+  for (const personaId of shuffledIds) {
     if (alreadyQueued.has(personaId)) continue;
     const persona = sm.persona_getById(personaId);
     if (!persona || persona.is_archived || persona.is_paused) continue;

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();