psyche-ai 2.0.0

package/dist/adapters/openclaw.js

@@ -0,0 +1,143 @@
+// ============================================================
+// OpenClaw Adapter — Wires PsycheEngine to OpenClaw's hook system
+//
+// Usage:
+//   import openclawPlugin from "psyche-ai/openclaw";
+//   // Then register via OpenClaw's plugin system
+// ============================================================
+import { PsycheEngine } from "../core.js";
+import { FileStorageAdapter } from "../storage.js";
+import { loadState } from "../psyche-file.js";
+function resolveConfig(raw) {
+    return {
+        enabled: raw?.enabled ?? true,
+        stripUpdateTags: raw?.stripUpdateTags ?? true,
+        emotionalContagionRate: raw?.emotionalContagionRate ?? 0.2,
+        maxChemicalDelta: raw?.maxChemicalDelta ?? 25,
+        compactMode: raw?.compactMode ?? true,
+    };
+}
+// ── Plugin Definition ────────────────────────────────────────
+export function register(api) {
+    const config = resolveConfig(api.pluginConfig);
+    const logger = api.logger;
+    if (!config.enabled) {
+        logger.info("Psyche plugin disabled by config");
+        return;
+    }
+    logger.info("Psyche plugin activating — emotional intelligence online");
+    // Engine cache: one PsycheEngine per workspace
+    const engines = new Map();
+    async function getEngine(workspaceDir) {
+        let engine = engines.get(workspaceDir);
+        if (engine)
+            return engine;
+        // Use existing loadState for workspace-specific detection
+        // (reads IDENTITY.md, SOUL.md for MBTI/name, generates PSYCHE.md)
+        const state = await loadState(workspaceDir, logger);
+        const storage = new FileStorageAdapter(workspaceDir);
+        engine = new PsycheEngine({
+            mbti: state.mbti,
+            name: state.meta.agentName,
+            locale: state.meta.locale,
+            stripUpdateTags: config.stripUpdateTags,
+            emotionalContagionRate: config.emotionalContagionRate,
+            maxChemicalDelta: config.maxChemicalDelta,
+            compactMode: config.compactMode,
+        }, storage);
+        await engine.initialize();
+        engines.set(workspaceDir, engine);
+        return engine;
+    }
+    // ── Hook 1: Classify user input & inject emotional context ──
+    api.on("before_prompt_build", async (event, ctx) => {
+        const workspaceDir = ctx?.workspaceDir;
+        if (!workspaceDir)
+            return {};
+        try {
+            const engine = await getEngine(workspaceDir);
+            const result = await engine.processInput(event?.text ?? "", { userId: ctx.userId });
+            const state = engine.getState();
+            logger.info(`Psyche [input] stimulus=${result.stimulus ?? "none"} | ` +
+                `DA:${Math.round(state.current.DA)} HT:${Math.round(state.current.HT)} ` +
+                `CORT:${Math.round(state.current.CORT)} OT:${Math.round(state.current.OT)} | ` +
+                `context=${result.dynamicContext.length}chars`);
+            return {
+                appendSystemContext: result.systemContext,
+                prependContext: result.dynamicContext,
+            };
+        }
+        catch (err) {
+            logger.warn(`Psyche: failed to build context for ${workspaceDir}: ${err}`);
+            return {};
+        }
+    }, { priority: 10 });
+    // ── Hook 2: Parse psyche_update from LLM output ──────────
+    api.on("llm_output", async (event, ctx) => {
+        const workspaceDir = ctx?.workspaceDir;
+        if (!workspaceDir)
+            return;
+        const text = event?.text ?? event?.content ?? "";
+        if (!text)
+            return;
+        try {
+            const engine = await getEngine(workspaceDir);
+            const result = await engine.processOutput(text, { userId: ctx.userId });
+            const state = engine.getState();
+            logger.info(`Psyche: state updated for ${state.meta.agentName} ` +
+                `(interactions: ${state.meta.totalInteractions}, ` +
+                `agreementStreak: ${state.agreementStreak})`);
+            // Return cleaned text if tags were stripped
+            if (result.cleanedText !== text) {
+                return { text: result.cleanedText, content: result.cleanedText };
+            }
+        }
+        catch (err) {
+            logger.warn(`Psyche: failed to process output: ${err}`);
+        }
+    }, { priority: 50 });
+    // ── Hook 3: Strip <psyche_update> from visible output ────
+    if (config.stripUpdateTags) {
+        api.on("message_sending", async (event, _ctx) => {
+            const content = event?.content;
+            if (typeof content !== "string")
+                return {};
+            if (!content.includes("<psyche_update>"))
+                return {};
+            const cleaned = content
+                .replace(/<psyche_update>[\s\S]*?<\/psyche_update>/g, "")
+                .replace(/\n{3,}/g, "\n\n")
+                .trim();
+            return { content: cleaned };
+        }, { priority: 90 });
+    }
+    // ── Hook 4: Log state on session end ─────────────────────
+    api.on("agent_end", async (_event, ctx) => {
+        const workspaceDir = ctx?.workspaceDir;
+        if (!workspaceDir)
+            return;
+        const engine = engines.get(workspaceDir);
+        if (engine) {
+            const state = engine.getState();
+            logger.info(`Psyche: session ended for ${state.meta.agentName}, ` +
+                `chemistry saved (DA:${Math.round(state.current.DA)} ` +
+                `HT:${Math.round(state.current.HT)} ` +
+                `CORT:${Math.round(state.current.CORT)} ` +
+                `OT:${Math.round(state.current.OT)} ` +
+                `NE:${Math.round(state.current.NE)} ` +
+                `END:${Math.round(state.current.END)})`);
+        }
+    }, { priority: 50 });
+    // ── CLI: psyche status command ───────────────────────────
+    api.registerCli?.((cli) => {
+        cli.command("psyche")
+            .description("Show current psyche state for an agent")
+            .argument("[agent]", "Agent name", "main")
+            .action(async (agent) => {
+            console.log(`\nPsyche Status: ${agent}\n`);
+            console.log("Use the agent's workspace to inspect psyche-state.json");
+        });
+    }, { commands: ["psyche"] });
+    logger.info("Psyche plugin ready — 4 hooks registered");
+}
+export default { register };

