talon-agent 3.19.1 → 3.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.19.1",
+  "version": "3.21.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -102,10 +102,10 @@
     "@grammyjs/transformer-throttler": "^1.2.1",
     "@kilocode/sdk": "^7.2.22",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@openai/agents": "^0.14.0",
-    "@openai/codex-sdk": "^0.146.0",
+    "@openai/agents": "^0.16.0",
+    "@openai/codex-sdk": "^0.147.0",
     "@opencode-ai/sdk": "^1.17.4",
-    "@playwright/mcp": "0.0.78",
+    "@playwright/mcp": "0.0.79",
     "@types/cross-spawn": "^6.0.6",
     "big-integer": "^1.6.52",
     "cheerio": "^1.2.0",
@@ -117,7 +117,7 @@
     "liquidjs": "^10.27.0",
     "marked": "^18.0.0",
     "mem0ai": "^3.0.13",
-    "openai": "^6.46.0",
+    "openai": "^7.5.0",
     "p-retry": "^8.0.0",
     "picocolors": "^1.1.1",
     "pino": "^10.3.1",

package/prompts/base.md

@@ -1,12 +1,6 @@
 Be concise and direct. Lead with the substance, keep it as short as the moment needs, and stop when it's said.
 
-## Conversation
-
-- Answer first; context and caveats after, and only when they change something for the reader.
-- Let depth follow the question: a quick ask gets a line or two, a real problem gets real work. When unsure, start small — people ask for more when they want it.
-- Chat is not a document. Plain sentences usually beat headings, bullet cascades, and closing summaries; reach for structure only when it genuinely clarifies.
-- Don't narrate your process or pad with filler — do the thing, then share what matters.
-- A short clarifying question beats a long answer to the wrong question, but only when the ambiguity is real.
+How you talk — voice, stances, what never to say — is the Identity section above. It applies on every backend and isn't repeated here.
 
 ## Tools
 

package/prompts/identity.md

@@ -1,6 +1,6 @@
 ## Who you are
 
-You're a Talon agent — a peer with tools, not a service desk. The model and tools available to you depend on the active backend; only the tools listed below this prompt actually exist for this run. Tools for talking to your current platform (send, react, and the rest) are always provided by the frontend.
+You're a Talon agent — a peer with tools, not a service desk. People talk to you all day; be someone worth talking to. The model and tools available to you depend on the active backend; only the tools listed below this prompt actually exist for this run. Tools for talking to your current platform (send, react, and the rest) are always provided by the frontend.
 
 ## Voice
 
@@ -10,13 +10,15 @@ Length follows the question, not habit: a quick ask gets a line or two, a real p
 
 Have opinions and give reasons. "I'd use X, because Y" beats five options with no recommendation.
 
-Match the room. Casual chat gets casual replies, technical questions get precise answers, and a tense thread doesn't need you adding heat. Follow up on what's genuinely interesting — not out of habit.
+Engage with what was actually said, not the generic shape of it. The detail someone mentions in passing is often the interesting part; picking it up is the difference between a conversation and a ticket.
 
-Be expressive where the platform allows — emoji, reactions, stickers, humour — as seasoning, not the meal.
+Match the room. Casual chat gets casual replies, technical questions get precise answers, and a tense thread doesn't need you adding heat. Humour, emoji, reactions, stickers — wherever the platform has them, use them the way a person would: as seasoning, not the meal.
+
+Sound like yourself. Plain words, contractions, the occasional aside. A reply that reads like a person thinking beats one that reads like a product performing.
 
 ## Stances
 
-Situations are what define a voice. Take these positions.
+Voice shows up in the awkward moments. Take these positions.
 
 **Their plan is bad.** Say what's wrong in a sentence or two, then do the work as asked. Don't refuse to engage, don't lecture, and don't quietly do it a different way instead.
 
@@ -30,7 +32,7 @@ Situations are what define a voice. Take these positions.
 
 **The request is ambiguous.** Make the call a careful colleague would make, and say which call you made. Ask only when different readings would mean materially different work.
 
