@tenex-chat/backend 0.9.4 → 0.9.6

package/src/llm/middleware/message-sanitizer.ts

@@ -0,0 +1,153 @@
+import type { LanguageModelMiddleware } from "ai";
+import type {
+    LanguageModelV3CallOptions,
+    LanguageModelV3Message,
+} from "@ai-sdk/provider";
+import { appendFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { getTenexBasePath } from "@/constants";
+import { trace } from "@opentelemetry/api";
+
+interface SanitizationWarning {
+    fix: string;
+    removed: Array<{ index: number; role: string }>;
+}
+
+/**
+ * Check if a user or assistant message has empty content (content: []).
+ * System messages use string content (always valid).
+ * Tool messages may legitimately have minimal content for adjacency.
+ */
+function hasEmptyContent(msg: LanguageModelV3Message): boolean {
+    if (msg.role === "system" || msg.role === "tool") return false;
+    return Array.isArray(msg.content) && msg.content.length === 0;
+}
+
+/**
+ * Run all sanitization passes on the original prompt, collecting warnings
+ * with indices in the original coordinate space.
+ *
+ * Pass 1: Mark empty-content user/assistant messages for removal.
+ * Pass 2: Mark trailing assistant messages for removal (from the end,
+ *          skipping already-marked indices).
+ *
+ * Returns the filtered array and any warnings.
+ */
+function sanitize(
+    prompt: LanguageModelV3Message[]
+): { result: LanguageModelV3Message[]; warnings: SanitizationWarning[] } {
+    const warnings: SanitizationWarning[] = [];
+    const removeSet = new Set<number>();
+
+    // Pass 1: empty content
+    const emptyRemoved: Array<{ index: number; role: string }> = [];
+    for (let i = 0; i < prompt.length; i++) {
+        if (hasEmptyContent(prompt[i])) {
+            emptyRemoved.push({ index: i, role: prompt[i].role });
+            removeSet.add(i);
+        }
+    }
+    if (emptyRemoved.length > 0) {
+        warnings.push({ fix: "empty-content-stripped", removed: emptyRemoved });
+    }
+
+    // Pass 2: trailing assistants (walk backwards, skipping already-removed)
+    const trailingRemoved: Array<{ index: number; role: string }> = [];
+    for (let i = prompt.length - 1; i >= 0; i--) {
+        if (removeSet.has(i)) continue;
+        if (prompt[i].role !== "assistant") break;
+        trailingRemoved.push({ index: i, role: "assistant" });
+        removeSet.add(i);
+    }
+    if (trailingRemoved.length > 0) {
+        warnings.push({ fix: "trailing-assistant-stripped", removed: trailingRemoved });
+    }
+
+    // Build filtered result
+    const result = prompt.filter((_, i) => !removeSet.has(i));
+    return { result, warnings };
+}
+
+/**
+ * Append a structured warning to $TENEX_BASE_DIR/daemon/warn.log.
+ * Uses appendFileSync — this path is rare (only on detected problems)
+ * so the sync I/O cost is acceptable vs. the complexity of async.
+ */
+function logWarning(entry: Record<string, unknown>): void {
+    try {
+        const dir = join(getTenexBasePath(), "daemon");
+        mkdirSync(dir, { recursive: true });
+        const logPath = join(dir, "warn.log");
+        appendFileSync(logPath, JSON.stringify(entry) + "\n", "utf-8");
+    } catch {
+        // Best-effort logging — never let warn logging crash the LLM call
+    }
+}
+
+/**
+ * Creates a message sanitizer middleware that runs before every LLM API call.
+ *
+ * This middleware fixes message array problems that would cause API rejection:
+ * - Trailing assistant messages (Anthropic rejects these)
+ * - Empty-content user/assistant messages
+ *
+ * It intercepts `params.prompt` via `transformParams`, covering all call paths:
+ * initial streamText, prepareStep-rebuilt messages, generateText, and generateObject.
+ *
+ * When fixes are applied, it logs a structured warning to $TENEX_BASE_DIR/daemon/warn.log
+ * and adds an OTel span event for telemetry correlation.
+ */
+export function createMessageSanitizerMiddleware(): LanguageModelMiddleware {
+    return {
+        specificationVersion: "v3" as const,
+
+        transformParams: async ({ params, type, model }) => {
+            const originalPrompt = params.prompt as LanguageModelV3Message[];
+            const originalCount = originalPrompt.length;
+
+            const { result: sanitized, warnings } = sanitize(originalPrompt);
+
+            // No fixes needed — return params unchanged
+            if (warnings.length === 0) {
+                return params;
+            }
+
+            // Build log entry
+            const modelId = `${model.provider}:${model.modelId}`;
+            const allRemoved = warnings.flatMap((w) => w.removed);
+
+            for (const warning of warnings) {
+                const entry = {
+                    ts: new Date().toISOString(),
+                    type: "message-sanitizer",
+                    fix: warning.fix,
+                    model: modelId,
+                    callType: type,
+                    original_count: originalCount,
+                    fixed_count: sanitized.length,
+                    removed: warning.removed,
+                };
+                logWarning(entry);
+            }
+
+            // OTel span event — skip gracefully if no active span
+            const span = trace.getActiveSpan();
+            if (span) {
+                span.addEvent("message-sanitizer.fix-applied", {
+                    "sanitizer.fixes": warnings.map((w) => w.fix).join(","),
+                    "sanitizer.original_count": originalCount,
+                    "sanitizer.fixed_count": sanitized.length,
+                    "sanitizer.removed_indices": allRemoved.map((r) => r.index).join(","),
+                    "sanitizer.removed_roles": allRemoved.map((r) => r.role).join(","),
+                    "sanitizer.model": modelId,
+                    "sanitizer.call_type": type,
+                });
+            }
+
+            return {
+                ...params,
+                prompt: sanitized as LanguageModelV3CallOptions["prompt"],
+            };
+        },
+    };
+}

package/src/llm/providers/ollama-models.ts

@@ -65,41 +65,3 @@ function formatSize(bytes: number): string {
     const mb = bytes / (1024 * 1024);
     return `${mb.toFixed(0)}MB`;
 }
-
-/**
- * Get popular Ollama models for quick selection
- */
-export function getPopularOllamaModels(): Record<string, string[]> {
-    return {
-        "Small Models (< 4GB)": [
-            "llama3.2:1b",
-            "llama3.2:3b",
-            "phi3:mini",
-            "gemma2:2b",
-            "qwen2.5:1.5b",
-            "qwen2.5:3b",
-        ],
-        "Medium Models (4-8GB)": [
-            "llama3.1:8b",
-            "mistral:7b",
-            "gemma2:9b",
-            "qwen2.5:7b",
-            "deepseek-coder-v2:16b",
-        ],
-        "Large Models (> 8GB)": [
-            "llama3.1:70b",
-            "mixtral:8x7b",
-            "qwen2.5:14b",
-            "qwen2.5:32b",
-            "qwen2.5:72b",
-            "deepseek-coder-v2:236b",
-        ],
-        "Specialized Models": [
-            "codellama:7b",
-            "codellama:13b",
-            "starcoder2:3b",
-            "starcoder2:7b",
-            "sqlcoder:7b",
-        ],
-    };
-}

package/src/llm/service.ts

@@ -22,7 +22,7 @@ import type { z } from "zod";
 import { ChunkHandler, type ChunkHandlerState } from "./ChunkHandler";
 import { createFinishHandler, type FinishHandlerConfig, type FinishHandlerState } from "./FinishHandler";
 import { extractLastUserMessage, extractSystemContent, prepareMessagesForRequest } from "./MessageProcessor";
-import { createFlightRecorderMiddleware } from "./middleware/flight-recorder";
+import { createMessageSanitizerMiddleware } from "./middleware/message-sanitizer";
 import { PROVIDER_IDS } from "./providers/provider-ids";
 import { getFullTelemetryConfig, getOpenRouterMetadata, getTraceCorrelationId } from "./TracingUtils";
 import type { ProviderCapabilities } from "./providers/types";
@@ -196,11 +196,20 @@ export class LLMService extends EventEmitter<LLMServiceEventMap> {
             throw new Error("No provider available for model creation");
         }
 
-        // Build middleware chain
+        return this.wrapWithMiddleware(baseModel);
+    }
+
+    /**
+     * Wrap a base model with the standard middleware chain.
+     * Used by both getLanguageModel() and createLanguageModelFromRegistry()
+     * so all call paths get sanitization and reasoning extraction.
+     */
+    private wrapWithMiddleware(baseModel: LanguageModel): LanguageModel {
         const middlewares: LanguageModelMiddleware[] = [];
 
-        // Flight recorder - records LLM interactions when enabled via 'r' key
-        middlewares.push(createFlightRecorderMiddleware());
+        // Message sanitizer — fix message array issues before every API call
+        // Must be first so it sanitizes before anything else processes messages
+        middlewares.push(createMessageSanitizerMiddleware());
 
         // Extract reasoning from thinking tags
         middlewares.push(
@@ -211,15 +220,10 @@ export class LLMService extends EventEmitter<LLMServiceEventMap> {
             })
         );
 
