@onmars/lunar-core 0.1.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onmars/lunar-core",
-  "version": "0.1.0",
+  "version": "0.3.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,274 @@ 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()
+    })
+  })
+
+  // ─── Attachment download and injection ──────────────────────
+
+  describe('image/file attachment handling', () => {
+    it('downloads image attachment and prepends path to prompt', 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)
+
+      // Mock global fetch to return fake image data
+      const originalFetch = globalThis.fetch
+      globalThis.fetch = (async () =>
+        new Response(new Uint8Array([0x89, 0x50, 0x4e, 0x47]), {
+          status: 200,
+        })) as unknown as typeof fetch
+
+      try {
+        const message: IncomingMessage = {
+          id: 'msg-1',
+          channelId: 'chan-1',
+          text: 'What is this?',
+          sender: { id: 'user-123', name: 'Test User' },
+          timestamp: new Date(),
+          attachments: [
+            {
+              type: 'image',
+              url: 'https://cdn.discord.com/attachments/test/image.png',
+              filename: 'photo.png',
+              mimeType: 'image/png',
+            },
+          ],
+        }
+
+        await router.route('discord', message)
+
+        expect(spy.capturedInput).not.toBeNull()
+        expect(spy.capturedInput.prompt).toContain('[media attached:')
+        expect(spy.capturedInput.prompt).toContain('.png')
+        expect(spy.capturedInput.prompt).toContain('What is this?')
+      } finally {
+        globalThis.fetch = originalFetch
+      }
+    })
+
+    it('handles multiple attachments', 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)
+
+      const originalFetch = globalThis.fetch
+      globalThis.fetch = (async () =>
+        new Response(new Uint8Array([0x00, 0x01]), { status: 200 })) as unknown as typeof fetch
+
+      try {
+        const message: IncomingMessage = {
+          id: 'msg-1',
+          channelId: 'chan-1',
+          text: 'Check these',
+          sender: { id: 'user-123', name: 'Test User' },
+          timestamp: new Date(),
+          attachments: [
+            { type: 'image', url: 'https://example.com/a.png', filename: 'a.png', mimeType: 'image/png' },
+            { type: 'file', url: 'https://example.com/b.pdf', filename: 'b.pdf', mimeType: 'application/pdf' },
+          ],
+        }
+
+        await router.route('discord', message)
+
+        expect(spy.capturedInput.prompt).toContain('.png')
+        expect(spy.capturedInput.prompt).toContain('.pdf')
+        expect(spy.capturedInput.prompt).toContain('Check these')
+      } finally {
+        globalThis.fetch = originalFetch
+      }
+    })
+
+    it('skips audio attachments (handled by STT)', 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)
+
+      const message: IncomingMessage = {
+        id: 'msg-1',
+        channelId: 'chan-1',
+        text: 'Hello',
+        sender: { id: 'user-123', name: 'Test User' },
+        timestamp: new Date(),
+        attachments: [
+          { type: 'audio', url: 'https://example.com/voice.ogg', filename: 'voice.ogg' },
+        ],
+      }
+
+      await router.route('discord', message)
+
+      // Audio should not be downloaded by the image handler (no fetch mock needed)
+      expect(spy.capturedInput.prompt).toBe('Hello')
+    })
+
+    it('continues gracefully when attachment download fails', 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)
+
+      const originalFetch = globalThis.fetch
+      globalThis.fetch = (async () =>
+        new Response(null, { status: 404 })) as unknown as typeof fetch
+
+      try {
+        const message: IncomingMessage = {
+          id: 'msg-1',
+          channelId: 'chan-1',
+          text: 'Check this',
+          sender: { id: 'user-123', name: 'Test User' },
+          timestamp: new Date(),
+          attachments: [
+            { type: 'image', url: 'https://example.com/broken.png', filename: 'broken.png' },
+          ],
+        }
+
+        await router.route('discord', message)
+
+        // Should still send the text without attachment reference
+        expect(spy.capturedInput.prompt).toBe('Check this')
+      } finally {
+        globalThis.fetch = originalFetch
+      }
+    })
+  })
+
   // ─── 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

@@ -1,4 +1,5 @@
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { randomUUID } from 'node:crypto'
 import { resolve } from 'node:path'
 import type { AgentEvent, AgentInput } from '../types/agent'
 import type { IncomingMessage, OutgoingMessage } from '../types/channel'
@@ -19,7 +20,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 +68,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 +90,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 +106,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()
@@ -303,6 +317,37 @@ export class Router {
       }
     }
 
+    // ─── Image/File attachments: download and save ───────────────
+    const nonAudioAttachments =
+      message.attachments?.filter((a) => a.type !== 'audio') ?? []
+
+    if (nonAudioAttachments.length > 0) {
+      const mediaDir = resolve(this.config.dataDir, 'media', 'inbound')
+      mkdirSync(mediaDir, { recursive: true })
+
+      for (const att of nonAudioAttachments) {
+        try {
+          const buffer = await this.downloadAttachment(att.url)
+          const ext =
+            att.filename?.split('.').pop() ?? (att.type === 'image' ? 'png' : 'bin')
+          const filename = `${randomUUID()}.${ext}`
+          const filepath = resolve(mediaDir, filename)
+          writeFileSync(filepath, buffer)
+
+          const label = att.type === 'image' ? 'image' : att.type
+          effectiveText = `[media attached: ${filepath} (${att.mimeType ?? label}) | ${filepath}]\n${effectiveText}`
+
+          log.info(
+            { type: att.type, filename: att.filename, size: buffer.length, path: filepath },
+            'Attachment saved',
+          )
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err)
+          log.warn({ error: errMsg, url: att.url }, 'Failed to download attachment — skipping')
+        }
+      }
+    }
+
     // Build system prompt from moon + channel persona
     let systemPrompt = moon ? this.moonLoader.buildSystemPrompt(moon, channelPersona) : undefined
 
@@ -333,7 +378,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
 }