openfeelz 0.9.3 → 0.9.5

package/README.md

@@ -37,7 +37,9 @@ openclaw plugins install openfeelz
 openclaw plugins enable openfeelz
 ```
 
-Restart the gateway after installing. To pin a version: `openclaw plugins install openfeelz@0.9.3`. To install from a local clone (e.g. for development), run `npm run build` in the repo first, then `openclaw plugins install /path/to/openfeelz`.
+Restart the gateway after installing. To pin a version: `openclaw plugins install openfeelz@0.9.4`. To install from a local clone (e.g. for development), run `npm run build` in the repo first, then `openclaw plugins install /path/to/openfeelz`.
+
+When using **reasoning models** (e.g. gpt-5-mini, o1, o3), the classifier omits custom temperature so the API accepts the request. Optional classification logging can be enabled via config (see `docs/OPENFEELZ-FIX-COMPLETE.md`).
 
 ## How It Works
 

package/dist/index.js

@@ -16,7 +16,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { DEFAULT_CONFIG } from "./src/types.js";
 import { StateManager } from "./src/state/state-manager.js";
-import { resolveAgentDir, resolveAgentStatePath, listAgentIds } from "./src/paths.js";
+import { resolveAgentDir, resolveAgentStatePath, resolveAgentWorkspaceDir, listAgentIds } from "./src/paths.js";
 import { createEmotionTool } from "./src/tool/emotion-tool.js";
 import { createBootstrapHook, createAgentEndHook } from "./src/hook/hooks.js";
 import { registerEmotionCli } from "./src/cli/cli.js";
@@ -71,25 +71,48 @@ function resolveConfig(raw) {
     };
 }
 /**
- * Attempt to resolve an Anthropic API key from OpenClaw's auth-profiles.json.
- * Falls back gracefully if the file doesn't exist or has no Anthropic profile.
+ * Attempt to resolve an API key from OpenClaw's auth-profiles.json.
+ * Supports both Anthropic and OpenAI providers.
+ * Falls back gracefully if the file doesn't exist or has no matching profile.
  */
 function resolveApiKeyFromAuthProfiles(api, agentId = "main") {
     try {
         const agentDir = resolveAgentDir(api.config, agentId);
         const authFile = path.join(agentDir, "auth-profiles.json");
-        if (!fs.existsSync(authFile))
+        console.log(`[openfeelz] Checking auth profiles at: ${authFile}`);
+        if (!fs.existsSync(authFile)) {
+            console.log("[openfeelz] Auth profiles file does not exist");
             return undefined;
+        }
         const raw = JSON.parse(fs.readFileSync(authFile, "utf8"));
         const profiles = raw?.profiles ?? {};
-        for (const profile of Object.values(profiles)) {
-            if (profile?.provider === "anthropic" && profile?.token) {
-                return profile.token;
+        const profileKeys = Object.keys(profiles);
+        console.log(`[openfeelz] Found ${profileKeys.length} auth profiles: ${profileKeys.join(", ")}`);
+        // Try to find Anthropic key first (preferred for claude models)
+        for (const [profileId, profile] of Object.entries(profiles)) {
+            if (profile?.provider === "anthropic") {
+                // Support both 'token' and 'key' fields
+                const key = profile?.token || profile?.key;
+                if (key) {
+                    console.log(`[openfeelz] Using Anthropic key from profile: ${profileId}`);
+                    return key;
+                }
             }
         }
+        // Fallback to OpenAI key
+        for (const [profileId, profile] of Object.entries(profiles)) {
+            if (profile?.provider === "openai") {
+                const key = profile?.token || profile?.key || profile?.apiKey;
+                if (key) {
+                    console.log(`[openfeelz] Using OpenAI key from profile: ${profileId}`);
+                    return key;
+                }
+            }
+        }
+        console.log("[openfeelz] No Anthropic or OpenAI keys found in auth profiles");
     }
-    catch {
-        // Not critical
+    catch (err) {
+        console.error("[openfeelz] Error reading auth profiles:", err);
     }
     return undefined;
 }
@@ -100,13 +123,22 @@ const emotionEnginePlugin = {
         "rumination, and multi-agent awareness",
     register(api) {
         const config = resolveConfig(api.pluginConfig);
+        console.log("[openfeelz] Initial config - apiKey present:", !!config.apiKey, "model:", config.model);
         // Resolve API key from OpenClaw auth profiles if not explicitly configured
         if (!config.apiKey) {
+            console.log("[openfeelz] No API key in config, attempting to resolve from auth profiles...");
             const resolvedKey = resolveApiKeyFromAuthProfiles(api);
             if (resolvedKey) {
                 config.apiKey = resolvedKey;
+                console.log("[openfeelz] Successfully resolved API key from auth profiles");
+            }
+            else {
+                console.warn("[openfeelz] Failed to resolve API key from auth profiles");
             }
         }
+        else {
+            console.log("[openfeelz] Using API key from config");
+        }
         const cfg = api.config;
         // Per-agent StateManager cache (state path = workspace/openfeelz.json)
         const managerCache = new Map();
@@ -135,9 +167,12 @@ const emotionEnginePlugin = {
             });
             return result;
         });
-        const agentEndHandler = createAgentEndHook(getManager, config);
+        // Set up classification log path
+        const classificationLogPath = path.join(resolveAgentWorkspaceDir(cfg, "main"), "openfeelz-classifications.jsonl");
+        const agentEndHandler = createAgentEndHook(getManager, config, classificationLogPath);
         api.on("agent_end", async (event) => {
             const agentId = event.agentId ?? "main";
+            console.log("[openfeelz] agent_end hook fired for agent:", agentId);
             await agentEndHandler({
                 success: event.success ?? true,
                 messages: event.messages ?? [],

package/dist/src/classify/classifier.d.ts

@@ -32,6 +32,8 @@ export interface ClassifyOptions {
     timeoutMs?: number;
     /** Injectable fetch function (for testing). */
     fetchFn?: typeof fetch;
+    /** Path to classification log file (JSONL). */
+    classificationLogPath?: string;
 }
 /**
  * Build the classification prompt (shared across providers).

package/dist/src/classify/classifier.js

@@ -11,6 +11,8 @@
  *
  * Falls back to neutral on any failure (no hard crashes in classification).
  */
+import fs from "node:fs";
+import path from "node:path";
 const NEUTRAL_RESULT = {
     label: "neutral",
     intensity: 0,
@@ -19,6 +21,37 @@ const NEUTRAL_RESULT = {
 };
 const ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages";
 const ANTHROPIC_VERSION = "2023-06-01";
+// Reasoning models that don't support custom temperature
+const REASONING_MODELS = ["gpt-5", "gpt-4o-mini", "o1", "o3"];
+/**
+ * Check if a model is a reasoning model that doesn't support custom temperature.
+ */
+function isReasoningModel(model) {
+    const lower = model.toLowerCase();
+    return REASONING_MODELS.some(prefix => lower.includes(prefix));
+}
+/**
+ * Log a classification attempt to JSONL file.
+ */
+function logClassification(logPath, data) {
+    if (!logPath)
+        return;
+    try {
+        const logDir = path.dirname(logPath);
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+        const entry = {
+            ...data,
+            textExcerpt: data.text.slice(0, 200) + (data.text.length > 200 ? "..." : ""),
+        };
+        delete entry.text; // Don't log full text for privacy
+        fs.appendFileSync(logPath, JSON.stringify(entry) + "\n", "utf8");
+    }
+    catch (err) {
+        console.error("[openfeelz] Failed to write classification log:", err);
+    }
+}
 // ---------------------------------------------------------------------------
 // Provider Detection
 // ---------------------------------------------------------------------------
@@ -113,27 +146,77 @@ export function coerceClassificationResult(result, labels, confidenceMin) {
 export async function classifyEmotion(text, role, options) {
     const fetchFn = options.fetchFn ?? fetch;
     const timeoutMs = options.timeoutMs ?? 10000;
+    const startTime = Date.now();
+    const timestamp = new Date().toISOString();
     try {
         if (options.classifierUrl) {
-            return await classifyViaEndpoint(text, role, options.classifierUrl, fetchFn, timeoutMs, options.emotionLabels, options.confidenceMin);
+            const result = await classifyViaEndpoint(text, role, options.classifierUrl, fetchFn, timeoutMs, options.emotionLabels, options.confidenceMin);
+            logClassification(options.classificationLogPath, {
+                timestamp,
+                role,
+                text,
+                model: "external",
+                provider: "endpoint",
+                result,
+                success: true,
+                responseTimeMs: Date.now() - startTime,
+            });
+            return result;
         }
         if (!options.apiKey) {
-            throw new Error("Emotion classifier requires either classifierUrl or apiKey. " +
-                "Configure apiKey or set ANTHROPIC_API_KEY / OPENAI_API_KEY in the openfeelz plugin config.");
+            const error = "Emotion classifier requires either classifierUrl or apiKey. " +
+                "Configure apiKey or set ANTHROPIC_API_KEY / OPENAI_API_KEY in environment or auth-profiles.json.";
+            console.error(`[openfeelz] ${error}`);
+            logClassification(options.classificationLogPath, {
+                timestamp,
+                role,
+                text,
+                model: options.model ?? "unknown",
+                provider: "unknown",
+                success: false,
+                error,
+            });
+            throw new Error(error);
         }
         const model = options.model ?? "claude-sonnet-4-5-20250514";
         const provider = options.provider ?? detectProvider(model);
+        console.log(`[openfeelz] Classifying ${role} emotion with ${provider}/${model}`);
+        let result;
         if (provider === "anthropic") {
-            return await classifyViaAnthropic(text, role, options.apiKey, model, fetchFn, timeoutMs, options.emotionLabels, options.confidenceMin);
+            result = await classifyViaAnthropic(text, role, options.apiKey, model, fetchFn, timeoutMs, options.emotionLabels, options.confidenceMin);
+        }
+        else {
+            result = await classifyViaOpenAI(text, role, options.apiKey, options.baseUrl ?? "https://api.openai.com/v1", model, fetchFn, timeoutMs, options.emotionLabels, options.confidenceMin);
         }
-        return await classifyViaOpenAI(text, role, options.apiKey, options.baseUrl ?? "https://api.openai.com/v1", model, fetchFn, timeoutMs, options.emotionLabels, options.confidenceMin);
+        logClassification(options.classificationLogPath, {
+            timestamp,
+            role,
+            text,
+            model,
+            provider,
+            result,
+            success: true,
+            responseTimeMs: Date.now() - startTime,
+        });
+        return result;
     }
     catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
         // If it's a configuration error (no apiKey), rethrow
         if (err instanceof Error && err.message.includes("requires either")) {
             throw err;
         }
         console.error("[openfeelz] Classification failed:", err);
+        logClassification(options.classificationLogPath, {
+            timestamp,
+            role,
+            text,
+            model: options.model ?? "unknown",
+            provider: options.provider ?? "unknown",
+            success: false,
+            error: errorMessage,
+            responseTimeMs: Date.now() - startTime,
+        });
         return { ...NEUTRAL_RESULT };
     }
 }
@@ -179,8 +262,8 @@ async function classifyViaAnthropic(text, role, apiKey, model, fetchFn, timeoutM
     });
     if (!response.ok) {
         const body = await response.text().catch(() => "");
-        console.error("[openfeelz] Anthropic classification API error:", response.status, body.slice(0, 500));
-        throw new Error(`Anthropic returned ${response.status}: ${body}`);
+        console.error("[openfeelz] Anthropic classification API error:", response.status, body.slice(0, 800));
+        throw new Error(`Anthropic returned ${response.status}: ${body.slice(0, 200)}`);
     }
     const data = (await response.json());
     const textBlock = data.content?.find((b) => b.type === "text");
@@ -196,28 +279,34 @@ async function classifyViaAnthropic(text, role, apiKey, model, fetchFn, timeoutM
 // ---------------------------------------------------------------------------
 async function classifyViaOpenAI(text, role, apiKey, baseUrl, model, fetchFn, timeoutMs, labels, confidenceMin) {
     const prompt = buildClassifierPrompt(text, role, labels);
+    // Reasoning models (gpt-5-mini, gpt-4o-mini, o1, o3) don't support custom temperature
+    const isReasoning = isReasoningModel(model);
+    const requestBody = {
+        model,
+        messages: [
+            { role: "system", content: buildSystemInstruction() },
+            { role: "user", content: prompt },
+        ],
+        response_format: { type: "json_object" },
+        max_completion_tokens: 1000, // reasoning models need headroom
+    };
+    // Only set temperature for non-reasoning models
+    if (!isReasoning) {
+        requestBody.temperature = 0.2;
+    }
     const response = await fetchFn(`${baseUrl.replace(/\/$/, "")}/chat/completions`, {
         method: "POST",
         headers: {
             "content-type": "application/json",
             authorization: `Bearer ${apiKey}`,
         },
-        body: JSON.stringify({
-            model,
-            messages: [
-                { role: "system", content: buildSystemInstruction() },
-                { role: "user", content: prompt },
-            ],
-            temperature: 0.2,
-            response_format: { type: "json_object" },
-            max_completion_tokens: 1000, // reasoning models (e.g. gpt-5-mini) need headroom
-        }),
+        body: JSON.stringify(requestBody),
         signal: AbortSignal.timeout(timeoutMs),
     });
     if (!response.ok) {
         const body = await response.text().catch(() => "");
-        console.error("[openfeelz] OpenAI classification API error:", response.status, body.slice(0, 500));
-        throw new Error(`OpenAI returned ${response.status}`);
+        console.error("[openfeelz] OpenAI classification API error:", response.status, body.slice(0, 800));
+        throw new Error(`OpenAI returned ${response.status}: ${body.slice(0, 200)}`);
     }
     const data = (await response.json());
     const content = data.choices?.[0]?.message?.content;

package/dist/src/hook/hooks.d.ts

@@ -45,5 +45,5 @@ export declare function createBootstrapHook(getManager: (agentId: string) => Sta
  * 4. Record in user/agent buckets
  * 5. Persist
  */
-export declare function createAgentEndHook(getManager: (agentId: string) => StateManager, config: EmotionEngineConfig, fetchFn?: typeof fetch): (event: AgentEndEvent) => Promise<void>;
+export declare function createAgentEndHook(getManager: (agentId: string) => StateManager, config: EmotionEngineConfig, classificationLogPath?: string, fetchFn?: typeof fetch): (event: AgentEndEvent) => Promise<void>;
 export {};

package/dist/src/hook/hooks.js

@@ -71,13 +71,15 @@ export function createBootstrapHook(getManager, config, openclawConfig) {
  * 4. Record in user/agent buckets
  * 5. Persist
  */
-export function createAgentEndHook(getManager, config, fetchFn) {
+export function createAgentEndHook(getManager, config, classificationLogPath, fetchFn) {
     return async (event) => {
         if (!event.success || !event.messages || event.messages.length === 0) {
+            console.log("[openfeelz] Skipping agent_end: no success or messages");
             return;
         }
         // Need either apiKey or classifierUrl to classify
         if (!config.apiKey && !config.classifierUrl) {
+            console.warn("[openfeelz] Skipping classification: no apiKey or classifierUrl configured");
             return;
         }
         const agentId = event.agentId ?? "main";
@@ -89,6 +91,7 @@ export function createAgentEndHook(getManager, config, fetchFn) {
             const userMsg = findLast(event.messages, "user");
             // Find latest assistant message
             const assistantMsg = findLast(event.messages, "assistant");
+            console.log(`[openfeelz] Processing messages - user: ${!!userMsg}, assistant: ${!!assistantMsg}`);
             const classifyOpts = {
                 apiKey: config.apiKey,
                 baseUrl: config.baseUrl,
@@ -97,12 +100,15 @@ export function createAgentEndHook(getManager, config, fetchFn) {
                 classifierUrl: config.classifierUrl,
                 emotionLabels: config.emotionLabels,
                 confidenceMin: config.confidenceMin,
+                classificationLogPath,
                 fetchFn,
             };
             if (userMsg) {
                 const text = extractMessageText(userMsg.content);
                 if (text) {
+                    console.log(`[openfeelz] Classifying user message (${text.length} chars)`);
                     const result = await classifyEmotion(text, "user", classifyOpts);
+                    console.log(`[openfeelz] User emotion: ${result.label} (intensity: ${result.intensity}, confidence: ${result.confidence})`);
                     if (result.label !== "neutral" || result.confidence > 0) {
                         state = manager.updateUserEmotion(state, userKey, result);
                         // Also apply as stimulus to the dimensional model
@@ -113,7 +119,9 @@ export function createAgentEndHook(getManager, config, fetchFn) {
             if (assistantMsg) {
                 const text = extractMessageText(assistantMsg.content);
                 if (text) {
+                    console.log(`[openfeelz] Classifying assistant message (${text.length} chars)`);
                     const result = await classifyEmotion(text, "assistant", classifyOpts);
+                    console.log(`[openfeelz] Assistant emotion: ${result.label} (intensity: ${result.intensity}, confidence: ${result.confidence})`);
                     if (result.label !== "neutral" || result.confidence > 0) {
                         state = manager.updateAgentEmotion(state, agentId, result);
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openfeelz",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "PAD + Ekman + OCEAN emotional model plugin for OpenClaw agents",
   "type": "module",
   "main": "dist/index.js",
@@ -29,6 +29,7 @@
     "openclaw": ">=2026.1.0"
   },
   "dependencies": {
+    "@clack/prompts": "^1.0.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "commander": "^14.0.3"
   },