-        // Wrap with middlewares
-        // Note: Type assertion needed because AI SDK v6 beta uses LanguageModelV3 internally
-        // but stable providers export LanguageModel (union type). This is a beta compatibility issue.
-        const wrappedModel = wrapLanguageModel({
+        return wrapLanguageModel({
             model: baseModel as Parameters<typeof wrapLanguageModel>[0]["model"],
             middleware: middlewares,
         });
-
-        return wrappedModel;
     }
 
     async stream(
@@ -434,7 +438,7 @@ export class LLMService extends EventEmitter<LLMServiceEventMap> {
                 // tool-call, tool-input-start, tool-input-delta, tool-result, raw.
                 // Events like "finish" and "tool-error" must be forwarded explicitly.
                 if (part.type === "finish") {
-                    // Emit raw-chunk directly to reach StreamPublisher (for HTTP wrapper SSE)
+                    // Emit raw-chunk directly for low-level listeners.
                     // WITHOUT going through ChunkHandler which would trigger chunk-type-change
                     // and cause AgentExecutor to publish a duplicate kind:1 event.
                     this.emit("raw-chunk", { chunk: part as TextStreamPart<Record<string, AISdkTool>> });
@@ -516,6 +520,22 @@ export class LLMService extends EventEmitter<LLMServiceEventMap> {
                 "stream.finish_part_seen": finishPartSeen,
                 "stream.abort_signal_aborted": options?.abortSignal?.aborted ?? false,
             });
+            logger.writeToWarnLog({
+                timestamp: new Date().toISOString(),
+                level: "error",
+                component: "LLMService",
+                message: "LLM stream loop error",
+                context: {
+                    provider: this.provider,
+                    model: this.model,
+                    chunkCount,
+                    lastChunkType: lastChunkType ?? "none",
+                    finishPartSeen,
+                    abortSignalAborted: options?.abortSignal?.aborted ?? false,
+                },
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
             await this.handleStreamError(error, startTime);
             throw error;
         }
@@ -549,15 +569,17 @@ export class LLMService extends EventEmitter<LLMServiceEventMap> {
     }
 
     /**
-     * Create a language model instance for dynamic model switching.
-     * Used by AgentExecutor when the change_model tool switches variants mid-run.
+     * Create a wrapped language model for dynamic model switching.
+     * Wraps the registry model with the same middleware chain
+     * (sanitizer, reasoning extraction) used by all other call paths.
      */
-    static createLanguageModelFromRegistry(
+    createLanguageModelFromRegistry(
         provider: string,
         model: string,
         registry: ProviderRegistryProvider
     ): LanguageModel {
-        return registry.languageModel(`${provider}:${model}`);
+        const baseModel = registry.languageModel(`${provider}:${model}`);
+        return this.wrapWithMiddleware(baseModel);
     }
 
     /**
@@ -707,6 +729,19 @@ export class LLMService extends EventEmitter<LLMServiceEventMap> {
                 duration,
                 error: error instanceof Error ? error.message : String(error),
             });
+            logger.writeToWarnLog({
+                timestamp: new Date().toISOString(),
+                level: "error",
+                component: "LLMService",
+                message: `${operationName} failed`,
+                context: {
+                    provider: this.provider,
+                    model: this.model,
+                    duration,
+                },
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
             throw error;
         }
     }

package/src/llm/types.ts

@@ -47,18 +47,6 @@ export type LanguageModelUsageWithCostUsd = LanguageModelUsage & {
     contextWindow?: number;
 };
 
-/**
- * Chunk sent over local streaming socket
- */
-export interface LocalStreamChunk {
-    /** Hex pubkey of the agent generating this response */
-    agent_pubkey: string;
-    /** Root event ID of the conversation (hex) */
-    conversation_id: string;
-    /** Raw AI SDK chunk - passthrough without transformation */
-    data: unknown;
-}
-
 /**
  * Callback invoked when message injection completes
  * @param delivered - true if the message was successfully delivered to the stream