mio-agent-runtime 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",

package/server/llm-client.js

@@ -6,27 +6,111 @@
 // mio-intelligence-mcp/index.js so both entry points call the same model with
 // the same configuration, and so "is an LLM configured?" has one answer.
 //
-// Configuration is entirely environment-based:
-//   LLM_API_URL       OpenAI-compatible endpoint (default: opencode zen)
-//   LLM_KEY           bearer token; empty means unauthenticated (common for a
-//                     local Ollama / llama.cpp server)
-//   LLM_CHAT_MODEL    model id, falls back to LLM_MODEL
+// Configuration resolution order (highest first):
+//   1. Environment variables
+//        LLM_API_URL       OpenAI-compatible endpoint (default: opencode zen)
+//        LLM_KEY           bearer token; empty means unauthenticated (common for
+//                          a local Ollama / llama.cpp server)
+//        LLM_CHAT_MODEL    model id, falls back to LLM_MODEL
+//   2. config.json under MIO_HOME (written by `mio config llm`) — the `llm`
+//      object's apiUrl / apiKey / model keys
+//   3. Built-in defaults
+//
+// Environment wins so a shell-level override can always beat a stored config
+// without editing files. The config file is read lazily and cached, so a long
+// running MCP process does not re-stat it on every call.
+
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
 
 const DEFAULT_API_URL = 'https://opencode.ai/zen/go/v1/chat/completions'
 const DEFAULT_MODEL = 'deepseek-v4-flash'
 
+// Resolve the directory holding config.json. The CLI and the MCP server use
+// different data dirs by design (MIO_HOME vs MIO_DATA_DIR||cwd/.mio-intelligence),
+// so we honour whichever is set and fall back to the CLI default. No third
+// convention is introduced here on purpose.
+function homeDir() {
+  return (
+    process.env.MIO_HOME ||
+    process.env.MIO_DATA_DIR ||
+    path.join(os.homedir(), '.mio-intelligence')
+  )
+}
+
+let cachedFileConfig
+let cachedFor = null
+
+// Read the `llm` block from config.json. Any failure (missing file, bad JSON,
+// wrong shape) degrades to {} — configuration must never crash a caller.
+function fileConfig() {
+  const target = homeDir()
+  if (cachedFor === target) return cachedFileConfig
+  cachedFor = target
+  cachedFileConfig = {}
+  try {
+    const raw = fs.readFileSync(path.join(target, 'config.json'), 'utf8')
+    const parsed = JSON.parse(raw)
+    const llm = parsed && typeof parsed.llm === 'object' && parsed.llm !== null ? parsed.llm : {}
+    const pick = (v) => (typeof v === 'string' && v.trim() !== '' ? v.trim() : undefined)
+    cachedFileConfig = {
+      apiUrl: pick(llm.apiUrl),
+      apiKey: pick(llm.apiKey),
+      model: pick(llm.model),
+    }
+  } catch (_) {
+    cachedFileConfig = {}
+  }
+  return cachedFileConfig
+}
+
+// Exposed so writers (`mio config llm`) can drop the cache after editing the
+// file, and so tests can reset between cases.
+function resetLlmConfigCache() {
+  cachedFor = null
+  cachedFileConfig = {}
+}
+
 function llmConfig() {
+  const file = fileConfig()
   return {
-    apiUrl: process.env.LLM_API_URL || DEFAULT_API_URL,
-    apiKey: process.env.LLM_KEY || '',
-    model: process.env.LLM_CHAT_MODEL || process.env.LLM_MODEL || DEFAULT_MODEL,
+    apiUrl: process.env.LLM_API_URL || file.apiUrl || DEFAULT_API_URL,
+    apiKey: process.env.LLM_KEY || file.apiKey || '',
+    model: process.env.LLM_CHAT_MODEL || process.env.LLM_MODEL || file.model || DEFAULT_MODEL,
   }
 }
 
 // True when the user has pointed us somewhere other than the default hosted
 // endpoint, or supplied a key. Used to warn (not block) before spending a call.
