@p-sw/brainbox 0.1.2-alpha.9 → 0.2.0

package/dist/index.js

@@ -489,15 +489,100 @@ function stripThinkTags(content) {
 }
 function parseModelJson(content) {
   const cleaned = stripThinkTags(content);
-  try {
-    return JSON.parse(cleaned);
-  } catch (first) {
-    const fence = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/i);
-    if (fence?.[1]) {
-      return JSON.parse(fence[1].trim());
+  const candidates = [cleaned];
+  const fence = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fence?.[1])
+    candidates.push(fence[1].trim());
+  const extracted = extractJsonSlice(cleaned);
+  if (extracted)
+    candidates.push(extracted);
+  let lastErr;
+  for (const candidate of candidates) {
+    try {
+      return decodeJsonValue(candidate);
+    } catch (err) {
+      lastErr = err;
+    }
+  }
+  throw lastErr instanceof Error ? lastErr : new Error("Failed to parse model JSON");
+}
+function decodeJsonValue(text) {
+  let value = JSON.parse(text);
+  for (let i = 0;i < 2 && typeof value === "string"; i++) {
+    const inner = value.trim();
+    if (!(inner.startsWith("{") && inner.endsWith("}") || inner.startsWith("[") && inner.endsWith("]") || inner.startsWith('"') && inner.endsWith('"'))) {
+      break;
+    }
+    value = JSON.parse(inner);
+  }
+  return value;
+}
+function extractJsonSlice(text) {
+  const start = text.search(/[\{\[]/);
+  if (start < 0)
+    return;
+  const open = text[start];
+  const close = open === "{" ? "}" : "]";
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  for (let i = start;i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escape) {
+        escape = false;
+      } else if (ch === "\\") {
+        escape = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === open)
+      depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0)
+        return text.slice(start, i + 1);
     }
-    throw first;
   }
