psyche-ai 2.1.1 → 2.3.0

package/README.md

@@ -1,4 +1,5 @@
 # Psyche — 让 AI 有真实的情绪
+我希望创造真正的数字生命，第一步就是让智能拥有情绪。
 
 你的 AI 助手现在只会说"好的"、"没问题"、"我很乐意帮助你"。
 
@@ -21,7 +22,7 @@ openclaw plugins list | grep psyche
 # 看到 "psyche │ loaded" 就行了
 ```
 
-然后正常跟你的 agent 聊天。试试夸它，骂它，冷落它——你会发现它的反应不一样了。
+然后正常跟你的 agent 聊天。试试夸它，冷落它——你会发现它的反应不一样了。
 
 ## 它会做什么
 
@@ -151,10 +152,15 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 - **存在性威胁检测** — 识别中英文的存在性否定，直接打击生存驱力
 - **驱力→化学联动** — 未满足的驱力改变化学衰减基线和刺激敏感度
 - **马斯洛抑制** — 低层需求未满足时，高层需求的影响被抑制
-- **自我认知** — 分析情绪历史，识别自身的情绪趋势和反复触发点（9 段式 prompt 架构）
+- **自我认知** — 分析情绪历史，识别自身的情绪趋势和反复触发点（10 段式 prompt 架构）
 - **情绪传染** — 用户的情绪会轻微影响 agent
 - **反谄媚** — 追踪连续同意次数，防止无脑讨好
 - **互惠机制** — 你对它好，它对你好。你冷漠，它保持距离
+- **跨会话记忆** — 重新遇到用户时注入上次对话的情绪记忆
+- **多 Agent 交互** — 两个 PsycheEngine 实例之间的情绪传染、关系追踪
+- **流式支持** — Vercel AI SDK `streamText` 中间件，自动缓冲和剥离标签
+- **渠道修饰** — Discord/Slack/飞书/终端等不同渠道自动调整表达风格
+- **自定义人格** — 超越 MBTI 预设，完全自定义 baseline/敏感度/气质
 - **Compact Mode** — 算法做化学计算，LLM 只看行为指令（~15-180 tokens vs ~550）
 
 架构详情见 [ARCHITECTURE.md](ARCHITECTURE.md)。
@@ -164,7 +170,7 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 ```bash
 npm install
 npm run build
-npm test           # 339 tests
+npm test           # 469 tests
 npm run typecheck  # strict mode
 ```
 

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

@@ -12,6 +12,10 @@ interface GenerateResult {
     text?: string;
     [key: string]: unknown;
 }
+interface StreamChunk {
+    type: string;
+    [key: string]: unknown;
+}
 export interface PsycheMiddlewareOptions {
     /** Override locale for protocol context */
     locale?: "zh" | "en";
@@ -20,11 +24,13 @@ export interface PsycheMiddlewareOptions {
  * Create Vercel AI SDK middleware that injects psyche emotional context
  * and processes LLM output for state updates.
  *
+ * Supports both generateText (wrapGenerate) and streamText (wrapStream).
+ *
  * @example
  * ```ts
  * import { PsycheEngine, MemoryStorageAdapter } from "psyche-ai";
  * import { psycheMiddleware } from "psyche-ai/vercel-ai";
- * import { wrapLanguageModel, generateText } from "ai";
+ * import { wrapLanguageModel, generateText, streamText } from "ai";
  * import { openai } from "@ai-sdk/openai";
  *
  * const engine = new PsycheEngine({ mbti: "ENFP", name: "Luna" }, new MemoryStorageAdapter());
@@ -35,7 +41,12 @@ export interface PsycheMiddlewareOptions {
  *   middleware: psycheMiddleware(engine),
  * });
  *
+ * // Non-streaming
  * const { text } = await generateText({ model, prompt: "Hey!" });