+// "Configured" counts either source: an env var or a stored config.json entry.
 function isLlmConfigured() {
-  return Boolean(process.env.LLM_API_URL || process.env.LLM_KEY)
+  const file = fileConfig()
+  return Boolean(
+    process.env.LLM_API_URL ||
+      process.env.LLM_KEY ||
+      file.apiUrl ||
+      file.apiKey ||
+      file.model
+  )
+}
+
+// Which source each field came from, for `mio config show` to display honestly.
+// Reporting a value without its origin is how users end up editing config.json
+// and wondering why nothing changed (an env var was shadowing them).
+function llmConfigSources() {
+  const file = fileConfig()
+  return {
+    apiUrl: process.env.LLM_API_URL ? 'env' : file.apiUrl ? 'config' : 'default',
+    apiKey: process.env.LLM_KEY ? 'env' : file.apiKey ? 'config' : 'unset',
+    model: process.env.LLM_CHAT_MODEL
+      ? 'env'
+      : process.env.LLM_MODEL
+        ? 'env'
+        : file.model
+          ? 'config'
+          : 'default',
+  }
 }
 
 async function chatJson(userText, opts = {}) {
@@ -66,4 +150,12 @@ async function chatJson(userText, opts = {}) {
   }
 }
 
-module.exports = { chatJson, llmConfig, isLlmConfigured }
+module.exports = {
+  chatJson,
+  llmConfig,
+  isLlmConfigured,
+  llmConfigSources,
+  resetLlmConfigCache,
+  DEFAULT_API_URL,
+  DEFAULT_MODEL,
+}

package/server/mio-intelligence-mcp/index.js

@@ -913,6 +913,9 @@ function observerStatus(args = {}) {
   return observerStore.status(args)
 }
 
+// Both return promises (the upstream collector and fermentation engine are
+// async). callTool is async, so the promise is awaited before the result is
+// serialized -- but nothing here may treat them as synchronous values.
 function observerCollect(args = {}) {
   return observerStore.collect(args)
 }

package/server/observer-store.js

@@ -161,19 +161,28 @@ function createObserverStore(options = {}) {
     return { summaries, summaryCount: summaries.reduce((a, s) => a + s.summaries.length, 0) }
   }
 
-  function collect(args = {}) {
+  // ObserverService.collectBySource and FermentationEngine.ferment are both
+  // async. They must be awaited here: a Promise is `typeof 'object'` with no
+  // own enumerable keys, so the previous synchronous version of collect()
+  // happily "iterated" one and pushed nothing -- every call reported
+  // `collected: 0` no matter how much the collectors actually returned.
+  async function collect(args = {}) {
     if (!ObserverService) throw new Error('@akemi-mio/observer not installed')
     const service = new ObserverService({ baseDir: baseDirOf(args), collectorConfig: {} })
     const sources = args.sources || ['bilibili', 'hackernews', 'github', 'douyin', 'rss']
     const allObs = []
     for (const src of sources) {
       try {
-        const collectFn = service.collectBySource ? service.collectBySource : service.collect
-        if (collectFn) {
-          const result = collectFn.call(service, [src], args.keywords || [], args.limit || 20)
-          if (Array.isArray(result)) allObs.push(...result)
-          else if (result && typeof result === 'object') {
-            for (const [, items] of Object.entries(result)) allObs.push(...items)
+        const collectFn = service.collectBySource || service.collect
+        if (!collectFn) {
+          throw new Error('ObserverService exposes neither collectBySource nor collect')
+        }
+        const result = await collectFn.call(service, [src], args.keywords || [], args.limit || 20)
+        if (Array.isArray(result)) allObs.push(...result)
+        else if (result && typeof result === 'object') {
+          // Record<sourceName, Observation[]>: keep every list, in key order.
+          for (const items of Object.values(result)) {
+            if (Array.isArray(items)) allObs.push(...items)
           }
         }
       } catch (e) {
@@ -183,13 +192,13 @@ function createObserverStore(options = {}) {
     return { collected: allObs.length, observations: allObs }
   }
 
-  function ferment(args = {}) {
+  async function ferment(args = {}) {
     if (!ObserverService) throw new Error('@akemi-mio/observer not installed')
     const service = new ObserverService({ baseDir: baseDirOf(args), collectorConfig: {} })
     const session = args.session || 'afternoon'
     try {
       const fermentation = service.getFermentation()
-      if (fermentation && fermentation.ferment) return fermentation.ferment(session)
+      if (fermentation && fermentation.ferment) return await fermentation.ferment(session)
       return { status: 'fermentation engine available but no ferment method' }
     } catch (e) {
       return { error: e.message }