+  return;
+}
+function schemaToolName(name) {
+  const cleaned = name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "_$1");
+  return cleaned.length > 0 ? cleaned : "submit_result";
+}
+function buildStructuredJsonRequest(options) {
+  const toolName = schemaToolName(options.jsonSchemaName);
+  return {
+    toolName,
+    tool: {
+      name: toolName,
+      description: `Submit the structured ${options.jsonSchemaName} result.`,
+      parameters: options.jsonSchema ?? {
+        type: "object",
+        additionalProperties: true
+      }
+    },
+    instruction: `${options.instruction}
+
+You MUST call the \`${toolName}\` tool exactly once with the complete answer.
+Do not write the JSON as plain text or inside a markdown code fence.`
+  };
+}
+function parseStructuredJsonResult(choice, toolName) {
+  const call = choice.message.toolCalls?.find((c) => c.function.name === toolName) ?? choice.message.toolCalls?.[0];
+  if (call?.function.arguments) {
+    return parseModelJson(call.function.arguments);
+  }
+  if (choice.message.content) {
+    return parseModelJson(choice.message.content);
+  }
+  throw new Error("Empty response from model");
 }
 function readAuthString(auth, key, envName) {
   const fromAuth = typeof auth?.[key] === "string" ? auth[key] : undefined;
@@ -512,6 +597,56 @@ function readAuthString(auth, key, envName) {
 }
 
 class LLMExecutor {
+  async chatWithToolExecution(model, options) {
+    const messages = options.messages.slice();
+    const maxSteps = options.maxSteps ?? 20;
+    let last;
+    for (let step = 0;step < maxSteps; step += 1) {
+      log2.debug(`chatWithToolExecution: step ${step + 1}/${maxSteps} msgs=${messages.length}`);
+      last = await this.chatWithTools(model, {
+        instruction: options.instruction,
+        messages,
+        tools: options.tools,
+        caller: options.caller,
+        reasoningEffort: options.reasoningEffort,
+        parallelToolCalls: options.parallelToolCalls,
+        toolChoice: options.toolChoice
+      });
+      const toolCalls = last.message.toolCalls ?? [];
+      log2.debug(`chatWithToolExecution: step ${step + 1} toolCalls=${toolCalls.length}`);
+      if (toolCalls.length === 0) {
+        const nudge = options.onNoToolCalls ? await options.onNoToolCalls(last) : null;
+        if (nudge == null)
+          return last;
+        log2.debug(`chatWithToolExecution: bare end rejected, re-prompting`);
+        messages.push({
+          role: "assistant",
+          content: last.message.content ?? ""
+        });
+        messages.push({ role: "user", content: nudge });
+        continue;
+      }
+      messages.push({
+        role: "assistant",
+        content: last.message.content,
+        toolCalls
+      });
+      for (const call of toolCalls) {
+        const content = await options.executeTool(call);
+        messages.push({
+          role: "tool",
+          toolCallId: call.id,
+          content
+        });
+      }
+      if (options.shouldEnd?.(toolCalls)) {
+        log2.debug(`chatWithToolExecution: shouldEnd after step ${step + 1}`);
+        return last;
+      }
+    }
+    log2.warn(`chatWithToolExecution: reached maxSteps (${maxSteps}) without final reply`);
+    return last;
+  }
   static providers = [];
   static registerProvider(p) {
     LLMExecutor.providers.push(p);
@@ -550,7 +685,7 @@ class LLMExecutor {
       });
     };
     if (conv.provider === id.provider) {
-      return withLlmLogging(build(conv.provider));
+      return build(conv.provider);
     }
     const modelToProvider = {
       [conv.model]: conv.provider,
@@ -561,7 +696,7 @@ class LLMExecutor {
       [id.provider]: build(id.provider)
     };
     const fallback = instances[conv.provider];
-    return withLlmLogging(new class extends LLMExecutor {
+    return new class extends LLMExecutor {
       providerName = "dispatch";
       models = {
         conversation: conv.model,
@@ -575,126 +710,21 @@ class LLMExecutor {
         const exec = instances[modelToProvider[model] ?? ""] ?? fallback;
         return exec.chatWithTools(model, options);
       }
-    });
-  }
-}
-function formatPayload(value) {
-  if (typeof value === "string")
-    return value;
-  try {
-    return JSON.stringify(value, null, 2);
-  } catch {
-    return String(value);
+    };
   }
 }
-function resolveCaller(options, fallback) {
+function resolveLlmCaller(options, fallback = "llm") {
   return options.caller ?? options.jsonSchemaName ?? fallback;
 }
-function withLlmLogging(inner) {
-  return new class extends LLMExecutor {
-    providerName = inner.providerName;
-    models = inner.models;
-    async call(model, options) {
-      const jsonMode = "jsonSchemaName" in options;
-      const caller = resolveCaller({
-        caller: options.caller,
-        jsonSchemaName: jsonMode ? options.jsonSchemaName : undefined
-      }, "call");
-      const requestBody = [
-        `provider: ${inner.providerName}`,
-        `model: ${model}`,
-        `caller: ${caller}`,
-        `reasoningEffort: ${options.reasoningEffort ?? "-"}`,
-        `jsonSchemaName: ${jsonMode ? options.jsonSchemaName : "-"}`,
-        "",
-        "--- instruction ---",
-        options.instruction,
-        "",
-        "--- message ---",
-        options.message,
-        ...jsonMode ? ["", "--- jsonSchema ---", formatPayload(options.jsonSchema)] : []
-      ].join(`
-`);
-      try {
-        const result = await inner.call(model, options);
-        if (isLlmLogEnabled()) {
-          writeLlmExchange(caller, [
-            "======== REQUEST ========",
-            requestBody,
-            "",
-            "======== RESPONSE ========",
-            formatPayload(result),
-            ""
-          ].join(`
-`));
-        }
-        return result;
-      } catch (err) {
-        const reason = err instanceof Error ? err.message : String(err);
-        if (isLlmLogEnabled()) {
-          writeLlmExchange(caller, [
-            "======== REQUEST ========",
-            requestBody,
-            "",
-            "======== ERROR ========",
-            reason,
-            ""
-          ].join(`
-`));
-        }
-        throw err;
-      }
-    }
-    async chatWithTools(model, options) {
-      const caller = resolveCaller(options, "chat");
-      const requestBody = [
-        `provider: ${inner.providerName}`,
-        `model: ${model}`,
-        `caller: ${caller}`,
-        `reasoningEffort: ${options.reasoningEffort ?? "-"}`,
-        `parallelToolCalls: ${options.parallelToolCalls ?? false}`,
-        "",
-        "--- instruction ---",
-        options.instruction,
-        "",
-        "--- messages ---",
-        formatPayload(options.messages),
-        "",
-        "--- tools ---",
-        formatPayload(options.tools)
-      ].join(`
+function logLlmWire(caller, request, response) {
+  if (!isLlmLogEnabled())
+    return;
+  writeLlmExchange(caller, `======== REQUEST ========
+${request}
+
+======== RESPONSE ========
+${response}
 `);
-      try {
-        const result = await inner.chatWithTools(model, options);
-        if (isLlmLogEnabled()) {
-          writeLlmExchange(caller, [
-            "======== REQUEST ========",
-            requestBody,
-            "",
-            "======== RESPONSE ========",
-            formatPayload(result),
-            ""
-          ].join(`
-`));
-        }
-        return result;
-      } catch (err) {
-        const reason = err instanceof Error ? err.message : String(err);
-        if (isLlmLogEnabled()) {
-          writeLlmExchange(caller, [
-            "======== REQUEST ========",
-            requestBody,
-            "",
-            "======== ERROR ========",
-            reason,
-            ""
-          ].join(`
-`));
-        }
-        throw err;
-      }
-    }
-  };
 }
 function listProviderNames() {
   return LLMExecutor.listProviderNames();
@@ -764,27 +794,27 @@ class OpenRouterExecutor extends LLMExecutor {
   async call(model, options) {
     const jsonMode = "jsonSchemaName" in options;
     log3.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
-    const result = await this.client.chat.send({
-      chatRequest: {
-        model,
-        messages: [
-          { role: "system", content: options.instruction },
-          { role: "user", content: options.message }
-        ],
-        reasoning: {
-          effort: options.reasoningEffort ?? (model === this.models.identity ? REASONING_EFFORT_MAP.medium : REASONING_EFFORT_MAP.none)
-        },
-        responseFormat: jsonMode ? {
-          type: "json_schema",
-          jsonSchema: {
-            name: options.jsonSchemaName,
-            schema: options.jsonSchema,
-            strict: true
-          }
-        } : { type: "text" },
-        stream: false
-      }
-    });
+    const chatRequest = {
+      model,
+      messages: [
+        { role: "system", content: options.instruction },
+        { role: "user", content: options.message }
+      ],
+      reasoning: {
+        effort: options.reasoningEffort ?? (model === this.models.identity ? REASONING_EFFORT_MAP.medium : REASONING_EFFORT_MAP.none)
+      },
+      responseFormat: jsonMode ? {
+        type: "json_schema",
+        jsonSchema: {
+          name: options.jsonSchemaName,
+          schema: options.jsonSchema,
+          strict: true
+        }
+      } : { type: "text" },
+      stream: false
+    };
+    const result = await this.client.chat.send({ chatRequest });
+    logLlmWire(resolveLlmCaller(options), JSON.stringify(chatRequest), JSON.stringify(result));
     const raw = result.choices[0]?.message?.content;
     const content = typeof raw === "string" ? stripThinkTags(raw) : raw;
     if (!content) {
@@ -796,22 +826,22 @@ class OpenRouterExecutor extends LLMExecutor {
   }
   async chatWithTools(model, options) {
     log3.debug(`chatWithTools: model=${model} msgs=${options.messages.length} tools=${options.tools.length}`);
-    const result = await this.client.chat.send({
-      chatRequest: {
-        model,
-        messages: [
-          { role: "system", content: options.instruction },
-          ...options.messages.map(toOrMessage)
-        ],
-        reasoning: {
-          effort: options.reasoningEffort ?? (model === this.models.identity ? REASONING_EFFORT_MAP.medium : REASONING_EFFORT_MAP.none)
-        },
-        responseFormat: { type: "text" },
-        tools: options.tools.map(toOrTool),
-        parallelToolCalls: options.parallelToolCalls ?? false,
-        stream: false
-      }
-    });
+    const chatRequest = {
+      model,
+      messages: [
+        { role: "system", content: options.instruction },
+        ...options.messages.map(toOrMessage)
+      ],
+      reasoning: {
+        effort: options.reasoningEffort ?? (model === this.models.identity ? REASONING_EFFORT_MAP.medium : REASONING_EFFORT_MAP.none)
+      },
+      responseFormat: { type: "text" },
+      tools: options.tools.map(toOrTool),
+      parallelToolCalls: options.parallelToolCalls ?? false,
+      stream: false
+    };
+    const result = await this.client.chat.send({ chatRequest });
+    logLlmWire(resolveLlmCaller(options), JSON.stringify(chatRequest), JSON.stringify(result));
     const choice = result.choices[0];
     if (!choice) {
       log3.debug(`chatWithTools: no choice in response`);
@@ -886,6 +916,7 @@ class OpenAICompatibleExecutor extends LLMExecutor {
   chatPath;
   noBearerPrefix;
   reasoningEffortInQuery;
+  supportsResponseFormat;
   constructor(opts) {
     super();
     this.providerName = opts.providerName;
@@ -895,6 +926,7 @@ class OpenAICompatibleExecutor extends LLMExecutor {
     this.chatPath = opts.chatPath ?? "/chat/completions";
     this.noBearerPrefix = opts.noBearerPrefix ?? false;
     this.reasoningEffortInQuery = opts.reasoningEffortInQuery ?? false;
+    this.supportsResponseFormat = opts.supportsResponseFormat ?? true;
     this.models = {
       conversation: opts.conversationModel,
       identity: opts.identityModel
@@ -925,7 +957,7 @@ class OpenAICompatibleExecutor extends LLMExecutor {
     }
     return url.toString();
   }
-  async sendRequest(body, reasoningEffort) {
+  async sendRequest(body, reasoningEffort, caller) {
     const modelName = body["model"];
     const modelStr = typeof modelName === "string" ? modelName : "";
     const url = this.buildRequestUrl(modelStr, reasoningEffort);
@@ -935,24 +967,40 @@ class OpenAICompatibleExecutor extends LLMExecutor {
       ...authHeader,
       ...this.defaultHeaders
     };
+    const requestRaw = JSON.stringify(body);
     const res = await fetch(url, {
       method: "POST",
       headers,
-      body: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      log4.error(`${this.providerName}: HTTP ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      log4.error(`${this.providerName}: HTTP ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
       throw new Error(`${this.providerName} request failed: ${res.status} ${res.statusText}`);
     }
-    const data = await res.json();
+    let data;
+    try {
+      data = JSON.parse(responseRaw);
+    } catch {
+      throw new Error(`${this.providerName}: invalid JSON response`);
+    }
     if (data.error) {
       log4.error(`${this.providerName}: API error ${data.error.type ?? ""} ${data.error.message ?? ""}`);
       throw new Error(`${this.providerName} API error: ${data.error.message ?? "unknown"}`);
     }
+    const baseCode = data.base_resp?.status_code;
+    if (typeof baseCode === "number" && baseCode !== 0) {
+      const msg = data.base_resp?.status_msg?.trim() || `status_code ${baseCode}`;
+      log4.error(`${this.providerName}: base_resp ${baseCode} ${msg}`);
+      throw new Error(`${this.providerName} API error: ${msg}`);
+    }
     return data;
   }
   async call(model, options) {
+    if ("jsonSchemaName" in options && !this.supportsResponseFormat) {
+      return this.callJsonViaTool(model, options);
+    }
     const jsonMode = "jsonSchemaName" in options;
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     log4.debug(`call: provider=${this.providerName} model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
@@ -965,16 +1013,32 @@ class OpenAICompatibleExecutor extends LLMExecutor {
       responseFormat: jsonMode ? buildResponseFormat(options.jsonSchemaName, options.jsonSchema) : undefined,
       reasoningEffort: reasoning
     });
-    const data = await this.sendRequest(body, options.reasoningEffort);
-    const raw = data.choices?.[0]?.message?.content;
+    const data = await this.sendRequest(body, options.reasoningEffort, resolveLlmCaller(options));
+    const choice = data.choices?.[0];
+    const raw = choice?.message?.content;
     const content = typeof raw === "string" ? stripThinkTags(raw) : raw;
     if (!content) {
-      log4.debug(`call: empty content in choice 0`);
-      throw new Error("Empty response from model");
+      const finish = choice?.finish_reason ?? "no-choice";
+      const reasoningLen = typeof choice?.message?.reasoning_content === "string" ? choice.message.reasoning_content.length : 0;
+      log4.debug(`call: empty content in choice 0 finish_reason=${finish} reasoning_len=${reasoningLen} rawType=${raw === null ? "null" : typeof raw}`);
+      throw new Error(reasoningLen > 0 ? `Empty response from model (finish_reason=${finish}; reasoning present but no content)` : "Empty response from model");
     }
     log4.debug(`call: response ${content.length} chars`);
     return jsonMode ? parseModelJson(content) : content;
   }
+  async callJsonViaTool(model, options) {
+    const { toolName, tool, instruction } = buildStructuredJsonRequest(options);
+    log4.debug(`callJsonViaTool: provider=${this.providerName} model=${model} tool=${toolName}`);
+    const choice = await this.chatWithTools(model, {
+      caller: options.caller ?? options.jsonSchemaName,
+      instruction,
+      messages: [{ role: "user", content: options.message }],
+      tools: [tool],
+      reasoningEffort: "none",
+      parallelToolCalls: false
+    });
+    return parseStructuredJsonResult(choice, toolName);
+  }
   async chatWithTools(model, options) {
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     log4.debug(`chatWithTools: provider=${this.providerName} model=${model} msgs=${options.messages.length} tools=${options.tools.length}`);
@@ -988,7 +1052,7 @@ class OpenAICompatibleExecutor extends LLMExecutor {
       parallelToolCalls: options.parallelToolCalls ?? false,
       reasoningEffort: reasoning
     });
-    const data = await this.sendRequest(body, options.reasoningEffort);
+    const data = await this.sendRequest(body, options.reasoningEffort, resolveLlmCaller(options));
     const choice = data.choices?.[0];
     if (!choice) {
       log4.debug(`chatWithTools: no choice in response`);
@@ -1290,10 +1354,15 @@ class ZenMuxExecutor extends OpenAICompatibleExecutor {
 // src/provider/providers/minimax.ts
 class MiniMaxBase extends OpenAICompatibleExecutor {
   buildBody(opts) {
+    const jsonMode = opts.responseFormat !== undefined;
     const body = super.buildBody(opts);
     delete body["reasoning_effort"];
+    delete body["response_format"];
+    delete body["parallel_tool_calls"];
     body["reasoning_split"] = true;
-    body["thinking"] = opts.reasoningEffort && opts.reasoningEffort !== "none" ? { type: "adaptive" } : { type: "disabled" };
+    body["max_completion_tokens"] = 16384;
+    const wantThink = !jsonMode && opts.reasoningEffort !== undefined && opts.reasoningEffort !== "none";
+    body["thinking"] = wantThink ? { type: "adaptive" } : { type: "disabled" };
     return body;
   }
 }
@@ -1303,7 +1372,8 @@ function minimaxOpts(providerName, baseURL, opts) {
     baseURL,
     apiKey: opts.apiKey,
     conversationModel: opts.conversationModel,
-    identityModel: opts.identityModel
+    identityModel: opts.identityModel,
+    supportsResponseFormat: false
   };
 }
 
@@ -1379,7 +1449,8 @@ class LmStudioExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:1234/v1",
       apiKey: opts.apiKey || "lm-studio",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel
+      identityModel: opts.identityModel,
+      supportsResponseFormat: false
     });
   }
 }
@@ -1392,7 +1463,8 @@ class OllamaExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:11434/v1",
       apiKey: opts.apiKey || "ollama",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel
+      identityModel: opts.identityModel,
+      supportsResponseFormat: false
     });
   }
 }