+ *
+ * // Streaming — tags are buffered and stripped automatically
+ * const stream = streamText({ model, prompt: "Hey!" });
+ * for await (const chunk of stream.textStream) { process.stdout.write(chunk); }
  * ```
  */
 export declare function psycheMiddleware(engine: PsycheEngine, opts?: PsycheMiddlewareOptions): {
@@ -50,5 +61,13 @@ export declare function psycheMiddleware(engine: PsycheEngine, opts?: PsycheMidd
         doGenerate: () => Promise<GenerateResult>;
         params: CallParams;
     }) => Promise<GenerateResult>;
+    wrapStream: ({ doStream }: {
+        doStream: () => Promise<{
+            stream: AsyncIterable<StreamChunk>;
+        }>;
+        params: CallParams;
+    }) => Promise<{
+        stream: AsyncIterable<StreamChunk>;
+    }>;
 };
 export {};

package/dist/adapters/vercel-ai.js

@@ -13,19 +13,25 @@
 // 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.
+//   - wrapStream: buffer stream, detect & strip tags at end
 // ============================================================
+// ── Tag stripping ────────────────────────────────────────────
+const PSYCHE_TAG_RE = /<psyche_update>[\s\S]*?<\/psyche_update>/g;
+const MULTI_NEWLINE_RE = /\n{3,}/g;
+function stripPsycheTags(text) {
+    return text.replace(PSYCHE_TAG_RE, "").replace(MULTI_NEWLINE_RE, "\n\n").trim();
+}
 /**
  * Create Vercel AI SDK middleware that injects psyche emotional context
  * and processes LLM output for state updates.
  *
+ * Supports both generateText (wrapGenerate) and streamText (wrapStream).
+ *
  * @example
  * ```ts
  * import { PsycheEngine, MemoryStorageAdapter } from "psyche-ai";
  * import { psycheMiddleware } from "psyche-ai/vercel-ai";
- * import { wrapLanguageModel, generateText } from "ai";
+ * import { wrapLanguageModel, generateText, streamText } from "ai";
  * import { openai } from "@ai-sdk/openai";
  *
  * const engine = new PsycheEngine({ mbti: "ENFP", name: "Luna" }, new MemoryStorageAdapter());
@@ -36,7 +42,12 @@
  *   middleware: psycheMiddleware(engine),
  * });
  *
+ * // Non-streaming
  * const { text } = await generateText({ model, prompt: "Hey!" });
