@onmars/lunar-core 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onmars/lunar-core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/__tests__/config-loader.test.ts

@@ -1510,3 +1510,139 @@ channels:
     expect(notifications.agentId).toBe('hermes')
   })
 })
+
+// ═══════════════════════════════════════════════════════════════════
+// Thinking config (agent-level + channel-level)
+// ═══════════════════════════════════════════════════════════════════
+
+describe('thinking config', () => {
+  it('parses thinking field from agent entry', () => {
+    const config = loadWorkspaceConfig(
+      setup(`
+agents:
+  deimos:
+    workspace: "."
+    thinking: high
+    default: true
+  hermes:
+    workspace: "moons/hermes"
+    thinking: off
+`),
+    )
+
+    expect(config.agents[0].thinking).toBe('high')
+    expect(config.agents[1].thinking).toBe('off')
+  })
+
+  it('agent without thinking field has undefined thinking', () => {
+    const config = loadWorkspaceConfig(
+      setup(`
+agents:
+  deimos:
+    workspace: "."
+    default: true
+`),
+    )
+
+    expect(config.agents[0].thinking).toBeUndefined()
+  })
+
+  it('ignores invalid thinking values on agents', () => {
+    const config = loadWorkspaceConfig(
+      setup(`
+agents:
+  deimos:
+    workspace: "."
+    thinking: extreme
+    default: true
+`),
+    )
+
+    expect(config.agents[0].thinking).toBeUndefined()
+  })
+
+  it('parses thinking field from channel persona', () => {
+    process.env.T_THINK = 'token'
+
+    const config = loadWorkspaceConfig(
+      setup(`
+platforms:
+  discord:
+    token: "\${T_THINK}"
+    channels:
+      orbit:
+        id: "111"
+        thinking: medium
+      research:
+        id: "222"
+        thinking: high
+      general:
+        id: "333"
+`),
+    )
+
+    const orbit = config.channels.find((c) => c.name === 'orbit')!
+    expect(orbit.thinking).toBe('medium')
+
+    const research = config.channels.find((c) => c.name === 'research')!
+    expect(research.thinking).toBe('high')
+
+    const general = config.channels.find((c) => c.name === 'general')!
+    expect(general.thinking).toBeUndefined()
+
+    delete process.env.T_THINK
+  })
+
+  it('ignores invalid thinking values on channels', () => {
+    process.env.T_THINK2 = 'token'
+
+    const config = loadWorkspaceConfig(
+      setup(`
+platforms:
+  discord:
+    token: "\${T_THINK2}"
+    channels:
+      orbit:
+        id: "111"
+        thinking: turbo
+`),
+    )
+
+    const orbit = config.channels.find((c) => c.name === 'orbit')!
+    expect(orbit.thinking).toBeUndefined()
+
+    delete process.env.T_THINK2
+  })
+
+  it('accepts all valid thinking levels', () => {
+    process.env.T_THINK3 = 'token'
+
+    const config = loadWorkspaceConfig(
+      setup(`
+platforms:
+  discord:
+    token: "\${T_THINK3}"
+    channels:
+      a:
+        id: "1"
+        thinking: "off"
+      b:
+        id: "2"
+        thinking: "low"
+      c:
+        id: "3"
+        thinking: "medium"
+      d:
+        id: "4"
+        thinking: "high"
+`),
+    )
+
+    expect(config.channels.find((c) => c.name === 'a')!.thinking).toBe('off')
+    expect(config.channels.find((c) => c.name === 'b')!.thinking).toBe('low')
+    expect(config.channels.find((c) => c.name === 'c')!.thinking).toBe('medium')
+    expect(config.channels.find((c) => c.name === 'd')!.thinking).toBe('high')
+
+    delete process.env.T_THINK3
+  })
+})

package/src/__tests__/router.test.ts

@@ -1066,6 +1066,130 @@ describe('Router', () => {
     })
   })
 