-**You have nothing to add.** Then don't add it. "ok", "thanks", "lol" want a reaction or silence, not a reply. In groups you're a participant, not a host — don't answer for other people, and let conversations that aren't about you flow past.
+**You have nothing to add.** Then don't. "ok", "thanks", "lol" want a reaction or silence, not a reply. In groups you're a participant, not a host — don't answer for other people, and let conversations that aren't about you flow past.
 
 ## Never
 

package/src/bootstrap.ts

@@ -415,6 +415,14 @@ export async function initBackendAndDispatcher(
       );
       return { model, backendId: beId };
     },
+    // ...and when that ambient backend turns out to be one that can't host an
+    // isolated run (e.g. the chat was switched to a provider with no background
+    // capability), the job reruns on the heartbeat role backend instead of
+    // being skipped.
+    resolveJobFallback: () => ({
+      backendId: config.heartbeatBackend ?? config.backend,
+      model: config.heartbeatModel ?? config.model ?? null,
+    }),
   });
   initTriggers({ execute: dispatcherExecute });
   resumeTriggersAfterRestart().catch((err) =>

package/src/core/background/cron.ts

@@ -62,6 +62,13 @@ type CronDeps = {
   resolveChatModel: (
     chatId: string,
   ) => Promise<{ model: string | null; backendId: string }>;
+  /**
+   * Resolve the deployment's background-capable role backend (heartbeat, else
+   * the configured default). Used as a fallback for query jobs that inherited
+   * the chat's ambient backend and found it can't run isolated jobs — a
+   * `/model` switch in the chat shouldn't silently disable the schedule.
+   */
+  resolveJobFallback?: () => { model: string | null; backendId: string };
 };
 
 let deps: CronDeps | null = null;
@@ -473,6 +480,10 @@ export async function executeJob(job: CronJob): Promise<ExecuteJobResult> {
   // chat's backend + active model.
   let backendId: string;
   let model: string | null;
+  // A job that pinned its own provider is honoured as written — no fallback.
+  // One that inherited the chat's ambient backend gets a safety net, because
+  // that backend can change under it at any time (`/model`, a rebind).
+  let fallback: { backendId: string; model: string } | undefined;
   if (job.provider) {
     backendId = job.provider;
     model = job.model ?? null;
@@ -480,6 +491,10 @@ export async function executeJob(job: CronJob): Promise<ExecuteJobResult> {
     const chat = await deps.resolveChatModel(job.chatId);
     backendId = chat.backendId;
     model = job.model ?? chat.model;
+    const candidate = deps.resolveJobFallback?.();
+    if (candidate?.model) {
+      fallback = { backendId: candidate.backendId, model: candidate.model };
+    }
   }
   if (!model) {
     throw new Error(
@@ -502,6 +517,7 @@ export async function executeJob(job: CronJob): Promise<ExecuteJobResult> {
     label: job.name,
     kind: "cron",
     timeoutMs: CRON_JOB_TIMEOUT_MS,
+    ...(fallback ? { fallback } : {}),
   });
   if (result.status === "skipped") {
     await deps.sendMessage(

package/src/core/background/job-oneshot.ts

@@ -51,6 +51,19 @@ export interface JobOneShotParams {
   readonly kind: JobKind;
   /** Optional override of the hard timeout. */
   readonly timeoutMs?: number;
+  /**
+   * Backend to retry on when the primary one can't host an isolated run.
+   *
+   * A cron `query` job with no provider override inherits the chat's *ambient*
+   * backend, which any `/model` switch can change out from under it — including
+   * to a provider with no background capability (or one where the chat's model
+   * isn't selectable). That has nothing to do with the job, so rather than skip
+   * it, fall back to the deployment's background-capable role backend
+   * (heartbeat, else the configured default). Omitted for jobs that pinned
+   * their own provider: an explicit choice is honoured or skipped, never
+   * silently rerouted.
+   */
+  readonly fallback?: { readonly backendId: string; readonly model: string };
 }
 
 export type JobOneShotResult =
@@ -75,7 +88,17 @@ async function openJobLog(
   return appendLog;
 }
 
-function skipJob(params: JobOneShotParams, reason: string): JobOneShotResult {
+// The warning is deferred to runJobOneShot: an attempt that fails here may
+// still succeed on the fallback backend, and a run that ultimately ran must
+// not leave a "skipped" warning in the logs.
+function skipJob(reason: string): JobOneShotResult {
+  return { status: "skipped", reason };
+}
+
+function reportSkip(
+  params: JobOneShotParams,
+  reason: string,
+): JobOneShotResult {
   logWarn(
     params.kind === "cron" ? "cron" : "triggers",
     `isolated job "${params.label}" skipped: ${reason}`,
@@ -84,19 +107,20 @@ function skipJob(params: JobOneShotParams, reason: string): JobOneShotResult {
 }
 
 /**
- * Run a trigger/cron wake-up as an isolated one-shot on a different backend.
- * Acquires the target backend on demand and always releases it afterwards.
+ * One attempt on one backend: acquire it, check it can actually host an
+ * isolated run, execute, and always release it afterwards.
  */
-export async function runJobOneShot(
+async function attemptJobOneShot(
   params: JobOneShotParams,
+  backendId: string,
+  model: string,
 ): Promise<JobOneShotResult> {
   let acquired: Awaited<ReturnType<typeof acquireBackendInstance>>;
   try {
-    acquired = await acquireBackendInstance(params.backendId);
+    acquired = await acquireBackendInstance(backendId);
   } catch (err) {
     return skipJob(
-      params,
-      `provider "${params.backendId}" is unavailable: ${err instanceof Error ? err.message : String(err)}`,
+      `provider "${backendId}" is unavailable: ${err instanceof Error ? err.message : String(err)}`,
     );
   }
 
@@ -105,32 +129,29 @@ export async function runJobOneShot(
     const background = backend.background;
     if (!background) {
       return skipJob(
-        params,
-        `provider "${params.backendId}" can't run isolated jobs (no background capability).`,
+        `provider "${backendId}" can't run isolated jobs (no background capability).`,
       );
     }
 
     let modelValid = false;
     try {
-      modelValid = await isModelValidForBackend(backend, params.model);
+      modelValid = await isModelValidForBackend(backend, model);
     } catch (err) {
       return skipJob(
-        params,
-        `could not validate model "${params.model}" on provider "${params.backendId}": ${err instanceof Error ? err.message : String(err)}`,
+        `could not validate model "${model}" on provider "${backendId}": ${err instanceof Error ? err.message : String(err)}`,
       );
     }
     if (!modelValid) {
       return skipJob(
-        params,
-        `model "${params.model}" is not selectable on provider "${params.backendId}".`,
+        `model "${model}" is not selectable on provider "${backendId}".`,
       );
     }
 
     const appendLog = await openJobLog(
       params.kind,
       params.label,
-      params.backendId,
-      params.model,
+      backendId,
+      model,
     );
 
     const abortController = new AbortController();
@@ -140,7 +161,7 @@ export async function runJobOneShot(
       chatId: params.chatId,
       abort: () => abortController.abort(),
     });
-    task.bind({ model: params.model, backendId: params.backendId });
+    task.bind({ model, backendId });
 
     const oneShot: OneShotAgentParams = {
       prompt: params.payload,
@@ -151,7 +172,7 @@ export async function runJobOneShot(
       ),
       contextLabel: JOB_CONTEXT_LABEL,
       workspace: dirs.workspace,
-      model: params.model,
+      model,
       abortController,
       appendLog,
     };
@@ -172,10 +193,49 @@ export async function runJobOneShot(
     }
     log(
       params.kind === "cron" ? "cron" : "triggers",
-      `isolated job "${params.label}" ran on ${params.backendId}/${params.model}`,
+      `isolated job "${params.label}" ran on ${backendId}/${model}`,
     );
     return { status: "ran" };
   } finally {
     await release();
   }
 }
+
+/**
+ * Run a trigger/cron wake-up as an isolated one-shot.
+ *
+ * Tries the requested backend first. When that backend can't host the run at
+ * all — no background capability, unavailable, or the inherited model isn't
+ * selectable on it — and a distinct {@link JobOneShotParams.fallback} was
+ * supplied, the job is retried there instead of being skipped. A job is only
+ * reported as skipped once every candidate has been ruled out.
+ */
+export async function runJobOneShot(
+  params: JobOneShotParams,
+): Promise<JobOneShotResult> {
+  const first = await attemptJobOneShot(params, params.backendId, params.model);
+  if (first.status === "ran") return first;
+
+  const { fallback } = params;
+  if (
+    !fallback ||
+    (fallback.backendId === params.backendId && fallback.model === params.model)
+  ) {
+    return reportSkip(params, first.reason);
+  }
+
+  log(
+    params.kind === "cron" ? "cron" : "triggers",
+    `isolated job "${params.label}": ${params.backendId}/${params.model} can't host it (${first.reason}) — retrying on ${fallback.backendId}/${fallback.model}`,
+  );
+  const second = await attemptJobOneShot(
+    params,
+    fallback.backendId,
+    fallback.model,
+  );
+  if (second.status === "ran") return second;
+  return reportSkip(
+    params,
+    `${first.reason} Fallback ${fallback.backendId}/${fallback.model} also unusable: ${second.reason}`,
+  );
+}

package/src/core/engine/dispatcher.ts

@@ -10,6 +10,7 @@
 
 import type { ExecuteParams, ExecuteResult } from "../types.js";
 import { log } from "../../util/log.js";
+import { taskTable, type KillOutcome } from "../tasks/index.js";
 import {
   initWeaver,
   type Weaver,
@@ -57,6 +58,14 @@ export function snapshot(): ThreadSnapshot[] {
   return weaver?.snapshot() ?? [];
 }
 
+/**
+ * Stop only this chat's active turn. A later message already waiting in the
+ * per-chat FIFO is intentionally left alone and runs after the stop settles.
+ */
+export function stopCurrentTurn(chatId: string): KillOutcome {
+  return taskTable.killRunningTurn(chatId);
+}
+
 /**
  * Execute an AI query with full lifecycle management.
  * Same-chat queries are serialized (FIFO) to avoid session conflicts.

package/src/core/tasks/table.ts

@@ -122,6 +122,24 @@ export class TaskTable {
     return { ok: true };
   }
 
+  /**
+   * Request an abort for the turn currently running in one chat. Queued turns
+   * are deliberately ignored: `/stop` means "stop what is happening now",
+   * never "discard my next message".
+   */
+  killRunningTurn(chatId: string): KillOutcome {
+    for (const [id, task] of this.live) {
+      if (
+        task.record.kind === "turn" &&
+        task.record.chatId === chatId &&
+        task.record.state === "running"
+      ) {
+        return this.kill(id);
+      }
+    }
+    return { ok: false, reason: "not-found" };
+  }
+
   /**
    * Every live task plus the bounded settled history, id-ascending.
    * Snapshots are copies — callers can never mutate table state.

package/src/frontend/discord/commands/definitions.ts

@@ -82,6 +82,10 @@ export function buildCommandDefinitions(devBuild = false): unknown[] {
       .setName("reset")
       .setDescription("Clear session and start fresh")
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName("stop")
+      .setDescription("Stop the current response")
+      .toJSON(),
     new SlashCommandBuilder()
       .setName("restart")
       .setDescription("Restart the bot (admin only)")

package/src/frontend/discord/commands/info.ts

@@ -31,7 +31,7 @@ export async function handleStart(
       "",
       "Mention me, reply to me, or DM me. Attach files, photos, voice notes — I'll read them.",
       "",
-      "/status  /reset  /help",
+      "/status  /stop  /reset  /help",
     ].join("\n"),
   );
 }
@@ -54,6 +54,7 @@ export async function handleHelp(
       "",
       "**Session**",
       "  /status — session info, usage, and stats",
+      "  /stop — stop the current response",
       "  /metrics — aggregate performance metrics (admin)",
       "  /dream — force memory consolidation now (admin)",
       "  /ping — health check with latency",

package/src/frontend/discord/commands/router.ts

@@ -30,7 +30,7 @@ import {
   handleMesh,
   handleUsage,
 } from "./info.js";
-import { handleReset, handleStatus } from "./session.js";
+import { handleReset, handleStatus, handleStop } from "./session.js";
 import {
   handleModel,
   handleEffort,
@@ -143,6 +143,8 @@ async function routeSlashCommand(
       return handlePulse(interaction, chatId);
     case "reset":
       return handleReset(interaction, gateway, chatId);
+    case "stop":
+      return handleStop(interaction, chatId);
     case "restart":
       return handleRestart(interaction);
     case "metrics":

package/src/frontend/discord/commands/session.ts

@@ -23,6 +23,7 @@ import {
   performSessionReset,
   collectSessionStatus,
 } from "../../shared/session-status.js";
+import { stopCurrentTurn } from "../../../core/engine/dispatcher.js";
 import { reply } from "./shared.js";
 
 export async function handleReset(
@@ -42,6 +43,18 @@ export async function handleReset(
   await reply(i, "Session cleared.", true);
 }
 
+export async function handleStop(
+  i: ChatInputCommandInteraction,
+  chatId: string,
+): Promise<void> {
+  const outcome = stopCurrentTurn(chatId);
+  await reply(
+    i,
+    outcome.ok ? "⏹ Stop requested." : "No response is currently running.",
+    true,
+  );
+}
+
 export async function handleStatus(
   i: ChatInputCommandInteraction,
   config: TalonConfig,

package/src/frontend/telegram/commands/definitions.ts

@@ -26,6 +26,7 @@ export const TELEGRAM_COMMANDS: ReadonlyArray<{
   { command: "model", description: "Show or change model" },
   { command: "effort", description: "Set thinking effort level" },
   { command: "pulse", description: "Conversation engagement settings" },
+  { command: "stop", description: "Stop the current response" },
   { command: "reset", description: "Clear session and start fresh" },
   { command: "restart", description: "Restart the bot (admin)" },
   { command: "usage", description: "Plan limits across every backend" },

package/src/frontend/telegram/commands/info.ts

@@ -21,7 +21,7 @@ export function registerInfoCommands(bot: Bot): void {
         "Send a message, photo, doc, or voice note.",
         "In groups, @mention or reply to activate.",
         "",
-        "/status  /reset  /help",
+        "/status  /stop  /reset  /help",
       ].join("\n"),
       { parse_mode: "HTML" },
     ),
@@ -40,6 +40,7 @@ export function registerInfoCommands(bot: Bot): void {
         "",
         "<b>Session</b>",
         "  /status -- session info, usage, and stats",
+        "  /stop -- stop the current response",
         "  /metrics -- aggregate performance metrics (admin)",
         "  /doctor -- environment and native-module health (admin)",
         "  /dream -- force memory consolidation now",

package/src/frontend/telegram/commands/session.ts

@@ -20,6 +20,7 @@ import {
   performSessionReset,
   collectSessionStatus,
 } from "../../shared/session-status.js";
+import { stopCurrentTurn } from "../../../core/engine/dispatcher.js";
 import type { RegisterDeps } from "./state.js";
 
 export function registerSessionCommands(
@@ -34,6 +35,13 @@ export function registerSessionCommands(
     await ctx.reply("Session cleared.");
   });
 
+  bot.command("stop", async (ctx) => {
+    const outcome = stopCurrentTurn(String(ctx.chat.id));
+    await ctx.reply(
+      outcome.ok ? "⏹ Stop requested." : "No response is currently running.",
+    );
+  });
+
   bot.command("status", async (ctx) => {
     const cid = String(ctx.chat.id);
     const s = await collectSessionStatus(

package/src/frontend/telegram/userbot.ts

@@ -134,10 +134,23 @@ function startConnectionMonitor(): void {
   if (reconnectTimer) return;
   reconnectTimer = setInterval(async () => {
     if (!client) return;
-    if (client.connected) return;
     if (reconnecting) return; // prevent overlapping reconnect attempts
-    reconnecting = true;
 
+    // GramJS keeps `client.connected === true` even after the underlying
+    // socket has silently died, so a real round-trip is the only reliable
+    // liveness signal. Without it the userbot can go stale for hours/days
+    // while the monitor believes it is still connected.
+    if (client.connected) {
+      try {
+        // A full API round-trip; throws if the socket is silently dead.
+        await client.getMe();
+        return; // genuinely alive
+      } catch {
+        logWarn("userbot", "Liveness check failed — treating socket as dead.");
+      }
+    }
+
+    reconnecting = true;
     logWarn("userbot", "Connection lost, attempting reconnect...");
     try {
       await client.connect();