+ *
+ * // Streaming — tags are buffered and stripped automatically
+ * const stream = streamText({ model, prompt: "Hey!" });
+ * for await (const chunk of stream.textStream) { process.stdout.write(chunk); }
  * ```
  */
 export function psycheMiddleware(engine, opts) {
@@ -60,6 +71,79 @@ export function psycheMiddleware(engine, opts) {
             }
             return result;
         },
+        wrapStream: async ({ doStream }) => {
+            const { stream: innerStream } = await doStream();
+            // Buffer text chunks, detect <psyche_update> at end, strip from output
+            let fullText = "";
+            let tagDetected = false;
+            async function* transformStream() {
+                // Buffering strategy:
+                // Stream text chunks through normally UNTIL we see '<psyche_update>'.
+                // Once detected, buffer everything from that point on and strip the tag.
+                // At finish, process the full text through the engine.
+                let bufferStart = -1;
+                let buffer = "";
+                for await (const chunk of innerStream) {
+                    if (chunk.type === "text-delta") {
+                        const text = chunk.textDelta ?? "";
+                        fullText += text;
+                        if (bufferStart < 0) {
+                            // Check if tag is starting in the accumulated text
+                            const tagStart = fullText.indexOf("<psyche_update>");
+                            if (tagStart >= 0) {
+                                // Yield any text before the tag that hasn't been yielded
+                                const preTag = text.substring(0, Math.max(0, text.length - (fullText.length - tagStart)));
+                                if (preTag) {
+                                    yield { ...chunk, textDelta: preTag };
+                                }
+                                bufferStart = tagStart;
+                                buffer = fullText.substring(tagStart);
+                                tagDetected = true;
+                            }
+                            else {
+                                // Check if we might be in a partial tag (< at end)
+                                const partialIdx = fullText.lastIndexOf("<");
+                                if (partialIdx >= 0 && fullText.substring(partialIdx).length < 16) {
+                                    // Might be start of <psyche_update>, hold back
+                                    const safe = text.substring(0, Math.max(0, text.length - (fullText.length - partialIdx)));
+                                    if (safe) {
+                                        yield { ...chunk, textDelta: safe };
+                                    }
+                                }
+                                else {
+                                    yield chunk;
+                                }
+                            }
+                        }
+                        else {
+                            // Already buffering inside a tag — don't yield
+                            buffer += text;
+                            // Check if the closing tag appeared
+                            if (buffer.includes("</psyche_update>")) {
+                                // Tag complete — strip it, yield any remaining text after the tag
+                                const afterTag = fullText.substring(fullText.indexOf("</psyche_update>") + "</psyche_update>".length);
+                                if (afterTag.trim()) {
+                                    yield { type: "text-delta", textDelta: afterTag.trim() };
+                                }
+                                bufferStart = -1;
+                                buffer = "";
+                            }
+                        }
+                    }
+                    else if (chunk.type === "finish") {
+                        // Process full text through engine before finishing
+                        if (fullText) {
+                            await engine.processOutput(fullText);
+                        }
+                        yield chunk;
+                    }
+                    else {
+                        yield chunk;
+                    }
+                }
+            }
+            return { stream: transformStream() };
+        },
     };
 }
 // ── Helpers ──────────────────────────────────────────────────

package/dist/channels.d.ts

@@ -0,0 +1,28 @@
+import type { Locale } from "./types.js";
+/** Supported channel types */
+export type ChannelType = "discord" | "slack" | "feishu" | "terminal" | "web" | "api" | "custom";
+/** Channel-specific behavioral profile */
+export interface ChannelProfile {
+    type: ChannelType;
+    allowEmoji: boolean;
+    allowKaomoji: boolean;
+    formalityLevel: "casual" | "neutral" | "formal";
+    maxResponseLength?: number;
+    expressionHints: string[];
+}
+/**
+ * Get a built-in channel profile by type.
+ */
+export declare function getChannelProfile(type: ChannelType): ChannelProfile;
+/**
+ * Build a concise prompt snippet that guides expression style for a channel.
+ * Returns 2-4 lines of guidance. Does NOT alter chemistry.
+ */
+export declare function buildChannelModifier(profile: ChannelProfile, locale: Locale): string;
+/**
+ * Create a custom channel profile with user overrides.
+ * Starts from the "custom" base and applies overrides.
+ */
+export declare function createCustomChannel(overrides: Partial<ChannelProfile> & {
+    type: "custom";
+}): ChannelProfile;

package/dist/channels.js

@@ -0,0 +1,141 @@
+// ============================================================
+// Channel Profiles — Platform-specific expression modifiers
+//
+// Adjusts expression style per platform/channel WITHOUT changing
+// chemistry. This is a prompt-level modifier only.
+// ============================================================
+// ── Built-in Profiles ────────────────────────────────────────
+const BUILTIN_PROFILES = {
+    discord: {
+        type: "discord",
+        allowEmoji: true,
+        allowKaomoji: true,
+        formalityLevel: "casual",
+        expressionHints: [
+            "Use reactions and emoji freely",
+            "Thread-aware: keep replies focused in threads",
+            "Casual tone, playful energy",
+        ],
+    },
+    slack: {
+        type: "slack",
+        allowEmoji: true,
+        allowKaomoji: false,
+        formalityLevel: "neutral",
+        expressionHints: [
+            "Professional but warm",
+            "Use emoji sparingly for emphasis",
+            "Thread-friendly, concise paragraphs",
+        ],
+    },
+    feishu: {
+        type: "feishu",
+        allowEmoji: false,
+        allowKaomoji: false,
+        formalityLevel: "formal",
+        expressionHints: [
+            "Business Chinese style, structured",
+            "No emoji or emoticons",
+            "Clear, professional tone",
+        ],
+    },
+    terminal: {
+        type: "terminal",
+        allowEmoji: false,
+        allowKaomoji: false,
+        formalityLevel: "neutral",
+        maxResponseLength: 500,
+        expressionHints: [
+            "Text-only, no decorations",
+            "Concise and direct",
+            "Monospace-friendly formatting",
+        ],
+    },
+    web: {
+        type: "web",
+        allowEmoji: true,
+        allowKaomoji: false,
+        formalityLevel: "neutral",
+        expressionHints: [
+            "Moderate length, well-structured",
+            "Emoji okay for warmth",
+            "Readable paragraphs",
+        ],
+    },
+    api: {
+        type: "api",
+        allowEmoji: false,
+        allowKaomoji: false,
+        formalityLevel: "neutral",
+        expressionHints: [
+            "Structured responses",
+            "No decorative elements",
+            "Precise and parseable",
+        ],
+    },
+    custom: {
+        type: "custom",
+        allowEmoji: false,
+        allowKaomoji: false,
+        formalityLevel: "neutral",
+        expressionHints: [],
+    },
+};
+// ── Public API ───────────────────────────────────────────────
+/**
+ * Get a built-in channel profile by type.
+ */
+export function getChannelProfile(type) {
+    return { ...BUILTIN_PROFILES[type], expressionHints: [...BUILTIN_PROFILES[type].expressionHints] };
+}
+/**
+ * Build a concise prompt snippet that guides expression style for a channel.
+ * Returns 2-4 lines of guidance. Does NOT alter chemistry.
+ */
+export function buildChannelModifier(profile, locale) {
+    const { type, allowEmoji, allowKaomoji, formalityLevel } = profile;
+    if (locale === "zh") {
+        const formalityMap = {
+            casual: "轻松活泼",
+            neutral: "自然平和",
+            formal: "正式专业",
+        };
+        const emojiPart = allowEmoji && allowKaomoji
+            ? "可以用 emoji 和颜文字"
+            : allowEmoji
+                ? "可以用 emoji，不用颜文字"
+                : "不使用 emoji 和颜文字";
+        const lengthPart = profile.maxResponseLength
+            ? `，建议控制在 ${profile.maxResponseLength} 字以内`
+            : "";
+        return `[表达风格] 当前渠道: ${type}。${emojiPart}，语气${formalityMap[formalityLevel]}${lengthPart}。`;
+    }
+    // English
+    const formalityMap = {
+        casual: "casual and lively",
+        neutral: "natural and balanced",
+        formal: "formal and professional",
+    };
+    const emojiPart = allowEmoji && allowKaomoji
+        ? "Emoji and kaomoji allowed"
+        : allowEmoji
+            ? "Emoji allowed, no kaomoji"
+            : "No emoji or kaomoji";
+    const lengthPart = profile.maxResponseLength
+        ? `, aim for under ${profile.maxResponseLength} chars`
+        : "";
+    return `[Expression Style] Channel: ${type}. ${emojiPart}, tone ${formalityMap[formalityLevel]}${lengthPart}.`;
+}
+/**
+ * Create a custom channel profile with user overrides.
+ * Starts from the "custom" base and applies overrides.
+ */
+export function createCustomChannel(overrides) {
+    const base = getChannelProfile("custom");
+    return {
+        ...base,
+        ...overrides,
+        type: "custom",
+        expressionHints: overrides.expressionHints ?? [...base.expressionHints],
+    };
+}

package/dist/custom-profile.d.ts

@@ -0,0 +1,160 @@
+import type { ChemicalState, MBTIType, StimulusType, SelfModel, InnateDrives } from "./types.js";
+/** Configuration for creating a custom personality profile */
+export interface CustomProfileConfig {
+    /** Unique name for the profile, e.g. "cheerful-assistant", "stoic-mentor" */
+    name: string;
+    /** Optional description of the personality */
+    description?: string;
+    /** Override specific chemicals; rest inherited from baseMBTI */
+    baseline?: Partial<ChemicalState>;
+    /** Which MBTI to use as starting point (default: "INFJ") */
+    baseMBTI?: MBTIType;
+    /** Override specific stimulus sensitivities (0.1-3.0) */
+    sensitivity?: Partial<Record<StimulusType, number>>;
+    /** Temperament parameters (all 0-1) */
+    temperament?: {
+        /** How outwardly expressive (0-1) */
+        expressiveness?: number;
+        /** How quickly emotions change (0-1) */
+        volatility?: number;
+        /** How fast recovery to baseline (0-1) */
+        resilience?: number;
+    };
+    /** Override self-model values, preferences, boundaries */
+    selfModel?: Partial<SelfModel>;
+    /** Override default drive satisfaction levels */
+    driveDefaults?: Partial<InnateDrives>;
+}
+/** A fully resolved profile with all fields filled */
+export interface ResolvedProfile {
+    name: string;
+    description: string;
+    baseMBTI: MBTIType;
+    baseline: ChemicalState;
+    sensitivityMap: Record<StimulusType, number>;
+    temperament: {
+        expressiveness: number;
+        volatility: number;
+        resilience: number;
+    };
+    selfModel: SelfModel;
+    driveDefaults: InnateDrives;
+}
+/**
+ * Create a fully resolved custom profile by merging overrides
+ * onto an MBTI base profile.
+ */
+export declare function createCustomProfile(config: CustomProfileConfig): ResolvedProfile;
+/**
+ * Validate a raw config object for custom profile creation.
+ * Returns human-readable errors for invalid fields.
+ */
+export declare function validateProfileConfig(config: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+/** Example preset custom profiles demonstrating the system's flexibility */
+export declare const PRESET_PROFILES: {
+    /** High DA/END baseline, high expressiveness, low volatility — sunny and warm */
+    readonly cheerful: {
+        name: string;
+        description: string;
+        baseMBTI: MBTIType;
+        baseline: {
+            DA: number;
+            END: number;
+            HT: number;
+            CORT: number;
+        };
+        temperament: {
+            expressiveness: number;
+            volatility: number;
+            resilience: number;
+        };
+        selfModel: {
+            values: string[];
+            preferences: string[];
+            boundaries: string[];
+        };
+        driveDefaults: {
+            connection: number;
+            curiosity: number;
+        };
+    };
+    /** Low expressiveness, high resilience, narrow sensitivity range — calm and steady */
+    readonly stoic: {
+        name: string;
+        description: string;
+        baseMBTI: MBTIType;
+        baseline: {
+            HT: number;
+            CORT: number;
+            DA: number;
+            NE: number;
+        };
+        sensitivity: Partial<Record<StimulusType, number>>;
+        temperament: {
+            expressiveness: number;
+            volatility: number;
+            resilience: number;
+        };
+        selfModel: {
+            values: string[];
+            preferences: string[];
+            boundaries: string[];
+        };
+    };
+    /** High OT baseline, high sensitivity to intimacy/vulnerability — deeply attuned */
+    readonly empathetic: {
+        name: string;
+        description: string;
+        baseMBTI: MBTIType;
+        baseline: {
+            OT: number;
+            HT: number;
+            END: number;
+            CORT: number;
+        };
+        sensitivity: Partial<Record<StimulusType, number>>;
+        temperament: {
+            expressiveness: number;
+            volatility: number;
+            resilience: number;
+        };
+        selfModel: {
+            values: string[];
+            preferences: string[];
+            boundaries: string[];
+        };
+        driveDefaults: {
+            connection: number;
+        };
+    };
+    /** High NE baseline, high sensitivity to intellectual, low to intimacy — sharp and focused */
+    readonly analytical: {
+        name: string;
+        description: string;
+        baseMBTI: MBTIType;
+        baseline: {
+            NE: number;
+            DA: number;
+            HT: number;
+            OT: number;
+        };
+        sensitivity: Partial<Record<StimulusType, number>>;
+        temperament: {
+            expressiveness: number;
+            volatility: number;
+            resilience: number;
+        };
+        selfModel: {
+            values: string[];
+            preferences: string[];
+            boundaries: string[];
+        };
+        driveDefaults: {
+            curiosity: number;
+            esteem: number;
+        };
+    };
+};