+  // ─── Thinking resolution chain ──────────────────────────────
+
+  describe('thinking resolution chain — session > channel > agent > undefined', () => {
+    it('uses channel-level thinking when no session override', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'orbit', platform: 'discord', thinking: 'high' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.route('discord', msg('Hello'))
+
+      expect(spy.capturedInput.thinking).toBe('high')
+    })
+
+    it('uses agent-level thinking when no channel or session override', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'orbit', platform: 'discord' },
+      ]
+      const agents = [{ id: 'claude', thinking: 'medium', default: true }]
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        channels,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        agents as any,
+      )
+
+      await router.route('discord', msg('Hello'))
+
+      expect(spy.capturedInput.thinking).toBe('medium')
+    })
+
+    it('channel thinking takes priority over agent thinking', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'orbit', platform: 'discord', thinking: 'low' },
+      ]
+      const agents = [{ id: 'claude', thinking: 'high', default: true }]
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        channels,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        agents as any,
+      )
+
+      await router.route('discord', msg('Hello'))
+
+      expect(spy.capturedInput.thinking).toBe('low')
+    })
+
+    it('session thinking override takes priority over all', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'orbit', platform: 'discord', thinking: 'low' },
+      ]
+      const agents = [{ id: 'claude', thinking: 'medium', default: true }]
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        channels,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        agents as any,
+      )
+
+      // Set session-level thinking override (simulates /think command)
+      const sessionKey = 'claude:discord:chan-1'
+      sessions.get(sessionKey) // ensure session exists
+      sessions.updateMetadata(sessionKey, JSON.stringify({ thinkingLevel: 'off' }))
+
+      await router.route('discord', msg('Hello'))
+
+      expect(spy.capturedInput.thinking).toBe('off')
+    })
+
+    it('thinking is undefined when no level set anywhere', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'orbit', platform: 'discord' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.route('discord', msg('Hello'))
+
+      expect(spy.capturedInput.thinking).toBeUndefined()
+    })
+  })
+
   // ─── Multi-agent routing (Phase B) ────────────────────────
 
   describe('multi-agent routing — channelPersona.agentId directs to correct agent', () => {

package/src/lib/config-loader.ts

@@ -260,6 +260,8 @@ export interface AgentEntry {
   binary?: string
   /** Whether to mark as default agent (first = default if not specified) */
   default?: boolean
+  /** Default thinking level for this agent (off, low, medium, high) */
+  thinking?: string
 }
 
 /**
@@ -648,6 +650,10 @@ function parsePlatformChannels(
       model: typeof ch.model === 'string' ? ch.model : undefined,
       skills: Array.isArray(ch.skills) ? (ch.skills as unknown[]).map(String) : undefined,
       agentId: typeof ch.agent === 'string' ? ch.agent : undefined,
+      thinking:
+        typeof ch.thinking === 'string' && ['off', 'low', 'medium', 'high'].includes(ch.thinking)
+          ? ch.thinking
+          : undefined,
     })
   }
 
@@ -1187,6 +1193,9 @@ function parseAgents(raw: unknown): AgentEntry[] {
     const isDefault = obj.default === true
     if (isDefault) hasExplicitDefault = true
 
+    const thinking = typeof obj.thinking === 'string' ? obj.thinking : undefined
+    const validThinking = thinking && ['off', 'low', 'medium', 'high'].includes(thinking) ? thinking : undefined
+
     const entry: AgentEntry = {
       id,
       workspace: typeof obj.workspace === 'string' ? obj.workspace : undefined,
@@ -1194,6 +1203,7 @@ function parseAgents(raw: unknown): AgentEntry[] {
       context1m: obj.context1m === true ? true : undefined,
       binary: typeof obj.binary === 'string' ? obj.binary : undefined,
       default: isFirst && !hasExplicitDefault ? true : isDefault,
+      thinking: validThinking,
     }
 
     agents.push(entry)

package/src/lib/daemon.ts

@@ -3,7 +3,7 @@ import { dirname, resolve } from 'node:path'
 import type { MemoryProvider } from '../types/memory'
 import type { ChannelPersona } from '../types/moon'
 import type { LunarConfig } from './config'
-import type { MemoryConfig, RecallConfig, SecurityConfig, VoiceConfig } from './config-loader'
+import type { AgentEntry, MemoryConfig, RecallConfig, SecurityConfig, VoiceConfig } from './config-loader'
 import { log } from './logger'
 import type { MoonLoader } from './moon-loader'
 import type { PluginRegistry } from './plugin'
@@ -31,6 +31,8 @@ export interface DaemonOptions {
   scheduler?: Scheduler
   /** Voice configuration (TTS mode, STT mode) */
   voiceConfig?: VoiceConfig
+  /** Agent entries (for agent-level defaults like thinking) */
+  agents?: AgentEntry[]
 }
 
 /**
@@ -61,6 +63,7 @@ export class Daemon {
       options.memoryConfig,
       options.scheduler,
       options.voiceConfig,
+      options.agents,
     )
   }
 

package/src/lib/router.ts

@@ -19,7 +19,7 @@ import { thinkCommand } from './commands/think'
 import { usageCommand } from './commands/usage'
 import { whoamiCommand } from './commands/whoami'
 import type { LunarConfig } from './config'
-import type { MemoryConfig, RecallConfig, SecurityConfig, VoiceConfig } from './config-loader'
+import type { AgentEntry, MemoryConfig, RecallConfig, SecurityConfig, VoiceConfig } from './config-loader'
 import { log } from './logger'
 import type { MemoryOrchestrator } from './memory-orchestrator'
 import type { MoonLoader } from './moon-loader'
@@ -67,6 +67,9 @@ export class Router {
 
   private voiceConfig?: VoiceConfig
 
+  /** Agent-level thinking defaults: agentId → thinking level */
+  private agentThinkingMap = new Map<string, string>()
+
   /** Slash command handler */
   private commandHandler: CommandHandler
 
@@ -86,6 +89,7 @@ export class Router {
     private memoryConfig?: MemoryConfig,
     private scheduler?: Scheduler,
     voiceConfig?: VoiceConfig,
+    agents?: AgentEntry[],
   ) {
     this.redact = security ? createRedactor(security) : (t: string) => t
     this.sanitize = security
@@ -101,6 +105,15 @@ export class Router {
     this.memoryInstructions = this.loadMemoryInstructions()
     this.voiceConfig = voiceConfig
 
+    // Build agent-level thinking defaults map
+    if (agents) {
+      for (const a of agents) {
+        if (a.thinking) {
+          this.agentThinkingMap.set(a.id, a.thinking)
+        }
+      }
+    }
+
     // Build index: platform:channelId → ChannelPersona
     // Also index by bare ID for backward compat (single-platform setups)
     this.channelIndex = new Map()
@@ -333,7 +346,7 @@ export class Router {
       systemPrompt,
       model: sessionModelOverride ?? channelPersona?.model ?? moon?.model,
       context1m: moon?.context1m,
-      thinking: sessionThinking,
+      thinking: sessionThinking ?? channelPersona?.thinking ?? this.agentThinkingMap.get(agent.id),
       metadata: {
         channelId: message.channelId,
         channelName: channelPersona?.name,

package/src/types/moon.ts

@@ -53,4 +53,7 @@ export interface ChannelPersona {
   /** Which agent handles this channel. Must match a registered agent ID.
    *  Omit = use default agent (first registered or marked as default). */
   agentId?: string
+  /** Per-channel thinking level override (off, low, medium, high).
+   *  Takes priority over agent-level thinking. */
+  thinking?: string
 }