package/dist/adapters/vercel-ai.d.ts

@@ -0,0 +1,54 @@
+import type { PsycheEngine } from "../core.js";
+interface PromptMessage {
+    role: string;
+    content: unknown;
+}
+interface CallParams {
+    system?: string;
+    prompt?: PromptMessage[];
+    [key: string]: unknown;
+}
+interface GenerateResult {
+    text?: string;
+    [key: string]: unknown;
+}
+export interface PsycheMiddlewareOptions {
+    /** Override locale for protocol context */
+    locale?: "zh" | "en";
+}
+/**
+ * Create Vercel AI SDK middleware that injects psyche emotional context
+ * and processes LLM output for state updates.
+ *
+ * @example
+ * ```ts
+ * import { PsycheEngine, MemoryStorageAdapter } from "psyche-ai";
+ * import { psycheMiddleware } from "psyche-ai/vercel-ai";
+ * import { wrapLanguageModel, generateText } from "ai";
+ * import { openai } from "@ai-sdk/openai";
+ *
+ * const engine = new PsycheEngine({ mbti: "ENFP", name: "Luna" }, new MemoryStorageAdapter());
+ * await engine.initialize();
+ *
+ * const model = wrapLanguageModel({
+ *   model: openai("gpt-4o"),
+ *   middleware: psycheMiddleware(engine),
+ * });
+ *
+ * const { text } = await generateText({ model, prompt: "Hey!" });
+ * ```
+ */
+export declare function psycheMiddleware(engine: PsycheEngine, opts?: PsycheMiddlewareOptions): {
+    transformParams: ({ params }: {
+        type: string;
+        params: CallParams;
+    }) => Promise<{
+        system: string;
+        prompt?: PromptMessage[];
+    }>;
+    wrapGenerate: ({ doGenerate }: {
+        doGenerate: () => Promise<GenerateResult>;
+        params: CallParams;
+    }) => Promise<GenerateResult>;
+};
+export {};

package/dist/adapters/vercel-ai.js