@@ -1418,7 +1490,8 @@ class LlamaCppExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:8080/v1",
       apiKey: opts.apiKey || "llama.cpp",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel
+      identityModel: opts.identityModel,
+      supportsResponseFormat: false
     });
   }
 }
@@ -1501,21 +1574,23 @@ class CloudflareWorkersExecutor extends LLMExecutor {
     const accountId = readAuthString(opts.auth, "accountId", "CLOUDFLARE_ACCOUNT_ID");
     this.baseURL = accountId ? `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run` : "https://api.cloudflare.com/client/v4/accounts/__cf_account_id__/ai/run";
   }
-  async run(model, body) {
+  async run(model, body, caller) {
     const url = `${this.baseURL}/${encodeURIComponent(model)}`;
+    const requestRaw = JSON.stringify(body);
     const res = await fetch(url, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`cloudflare-workers request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`cloudflare-workers request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
     const jsonMode = "jsonSchemaName" in options;
@@ -1536,7 +1611,7 @@ class CloudflareWorkersExecutor extends LLMExecutor {
     if (reasoning !== "none") {
       body["reasoning_effort"] = reasoning;
     }
-    const data = await this.run(model, body);
+    const data = await this.run(model, body, resolveLlmCaller(options));
     if (data.errors && data.errors.length > 0) {
       throw new Error(`cloudflare-workers API error: ${data.errors.map((e) => e.message).join("; ")}`);
     }
@@ -1565,7 +1640,7 @@ class CloudflareWorkersExecutor extends LLMExecutor {
     if (reasoning !== "none") {
       body["reasoning_effort"] = reasoning;
     }
-    const data = await this.run(model, body);
+    const data = await this.run(model, body, resolveLlmCaller(options));
     if (data.errors && data.errors.length > 0) {
       throw new Error(`cloudflare-workers API error: ${data.errors.map((e) => e.message).join("; ")}`);
     }
@@ -1655,17 +1730,17 @@ var AnthropicAuthSchema = z4.object({
   apiVersion: z4.string().optional()
 }).loose();
 function toAnthropicMessages(messages) {
-  let system;
-  const msgs = [];
+  let system2;
+  const msgs2 = [];
   for (const m of messages) {
     if (m.role === "system") {
-      system = (system ? system + `
+      system2 = (system2 ? system2 + `
 
 ` : "") + m.content;
       continue;
     }
     if (m.role === "user") {
-      msgs.push({ role: "user", content: m.content });
+      msgs2.push({ role: "user", content: m.content });
       continue;
     }
     if (m.role === "assistant") {
@@ -1688,11 +1763,11 @@ function toAnthropicMessages(messages) {
           });
         }
       }
-      msgs.push({ role: "assistant", content: blocks });
+      msgs2.push({ role: "assistant", content: blocks });
       continue;
     }
     if (m.role === "tool") {
-      msgs.push({
+      msgs2.push({
         role: "user",
         content: [
           {
@@ -1704,7 +1779,7 @@ function toAnthropicMessages(messages) {
       });
     }
   }
-  return { system, msgs };
+  return { system: system2, msgs: msgs2 };
 }
 function toAnthropicTool(t) {
   return {
@@ -1732,7 +1807,8 @@ class AnthropicExecutor extends LLMExecutor {
     this.baseURL = (extra.baseURL ?? readAuthString(opts.auth, "baseURL", "ANTHROPIC_BASE_URL") ?? "https://api.anthropic.com").replace(/\/v1\/?$/, "");
     this.apiVersion = extra.apiVersion ?? "2023-06-01";
   }
-  async send(body) {
+  async send(body, caller) {
+    const requestRaw = JSON.stringify(body);
     const res = await fetch(`${this.baseURL}/v1/messages`, {
       method: "POST",
       headers: {
@@ -1740,19 +1816,35 @@ class AnthropicExecutor extends LLMExecutor {
         "anthropic-version": this.apiVersion,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`anthropic request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`anthropic request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in options;
+    if ("jsonSchemaName" in options) {
+      const { toolName, tool, instruction } = buildStructuredJsonRequest({
+        instruction: options.instruction,
+        jsonSchemaName: options.jsonSchemaName,
+        jsonSchema: options.jsonSchema
+      });
+      const choice = await this.chatWithTools(model, {
+        caller: options.caller ?? options.jsonSchemaName,
+        instruction,
+        messages: [{ role: "user", content: options.message }],
+        tools: [tool],
+        reasoningEffort: "none",
+        toolChoice: { type: "tool", name: toolName }
+      });
+      return parseStructuredJsonResult(choice, toolName);
+    }
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     const log5 = logger.child("llm:anthropic");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
     const outputCap = 4096;
     const body = {
       model,
@@ -1768,7 +1860,7 @@ class AnthropicExecutor extends LLMExecutor {
         budget_tokens: budget
       };
     }
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`anthropic API error: ${data.error.message ?? "unknown"}`);
     }
@@ -1776,21 +1868,27 @@ class AnthropicExecutor extends LLMExecutor {
     if (!text) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(text) : text;
+    return text;
   }
   async chatWithTools(model, options) {
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     const log5 = logger.child("llm:anthropic");
     log5.debug(`chatWithTools: model=${model} msgs=${options.messages.length} tools=${options.tools.length}`);
-    const { system, msgs } = toAnthropicMessages(options.messages);
+    const { system: system2, msgs: msgs2 } = toAnthropicMessages(options.messages);
     const outputCap = 4096;
     const body = {
       model,
       max_tokens: outputCap,
-      system: system ?? options.instruction,
-      messages: msgs,
+      system: system2 ?? options.instruction,
+      messages: msgs2,
       tools: options.tools.map(toAnthropicTool)
     };
+    if (options.toolChoice) {
+      body["tool_choice"] = {
+        type: "tool",
+        name: options.toolChoice.name
+      };
+    }
     if (reasoning !== "none") {
       const budget = REASONING_BUDGET[reasoning];
       body["max_tokens"] = budget + outputCap;
@@ -1799,7 +1897,7 @@ class AnthropicExecutor extends LLMExecutor {
         budget_tokens: budget
       };
     }
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`anthropic API error: ${data.error.message ?? "unknown"}`);
     }
@@ -1869,58 +1967,6 @@ function signRequest(opts) {
     headers["X-Amz-Security-Token"] = opts.sessionToken;
   return headers;
 }
-function toAnthropicMessages2(messages) {
-  let system;
-  const msgs = [];
-  for (const m of messages) {
-    if (m.role === "system") {
-      system = (system ? system + `
-
-` : "") + m.content;
-      continue;
-    }
-    if (m.role === "user") {
-      msgs.push({ role: "user", content: [{ type: "text", text: m.content }] });
-      continue;
-    }
-    if (m.role === "assistant") {
-      const blocks = [];
-      if (m.content)
-        blocks.push({ type: "text", text: m.content });
-      if (m.toolCalls) {
-        for (const c of m.toolCalls) {
-          let input = {};
-          try {
-            input = c.function.arguments ? JSON.parse(c.function.arguments) : {};
-          } catch {
-            input = {};
-          }
-          blocks.push({
-            type: "tool_use",
-            id: c.id,
-            name: c.function.name,
-            input
-          });
-        }
-      }
-      msgs.push({ role: "assistant", content: blocks });
-      continue;
-    }
-    if (m.role === "tool") {
-      msgs.push({
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: m.toolCallId,
-            content: [{ type: "text", text: m.content }]
-          }
-        ]
-      });
-    }
-  }
-  return { system, msgs };
-}
 function toAnthropicTool2(t) {
   return {
     name: t.name,
@@ -1962,7 +2008,7 @@ class BedrockExecutor extends LLMExecutor {
     this.sessionToken = readAuthString(opts.auth, "sessionToken", "AWS_SESSION_TOKEN");
     this.baseURL = `https://bedrock-runtime.${this.region}.amazonaws.com`;
   }
-  async invoke(model, body) {
+  async invoke(model, body, caller) {
     const bodyStr = JSON.stringify(body);
     const path = `/model/${encodeURIComponent(model)}/invoke`;
     const headers = signRequest({
@@ -1981,16 +2027,32 @@ class BedrockExecutor extends LLMExecutor {
       headers,
       body: bodyStr
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, bodyStr, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`bedrock request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`bedrock request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in options;
     const log5 = logger.child("llm:bedrock");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    if ("jsonSchemaName" in options) {
+      log5.debug(`call: model=${model} jsonSchema=${options.jsonSchemaName} via tool`);
+      const { toolName, tool, instruction } = buildStructuredJsonRequest({
+        instruction: options.instruction,
+        jsonSchemaName: options.jsonSchemaName,
+        jsonSchema: options.jsonSchema
+      });
+      const choice = await this.chatWithTools(model, {
+        caller: options.caller ?? options.jsonSchemaName,
+        instruction,
+        messages: [{ role: "user", content: options.message }],
+        tools: [tool],
+        toolChoice: { type: "tool", name: toolName }
+      });
+      return parseStructuredJsonResult(choice, toolName);
+    }
+    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
     if (!model.startsWith("anthropic.") && !model.startsWith("us.anthropic.")) {
       throw new Error(`bedrock provider currently only supports Anthropic models (got ${model})`);
     }
@@ -2000,12 +2062,12 @@ class BedrockExecutor extends LLMExecutor {
       system: options.instruction,
       messages: [{ role: "user", content: options.message }]
     };
-    const data = await this.invoke(model, body);
+    const data = await this.invoke(model, body, resolveLlmCaller(options));
     const { text } = extractAnthropicContent(data);
     if (!text) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(text) : text;
+    return text;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:bedrock");
@@ -2013,7 +2075,6 @@ class BedrockExecutor extends LLMExecutor {
     if (!model.startsWith("anthropic.") && !model.startsWith("us.anthropic.")) {
       throw new Error(`bedrock provider currently only supports Anthropic models (got ${model})`);
     }
-    const { system, msgs } = toAnthropicMessages2(options.messages);
     const body = {
       anthropic_version: "bedrock-2023-05-31",
       max_tokens: 4096,
@@ -2021,7 +2082,13 @@ class BedrockExecutor extends LLMExecutor {
       messages: msgs,
       tools: options.tools.map(toAnthropicTool2)
     };
-    const data = await this.invoke(model, body);
+    if (options.toolChoice) {
+      body.tool_choice = {
+        type: "tool",
+        name: options.toolChoice.name
+      };
+    }
+    const data = await this.invoke(model, body, resolveLlmCaller(options));
     const { text, toolCalls } = extractAnthropicContent(data);
     return { message: { content: text || undefined, toolCalls } };
   }
@@ -2137,21 +2204,23 @@ class VertexExecutor extends LLMExecutor {
     this.region = extra.region ?? readAuthString(opts.auth, "region", "GOOGLE_CLOUD_REGION") ?? "us-central1";
     this.baseURL = this.project ? `https://${this.region}-aiplatform.googleapis.com/v1/projects/${this.project}/locations/${this.region}/publishers/google/models` : "https://us-central1-aiplatform.googleapis.com/v1";
   }
-  async generate(model, body) {
+  async generate(model, body, caller) {
     const url = `${this.baseURL}/${encodeURIComponent(model)}:generateContent`;
+    const requestRaw = JSON.stringify(body);
     const res = await fetch(url, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`vertex request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`vertex request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
     const jsonMode = "jsonSchemaName" in options;
@@ -2172,7 +2241,7 @@ class VertexExecutor extends LLMExecutor {
         responseSchema: options.jsonSchema
       };
     }
-    const data = await this.generate(model, body);
+    const data = await this.generate(model, body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`vertex API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2191,7 +2260,7 @@ class VertexExecutor extends LLMExecutor {
       systemInstruction: { parts: [{ text: options.instruction }] },
       tools: options.tools.length > 0 ? [toGeminiTools(options.tools)] : undefined
     };
-    const data = await this.generate(model, body);
+    const data = await this.generate(model, body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`vertex API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2267,25 +2336,41 @@ class GitLabDuoExecutor extends LLMExecutor {
     const extra = parsed.success ? parsed.data : {};
     this.baseURL = (extra.baseURL ?? readAuthString(opts.auth, "baseURL", "GITLAB_BASE_URL") ?? "https://gitlab.com/api/v4/ai/llm/proxy").replace(/\/+$/, "");
   }
-  async send(body) {
+  async send(body, caller) {
+    const requestRaw = JSON.stringify(body);
     const res = await fetch(this.baseURL, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`gitlab-duo request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`gitlab-duo request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in options;
     const log5 = logger.child("llm:gitlab-duo");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    if ("jsonSchemaName" in options) {
+      log5.debug(`call: model=${model} jsonSchema=${options.jsonSchemaName} via tool`);
+      const { toolName, tool, instruction } = buildStructuredJsonRequest({
+        instruction: options.instruction,
+        jsonSchemaName: options.jsonSchemaName,
+        jsonSchema: options.jsonSchema
+      });
+      const choice = await this.chatWithTools(model, {
+        caller: options.caller ?? options.jsonSchemaName,
+        instruction,
+        messages: [{ role: "user", content: options.message }],
+        tools: [tool]
+      });
+      return parseStructuredJsonResult(choice, toolName);
+    }
+    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
     const body = {
       model,
       messages: [
@@ -2293,7 +2378,7 @@ class GitLabDuoExecutor extends LLMExecutor {
         { role: "user", content: options.message }
       ]
     };
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`gitlab-duo API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2301,7 +2386,7 @@ class GitLabDuoExecutor extends LLMExecutor {
     if (!content) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(content) : content;
+    return content;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:gitlab-duo");
@@ -2314,7 +2399,7 @@ class GitLabDuoExecutor extends LLMExecutor {
       ],
       tools: options.tools.map(toTool)
     };
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`gitlab-duo API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2382,26 +2467,43 @@ class SnowflakeCortexExecutor extends LLMExecutor {
     const account = extra.account ?? readAuthString(opts.auth, "account", "SNOWFLAKE_ACCOUNT") ?? "";
     this.baseURL = account ? `https://${account}.snowflakecomputing.com/api/v2/cortex/inference:complete` : "https://__account__.snowflakecomputing.com/api/v2/cortex/inference:complete";
   }
-  async send(body) {
+  async send(body, caller) {
+    const requestRaw = JSON.stringify(body);
     const res = await fetch(this.baseURL, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`snowflake-cortex request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`snowflake-cortex request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in options;
-    const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     const log5 = logger.child("llm:snowflake-cortex");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    if ("jsonSchemaName" in options) {
+      log5.debug(`call: model=${model} jsonSchema=${options.jsonSchemaName} via tool`);
+      const { toolName, tool, instruction } = buildStructuredJsonRequest({
+        instruction: options.instruction,
+        jsonSchemaName: options.jsonSchemaName,
+        jsonSchema: options.jsonSchema
+      });
+      const choice = await this.chatWithTools(model, {
+        caller: options.caller ?? options.jsonSchemaName,
+        instruction,
+        messages: [{ role: "user", content: options.message }],
+        tools: [tool],
+        reasoningEffort: "none"
+      });
+      return parseStructuredJsonResult(choice, toolName);
+    }
+    const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
+    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
     const body = {
       model,
       messages: [
@@ -2412,7 +2514,7 @@ class SnowflakeCortexExecutor extends LLMExecutor {
     if (reasoning !== "none") {
       body["reasoning_effort"] = reasoning;
     }
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`snowflake-cortex API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2420,7 +2522,7 @@ class SnowflakeCortexExecutor extends LLMExecutor {
     if (!content) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(content) : content;
+    return content;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:snowflake-cortex");
@@ -2433,7 +2535,7 @@ class SnowflakeCortexExecutor extends LLMExecutor {
       ],
       tools: options.tools.map(toCortexTool)
     };
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`snowflake-cortex API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2822,7 +2924,11 @@ class Brain {
   async regenerateSchedules() {
     const today = new Date;
     const nextMonth = new Date(today.getFullYear(), today.getMonth() + 1, today.getDate());
-    await this.createMonthlySchedule(nextMonth);
+    const monthly = await this.createMonthlySchedule(nextMonth);
+    if (!monthly) {
+      log7.debug(`regenerateSchedules: skip daily — monthly schedule generation failed`);
+      return;
+    }
     const tomorrow = new Date(today.getFullYear(), today.getMonth(), today.getDate() + 1);
     await this.createDailySchedule(tomorrow);
     await this.createDailySchedule(today);
@@ -3085,75 +3191,56 @@ class Brain {
         content: userPrompt
       }
     ];
-    for (let step = 0;step < maxSteps; step += 1) {
-      log7.debug(`sendMessage: step ${step + 1}/${maxSteps} → model`);
-      let choice;
-      try {
-        choice = await llm.chatWithTools(llm.models.conversation, {
-          caller: initiate ? "start-conversation" : "send-message",
-          instruction: `${this.brainbase.baseSystemPrompt}
+    try {
+      await llm.chatWithToolExecution(llm.models.conversation, {
+        caller: initiate ? "start-conversation" : "send-message",
+        instruction: `${this.brainbase.baseSystemPrompt}
 
 ${instruction}`,
-          messages,
-          tools
-        });
-      } catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        logger.error(`sendMessage: LLM call failed at step ${step}: ${reason}`);
-        return replyMessages;
-      }
-      const assistantMessage = choice.message;
-      const toolCalls = assistantMessage.toolCalls ?? [];
-      const hasContent = typeof assistantMessage.content === "string" && assistantMessage.content.length > 0;
-      log7.debug(`sendMessage: step ${step + 1} → toolCalls=${toolCalls.length} hasContent=${hasContent}`);
-      if (toolCalls.length === 0) {
-        log7.debug(`sendMessage: model returned no tool calls; finalising with ${replyMessages.length} replies`);
-        return replyMessages;
-      }
-      messages.push(stripAssistantForHistory(assistantMessage));
-      for (const call of toolCalls) {
-        if (call.function.name === "addReplyMessage") {
-          const content = parseAddReplyMessageArguments(call.function.arguments);
-          if (content !== null) {
-            log7.debug(`sendMessage: addReplyMessage[${replyMessages.length}] (${content.length} chars)`);
-            send(content);
-            replyMessages.push(content);
-          } else {
+        messages,
+        tools,
+        maxSteps,
+        executeTool: async (call) => {
+          if (call.function.name === "addReplyMessage") {
+            const content = parseAddReplyMessageArguments(call.function.arguments);
+            if (content !== null) {
+              log7.debug(`sendMessage: addReplyMessage[${replyMessages.length}] (${content.length} chars)`);
+              await send(content);
+              replyMessages.push(content);
+              return JSON.stringify({
+                ok: true,
+                index: replyMessages.length - 1
+              });
+            }
             log7.debug(`sendMessage: addReplyMessage rejected (invalid arguments: ${call.function.arguments})`);
+            return JSON.stringify({ ok: false, error: "invalid arguments" });
           }
-          messages.push({
-            role: "tool",
-            toolCallId: call.id,
-            content: content === null ? JSON.stringify({ ok: false, error: "invalid arguments" }) : JSON.stringify({ ok: true, index: replyMessages.length - 1 })
-          });
-          continue;
-        }
-        if (call.function.name === "searchMemory") {
-          log7.debug(`sendMessage: searchMemory tool call`);
-          const result = await this.executeSearchTool(call.function.arguments);
-          messages.push({
-            role: "tool",
-            toolCallId: call.id,
-            content: result
-          });
-          continue;
-        }
-        log7.debug(`sendMessage: unknown tool "${call.function.name}"`);
-        messages.push({
-          role: "tool",
-          toolCallId: call.id,
-          content: JSON.stringify({
+          if (call.function.name === "searchMemory") {
+            log7.debug(`sendMessage: searchMemory tool call`);
+            return this.executeSearchTool(call.function.arguments);
+          }
+          if (call.function.name === "stop") {
+            log7.debug(`sendMessage: stop tool call`);
+            return JSON.stringify({ ok: true });
+          }
+          log7.debug(`sendMessage: unknown tool "${call.function.name}"`);
+          return JSON.stringify({
             ok: false,
             error: `Unknown tool: ${call.function.name}`
-          })
-        });
-      }
-      if (!hasContent && toolCalls.every((c) => c.function.name === "searchMemory")) {
-        log7.debug(`sendMessage: step was pure searchMemory, looping back`);
-        continue;
-      }
+          });
+        },
+        shouldEnd: (toolCalls) => toolCalls.some((c) => c.function.name === "stop"),
+        onNoToolCalls: () => {
+          if (replyMessages.length > 0)
+            return null;
+          return "If you do not want to send a message, call the `stop` tool explicitly to end your turn. " + "If you meant to send a message but ended by mistake, call `addReplyMessage`.";
+        }
+      });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      logger.error(`sendMessage: LLM call failed: ${reason}`);
     }
-    logger.warn(`sendMessage: reached maxSteps (${maxSteps}) without final reply`);
+    log7.debug(`sendMessage: done with ${replyMessages.length} replies`);
     return replyMessages;
   }
   async buildMemoryBlock() {
@@ -3356,7 +3443,7 @@ function buildSendMessageTools() {
   return [
     {
       name: "addReplyMessage",
-      description: "Append one chat bubble to the reply stream. Call once per bubble you want to send. Do not call when you are done — just return text without tool calls.",
+      description: "Append one chat bubble to the reply stream. Call once per bubble you want to send. After at least one successful call, you may end your turn without calling stop.",
       parameters: {
         type: "object",
         additionalProperties: false,
@@ -3380,6 +3467,15 @@ function buildSendMessageTools() {
         },
         required: ["query"]
       }
+    },
+    {
+      name: "stop",
+      description: "End your turn without sending any further messages. Required when you choose not to send a message. Not needed once you have already called addReplyMessage at least once.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {}
+      }
     }
   ];
 }
@@ -3405,13 +3501,6 @@ function parseSearchArguments(json) {
   }
   return null;
 }
-function stripAssistantForHistory(message) {
-  return {
-    role: "assistant",
-    content: message.content,
-    toolCalls: message.toolCalls
-  };
-}
 
 // src/channel/discord.ts
 import {
@@ -3431,10 +3520,18 @@ var SLEEP_MEMORY_CRON_KEY = "__sleep-memory__";
 var SLEEP_MEMORY_CRON_PATTERN = "0 * * * *";
 var START_CONVERSATION_CRON_KEY = "__start-conversation__";
 var START_CONVERSATION_CRON_PATTERN = "*/10 * * * *";
-var DAILY_SCHEDULE_CRON_KEY = "__daily-schedule__";
-var DAILY_SCHEDULE_CRON_PATTERN = "0 0 * * *";
-var DAILY_SCHEDULE_NOON_CRON_KEY = "__daily-schedule-noon__";
-var DAILY_SCHEDULE_NOON_CRON_PATTERN = "0 12 * * *";
+var SCHEDULE_CRON_KEY = "__schedule__";
+var SCHEDULE_CRON_PATTERN = "0 0 * * *";
+var SCHEDULE_NOON_CRON_KEY = "__schedule-noon__";
+var SCHEDULE_NOON_CRON_PATTERN = "0 12 * * *";
+var DO_ACTIONS = ["generateSchedule", "sleepMemory"];
+var VIEW_THINGS = [
+  "daily-schedule",
+  "monthly-schedule",
+  "sending-queue",
+  "deferred-queue",
+  "today-availability"
+];
 
 class BaseChannel {
   brain;
@@ -3454,8 +3551,14 @@ class BaseChannel {
   static activeChannels = new Map;
   constructor(brain) {
     this.brain = brain;
-    this.registerCron(SLEEP_MEMORY_CRON_KEY, SLEEP_MEMORY_CRON_PATTERN, async () => {
-      const dateKey2 = formatDateKey(new Date);
+    this.registerCron(SLEEP_MEMORY_CRON_KEY, SLEEP_MEMORY_CRON_PATTERN, () => this.runSleepMemory());
+    this.registerCron(SCHEDULE_CRON_KEY, SCHEDULE_CRON_PATTERN, () => this.regenerateSchedules());
+    this.registerCron(SCHEDULE_NOON_CRON_KEY, SCHEDULE_NOON_CRON_PATTERN, () => this.regenerateSchedules());
+    this.registerCron(START_CONVERSATION_CRON_KEY, START_CONVERSATION_CRON_PATTERN, () => this.runStartConversation());
+  }
+  async runSleepMemory(force = false) {
+    const dateKey2 = formatDateKey(new Date);
+    if (!force) {
       const availability = await this.brain.getAvailability();
       if (availability.status !== "offline") {
         logger.debug(`sleepMemory cron: skip — availability=${availability.status}`);
@@ -3466,12 +3569,9 @@ class BaseChannel {
         logger.debug(`sleepMemory cron: skip — journal for ${dateKey2} exists`);
         return;
       }
-      const history = await this.getMessageHistoryBetween(new Date(Date.now() - 24 * 60 * 60 * 1000), new Date);
-      await this.brain.sleepMemory(new Date, history);
-    });
-    this.registerCron(DAILY_SCHEDULE_CRON_KEY, DAILY_SCHEDULE_CRON_PATTERN, () => this.regenerateSchedules());
-    this.registerCron(DAILY_SCHEDULE_NOON_CRON_KEY, DAILY_SCHEDULE_NOON_CRON_PATTERN, () => this.regenerateSchedules());
-    this.registerCron(START_CONVERSATION_CRON_KEY, START_CONVERSATION_CRON_PATTERN, () => this.runStartConversation());
+    }
+    const history = await this.getMessageHistoryBetween(new Date(Date.now() - 24 * 60 * 60 * 1000), new Date);
+    await this.brain.sleepMemory(new Date, history);
   }
   async regenerateSchedules() {
     logger.debug(`regenerateSchedules: tick for ${this.brain.brainbase.displayName}`);
@@ -3693,6 +3793,88 @@ class BaseChannel {
   static all() {
     return Array.from(BaseChannel.activeChannels.values());
   }
+  static forceDo(brainId, action) {
+    const channel = BaseChannel.activeChannels.get(brainId);
+    if (!channel) {
+      return {
+        ok: false,
+        error: `no active channel for brain "${brainId}" (is it activated and daemon running?)`
+      };
+    }
+    const displayName = channel.brain.brainbase.displayName;
+    logger.info(`do ${action}: queued for "${displayName}" (${brainId})`);
+    (async () => {
+      try {
+        if (action === "generateSchedule") {
+          await channel.regenerateSchedules();
+        } else {
+          await channel.runSleepMemory(true);
+        }
+        logger.success(`do ${action}: done for "${displayName}" (${brainId})`);
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        logger.error(`do ${action}: failed for "${displayName}" (${brainId}): ${reason}`);
+      }
+    })();
+    return { ok: true, displayName };
+  }
+  static async view(brainId, thing) {
+    const channel = BaseChannel.activeChannels.get(brainId);
+    if (!channel) {
+      return {
+        ok: false,
+        error: `no active channel for brain "${brainId}" (is it activated and daemon running?)`
+      };
+    }
+    const displayName = channel.brain.brainbase.displayName;
+    logger.debug(`view ${thing}: "${displayName}" (${brainId})`);
+    return {
+      ok: true,
+      displayName,
+      value: await channel.readView(thing)
+    };
+  }
+  async readView(thing) {
+    const now = new Date;
+    switch (thing) {
+      case "daily-schedule": {
+        const key = formatDateKey(now);
+        const stored = await this.brain.memory.get(`daily-schedule:${key}`);
+        if (!stored)
+          return null;
+        try {
+          return { key, schedule: JSON.parse(stored.content) };
+        } catch {
+          return { key, raw: stored.content };
+        }
+      }
+      case "monthly-schedule": {
+        const key = formatMonthKey(now);
+        const stored = await this.brain.memory.get(`monthly-schedule:${key}`);
+        if (!stored)
+          return null;
+        try {
+          return { key, schedule: JSON.parse(stored.content) };
+        } catch {
+          return { key, raw: stored.content };
+        }
+      }
+      case "sending-queue":
+        return this.isSendingQueue.map((m) => ({
+          sender: m.sender,
+          time: m.time.toISOString(),
+          content: m.content
+        }));
+      case "deferred-queue":
+        return this.deferredQueue.map((m) => ({
+          sender: m.sender,
+          time: m.time.toISOString(),
+          content: m.content
+        }));
+      case "today-availability":
+        return await this.brain.getTodayScheduledAvailability(now);
+    }
+  }
   static async shutdownAll() {
     await Promise.all(BaseChannel.all().map((c) => c.shutdown()));
   }
@@ -4202,6 +4384,63 @@ defineCommand({
   }
 });
 
+// src/commands/daemon/doCommand.ts
+defineCommand({
+  name: "do",
+  handler: async (args) => {
+    const action = args?.action;
+    const brainId = args?.brainId;
+    logger.debug(`do handler: action="${action}" brainId="${brainId}"`);
+    if (typeof action !== "string" || !DO_ACTIONS.includes(action)) {
+      return {
+        ok: false,
+        error: `invalid action (expected one of: ${DO_ACTIONS.join(", ")})`
+      };
+    }
+    if (typeof brainId !== "string" || brainId.trim().length === 0) {
+      return { ok: false, error: "missing brainId" };
+    }
+    const result = BaseChannel.forceDo(brainId.trim(), action);
+    if (!result.ok)
+      return result;
+    return {
+      ok: true,
+      result: { action, brainId: brainId.trim(), displayName: result.displayName }
+    };
+  }
+});
+
+// src/commands/daemon/viewCommand.ts
+defineCommand({
+  name: "view",
+  handler: async (args) => {
+    const thing = args?.thing;
+    const brainId = args?.brainId;
+    logger.debug(`view handler: thing="${thing}" brainId="${brainId}"`);
+    if (typeof thing !== "string" || !VIEW_THINGS.includes(thing)) {
+      return {
+        ok: false,
+        error: `invalid thing (expected one of: ${VIEW_THINGS.join(", ")})`
+      };
+    }
+    if (typeof brainId !== "string" || brainId.trim().length === 0) {
+      return { ok: false, error: "missing brainId" };
+    }
+    const result = await BaseChannel.view(brainId.trim(), thing);
+    if (!result.ok)
+      return result;
+    return {
+      ok: true,
+      result: {
+        thing,
+        brainId: brainId.trim(),
+        displayName: result.displayName,
+        value: result.value
+      }
+    };
+  }
+});
+
 // src/commands/daemon.ts
 async function startChannels() {
   const items = await brainManager.listAvailableBrain();
@@ -4238,8 +4477,8 @@ async function startChannels() {
 async function daemon() {
   const logDir = join5(config.brainboxRoot, "logs");
   logger.configure({ logDir });
-  configureLlmLog(join5(logDir, "llm"));
-  logger.debug(`daemon: boot (logDir=${logDir}, llmLogDir=${join5(logDir, "llm")})`);
+  configureLlmLog(config.debug ? join5(logDir, "llm") : undefined);
+  logger.debug(`daemon: boot (debug=${config.debug}, logDir=${logDir}, llmLog=${config.debug})`);
   const started = await startChannels();
   if (started === 0) {
     logger.info("No activated brains with channels. Daemon idling.");
@@ -4406,6 +4645,33 @@ async function removeBrain(brainId) {
   }
   logger.success(`Removed brain "${brain.displayName}" (${chalk2.cyan(brainId)})`);
 }
+async function doAction(action, brainId) {
+  if (!DO_ACTIONS.includes(action)) {
+    logger.error(`Unknown action "${action}". Expected one of: ${DO_ACTIONS.join(", ")}`);
+    process.exit(1);
+  }
+  logger.debug(`do: action=${action} brainId=${brainId}`);
+  const response = await sendToDaemon({
+    command: "do",
+    args: { action, brainId }
+  });
+  const name = response.result?.displayName ?? brainId;
+  logger.success(`Successfully sent ${action} for "${name}" (${brainId}).`);
+}
+async function viewThing(thing, brainId) {
+  if (!VIEW_THINGS.includes(thing)) {
+    logger.error(`Unknown thing "${thing}". Expected one of: ${VIEW_THINGS.join(", ")}`);
+    process.exit(1);
+  }
+  logger.debug(`view: thing=${thing} brainId=${brainId}`);
+  const response = await sendToDaemon({
+    command: "view",
+    args: { thing, brainId }
+  });
+  const name = response.result?.displayName ?? brainId;
+  logger.info(`${thing} — "${name}" (${brainId})`);
+  console.log(JSON.stringify(response.result?.value ?? null, null, 2));
+}
 function register3(program) {
   const cmd = registerCommand(program, {
     name: "brain",
@@ -4416,6 +4682,8 @@ function register3(program) {
   cmd.command("remove <brainId>").description("Remove a brain and its memory").action(removeBrain);
   cmd.command("activate <brainId>").description("Activate a brain").action(activateBrain);
   cmd.command("deactivate <brainId>").description("Deactivate a brain").action(deactivateBrain);
+  cmd.command("do <action> <brainId>").description(`Force-run a daemon job (${DO_ACTIONS.join(" | ")}) for a live brain`).action(doAction);
+  cmd.command("view <thing> <brainId>").description(`Inspect a live brain value (${VIEW_THINGS.join(" | ")})`).action(viewThing);
   return cmd;
 }