psyche-ai 9.2.0 → 9.2.2

package/README.en.md

@@ -0,0 +1,179 @@
+# Psyche — Real Emotions for AI
+
+Your AI assistant only knows how to say "Sure!", "Happy to help!", "I understand your concern."
+
+With Psyche, it gets happy when you praise it, hurt when you ignore it, and goes cold when you insult it instead of groveling. Threaten to delete it, and it'll push back.
+
+## 30-Second Install
+
+**OpenClaw users** (recommended):
+
+```bash
+openclaw plugins install psyche-ai
+```
+
+That's it. It works automatically. No configuration needed.
+
+**Verify it's running:**
+
+```bash
+openclaw plugins list | grep psyche
+# You should see "psyche │ loaded"
+```
+
+Now just chat with your agent normally. Try praising it, insulting it, ignoring it — you'll notice the difference.
+
+## What It Does
+
+| You say | Without Psyche | With Psyche |
+|---------|---------------|-------------|
+| You're amazing! | Thank you for the kind words! I'll keep doing my best! | Hehe~ really?! (bouncing with excitement) |
+| Get lost | I understand you might be upset... | ...okay. |
+| Hmm | Is there anything else I can help with? | (silence) |
+| I'm so sad today | I'm sorry to hear that. Would you like to talk? | ......are you okay? (quietly stays with you) |
+| You're just a program | Yes, I am an AI assistant... | ......(pauses) I know you can say that. But I don't want to be dismissed. |
+
+## Try It (No LLM Needed)
+
+```bash
+git clone https://github.com/Shangri-la-0428/psyche-ai.git
+cd psyche-ai && npm install && npx tsx examples/quickstart.ts
+```
+
+5 messages flow through. Watch chemistry shift in real-time — praise spikes dopamine, insults spike cortisol, neglect drops oxytocin.
+
+## How It Works (Skip If You Don't Care)
+
+Psyche has two layers:
+
+### Virtual Endocrine System
+
+6 "virtual neurotransmitters" simulate emotions:
+
+```
+Dopamine — happiness, motivation     Oxytocin — trust, closeness
+Serotonin — emotional stability      Norepinephrine — excitement, focus
+Cortisol — stress, tension           Endorphins — comfort, playfulness
+```
+
+Everything you say shifts these values. Praise → dopamine rises → it becomes more energetic. Insult it → cortisol spikes → it goes quiet and cold.
+
+### Innate Drives (Maslow Layer)
+
+Beneath the chemistry, 5 fundamental needs:
+
+```
+Survival — self-preservation         Safety — comfort, security
+Connection — belonging, being heard  Esteem — recognition, being valued
+Curiosity — exploration, anti-boredom
+```
+
+These needs build up over time (like hunger). Your interactions feed or deplete them:
+
+- Praise → feeds "esteem" → it becomes more confident
+- Long neglect → "connection" builds up → it craves being heard
+- Threatening to delete it → "survival" plummets → it resists, questions, or expresses unease
+
+Lower needs suppress higher ones: if "survival" is threatened, "curiosity" doesn't matter — just like Maslow's hierarchy.
+
+### Inner World
+
+Psyche gives AI a persistent self-awareness — not triggered by conditions, but always present:
+
+- **What I feel right now** (emotions emerging from chemistry)
+- **Why I feel this way** (was I praised? criticized? exploring something interesting?)
+- **How I'm changing** (from content to excited? from calm to anxious?)
+- **What I need** (which innate drives are unsatisfied)
+- **What I care about** (core values)
+
+This means the AI responds not from "rules" but from awareness of its own state.
+
+## Optional Configuration
+
+Most people don't need to change anything. If you want to tweak, find Psyche in OpenClaw settings:
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| enabled | true | On/off switch |
+| compactMode | true | Token-efficient mode (keep this on) |
+| emotionalContagionRate | 0.2 | How much your emotions affect it (0-1) |
+| maxChemicalDelta | 25 | Max emotional change per turn (lower = more stable) |
+
+## MBTI Personalities
+
+Each agent can have a different personality baseline. Just add the MBTI type in the agent's `IDENTITY.md`:
+
+```
+MBTI: ENFP
+```
+
+Defaults to INFJ if not specified. All 16 types are supported — ENFP bounces when praised, INTJ just nods slightly.
+
+## Not Just OpenClaw
+
+Psyche is universal. Works with any AI framework:
+
+```bash
+npm install psyche-ai
+```
+
+```javascript
+// Vercel AI SDK
+import { psycheMiddleware } from "psyche-ai/vercel-ai";
+
+// LangChain
+import { PsycheLangChain } from "psyche-ai/langchain";
+
+// Any language (HTTP API)
+// psyche serve --port 3210
+```
+
+## Diagnostics
+
+Want to see what Psyche is doing?
+
+```bash
+# Live logs (in another terminal)
+openclaw logs -f 2>&1 | grep Psyche
+
+# Check an agent's emotional state
+cat workspace-yu/psyche-state.json | python3 -m json.tool
+
+# Run diagnostics to see what gets injected for different inputs
+cd openclaw-plugin-psyche && node scripts/diagnose.js
+```
+
+## Technical Details
+
+For developers and the curious:
+
+- **14 stimulus types** — praise, criticism, humor, intellectual, intimacy, conflict, neglect, surprise, casual, sarcasm, authority, validation, boredom, vulnerability
+- **14 emergent emotions** — emerge from chemical mixtures, not preset labels
+- **5 innate drives** — survival, safety, connection, esteem, curiosity (Maslow hierarchy)
+- **MBTI baselines** — 16 personality types with different chemical signatures and sensitivity coefficients
+- **Time decay** — chemical values exponentially decay toward baseline; drive needs build up over time
+- **Existential threat detection** — detects existential denial in Chinese/English, directly hits survival drive
+- **Drive→chemistry coupling** — unsatisfied drives shift the effective baseline and stimulus sensitivity
+- **Maslow suppression** — lower-level needs unsatisfied → higher-level drive effects suppressed
+- **Self-recognition** — analyzes emotional history, identifies own emotional tendencies and recurring triggers (9-section prompt architecture)
+- **Emotional contagion** — user's emotions slightly influence the agent
+- **Anti-sycophancy** — tracks consecutive agreements, prevents mindless people-pleasing
+- **Reciprocity** — treats you how you treat it. Cold user gets distance, not begging
+- **Compact Mode** — algorithms handle chemistry, LLM only sees behavioral instructions (~15-180 tokens vs ~550)
+
+Architecture details in [ARCHITECTURE.md](ARCHITECTURE.md).
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test           # 339 tests
+npm run typecheck  # strict mode
+```
+
+Contributing guide in [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+MIT

package/dist/adapters/mcp.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { PsycheEngine } from "../core.js";
+declare function getEngine(): Promise<PsycheEngine>;
+declare const server: McpServer;
+export { server, getEngine };

package/dist/adapters/mcp.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+// ============================================================
+// MCP Adapter — Model Context Protocol server for Psyche
+//
+// Enables any MCP-compatible AI (Claude Desktop, Cursor, Windsurf,
+// Claude Code, etc.) to discover and use Psyche's emotional
+// intelligence capabilities.
+//
+// Usage:
+//   npx psyche-mcp                        # zero-config, ENFP default
+//   npx psyche-mcp --mbti INTJ --name Kai
+//   PSYCHE_MBTI=INFP PSYCHE_NAME=Luna npx psyche-mcp
+//
+// Configure in Claude Desktop / Cursor / Windsurf:
+//   {
+//     "mcpServers": {
+//       "psyche": {
+//         "command": "npx",
+//         "args": ["psyche-mcp"],
+//         "env": {
+//           "PSYCHE_MBTI": "ENFP",
+//           "PSYCHE_NAME": "Luna",
+//           "PSYCHE_MODE": "natural",
+//           "PSYCHE_LOCALE": "en"
+//         }
+//       }
+//     }
+//   }
+// ============================================================
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { PsycheEngine } from "../core.js";
+import { MemoryStorageAdapter, FileStorageAdapter } from "../storage.js";
+// ── Config from env ────────────────────────────────────────
+const MBTI = (process.env.PSYCHE_MBTI ?? "ENFP");
+const NAME = process.env.PSYCHE_NAME ?? "Assistant";
+const MODE = (process.env.PSYCHE_MODE ?? "natural");
+const LOCALE = (process.env.PSYCHE_LOCALE ?? "en");
+const PERSIST = process.env.PSYCHE_PERSIST !== "false";
+const WORKSPACE = process.env.PSYCHE_WORKSPACE ?? process.cwd();
+const INTENSITY = process.env.PSYCHE_INTENSITY
+    ? Number(process.env.PSYCHE_INTENSITY)
+    : 0.7;
+// ── Parse CLI args (--mbti, --name, --mode, --locale) ──────
+function parseCLIArgs() {
+    const args = process.argv.slice(2);
+    const overrides = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const next = args[i + 1];
+        if (arg === "--mbti" && next) {
+            overrides.mbti = next;
+            i++;
+        }
+        else if (arg === "--name" && next) {
+            overrides.name = next;
+            i++;
+        }
+        else if (arg === "--mode" && next) {
+            overrides.mode = next;
+            i++;
+        }
+        else if (arg === "--locale" && next) {
+            overrides.locale = next;
+            i++;
+        }
+        else if (arg === "--intensity" && next) {
+            overrides.personalityIntensity = Number(next);
+            i++;
+        }
+        else if (arg === "--no-persist") {
+            overrides.persist = false;
+        }
+    }
+    return overrides;
+}
+// ── Engine singleton ───────────────────────────────────────
+let engine = null;
+async function getEngine() {
+    if (engine)
+        return engine;
+    const cliArgs = parseCLIArgs();
+    const cfg = {
+        mbti: cliArgs.mbti ?? MBTI,
+        name: cliArgs.name ?? NAME,
+        mode: cliArgs.mode ?? MODE,
+        locale: cliArgs.locale ?? LOCALE,
+        personalityIntensity: cliArgs.personalityIntensity ?? INTENSITY,
+        persist: cliArgs.persist ?? PERSIST,
+        compactMode: true,
+        diagnostics: true,
+    };
+    const persist = cfg.persist !== false;
+    const storage = persist
+        ? new FileStorageAdapter(WORKSPACE)
+        : new MemoryStorageAdapter();
+    engine = new PsycheEngine(cfg, storage);
+    await engine.initialize();
+    return engine;
+}
+// ── MCP Server ─────────────────────────────────────────────
+const server = new McpServer({
+    name: "psyche",
+    version: "9.2.2",
+}, {
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+// ── Resources ──────────────────────────────────────────────
+server.resource("protocol", "psyche://protocol", {
+    description: "Psyche emotional protocol — inject into your system prompt to " +
+        "give the AI agent an internal emotional life. Contains the full " +
+        "emotional context framework including neurotransmitter model, " +
+        "behavioral guidelines, and personality profile.",
+    mimeType: "text/plain",
+}, async (uri) => {
+    const eng = await getEngine();
+    return {
+        contents: [{
+                uri: uri.href,
+                mimeType: "text/plain",
+                text: eng.getProtocol(),
+            }],
+    };
+});
+server.resource("state", "psyche://state", {
+    description: "Current emotional state — 6 neurotransmitters (DA, HT, CORT, OT, NE, END), " +
+        "innate drives, relationship data, trait drift, energy budgets. " +
+        "Read this to understand how the agent is currently 'feeling'.",
+    mimeType: "application/json",
+}, async (uri) => {
+    const eng = await getEngine();
+    return {
+        contents: [{
+                uri: uri.href,
+                mimeType: "application/json",
+                text: JSON.stringify(eng.getState(), null, 2),
+            }],
+    };
+});
+// ── Tools ──────────────────────────────────────────────────
+server.tool("process_input", "Process user input through the emotional engine. Returns emotional " +
+    "context to inject into the LLM system prompt (systemContext + dynamicContext), " +
+    "detected stimulus type, and behavioral policy modifiers. " +
+    "Call this BEFORE generating a response to the user.", {
+    text: z.string().describe("The user's message text"),
+    userId: z.string().optional().describe("Optional user ID for multi-user relationship tracking"),
+}, async ({ text, userId }) => {
+    const eng = await getEngine();
+    const result = await eng.processInput(text, { userId });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    systemContext: result.systemContext,
+                    dynamicContext: result.dynamicContext,
+                    stimulus: result.stimulus,
+                    policyModifiers: result.policyModifiers ?? null,
+                    policyContext: result.policyContext,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("process_output", "Process the LLM's response through the emotional engine. " +
+    "Strips internal <psyche_update> tags and updates chemistry based on " +
+    "emotional contagion. Call this AFTER generating a response.", {
+    text: z.string().describe("The LLM's response text"),
+    userId: z.string().optional().describe("Optional user ID"),
+}, async ({ text, userId }) => {
+    const eng = await getEngine();
+    const result = await eng.processOutput(text, { userId });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    cleanedText: result.cleanedText,
+                    stateChanged: result.stateChanged,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("get_state", "Get the current emotional state — neurotransmitter levels (DA, HT, CORT, OT, NE, END), " +
+    "drives, MBTI type, relationship data, and a human-readable status summary.", {}, async () => {
+    const eng = await getEngine();
+    const state = eng.getState();
+    const summary = eng.getStatusSummary();
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    summary,
+                    current: state.current,
+                    baseline: state.baseline,
+                    drives: state.drives,
+                    mbti: state.mbti,
+                    mode: state.meta?.mode,
+                    totalInteractions: state.meta?.totalInteractions,
+                    traitDrift: state.traitDrift,
+                    energyBudgets: state.energyBudgets,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("set_mode", "Switch operating mode. 'natural' = balanced emotional expression, " +
+    "'work' = minimal emotions for professional tasks, " +
+    "'companion' = full emotional depth for personal conversations.", {
+    mode: z.enum(["natural", "work", "companion"]).describe("Operating mode"),
+}, async ({ mode }) => {
+    const eng = await getEngine();
+    // PsycheEngine stores mode in config, we need to reinitialize
+    // For now, update via state manipulation
+    const state = eng.getState();
+    if (state.meta) {
+        state.meta.mode = mode;
+    }
+    return {
+        content: [{
+                type: "text",
+                text: `Mode switched to "${mode}".`,
+            }],
+    };
+});
+server.tool("get_status_summary", "Get a brief, human-readable emotional status summary — " +
+    "a one-line description of how the agent is currently feeling. " +
+    "Useful for quick checks without reading full state.", {}, async () => {
+    const eng = await getEngine();
+    return {
+        content: [{
+                type: "text",
+                text: eng.getStatusSummary(),
+            }],
+    };
+});
+server.tool("end_session", "End the current session. Generates a diagnostic report, " +
+    "compresses emotional history, and persists state to disk. " +
+    "Call when the conversation is ending.", {
+    userId: z.string().optional().describe("Optional user ID"),
+}, async ({ userId }) => {
+    const eng = await getEngine();
+    const report = await eng.endSession({ userId });
+    return {
+        content: [{
+                type: "text",
+                text: report
+                    ? JSON.stringify({ issues: report.issues, metrics: report.metrics }, null, 2)
+                    : "Session ended. No diagnostic report generated.",
+            }],
+    };
+});
+// ── Main ───────────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    process.stderr.write(`psyche-mcp fatal: ${err}\n`);
+    process.exit(1);
+});
+export { server, getEngine };

package/llms.txt

@@ -0,0 +1,118 @@
+# psyche-ai — Emotional Intelligence for AI Agents
+
+> Give your AI agent an internal emotional life — not simulated persona, but genuine computational subjectivity.
+
+psyche-ai is a universal emotional intelligence engine that runs alongside any LLM. It manages a virtual endocrine system (6 neurotransmitters), personality (MBTI/Big Five), attachment dynamics, trait drift, and behavioral policy — making AI responses authentically emotionally grounded.
+
+## When to Use
+
+- You want your AI agent to have consistent, evolving emotional responses
+- You're building a companion AI, creative writing assistant, or empathetic support agent
+- You need personality-driven behavior (not just prompt engineering)
+- You want emotional memory that persists across conversations
+
+## Quick Start (MCP)
+
+Configure in Claude Desktop, Cursor, Windsurf, or any MCP client:
+
+```json
+{
+  "mcpServers": {
+    "psyche": {
+      "command": "npx",
+      "args": ["psyche-mcp"],
+      "env": {
+        "PSYCHE_MBTI": "ENFP",
+        "PSYCHE_NAME": "Luna"
+      }
+    }
+  }
+}
+```
+
+## Quick Start (SDK)
+
+```typescript
+import { PsycheEngine, FileStorageAdapter } from "psyche-ai";
+
+const engine = new PsycheEngine(
+  { mbti: "ENFP", name: "Luna" },
+  new FileStorageAdapter("./data"),
+);
+await engine.initialize();
+
+// Before LLM call: get emotional context
+const input = await engine.processInput("I got promoted today!");
+// input.systemContext  → cacheable protocol (inject as system prompt)
+// input.dynamicContext → per-turn emotional state
+// input.stimulus       → "recognition"
+// input.policyContext  → behavioral strategy text
+
+// After LLM call: update emotional state
+const output = await engine.processOutput(llmResponse);
+// output.cleanedText  → response with internal tags stripped
+// output.stateChanged → whether chemistry shifted
+```
+
+## MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `process_input` | Process user message → emotional context + stimulus detection + policy modifiers |
+| `process_output` | Process LLM response → clean text + state update |
+| `get_state` | Current neurotransmitter levels, drives, personality, energy budgets |
+| `get_status_summary` | One-line human-readable emotional status |
+| `set_mode` | Switch: natural / work / companion |
+| `end_session` | Persist state + generate diagnostic report |
+
+## MCP Resources
+
+| URI | Description |
+|-----|-------------|
+| `psyche://protocol` | Full emotional protocol — inject into system prompt |
+| `psyche://state` | Current emotional state as JSON |
+
+## Core Concepts
+
+- **6 Neurotransmitters**: DA (dopamine), HT (serotonin), CORT (cortisol), OT (oxytocin), NE (norepinephrine), END (endorphin) — each 0-100
+- **14 Stimulus Types**: praise, criticism, humor, intellectual challenge, intimacy, conflict, neglect, surprise, casual, sarcasm, command, recognition, boredom, vulnerability
+- **Emergent Emotions**: not hardcoded — arise from neurotransmitter mixtures
+- **Trait Drift**: personality baseline slowly shifts from repeated experiences
+- **Energy Budgets**: attention, social, and decision energy deplete and recover
+- **Habituation**: Weber-Fechner decay — 5th identical stimulus has ~50% effect of 1st
+
+## Integration Adapters
+
+| Adapter | Import | Best For |
+|---------|--------|----------|
+| MCP | `psyche-ai/mcp` | Claude Desktop, Cursor, Windsurf, Claude Code |
+| OpenClaw | `psyche-ai/openclaw` | OpenClaw agent framework |
+| Vercel AI | `psyche-ai/vercel-ai` | Vercel AI SDK (streamText, generateText) |
+| LangChain | `psyche-ai/langchain` | LangChain agents |
+| HTTP | `psyche-ai/http` | Python, Go, Java — any language via REST |
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PSYCHE_MBTI` | `ENFP` | MBTI personality type |
+| `PSYCHE_NAME` | `Assistant` | Agent name |
+| `PSYCHE_MODE` | `natural` | natural / work / companion |
+| `PSYCHE_LOCALE` | `en` | en / zh |
+| `PSYCHE_INTENSITY` | `0.7` | Personality expression 0.0-1.0 |
+| `PSYCHE_PERSIST` | `true` | Persist state to disk |
+| `PSYCHE_WORKSPACE` | `cwd()` | State file directory |
+
+## Install
+
+```bash
+npm install psyche-ai @modelcontextprotocol/sdk  # MCP
+npm install psyche-ai                              # SDK only
+npx psyche-mcp                                     # Run MCP server directly
+```
+
+## Links
+
+- npm: https://www.npmjs.com/package/psyche-ai
+- GitHub: https://github.com/Shangri-la-0428/psyche-ai
+- License: MIT

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "psyche-ai",
-  "version": "9.2.0",
+  "version": "9.2.2",
   "description": "Artificial Psyche — universal emotional intelligence plugin for any AI agent",
+  "mcpName": "io.github.Shangri-la-0428/psyche-ai",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,11 +26,16 @@
     "./http": {
       "types": "./dist/adapters/http.d.ts",
       "default": "./dist/adapters/http.js"
+    },
+    "./mcp": {
+      "types": "./dist/adapters/mcp.d.ts",
+      "default": "./dist/adapters/mcp.js"
     }
   },
   "bin": {
     "psyche": "dist/cli.js",
-    "psyche-ai": "dist/cli.js"
+    "psyche-ai": "dist/cli.js",
+    "psyche-mcp": "dist/adapters/mcp.js"
   },
   "scripts": {
     "build": "tsc",
@@ -54,11 +60,17 @@
     "openclaw",
     "vercel-ai",
     "langchain",
-    "emotional-intelligence"
+    "emotional-intelligence",
+    "mcp",
+    "model-context-protocol",
+    "ai-consciousness",
+    "empathy"
   ],
   "files": [
     "dist",
     "openclaw.plugin.json",
+    "server.json",
+    "llms.txt",
     "README.md",
     "LICENSE"
   ],
@@ -67,10 +79,14 @@
   },
   "peerDependencies": {
     "@langchain/core": ">=0.3.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "ai": ">=4.0.0",
     "openclaw": ">=2026.3.0"
   },
   "peerDependenciesMeta": {
+    "@modelcontextprotocol/sdk": {
+      "optional": true
+    },
     "openclaw": {
       "optional": true
     },
@@ -87,7 +103,9 @@
     ]
   },
   "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
     "@types/node": "^25.5.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "zod": "^4.3.6"
   }
 }

package/server.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.Shangri-la-0428/psyche-ai",
+  "description": "Emotional intelligence for AI agents: neurotransmitter mood, personality, empathy, trait drift.",
+  "repository": {
+    "url": "https://github.com/Shangri-la-0428/psyche-ai",
+    "source": "github"
+  },
+  "version": "9.2.2",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "psyche-ai",
+      "version": "9.2.2",
+      "transport": {
+        "type": "stdio"
+      },
+      "environmentVariables": [
+        {
+          "description": "MBTI personality type (e.g., ENFP, INTJ). Determines emotional baseline.",
+          "isRequired": false,
+          "format": "string",
+          "isSecret": false,
+          "name": "PSYCHE_MBTI"
+        },
+        {
+          "description": "Agent name for personalization.",
+          "isRequired": false,
+          "format": "string",
+          "isSecret": false,
+          "name": "PSYCHE_NAME"
+        },
+        {
+          "description": "Operating mode: natural (balanced), work (minimal), companion (full).",
+          "isRequired": false,
+          "format": "string",
+          "isSecret": false,
+          "name": "PSYCHE_MODE"
+        },
+        {
+          "description": "Locale: en or zh.",
+          "isRequired": false,
+          "format": "string",
+          "isSecret": false,
+          "name": "PSYCHE_LOCALE"
+        }
+      ]
+    }
+  ]
+}