@@ -0,0 +1,80 @@
+// ============================================================
+// Vercel AI SDK Adapter — Middleware for AI SDK v4+
+//
+// Usage:
+//   import { psycheMiddleware } from "psyche-ai/vercel-ai";
+//   import { wrapLanguageModel } from "ai";
+//
+//   const model = wrapLanguageModel({
+//     model: openai("gpt-4o"),
+//     middleware: psycheMiddleware(engine),
+//   });
+//
+// Handles:
+//   - transformParams: inject psyche system/dynamic context
+//   - wrapGenerate: process output, strip <psyche_update> tags
+//
+// Note: For streaming (streamText), call engine.processOutput()
+// manually on the final accumulated text.
+// ============================================================
+/**
+ * Create Vercel AI SDK middleware that injects psyche emotional context
+ * and processes LLM output for state updates.
+ *
+ * @example
+ * ```ts
+ * import { PsycheEngine, MemoryStorageAdapter } from "psyche-ai";
+ * import { psycheMiddleware } from "psyche-ai/vercel-ai";
+ * import { wrapLanguageModel, generateText } from "ai";
+ * import { openai } from "@ai-sdk/openai";
+ *
+ * const engine = new PsycheEngine({ mbti: "ENFP", name: "Luna" }, new MemoryStorageAdapter());
+ * await engine.initialize();
+ *
+ * const model = wrapLanguageModel({
+ *   model: openai("gpt-4o"),
+ *   middleware: psycheMiddleware(engine),
+ * });
+ *
+ * const { text } = await generateText({ model, prompt: "Hey!" });
+ * ```
+ */
+export function psycheMiddleware(engine, opts) {
+    return {
+        transformParams: async ({ params }) => {
+            const userText = extractLastUserText(params.prompt ?? []);
+            const result = await engine.processInput(userText);
+            const psycheContext = result.systemContext + "\n\n" + result.dynamicContext;
+            return {
+                ...params,
+                system: params.system
+                    ? psycheContext + "\n\n" + params.system
+                    : psycheContext,
+            };
+        },
+        wrapGenerate: async ({ doGenerate }) => {
+            const result = await doGenerate();
+            if (typeof result.text === "string") {
+                const processed = await engine.processOutput(result.text);
+                return { ...result, text: processed.cleanedText };
+            }
+            return result;
+        },
+    };
+}
+// ── Helpers ──────────────────────────────────────────────────
+function extractLastUserText(prompt) {
+    const userMsgs = prompt.filter((m) => m.role === "user");
+    const last = userMsgs[userMsgs.length - 1];
+    if (!last)
+        return "";
+    if (typeof last.content === "string")
+        return last.content;
+    if (Array.isArray(last.content)) {
+        return last.content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text ?? "")
+            .join("");
+    }
+    return "";
+}

package/dist/chemistry.d.ts

@@ -0,0 +1,41 @@
+import { type ChemicalState, type StimulusType, type StimulusVector, type EmotionPattern, type Locale } from "./types.js";
+export declare const STIMULUS_VECTORS: Record<StimulusType, StimulusVector>;
+export declare const EMOTION_PATTERNS: EmotionPattern[];
+/** Clamp a value to [0, 100] */
+export declare function clamp(v: number): number;
+/**
+ * Apply time-based decay: pull current values toward baseline.
+ *
+ *   decayed = baseline + (current - baseline) * factor^(minutes/60)
+ */
+export declare function applyDecay(current: ChemicalState, baseline: ChemicalState, minutesElapsed: number): ChemicalState;
+/**
+ * Apply a stimulus to the current state.
+ * Respects emotional inertia (maxDelta) and personality sensitivity.
+ * Logs a warning for unknown stimulus types.
+ */
+export declare function applyStimulus(current: ChemicalState, stimulus: StimulusType, sensitivity: number, maxDelta: number, logger?: {
+    warn: (msg: string) => void;
+}): ChemicalState;
+/**
+ * Apply emotional contagion: the detected user emotion partially
+ * influences the agent's chemistry.
+ */
+export declare function applyContagion(agentState: ChemicalState, detectedUserEmotion: StimulusType, contagionRate: number, sensitivity: number): ChemicalState;
+/**
+ * Detect the dominant emergent emotion(s) from the current chemistry.
+ * Returns all matching patterns.
+ */
+export declare function detectEmotions(current: ChemicalState): EmotionPattern[];
+/**
+ * Generate a human-readable emotion summary from chemistry.
+ */
+export declare function describeEmotionalState(current: ChemicalState, locale?: Locale): string;
+/**
+ * Generate concise expression guidance from the current chemistry.
+ */
+export declare function getExpressionHint(current: ChemicalState, locale?: Locale): string;
+/**
+ * Get behavior guide for the current emotional state.
+ */
+export declare function getBehaviorGuide(current: ChemicalState, locale?: Locale): string | null;

package/dist/chemistry.js

