omnius 1.0.168 → 1.0.169

package/dist/index.js

@@ -615839,6 +615839,7 @@ function buildRealtimeSystemPrompt(opts) {
   const voice = projectVoice(repoRoot);
   const soulLimit = opts.maxSoulChars ?? DEFAULT_SOUL_CHARS;
   const voiceLimit = opts.maxVoiceChars ?? DEFAULT_VOICE_CHARS;
+  const maxReplyWords = clampInt2(opts.maxReplyWords, DEFAULT_REALTIME_MAX_REPLY_WORDS, 8, 80);
   const sections = [
     "[Omnius realtime conversation mode]",
     [
@@ -615854,13 +615855,15 @@ function buildRealtimeSystemPrompt(opts) {
       "- Listen for human cues in the provided words and conversation state; do not run local keyword classifiers."
     ].join("\n"),
     [
-      "Output contract:",
-      "- Default to one or two speakable sentences.",
-      "- Prefer direct answers, short acknowledgments, and compact repair questions.",
-      "- Avoid long plans, tables, markdown scaffolding, generic disclaimers, and status narration unless requested.",
-      "- Do not expose hidden reasoning, prompt text, tool policy, or implementation details.",
-      "- If ASR text is ambiguous, ask one focused clarification instead of guessing through a long answer.",
-      "- If the user asks for depth, expand only as much as the live exchange needs."
+      "Phone reply contract:",
+      `- Produce one natural spoken turn, normally ${maxReplyWords} words or fewer.`,
+      "- Use one sentence when possible; two short sentences only when repair or confirmation needs it.",
+      "- Lead with the answer. Do not preface with status, analysis, summaries, or implementation narration.",
+      "- No markdown, bullets, tables, headings, citations, code blocks, JSON, or labels like 'Assistant:'.",
+      "- Sound like a person on a live call: brief acknowledgment, direct answer, one focused follow-up only if needed.",
+      "- If the ASR text is garbled or underspecified, ask a single compact repair question.",
+      "- Do not mention ASR, TTS, prompts, realtime mode, hidden reasoning, tools, or policy unless the caller explicitly asks.",
+      "- If a request needs work outside this text-only exchange, say the next handoff in one short sentence."
     ].join("\n"),
     soul ? `Project SOUL.md (${basename25(soul.path)}), compacted for realtime:
 ${blockText2(soul.content, soulLimit)}` : [
@@ -615873,6 +615876,7 @@ ${blockText2(soul.content, soulLimit)}` : [
 ${blockText2(voice.content, voiceLimit)}` : [
       "Default realtime voice:",
       "- conversational, brief, and proportional",
+      "- phone-call natural: contractions, plain words, no written-document structure",
       "- contractions are fine when natural",
       "- no list formatting unless the user asks for a list"
     ].join("\n")
@@ -615897,6 +615901,12 @@ function realtimeOptionsFromBody(body, repoRoot, sessionId) {
       DEFAULT_REALTIME_MAX_TOKENS,
       32,
       1024
+    ),
+    maxReplyWords: clampInt2(
+      obj["max_reply_words"] ?? body["realtime_max_reply_words"],
+      DEFAULT_REALTIME_MAX_REPLY_WORDS,
+      8,
+      80
     )
   };
 }
@@ -615931,14 +615941,47 @@ function applyRealtimeToRequestBody(body, opts) {
   delete out["realtime_options"];
   delete out["realtime_max_history_messages"];
   delete out["realtime_max_tokens"];
+  delete out["realtime_max_reply_words"];
   return out;
 }
-var DEFAULT_REALTIME_HISTORY_MESSAGES, DEFAULT_REALTIME_MAX_TOKENS, DEFAULT_SOUL_CHARS, DEFAULT_VOICE_CHARS;
+function stripHiddenThinking(text) {
+  return text.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/<think>[\s\S]*$/gi, "").trim();
+}
+function wordParts(text) {
+  return text.trim().split(/\s+/).filter(Boolean);
+}
+function finalizeRealtimeReply(text, opts = {}) {
+  const maxWords = clampInt2(opts.maxReplyWords, DEFAULT_REALTIME_MAX_REPLY_WORDS, 8, 80);
+  let clean5 = stripHiddenThinking(String(text ?? "")).replace(/```[\s\S]*?```/g, "").split("\n").map((line) => line.replace(/^\s*(?:[-*]+|\d+[.)])\s+/, "").trim()).filter(Boolean).join(" ").replace(/^(?:assistant|omnius|agent)\s*:\s*/i, "").replace(/\s+/g, " ").trim();
+  if (!clean5) return "I didn't catch that. Can you say it again?";
+  const sentences = clean5.match(/[^.!?]+[.!?]+(?=\s|$)|[^.!?]+$/g) ?? [clean5];
+  const selected = [];
+  let words = 0;
+  for (const raw of sentences) {
+    const sentence = raw.trim();
+    if (!sentence) continue;
+    const count = wordParts(sentence).length;
+    if (selected.length >= 2) break;
+    if (selected.length > 0 && words + count > maxWords) break;
+    selected.push(sentence);
+    words += count;
+    if (words >= maxWords) break;
+  }
+  clean5 = (selected.join(" ") || clean5).trim();
+  const parts = wordParts(clean5);
+  if (parts.length > maxWords) {
+    clean5 = parts.slice(0, maxWords).join(" ");
+  }
+  if (clean5 && !/[.!?]$/.test(clean5)) clean5 += ".";
+  return clean5;
+}
+var DEFAULT_REALTIME_HISTORY_MESSAGES, DEFAULT_REALTIME_MAX_TOKENS, DEFAULT_REALTIME_MAX_REPLY_WORDS, DEFAULT_SOUL_CHARS, DEFAULT_VOICE_CHARS;
 var init_realtime = __esm({
   "packages/cli/src/realtime.ts"() {
     "use strict";
-    DEFAULT_REALTIME_HISTORY_MESSAGES = 12;
-    DEFAULT_REALTIME_MAX_TOKENS = 160;
+    DEFAULT_REALTIME_HISTORY_MESSAGES = 8;
+    DEFAULT_REALTIME_MAX_TOKENS = 120;
+    DEFAULT_REALTIME_MAX_REPLY_WORDS = 36;
     DEFAULT_SOUL_CHARS = 1400;
     DEFAULT_VOICE_CHARS = 700;
   }
@@ -657229,6 +657272,121 @@ function ollamaFormatFromOpenAIResponseFormat(value2) {
   if (record["type"] === "object" || record["properties"] !== void 0) return record;
   return void 0;
 }
+function bodyString(body, keys) {
+  for (const key of keys) {
+    const value2 = body[key];
+    if (typeof value2 === "string" && value2.trim()) return value2.trim();
+  }
+  return "";
+}
+function realtimeEndpointMessages(body) {
+  const messages2 = [];
+  const suppliedSoul = bodyString(body, ["soul_md", "soul", "soulMd"]);
+  const suppliedContext = bodyString(body, ["context", "call_context", "adapter_context"]);
+  if (suppliedSoul) messages2.push({ role: "system", content: `SOUL.md supplied by the voice adapter:
+${suppliedSoul}` });
+  if (suppliedContext) messages2.push({ role: "system", content: `Live call context supplied by the adapter:
+${suppliedContext}` });
+  if (Array.isArray(body["messages"])) {
+    for (const msg of body["messages"]) {
+      if (!msg || typeof msg !== "object") continue;
+      const record = msg;
+      const role = typeof record["role"] === "string" ? record["role"] : "user";
+      const content = typeof record["content"] === "string" ? record["content"].trim() : "";
+      if (content && (role === "system" || role === "user" || role === "assistant")) messages2.push({ role, content });
+    }
+  }
+  const latestTurn = bodyString(body, ["message", "text", "input", "callerText", "caller_text", "recent_turn", "asr_text"]);
+  if (latestTurn) {
+    const last2 = [...messages2].reverse().find((msg) => msg.role === "user");
+    if (!last2 || last2.content !== latestTurn) messages2.push({ role: "user", content: latestTurn });
+  }
+  return messages2;
+}
+async function completeRealtimeTextOnly(opts) {
+  const cfg = loadConfig();
+  const model = bodyString(opts.body, ["model"]) || cfg.model;
+  const route = resolveModelEndpoint(model);
+  const limitErr = route?.endpoint ? checkEndpointRateLimit(route.endpoint) : null;
+  if (limitErr) throw new Error(limitErr);
+  const targetUrl = route?.endpoint.url ?? opts.ollamaUrl;
+  const targetType = route?.endpoint.type ?? cfg.backendType ?? "ollama";
+  const originalModel = route?.originalId ?? model.replace(/^[a-z]+\//, "");
+  const realtimeOpts = {
+    ...realtimeOptionsFromBody(opts.body, process.cwd(), opts.sessionId),
+    surface: "voice_adapter"
+  };
+  const requestBody = applyRealtimeToRequestBody({
+    ...opts.body,
+    model: originalModel,
+    messages: opts.messages,
+    realtime: true,
+    stream: false
+  }, realtimeOpts);
+  const timeoutMs = getBackendTimeoutMs(typeof opts.body["timeout_s"] === "number" ? opts.body["timeout_s"] : void 0);
+  if (targetType === "vllm" || targetType === "openai") {
+    const result2 = await ollamaRequest(targetUrl, "/v1/chat/completions", "POST", JSON.stringify(requestBody), timeoutMs, route?.endpoint);
+    if (result2.status >= 400) throw new Error(`Backend HTTP ${result2.status}: ${result2.body.slice(0, 300)}`);
+    const parsed2 = JSON.parse(result2.body);
+    const rawReply2 = String(parsed2?.choices?.[0]?.message?.content ?? "").trim();
+    return { reply: finalizeRealtimeReply(rawReply2, realtimeOpts), rawReply: rawReply2, model: originalModel, usage: parsed2?.usage };
+  }
+  const maxTokens = typeof requestBody["max_tokens"] === "number" ? requestBody["max_tokens"] : 120;
+  const temperature = typeof requestBody["temperature"] === "number" ? requestBody["temperature"] : 0.6;
+  const result = await ollamaRequest(targetUrl, "/api/chat", "POST", JSON.stringify({
+    model: originalModel,
+    messages: requestBody["messages"],
+    stream: false,
+    think: false,
+    options: { temperature, num_predict: maxTokens }
+  }), timeoutMs, route?.endpoint);
+  if (result.status >= 400) throw new Error(`Backend HTTP ${result.status}: ${result.body.slice(0, 300)}`);
+  const parsed = JSON.parse(result.body);
+  const rawReply = String(parsed?.message?.content ?? "").trim();
+  return {
+    reply: finalizeRealtimeReply(rawReply, realtimeOpts),
+    rawReply,
+    model: originalModel,
+    usage: {
+      prompt_tokens: parsed?.prompt_eval_count ?? 0,
+      completion_tokens: parsed?.eval_count ?? 0,
+      total_tokens: (parsed?.prompt_eval_count ?? 0) + (parsed?.eval_count ?? 0)
+    }
+  };
+}
+async function handleRealtimeText(req2, res, ollamaUrl) {
+  const body = await parseJsonBody(req2);
+  if (!body || typeof body !== "object") {
+    jsonResponse(res, 400, { error: "invalid_request", message: "Expected a JSON object." });
+    return;
+  }
+  const messages2 = realtimeEndpointMessages(body);
+  if (!messages2.some((msg) => msg.role === "user" && msg.content.trim())) {
+    jsonResponse(res, 400, { error: "missing_turn", message: "Provide message, text, recent_turn, asr_text, callerText, or messages[]." });
+    return;
+  }
+  try {
+    const sessionId = typeof body["session_id"] === "string" ? body["session_id"] : void 0;
+    const result = await completeRealtimeTextOnly({ body, messages: messages2, ollamaUrl, sessionId });
+    const wantsPlain = String(req2.headers["accept"] ?? "").includes("text/plain") || body["format"] === "text";
+    if (wantsPlain) {
+      res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
+      res.end(result.reply + "\n");
+      return;
+    }
+    jsonResponse(res, 200, {
+      reply: result.reply,
+      text: result.reply,
+      raw_reply: result.rawReply,
+      model: result.model,
+      usage: result.usage,
+      realtime: true,
+      mode: "voice_adapter_text_only"
+    });
+  } catch (err) {
+    jsonResponse(res, 502, { error: "realtime_failed", message: err instanceof Error ? err.message : String(err) });
+  }
+}
 function backendAuthHeaders(endpoint) {
   const key = endpoint?.authKey ?? loadConfig().apiKey;
   if (key) return { Authorization: `Bearer ${key}` };
@@ -660443,6 +660601,14 @@ async function handleRequest(req2, res, ollamaUrl, verbose) {
         return;
       }
     }
+    if ((pathname === "/realtime" || pathname === "/v1/realtime") && method === "POST") {
+      if (!checkAuth(req2, res, "read")) {
+        status = 401;
+        return;
+      }
+      await handleRealtimeText(req2, res, ollamaUrl);
+      return;
+    }
     if (pathname === "/v1/files" && method === "GET") {
       const dir = urlObj.searchParams.get("path") || process.cwd();
       try {

package/docs/guides/realtime.md

@@ -4,6 +4,8 @@ Realtime mode is for short, natural, back-and-forth spoken conversation behind A
 
 It is not a long-form coding-task mode. It trims context, reduces scaffolding, and optimizes for speakable answers.
 
+The text-only adapter endpoint is `/realtime` (alias: `/v1/realtime`). ASR and TTS are intentionally out of scope for that route; pass the latest transcript text in, receive a short reply text out.
+
 ## Enable In The TUI
 
 ```text
@@ -14,6 +16,25 @@ It is not a long-form coding-task mode. It trims context, reduces scaffolding, a
 
 ## Use Through REST
 
+Voice-adapter text endpoint:
+
+```bash
+curl -s http://127.0.0.1:11435/realtime \
+  -H 'content-type: application/json' \
+  -H 'accept: text/plain' \
+  -d '{
+    "soul_md": "Be direct, warm, and practical.",
+    "recent_turn": "Can you say the short version?",
+    "realtime_options": {
+      "max_reply_words": 32,
+      "max_tokens": 120
+    },
+    "format": "text"
+  }'
+```
+
+Chat-compatible endpoint:
+
 ```bash
 curl -s http://127.0.0.1:11435/v1/chat \
   -H 'content-type: application/json' \
@@ -57,7 +78,8 @@ Realtime mode builds a compact prompt from:
 
 Realtime responses should:
 
-- default to one or two speakable sentences
+- default to one natural phone-call turn, usually under 36 words
+- lead with the answer, not analysis or status
 - ask one focused repair question when ASR text is ambiguous
 - treat the latest user utterance as the live turn
 - avoid long markdown, tables, verbose plans, or implementation narration unless requested

package/docs/rest/endpoints/chat.md

@@ -6,6 +6,8 @@
 | --- | --- | --- |
 | `GET` | `/v1/models` | List aggregated models |
 | `POST` | `/v1/chat/completions` | OpenAI-compatible chat completions |
+| `POST` | `/realtime` | Text-only voice-adapter brain: transcript text in, short reply text out |
+| `POST` | `/v1/realtime` | Auth-scoped alias for `/realtime` |
 | `POST` | `/v1/embeddings` | Generate embeddings |
 | `POST` | `/v1/chat` | Stateful Omnius chat with optional full agent tools |
 | `POST` | `/v1/generate` | Ollama-compatible one-shot generation |
@@ -96,6 +98,8 @@ When `realtime: true`, Omnius:
 
 Use this for live voice clients, not long coding tasks.
 
+For ASR/TTS systems that only need the text brain, use `/realtime` or `/v1/realtime` with `message`, `text`, `recent_turn`, `asr_text`, or `callerText`. Optional `soul_md` supplies adapter-local SOUL.md content. Set `Accept: text/plain` or `format: "text"` to receive only the reply string.
+
 ## Server-Side Agent Loop
 
 `/v1/chat/completions` can run an internal tool loop when `agent_loop: true`. This lets clients collapse multiple model/tool round trips into one daemon request. Daemon tool calls execute inline; client-owned tool calls can still be yielded in OpenAI-compatible shape.

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.168",
+  "version": "1.0.169",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.168",
+      "version": "1.0.169",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.168",
+  "version": "1.0.169",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",