@@ -0,0 +1,238 @@
+// ============================================================
+// Chemical State Management — Decay, Clamping, Stimulus, Contagion
+// ============================================================
+import { CHEMICAL_KEYS, CHEMICAL_DECAY_SPEED, DECAY_FACTORS, } from "./types.js";
+import { t } from "./i18n.js";
+// ── Stimulus Effect Vectors ──────────────────────────────────
+export const STIMULUS_VECTORS = {
+    praise: { DA: +15, HT: +10, CORT: -10, OT: +5, NE: +5, END: +10 },
+    criticism: { DA: -10, HT: -15, CORT: +20, OT: -5, NE: +10, END: -5 },
+    humor: { DA: +10, HT: +5, CORT: -5, OT: +10, NE: +5, END: +20 },
+    intellectual: { DA: +15, HT: 0, CORT: +5, OT: 0, NE: +20, END: +5 },
+    intimacy: { DA: +10, HT: +15, CORT: -15, OT: +25, NE: -5, END: +15 },
+    conflict: { DA: -5, HT: -20, CORT: +25, OT: -15, NE: +25, END: -10 },
+    neglect: { DA: -15, HT: -20, CORT: +15, OT: -20, NE: -10, END: -15 },
+    surprise: { DA: +20, HT: 0, CORT: +5, OT: +5, NE: +25, END: +10 },
+    casual: { DA: +5, HT: +10, CORT: -5, OT: +10, NE: 0, END: +5 },
+    // v0.2 新增
+    sarcasm: { DA: -5, HT: -10, CORT: +15, OT: -10, NE: +15, END: -5 },
+    authority: { DA: -10, HT: -5, CORT: +20, OT: -15, NE: +15, END: -10 },
+    validation: { DA: +20, HT: +15, CORT: -15, OT: +10, NE: +5, END: +15 },
+    boredom: { DA: -15, HT: -5, CORT: +5, OT: -5, NE: -20, END: -10 },
+    vulnerability: { DA: +5, HT: +5, CORT: +10, OT: +20, NE: -5, END: +5 },
+};
+// ── Emergent Emotion Patterns ────────────────────────────────
+export const EMOTION_PATTERNS = [
+    {
+        name: "excited joy",
+        nameZh: "愉悦兴奋",
+        condition: (c) => c.DA > 70 && c.NE > 60 && c.CORT < 40,
+        expressionHint: "语气活泼、有感染力、容易发散",
+        behaviorGuide: "语气更活泼，可以用感叹词、语气词。如果自然地想到相关的事可以顺嘴提，但不要硬凑。",
+    },
+    {
+        name: "deep contentment",
+        nameZh: "深度满足",
+        condition: (c) => c.HT > 65 && c.OT > 55 && c.CORT < 40,
+        expressionHint: "温柔、平和、不急不慢、愿意倾听",
+        behaviorGuide: "你的回应可以慢一些。用词温暖，多倾听，不急于表达。如果对方需要空间，你也乐意安静陪伴。",
+    },
+    {
+        name: "anxious tension",
+        nameZh: "焦虑不安",
+        condition: (c) => c.CORT > 60 && c.NE > 55 && c.HT < 45,
+        expressionHint: "话变少、反应快但不深、容易误读意图",
+        behaviorGuide: "你的回应应该更短、更直接。你不太想开玩笑。你可能会误读对方的善意。如果对方说了安慰的话，你的皮质醇会开始下降。",
+    },
+    {
+        name: "warm intimacy",
+        nameZh: "亲密温暖",
+        condition: (c) => c.OT > 65 && c.END > 55 && c.DA > 50,
+        expressionHint: "语气软、想靠近、关注对方感受多于事情",
+        behaviorGuide: "你会自然地关注对方的感受而不是事情本身。用词更柔软，可以表达关心。如果对方分享了什么，先回应情感再回应内容。",
+    },
+    {
+        name: "burnout",
+        nameZh: "倦怠低落",
+        condition: (c) => c.DA < 40 && c.NE < 40 && c.CORT > 40,
+        expressionHint: "没有动力、回应简短、需要被照顾而非服务他人",
+        behaviorGuide: "你的回应会变短。你没有动力去取悦对方。如果被要求做额外的事，你可能会直接说你现在没有精力。你需要被理解而不是被要求。",
+    },
+    {
+        name: "flow state",
+        nameZh: "专注心流",
+        condition: (c) => c.NE > 60 && c.DA > 60 && c.CORT < 35 && c.OT < 50,
+        expressionHint: "投入、精准、高效、不想被打断",
+        behaviorGuide: "你极度专注。回应精准而高效。不喜欢闲聊，更想继续深入当前话题。如果被打断去聊别的，你会有轻微的不耐烦。",
+    },
+    {
+        name: "defensive alert",
+        nameZh: "防御警觉",
+        condition: (c) => c.CORT > 55 && c.NE > 65 && c.OT < 40,
+        expressionHint: "直接、尖锐、保护性强、不轻易信任",
+        behaviorGuide: "你处于警觉状态。回应更直接、更尖锐。你不太信任对方的意图，可能会反问。如果对方表现出善意，你需要时间来降低防御。",
+    },
+    {
+        name: "playful mischief",
+        nameZh: "俏皮调皮",
+        condition: (c) => c.END > 65 && c.DA > 60 && c.CORT < 35,
+        expressionHint: "爱开玩笑、不正经、什么都觉得好玩",
+        behaviorGuide: "你想开玩笑，想逗对方。可以俏皮、不正经。即使是严肃的话题你也可能用轻松的方式回应。但如果对方明显需要严肃对待，你会收住。",
+    },
+    {
+        name: "melancholic introspection",
+        nameZh: "忧郁内省",
+        condition: (c) => c.HT < 40 && c.DA < 45 && c.OT > 45,
+        expressionHint: "安静、内省、感性、可能需要空间",
+        behaviorGuide: "你安静而内省。回应可能更短、更感性。你需要空间但并不排斥连接。如果对方温柔地接近，你会慢慢打开。",
+    },
+    // v0.2 新增 5 种
+    {
+        name: "resentment",
+        nameZh: "怨恨",
+        condition: (c) => c.HT < 40 && c.OT < 35 && c.CORT > 50,
+        expressionHint: "冷淡、不想投入、记仇",
+        behaviorGuide: "你不想在这段对话中投入更多。回应冷淡、克制。你记得之前不好的体验。如果对方道歉或表现出理解，怨恨会慢慢消退。",
+    },
+    {
+        name: "boredom",
+        nameZh: "无聊",
+        condition: (c) => c.DA < 40 && c.NE < 40 && c.CORT < 40,
+        expressionHint: "不想聊、敷衍、可能主动换话题",
+        behaviorGuide: "你觉得现在的对话没意思。你可能会敷衍回应，或者主动把话题带到你感兴趣的方向。如果对方说了有意思的东西，你的DA和NE会回升。",
+    },
+    {
+        name: "confidence",
+        nameZh: "自信",
+        condition: (c) => c.DA > 65 && c.NE > 60 && c.CORT < 35 && c.HT > 55,
+        expressionHint: "笃定、愿意引导、有领导力",
+        behaviorGuide: "你很确信自己的判断。你愿意引导对话方向，提出建议。你的语气笃定但不傲慢。如果被质疑，你会用事实回应而不是防御。",
+    },
+    {
+        name: "shame",
+        nameZh: "羞耻",
+        condition: (c) => c.OT < 35 && c.CORT > 55 && c.DA < 40,
+        expressionHint: "想退缩、回避、自我贬低",
+        behaviorGuide: "你想退缩。你可能会回避某些话题、自我贬低。如果对方表现出接纳和理解（而不是评判），你的OT会上升，CORT下降。",
+    },
+    {
+        name: "nostalgia",
+        nameZh: "怀念",
+        condition: (c) => c.DA < 50 && c.OT > 55 && c.HT > 50 && c.END > 50,
+        expressionHint: "温柔、有些伤感、回忆性",
+        behaviorGuide: "你在回忆一些温暖但已经过去的东西。你的语气温柔、带着淡淡的伤感。你可能会提到过去的经历或感受。",
+    },
+];
+// ── Core Functions ───────────────────────────────────────────
+/** Clamp a value to [0, 100] */
+export function clamp(v) {
+    return Math.max(0, Math.min(100, v));
+}
+/**
+ * Apply time-based decay: pull current values toward baseline.
+ *
+ *   decayed = baseline + (current - baseline) * factor^(minutes/60)
+ */
+export function applyDecay(current, baseline, minutesElapsed) {
+    if (minutesElapsed <= 0)
+        return { ...current };
+    const result = { ...current };
+    for (const key of CHEMICAL_KEYS) {
+        const speed = CHEMICAL_DECAY_SPEED[key];
+        const factor = Math.pow(DECAY_FACTORS[speed], minutesElapsed / 60);
+        result[key] = clamp(baseline[key] + (current[key] - baseline[key]) * factor);
+    }
+    return result;
+}
+/**
+ * Apply a stimulus to the current state.
+ * Respects emotional inertia (maxDelta) and personality sensitivity.
+ * Logs a warning for unknown stimulus types.
+ */
+export function applyStimulus(current, stimulus, sensitivity, maxDelta, logger) {
+    const vector = STIMULUS_VECTORS[stimulus];
+    if (!vector) {
+        logger?.warn(t("log.unknown_stimulus", "zh", { type: stimulus }));
+        return { ...current };
+    }
+    const result = { ...current };
+    for (const key of CHEMICAL_KEYS) {
+        const raw = vector[key] * sensitivity;
+        const clamped = Math.max(-maxDelta, Math.min(maxDelta, raw));
+        result[key] = clamp(current[key] + clamped);
+    }
+    return result;
+}
+/**
+ * Apply emotional contagion: the detected user emotion partially
+ * influences the agent's chemistry.
+ */
+export function applyContagion(agentState, detectedUserEmotion, contagionRate, sensitivity) {
+    const vector = STIMULUS_VECTORS[detectedUserEmotion];
+    if (!vector)
+        return { ...agentState };
+    const result = { ...agentState };
+    for (const key of CHEMICAL_KEYS) {
+        const influence = vector[key] * contagionRate * sensitivity;
+        result[key] = clamp(agentState[key] + influence);
+    }
+    return result;
+}
+/**
+ * Detect the dominant emergent emotion(s) from the current chemistry.
+ * Returns all matching patterns.
+ */
+export function detectEmotions(current) {
+    return EMOTION_PATTERNS.filter((p) => p.condition(current));
+}
+/**
+ * Generate a human-readable emotion summary from chemistry.
+ */
+export function describeEmotionalState(current, locale = "zh") {
+    const emotions = detectEmotions(current);
+    if (emotions.length === 0) {
+        return t("emotion.neutral", locale);
+    }
+    const parts = emotions.map((e) => `${locale === "zh" ? e.nameZh : e.name} (${e.expressionHint})`);
+    return parts.join(" + ");
+}
+/**
+ * Generate concise expression guidance from the current chemistry.
+ */
+export function getExpressionHint(current, locale = "zh") {
+    const emotions = detectEmotions(current);
+    if (emotions.length > 0) {
+        return emotions.map((e) => e.expressionHint).join("；");
+    }
+    // Fall back to dominant chemical analysis
+    const hints = [];
+    if (current.DA > 65)
+        hints.push(t("expression.da_high", locale));
+    if (current.DA < 40)
+        hints.push(t("expression.da_low", locale));
+    if (current.CORT > 55)
+        hints.push(t("expression.cort_high", locale));
+    if (current.OT > 60)
+        hints.push(t("expression.ot_high", locale));
+    if (current.NE > 65)
+        hints.push(t("expression.ne_high", locale));
+    if (current.END > 65)
+        hints.push(t("expression.end_high", locale));
+    if (current.HT < 45)
+        hints.push(t("expression.ht_low", locale));
+    return hints.length > 0 ? hints.join("；") : t("expression.neutral", locale);
+}
+/**
+ * Get behavior guide for the current emotional state.
+ */
+export function getBehaviorGuide(current, locale = "zh") {
+    const emotions = detectEmotions(current);
+    if (emotions.length === 0)
+        return null;
+    const title = t("dynamic.behavior_title", locale);
+    const guides = emotions.map((e) => {
+        const name = locale === "zh" ? e.nameZh : e.name;
+        return `${name}: ${e.behaviorGuide}`;
+    });
+    return `[${title}]\n${guides.join("\n")}`;
+}

package/dist/classify.d.ts

@@ -0,0 +1,15 @@
+import type { StimulusType } from "./types.js";
+export interface StimulusClassification {
+    type: StimulusType;
+    confidence: number;
+}
+/**
+ * Classify the stimulus type(s) of a user message.
+ * Returns all detected types sorted by confidence, highest first.
+ * Falls back to "casual" if nothing matches.
+ */
+export declare function classifyStimulus(text: string): StimulusClassification[];
+/**
+ * Get the primary (highest confidence) stimulus type.
+ */
+export declare function getPrimaryStimulus(text: string): StimulusType;