@sulala/agent-os 0.1.28 → 0.1.30

package/dist/cli.js

@@ -1148,14 +1148,28 @@ async function callLLM(options) {
     body.tools = tools;
     body.tool_choice = "auto";
   }
-  const res = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${key}`
-    },
-    body: JSON.stringify(body)
-  });
+  const timeoutMs = Number(process.env.AGENT_OS_LLM_TIMEOUT_MS ?? 120000) || 120000;
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (controller.signal.aborted) {
+      throw new Error(`LLM request timed out after ${timeoutMs}ms`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timeout);
+  }
   if (!res.ok) {
     const text = await res.text();
     throw new Error(`LLM API error ${res.status}: ${text.slice(0, 200)}`);
@@ -1192,14 +1206,28 @@ async function* callLLMStream(options) {
     body.tools = tools;
     body.tool_choice = "auto";
   }
-  const res = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${key}`
-    },
-    body: JSON.stringify(body)
-  });
+  const timeoutMs = Number(process.env.AGENT_OS_LLM_TIMEOUT_MS ?? 120000) || 120000;
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (controller.signal.aborted) {
+      throw new Error(`LLM stream request timed out after ${timeoutMs}ms`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timeout);
+  }
   if (!res.ok) {
     const text = await res.text();
     throw new Error(`LLM API error ${res.status}: ${text.slice(0, 200)}`);
@@ -8707,6 +8735,11 @@ var init_skill_extract = __esm(() => {
 });
 
 // src/skills/skill-tools.ts
+function skillDebug(msg) {
+  if (!DEBUG_SKILLS)
+    return;
+  console.log(msg);
+}
 function getSkillBaseUrl() {
   const env = process.env.AGENT_OS_SKILL_BASE_URL?.trim();
   if (env)
@@ -8821,14 +8854,14 @@ function createDocOnlyRequestTool(skillId, apiBase, credentials, authScheme, aut
         }
       }
       const finalUrl = urlObj.toString();
-      console.log(`[skill:${skillId}] ${method} ${finalUrl} (auth: ${token ? "yes" : "no"})`);
+      skillDebug(`[skill:${skillId}] ${method} ${finalUrl} (auth: ${token ? "yes" : "no"})`);
       try {
         const res = await fetch(finalUrl, {
           method,
           headers,
           body: method !== "GET" && method !== "HEAD" && body != null ? JSON.stringify(body) : undefined
         });
-        console.log(`[skill:${skillId}] ${method} ${finalUrl} -> ${res.status}`);
+        skillDebug(`[skill:${skillId}] ${method} ${finalUrl} -> ${res.status}`);
         const text = await res.text();
         let data;
         try {
@@ -8875,14 +8908,14 @@ function createTokenRequestTool(skillId, toolId, baseUrl, description) {
         "Content-Type": "application/json",
         Authorization: `Bearer ${token}`
       };
-      console.log(`[skill:${skillId}] ${method} ${url} (token: yes)`);
+      skillDebug(`[skill:${skillId}] ${method} ${url} (token: yes)`);
       try {
         const res = await fetch(url, {
           method,
           headers,
           body: method !== "GET" && method !== "HEAD" && body != null ? JSON.stringify(body) : undefined
         });
-        console.log(`[skill:${skillId}] ${method} ${url} -> ${res.status}`);
+        skillDebug(`[skill:${skillId}] ${method} ${url} -> ${res.status}`);
         const text = await res.text();
         let data;
         try {
@@ -8899,7 +8932,10 @@ function createTokenRequestTool(skillId, toolId, baseUrl, description) {
     }
   };
 }
-var init_skill_tools = () => {};
+var DEBUG_SKILLS;
+var init_skill_tools = __esm(() => {
+  DEBUG_SKILLS = (process.env.AGENT_OS_DEBUG ?? "").trim() === "1" || (process.env.AGENT_OS_DEBUG_SKILLS ?? "").trim() === "1";
+});
 
 // src/skills/loader.ts
 import { readFile as readFile5, readdir as readdir3, cp, mkdir as mkdir3, writeFile as writeFile3, rm } from "fs/promises";
@@ -23201,13 +23237,34 @@ var init_events = __esm(() => {
 // src/core/runtime.ts
 import { readFile as readFile6 } from "fs/promises";
 import { join as join8 } from "path";
+function isRateLimitError(err) {
+  const msg = errorMessage(err);
+  return msg.includes("429") || /rate_limit|rate limit/i.test(msg);
+}
 function formatLLMErrorForUser(err) {
   const msg = errorMessage(err);
-  if (msg.includes("429") || /rate_limit|rate limit/i.test(msg)) {
+  if (isRateLimitError(err)) {
     return `Request limit reached. If this task requires a skill the agent doesn't have, install it from hub.sulala.ai and add it to this agent to avoid repeated attempts. Otherwise try again later.`;
   }
   return msg;
 }
+async function callLLMWithRetry(options) {
+  let lastErr;
+  for (let attempt = 0;attempt <= RATE_LIMIT_RETRIES; attempt++) {
+    try {
+      return await callLLM(options);
+    } catch (err) {
+      lastErr = err;
+      if (attempt < RATE_LIMIT_RETRIES && isRateLimitError(err)) {
+        const delay = RATE_LIMIT_BACKOFF_MS[attempt] ?? 8000;
+        await new Promise((r) => setTimeout(r, delay));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastErr;
+}
 function runAgentInner(options) {
   return (async () => {
     const { task, agent, conversationHistory = [], maxTurnsOverride } = options;
@@ -23255,7 +23312,7 @@ function runAgentInner(options) {
     while (turns < maxTurns) {
       turns++;
       try {
-        const response = await callLLM({
+        const response = await callLLMWithRetry({
           model: agent.model,
           messages,
           tools,
@@ -23406,7 +23463,7 @@ function runAgentInner(options) {
           ...messages,
           { role: "user", content: "Summarize the tool results above in one short paragraph for the user. Reply only with the summary, no tool calls." }
         ];
-        const summaryResponse = await callLLM({
+        const summaryResponse = await callLLMWithRetry({
           model: agent.model,
           messages: summaryMessages,
           tools: undefined
@@ -23699,7 +23756,7 @@ Use the following documentation to know how to call skill APIs. When you have a
 
 `);
 }
-var MAX_HISTORY_TURNS = 20, SKILL_REQUIRED_MESSAGE = "This task requires a skill that this agent doesn't have. Install the skill from hub.sulala.ai (Dashboard \u2192 Skills \u2192 install from store), then add it to this agent in Edit agent.", WORKSPACE_PROMPT_FILES;
+var MAX_HISTORY_TURNS = 20, SKILL_REQUIRED_MESSAGE = "This task requires a skill that this agent doesn't have. Install the skill from hub.sulala.ai (Dashboard \u2192 Skills \u2192 install from store), then add it to this agent in Edit agent.", RATE_LIMIT_RETRIES = 3, RATE_LIMIT_BACKOFF_MS, WORKSPACE_PROMPT_FILES;
 var init_runtime = __esm(() => {
   init_llm();
   init_tool_registry();
@@ -23710,6 +23767,7 @@ var init_runtime = __esm(() => {
   init_events();
   init_config();
   init_agent_registry();
+  RATE_LIMIT_BACKOFF_MS = [2000, 4000, 8000];
   WORKSPACE_PROMPT_FILES = ["IDENTITY.md", "USER.md", "SYSTEM.md", "TOOLS.md"];
 });
 
@@ -23854,6 +23912,75 @@ function validateGraph(graph) {
     throw new Error("Graph.edges must be an array");
   }
 }
+function graphDebug(msg) {
+  if (!DEBUG_GRAPHS)
+    return;
+  console.log(msg);
+}
+function truncatePredecessorOutput(text, maxChars) {
+  if (maxChars <= 0 || text.length <= maxChars)
+    return text;
+  return text.slice(0, maxChars) + `
+
+\u2026 [output truncated for next node]`;
+}
+function buildGraphNodeTaskInput(args) {
+  const { graphId, initialInput, nodeId, agentId, predecessors, successors } = args;
+  const predBlock = predecessors.length === 0 ? "(none)" : predecessors.map((p) => `---
+from: ${p.node_id} (${p.agent_id})
+content:
+${p.output.trim() || "(empty)"}`).join(`
+
+`);
+  const nextBlock = successors.length === 0 ? "(this is the final node; no next agent)" : successors.map((s, idx) => `${idx + 1}. ${s.node_id} (${s.agent_id || "agent"})`).join(`
+`);
+  return `You are running as part of a multi-agent graph pipeline.
+
+Graph: ${graphId}
+Current node: ${nodeId} (${agentId})
+
+Next node(s) in the pipeline:
+${nextBlock}
+
+User goal (original input):
+${initialInput.trim()}
+
+Handoff from previous node(s):
+${predBlock}
+
+Rules (strict):
+- Do NOT ask the user follow-up questions. If something is missing, make the most reasonable assumptions and proceed.
+- Treat the previous node outputs as authoritative context and continue the work.
+- Produce output that the NEXT node(s) above can immediately use.
+- If you used tools, include the final results in your output (not just \u201CI did it\u201D).
+
+Required output format:
+Return a single JSON object only (no markdown), with:
+{
+  "done": boolean,
+  "result": "your main deliverable (what you produced in this node)",
+  "next": "exact instruction to the next node(s) above about what to do with result. Address them by role, e.g. 'Source Verify Agent: verify these facts by checking reputable sources and flag anything inconsistent.'",
+  "artifacts": { "key": "value" }
+}
+
+Now do your node's job.`;
+}
+async function withTimeout(promise2, timeoutMs, label) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+    return promise2;
+  let timeout;
+  try {
+    return await Promise.race([
+      promise2,
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+  }
+}
 function topologicalLevels(graph) {
   const nodes = graph.nodes.map((n) => n.id);
   const incoming = new Map;
@@ -23905,20 +24032,50 @@ function getPredecessors(graph) {
     p.sort();
   return pred;
 }
+function getSuccessors(graph) {
+  const succ = new Map;
+  for (const n of graph.nodes)
+    succ.set(n.id, []);
+  for (const edge of graph.edges) {
+    if (succ.has(edge.from)) {
+      succ.get(edge.from).push(edge.to);
+    }
+  }
+  for (const [, s] of succ)
+    s.sort();
+  return succ;
+}
 async function runGraph(options) {
-  const { graph, input, max_turns_per_node = DEFAULT_GRAPH_MAX_TURNS_PER_NODE } = options;
+  const {
+    graph,
+    input,
+    max_turns_per_node = DEFAULT_GRAPH_MAX_TURNS_PER_NODE,
+    max_predecessor_output_chars = DEFAULT_GRAPH_MAX_PREDECESSOR_OUTPUT_CHARS
+  } = options;
+  const nodeTimeoutMs = Number(process.env.AGENT_OS_GRAPH_NODE_TIMEOUT_MS ?? DEFAULT_GRAPH_NODE_TIMEOUT_MS) || DEFAULT_GRAPH_NODE_TIMEOUT_MS;
   const levels = topologicalLevels(graph);
   const predecessors = getPredecessors(graph);
+  const successors = getSuccessors(graph);
   const outputs = new Map;
   const nodeResults = [];
-  for (const level of levels) {
+  const inputPreview = input.length > 80 ? input.slice(0, 80) + "\u2026" : input;
+  graphDebug(`[graph] Running graph "${graph.id}" (sync), input: ${JSON.stringify(inputPreview)}`);
+  for (let levelIndex = 0;levelIndex < levels.length; levelIndex++) {
+    const level = levels[levelIndex];
+    const nodeNames = level.map((id) => {
+      const n = graph.nodes.find((nn) => nn.id === id);
+      return n ? `${n.id} (${n.agent})` : id;
+    }).join(", ");
+    graphDebug(`[graph] Level ${levelIndex}: running nodes one by one: ${nodeNames}`);
     const runOne = async (nodeId) => {
       const node = graph.nodes.find((n) => n.id === nodeId);
       if (!node) {
+        graphDebug(`[graph] node ${nodeId} failed: Node not found`);
         return { node_id: nodeId, agent_id: "", success: false, output: "", error: "Node not found" };
       }
       const agent = await getAgent(node.agent);
       if (!agent) {
+        graphDebug(`[graph] node ${node.id} failed: Agent not found (${node.agent})`);
         return {
           node_id: node.id,
           agent_id: node.agent,
@@ -23928,29 +24085,55 @@ async function runGraph(options) {
         };
       }
       const preds = predecessors.get(node.id) ?? [];
-      const taskInput = preds.length === 0 ? input : preds.map((p) => outputs.get(p) ?? "").filter(Boolean).join(`
-
-`) || input;
-      const result = await runAgent({
-        agent,
-        task: taskInput,
-        maxTurnsOverride: max_turns_per_node
+      const predOutputs = preds.map((p) => {
+        const raw = outputs.get(p) ?? "";
+        const clipped = max_predecessor_output_chars > 0 ? truncatePredecessorOutput(raw, max_predecessor_output_chars) : raw;
+        return { node_id: p, agent_id: graph.nodes.find((n) => n.id === p)?.agent ?? "", output: clipped };
+      }).filter((p) => Boolean(p.output?.trim()));
+      const nextIds = successors.get(node.id) ?? [];
+      const nextMeta = nextIds.map((nid) => ({
+        node_id: nid,
+        agent_id: graph.nodes.find((n) => n.id === nid)?.agent ?? ""
+      }));
+      const taskInput = buildGraphNodeTaskInput({
+        graphId: graph.id,
+        initialInput: input,
+        nodeId: node.id,
+        agentId: node.agent,
+        predecessors: predOutputs,
+        successors: nextMeta
       });
-      outputs.set(node.id, result.output || "");
-      return {
-        node_id: node.id,
-        agent_id: node.agent,
-        success: result.success,
-        output: result.output,
-        error: result.error
-      };
+      graphDebug(`[graph] node ${node.id} (${node.agent}) running\u2026`);
+      try {
+        const result = await withTimeout(runAgent({
+          agent,
+          task: taskInput,
+          maxTurnsOverride: max_turns_per_node
+        }), nodeTimeoutMs, `[graph] node ${node.id} (${node.agent})`);
+        outputs.set(node.id, result.output || "");
+        const outPreview = (result.output?.length ?? 0) > 60 ? (result.output ?? "").slice(0, 60) + "\u2026" : result.output ?? "";
+        graphDebug(`[graph] node ${node.id} done: success=${result.success}${result.error ? ` error=${result.error}` : ""} output=${JSON.stringify(outPreview)}`);
+        return {
+          node_id: node.id,
+          agent_id: node.agent,
+          success: result.success,
+          output: result.output,
+          error: result.error
+        };
+      } catch (err) {
+        const msg = errorMessage(err);
+        graphDebug(`[graph] node ${node.id} failed: ${msg}`);
+        outputs.set(node.id, "");
+        return { node_id: node.id, agent_id: node.agent, success: false, output: "", error: msg };
+      }
     };
-    const levelResults = await Promise.all(level.map(runOne));
-    for (const r of levelResults) {
+    for (const nodeId of level) {
+      const r = await runOne(nodeId);
       nodeResults.push(r);
     }
   }
   const last = nodeResults[nodeResults.length - 1];
+  graphDebug(`[graph] Graph "${graph.id}" finished (sync). success=${last ? last.success : false}`);
   return {
     success: last ? last.success : false,
     output: last ? last.output : "",
@@ -23958,20 +24141,37 @@ async function runGraph(options) {
   };
 }
 async function runGraphStream(options, onEvent) {
-  const { graph, input, max_turns_per_node = DEFAULT_GRAPH_MAX_TURNS_PER_NODE } = options;
+  const {
+    graph,
+    input,
+    max_turns_per_node = DEFAULT_GRAPH_MAX_TURNS_PER_NODE,
+    max_predecessor_output_chars = DEFAULT_GRAPH_MAX_PREDECESSOR_OUTPUT_CHARS
+  } = options;
+  const nodeTimeoutMs = Number(process.env.AGENT_OS_GRAPH_NODE_TIMEOUT_MS ?? DEFAULT_GRAPH_NODE_TIMEOUT_MS) || DEFAULT_GRAPH_NODE_TIMEOUT_MS;
   const levels = topologicalLevels(graph);
   const predecessors = getPredecessors(graph);
+  const successors = getSuccessors(graph);
   const outputs = new Map;
   const nodeResults = [];
+  const inputPreview = input.length > 80 ? input.slice(0, 80) + "\u2026" : input;
+  graphDebug(`[graph] Running graph "${graph.id}", input: ${JSON.stringify(inputPreview)}`);
   try {
-    for (const level of levels) {
+    for (let levelIndex = 0;levelIndex < levels.length; levelIndex++) {
+      const level = levels[levelIndex];
+      const nodeNames = level.map((id) => {
+        const n = graph.nodes.find((nn) => nn.id === id);
+        return n ? `${n.id} (${n.agent})` : id;
+      }).join(", ");
+      graphDebug(`[graph] Level ${levelIndex}: running nodes one by one: ${nodeNames}`);
       const runOne = async (nodeId) => {
         const node = graph.nodes.find((n) => n.id === nodeId);
         if (!node) {
+          graphDebug(`[graph] node ${nodeId} failed: Node not found`);
           return { node_id: nodeId, agent_id: "", success: false, output: "", error: "Node not found" };
         }
         const agent = await getAgent(node.agent);
         if (!agent) {
+          graphDebug(`[graph] node ${node.id} failed: Agent not found (${node.agent})`);
           return {
             node_id: node.id,
             agent_id: node.agent,
@@ -23981,29 +24181,66 @@ async function runGraphStream(options, onEvent) {
           };
         }
         const preds = predecessors.get(node.id) ?? [];
-        const taskInput = preds.length === 0 ? input : preds.map((p) => outputs.get(p) ?? "").filter(Boolean).join(`
-
-`) || input;
-        const result = await runAgent({
-          agent,
-          task: taskInput,
-          maxTurnsOverride: max_turns_per_node
+        const predOutputs = preds.map((p) => {
+          const raw = outputs.get(p) ?? "";
+          const clipped = max_predecessor_output_chars > 0 ? truncatePredecessorOutput(raw, max_predecessor_output_chars) : raw;
+          return { node_id: p, agent_id: graph.nodes.find((n) => n.id === p)?.agent ?? "", output: clipped };
+        }).filter((p) => Boolean(p.output?.trim()));
+        const nextIds = successors.get(node.id) ?? [];
+        const nextMeta = nextIds.map((nid) => ({
+          node_id: nid,
+          agent_id: graph.nodes.find((n) => n.id === nid)?.agent ?? ""
+        }));
+        const taskInput = buildGraphNodeTaskInput({
+          graphId: graph.id,
+          initialInput: input,
+          nodeId: node.id,
+          agentId: node.agent,
+          predecessors: predOutputs,
+          successors: nextMeta
         });
-        outputs.set(node.id, result.output || "");
-        const payload = {
-          node_id: node.id,
-          agent_id: node.agent,
-          success: result.success,
-          output: result.output,
-          error: result.error
-        };
-        nodeResults.push(payload);
-        onEvent({ type: "node_done", ...payload });
-        return payload;
+        graphDebug(`[graph] node ${node.id} (${node.agent}) running\u2026`);
+        try {
+          const result = await withTimeout(runAgent({
+            agent,
+            task: taskInput,
+            maxTurnsOverride: max_turns_per_node
+          }), nodeTimeoutMs, `[graph] node ${node.id} (${node.agent})`);
+          outputs.set(node.id, result.output || "");
+          const payload = {
+            node_id: node.id,
+            agent_id: node.agent,
+            success: result.success,
+            output: result.output,
+            error: result.error
+          };
+          nodeResults.push(payload);
+          const outPreview = (result.output?.length ?? 0) > 60 ? (result.output ?? "").slice(0, 60) + "\u2026" : result.output ?? "";
+          graphDebug(`[graph] node ${node.id} done: success=${result.success}${result.error ? ` error=${result.error}` : ""} output=${JSON.stringify(outPreview)}`);
+          onEvent({ type: "node_done", ...payload });
+          return payload;
+        } catch (err) {
+          const msg = errorMessage(err);
+          graphDebug(`[graph] node ${node.id} failed: ${msg}`);
+          const payload = {
+            node_id: node.id,
+            agent_id: node.agent,
+            success: false,
+            output: "",
+            error: msg
+          };
+          outputs.set(node.id, "");
+          nodeResults.push(payload);
+          onEvent({ type: "node_done", ...payload });
+          return payload;
+        }
       };
-      await Promise.all(level.map(runOne));
+      for (const nodeId of level) {
+        await runOne(nodeId);
+      }
     }
     const last = nodeResults[nodeResults.length - 1];
+    graphDebug(`[graph] Graph "${graph.id}" finished. success=${last ? last.success : false}`);
     onEvent({
       type: "done",
       success: last ? last.success : false,
@@ -24012,15 +24249,17 @@ async function runGraphStream(options, onEvent) {
     });
   } catch (err) {
     const msg = errorMessage(err);
+    console.error(`[graph] Graph "${graph.id}" error:`, msg);
     onEvent({ type: "error", message: msg });
     throw err;
   }
 }
-var DEFAULT_GRAPHS_DIR, DEFAULT_GRAPH_MAX_TURNS_PER_NODE = 5;
+var DEFAULT_GRAPHS_DIR, DEFAULT_GRAPH_MAX_TURNS_PER_NODE = 5, DEFAULT_GRAPH_MAX_PREDECESSOR_OUTPUT_CHARS = 4000, DEFAULT_GRAPH_NODE_TIMEOUT_MS = 120000, DEBUG_GRAPHS;
 var init_graphs = __esm(() => {
   init_agent_registry();
   init_runtime();
   DEFAULT_GRAPHS_DIR = join9(process.env.HOME || process.env.USERPROFILE || "~", ".agent-os", "graphs");
+  DEBUG_GRAPHS = (process.env.AGENT_OS_DEBUG ?? "").trim() === "1" || (process.env.AGENT_OS_DEBUG_GRAPHS ?? "").trim() === "1";
 });
 
 // src/http/utils.ts
@@ -25965,9 +26204,166 @@ var init_tasks = __esm(() => {
   TASKS_DIR = process.env.AGENT_OS_TASKS_DIR || join10(process.env.HOME || process.env.USERPROFILE || "~", ".agent-os", "tasks");
   TASKS_FILE = join10(TASKS_DIR, "tasks.log");
   memoryTaskStore = new MemoryTaskStore;
-  maxWorkers = Math.max(1, (os.cpus?.().length ?? 1) * 2);
+  maxWorkers = process.env.AGENT_OS_MAX_WORKERS != null ? Math.max(1, parseInt(process.env.AGENT_OS_MAX_WORKERS, 10) || 1) : Math.max(1, (os.cpus?.().length ?? 1) * 2);
 });
 
+// src/core/prompt-gate.ts
+function looksLikeOnlyUrl(text) {
+  const t = text.trim();
+  if (!t)
+    return false;
+  const urlRegex = /https?:\/\/\S+/g;
+  const urls = t.match(urlRegex) ?? [];
+  if (urls.length !== 1)
+    return false;
+  const withoutUrl = t.replace(urlRegex, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+  return withoutUrl.length <= 12;
+}
+function hasAny(text, needles) {
+  const t = text.toLowerCase();
+  return needles.some((n) => t.includes(n));
+}
+function genericTemplate(mode) {
+  const scope = mode.kind === "graph_run" ? `Graph: ${mode.graph_id}` : `Agent: ${mode.agent_id}`;
+  return `Goal (${scope}):
+
+Constraints (optional but recommended):
+- How many results? (e.g. 1)
+- Allowed sources: [general knowledge only] [web allowed]
+- If web allowed: max pages/sources (e.g. 1) + what to do if blocked (stop/skip)
+- Output format: (e.g. JSON) + required keys
+- Length limit: (e.g. <= 120 words)
+
+If this involves actions (CRM / posting / updating):
+- Which system?
+- Exact fields to write
+- Failure policy (return payload only / retry / stop)`;
+}
+function genericSuggestions(text) {
+  const wantsCrm = hasAny(text, ["crm", "hubspot", "salesforce", "pipeline", "deal", "contact", "sync", "update", "create"]);
+  const wantsWeb = hasAny(text, ["http://", "https://", "browse", "web", "site", "link", "scrape", "crawl", "research"]);
+  return [
+    {
+      id: "fast_no_tools",
+      title: "Fast (no tools)",
+      prompt: `Do NOT browse the web or call any tools.
+Use general knowledge only.
+Return strict JSON only.
+Keep it under 120 words.`
+    },
+    {
+      id: "balanced_bounded_web",
+      title: "Balanced (bounded web)",
+      prompt: `If you browse the web, browse at most ONE page total. If blocked/slow, reply exactly: "BLOCKED".
+Return strict JSON only.
+Keep it under 160 words.`
+    },
+    ...wantsWeb ? [
+      {
+        id: "thorough_bounded",
+        title: "Thorough (bounded)",
+        prompt: `Use up to 3 sources/pages max.
+Stop once you have enough for ONE high-confidence answer.
+Return strict JSON only.
+If any source is blocked, skip it.`
+      }
+    ] : [],
+    ...wantsCrm ? [
+      {
+        id: "action_only_no_research",
+        title: "Action-only (no research)",
+        prompt: `Do NOT browse the web.
+If required info is missing, ask for it first.
+Then perform the action.
+If the action fails, return the JSON payload you would write.`
+      }
+    ] : []
+  ];
+}
+function detectRiskScore(text) {
+  let score = 0;
+  if (hasAny(text, ["find", "research", "scrape", "crawl", "lookup", "look up", "analyze", "compare", "summarize"]))
+    score += 2;
+  if (hasAny(text, ["lead", "prospect", "enterprise", "companies", "list", "enrich"]))
+    score += 2;
+  if (hasAny(text, ["http://", "https://", "website", "link", "url"]))
+    score += 2;
+  if (hasAny(text, ["crm", "hubspot", "salesforce", "pipeline", "deal", "contact", "sync", "update", "create"]))
+    score += 3;
+  if (text.length > 400)
+    score += 1;
+  return score;
+}
+function detectBoundsScore(text) {
+  let score = 0;
+  const t = text.toLowerCase();
+  if (/\bjson\b/.test(t) || hasAny(t, ["output json", "return json", "keys:"]))
+    score += 2;
+  if (/\b(one|1|exactly\s+\d+)\b/.test(t))
+    score += 2;
+  if (hasAny(t, ["do not browse", "don't browse", "no tools", "do not call any tools", "web allowed"]))
+    score += 2;
+  if (hasAny(t, ["max", "at most", "no more than", "one page", "one source", "sources", "limit"]))
+    score += 1;
+  if (hasAny(t, ["under", "<=", "words", "characters"]))
+    score += 1;
+  if (hasAny(t, ["if blocked", "if slow", "timeout", "skip", "stop"]))
+    score += 1;
+  return score;
+}
+function shouldGate(mode, text) {
+  const risk = detectRiskScore(text);
+  const bounds = detectBoundsScore(text);
+  const graphBias = mode.kind === "graph_run" ? 1 : 0;
+  return risk + graphBias >= 4 && bounds <= 2;
+}
+function promptGate(mode, input) {
+  const text = (input ?? "").trim();
+  if (!text) {
+    return {
+      decision: "needs_clarification",
+      reason: "Empty prompt",
+      template: genericTemplate(mode),
+      suggestions: genericSuggestions(text),
+      questions: [{ id: "goal", prompt: "What is the goal?", example: "Find one lead and draft an intro message" }]
+    };
+  }
+  if (looksLikeOnlyUrl(text)) {
+    return {
+      decision: "needs_clarification",
+      reason: "Prompt is mostly a URL; missing goal/constraints",
+      template: genericTemplate(mode),
+      suggestions: genericSuggestions(text),
+      questions: [
+        { id: "task", prompt: "What should I do with this link?", example: "Extract 1 company lead and summarize why it's a fit" },
+        { id: "constraints", prompt: "Any constraints (geo/ICP/format)?" }
+      ]
+    };
+  }
+  if (shouldGate(mode, text)) {
+    const riskBits = [];
+    if (hasAny(text, ["lead", "prospect", "companies"]))
+      riskBits.push("lead finding");
+    if (hasAny(text, ["http://", "https://", "link", "url", "website"]))
+      riskBits.push("web access");
+    if (hasAny(text, ["crm", "hubspot", "salesforce", "sync", "update", "create"]))
+      riskBits.push("actions/CRM");
+    const reason = riskBits.length > 0 ? `This request may trigger ${riskBits.join(" + ")} without clear limits. Choose a safe mode or add bounds (format, limits, tool policy).` : "This request is high-cost without clear limits. Add bounds or choose a safe mode.";
+    return {
+      decision: "needs_clarification",
+      reason,
+      template: genericTemplate(mode),
+      suggestions: genericSuggestions(text),
+      questions: [
+        { id: "count", prompt: "How many results do you want?", example: "1" },
+        { id: "tools", prompt: "Should I use the web/tools or general knowledge only?", example: "General knowledge only (fast)" },
+        { id: "format", prompt: "What output format do you want?", example: "JSON with keys: company, reason, next_step" }
+      ]
+    };
+  }
+  return { decision: "allow" };
+}
+
 // src/http/handlers.ts
 import { readFile as readFile9, writeFile as writeFile5, stat } from "fs/promises";
 import { join as join11 } from "path";
@@ -26004,6 +26400,17 @@ async function handleRun(req, memoryStore) {
       conversationHistory = getConversationHistoryForRun(memoryStore, conversation_id.trim());
     } catch {}
   }
+  const gate = promptGate({ kind: "agent_run", agent_id }, task);
+  if (gate.decision === "needs_clarification") {
+    return jsonResponse({
+      success: false,
+      gated: true,
+      reason: gate.reason,
+      template: gate.template,
+      suggestions: gate.suggestions,
+      questions: gate.questions
+    }, 400);
+  }
   try {
     const result = await runAgent({ agent, task, conversationHistory });
     return jsonResponse(result);
@@ -26034,6 +26441,26 @@ async function handleRunStream(req, memoryStore) {
       conversationHistory = getConversationHistoryForRun(memoryStore, conversation_id.trim());
     } catch {}
   }
+  const gate = promptGate({ kind: "agent_run", agent_id }, task);
+  if (gate.decision === "needs_clarification") {
+    let send2 = function(type, data) {
+      return `event: ${type}
+data: ${JSON.stringify(data)}
+
+`;
+    };
+    const msg = `${gate.reason}
+
+${gate.template}`;
+    const encoder2 = new TextEncoder;
+    const stream2 = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoder2.encode(send2("error", { message: msg, gated: true, suggestions: gate.suggestions, questions: gate.questions })));
+        controller.close();
+      }
+    });
+    return new Response(stream2, { headers: SSE_HEADERS });
+  }
   const encoder = new TextEncoder;
   function send(type, data) {
     return `event: ${type}
@@ -26110,6 +26537,32 @@ async function handleTasks(req, url) {
     if (typeof task !== "string") {
       return jsonResponse({ error: "Missing required field: task" }, 400);
     }
+    if (graph_id && !agent_id) {
+      const gate = promptGate({ kind: "graph_run", graph_id }, task);
+      if (gate.decision === "needs_clarification") {
+        return jsonResponse({
+          success: false,
+          gated: true,
+          reason: gate.reason,
+          template: gate.template,
+          suggestions: gate.suggestions,
+          questions: gate.questions
+        }, 400);
+      }
+    }
+    if (agent_id && !graph_id) {
+      const gate = promptGate({ kind: "agent_run", agent_id }, task);
+      if (gate.decision === "needs_clarification") {
+        return jsonResponse({
+          success: false,
+          gated: true,
+          reason: gate.reason,
+          template: gate.template,
+          suggestions: gate.suggestions,
+          questions: gate.questions
+        }, 400);
+      }
+    }
     if (graph_id && !agent_id) {
       const t = await enqueueGraphTask(graph_id, task);
       return jsonResponse({ task: t }, 202);
@@ -26370,6 +26823,16 @@ async function handleGraphRun(req) {
   if (!graph) {
     return jsonResponse({ error: `Graph not found: ${graph_id}` }, 404);
   }
+  const gate = promptGate({ kind: "graph_run", graph_id }, input);
+  if (gate.decision === "needs_clarification") {
+    return jsonResponse({
+      success: false,
+      gated: true,
+      reason: gate.reason,
+      template: gate.template,
+      questions: gate.questions
+    }, 400);
+  }
   try {
     const result = await runGraph({ graph, input });
     return jsonResponse(result);
@@ -26390,6 +26853,9 @@ async function handleGraphRunStream(req) {
   if (!graph) {
     return jsonResponse({ error: `Graph not found: ${graph_id}` }, 404);
   }
+  if ((process.env.AGENT_OS_DEBUG ?? "").trim() === "1" || (process.env.AGENT_OS_DEBUG_GRAPHS ?? "").trim() === "1") {
+    console.log(`[graph] Graph chat stream requested: graph_id=${graph_id}, input length=${input?.length ?? 0}`);
+  }
   const encoder = new TextEncoder;
   function send(type, data) {
     return `event: ${type}
@@ -26397,12 +26863,58 @@ data: ${JSON.stringify(data)}
 
 `;
   }
+  const gate = promptGate({ kind: "graph_run", graph_id }, input);
+  if (gate.decision === "needs_clarification") {
+    const msg = `${gate.reason}
+
+${gate.template}`;
+    const stream2 = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoder.encode(send("error", { message: msg, gated: true, questions: gate.questions })));
+        controller.close();
+      }
+    });
+    return new Response(stream2, { headers: SSE_HEADERS });
+  }
+  const KEEPALIVE_INTERVAL_MS = 30000;
   const stream = new ReadableStream({
     async start(controller) {
+      let closed = false;
+      function safeEnqueue(data) {
+        if (closed)
+          return;
+        try {
+          controller.enqueue(data);
+        } catch {
+          closed = true;
+        }
+      }
+      function safeClose() {
+        if (closed)
+          return;
+        try {
+          controller.close();
+        } catch {}
+        closed = true;
+      }
+      const keepalive = setInterval(() => {
+        if (closed) {
+          clearInterval(keepalive);
+          return;
+        }
+        try {
+          controller.enqueue(encoder.encode(`: keepalive
+
+`));
+        } catch {
+          clearInterval(keepalive);
+          closed = true;
+        }
+      }, KEEPALIVE_INTERVAL_MS);
       try {
         await runGraphStream({ graph, input }, (ev) => {
           if (ev.type === "node_done") {
-            controller.enqueue(encoder.encode(send("node_done", {
+            safeEnqueue(encoder.encode(send("node_done", {
               node_id: ev.node_id,
               agent_id: ev.agent_id,
               success: ev.success,
@@ -26410,20 +26922,21 @@ data: ${JSON.stringify(data)}
               error: ev.error
             })));
           } else if (ev.type === "done") {
-            controller.enqueue(encoder.encode(send("done", {
+            safeEnqueue(encoder.encode(send("done", {
               success: ev.success,
               output: ev.output,
               node_results: ev.node_results
             })));
           } else if (ev.type === "error") {
-            controller.enqueue(encoder.encode(send("error", { message: ev.message })));
+            safeEnqueue(encoder.encode(send("error", { message: ev.message })));
           }
         });
       } catch (err) {
         const msg = errorMessage(err);
-        controller.enqueue(encoder.encode(send("error", { message: msg })));
+        safeEnqueue(encoder.encode(send("error", { message: msg })));
       } finally {
-        controller.close();
+        clearInterval(keepalive);
+        safeClose();
       }
     }
   });
@@ -26684,7 +27197,7 @@ async function getDefaultAgent(config2, defaultAgentIdKey) {
   }
   return agents[0] ?? null;
 }
-async function runAgentWithConversation(memoryStore, agent, conversationId, userId, task, sendReply) {
+async function runOneWithConversation(memoryStore, agent, conversationId, userId, task, sendReply) {
   memoryStore.ensureConversation(conversationId, agent.id, userId);
   const conversationHistory = getConversationHistoryForRun(memoryStore, conversationId);
   memoryStore.insertConversationMessage({
@@ -26705,10 +27218,20 @@ async function runAgentWithConversation(memoryStore, agent, conversationId, user
   });
   await sendReply(output);
 }
+async function runAgentWithConversation(memoryStore, agent, conversationId, userId, task, sendReply) {
+  const prev = conversationTails.get(conversationId) ?? Promise.resolve();
+  const next = prev.then(() => runOneWithConversation(memoryStore, agent, conversationId, userId, task, sendReply)).catch((err) => {
+    console.error(`[channel] conversation ${conversationId} error:`, err);
+  });
+  conversationTails.set(conversationId, next);
+  return next;
+}
+var conversationTails;
 var init_channel_run = __esm(() => {
   init_agent_registry();
   init_runtime();
   init_utils();
+  conversationTails = new Map;
 });
 
 // src/http/telegram.ts
@@ -26834,22 +27357,45 @@ async function handleTelegramWebhook(req, memoryStore) {
 }
 function startTelegramPolling(memoryStore) {
   let offset = 0;
+  let webhookDeletedForToken = null;
+  let loggedPollingStarted = false;
   async function poll() {
     const config2 = await readConfig();
     const botToken = config2.telegram_bot_token?.trim();
     if (!botToken) {
+      webhookDeletedForToken = null;
+      loggedPollingStarted = false;
       setTimeout(poll, POLLING_INTERVAL_MS);
       return;
     }
     try {
-      const url = `https://api.telegram.org/bot${botToken}/getUpdates?offset=${offset}&timeout=${GET_UPDATES_TIMEOUT}`;
-      const res = await fetch(url);
+      const res = await fetch(`https://api.telegram.org/bot${botToken}/getWebhookInfo`);
       if (!res.ok) {
         setTimeout(poll, POLLING_INTERVAL_MS);
         return;
       }
       const data = await res.json();
-      const updates = Array.isArray(data?.result) ? data.result : [];
+      const webhookUrl = data?.result?.url?.trim();
+      if (webhookUrl) {
+        setTimeout(poll, POLLING_INTERVAL_MS);
+        return;
+      }
+      if (webhookDeletedForToken !== botToken) {
+        await fetch(`https://api.telegram.org/bot${botToken}/deleteWebhook`).catch(() => {});
+        webhookDeletedForToken = botToken;
+      }
+      if (!loggedPollingStarted) {
+        console.info("[telegram] polling started (no webhook set; no HTTPS required).");
+        loggedPollingStarted = true;
+      }
+      const url = `https://api.telegram.org/bot${botToken}/getUpdates?offset=${offset}&timeout=${GET_UPDATES_TIMEOUT}`;
+      const getRes = await fetch(url);
+      if (!getRes.ok) {
+        setTimeout(poll, POLLING_INTERVAL_MS);
+        return;
+      }
+      const updateData = await getRes.json();
+      const updates = Array.isArray(updateData?.result) ? updateData.result : [];
       for (const update of updates) {
         if (update.update_id != null && update.update_id >= offset) {
           offset = update.update_id + 1;
@@ -26863,22 +27409,7 @@ function startTelegramPolling(memoryStore) {
     }
     setTimeout(poll, 0);
   }
-  readConfig().then(async (config2) => {
-    const botToken = config2.telegram_bot_token?.trim();
-    if (!botToken)
-      return;
-    const res = await fetch(`https://api.telegram.org/bot${botToken}/getWebhookInfo`);
-    if (!res.ok)
-      return;
-    const data = await res.json();
-    const webhookUrl = data?.result?.url?.trim();
-    if (webhookUrl) {
-      return;
-    }
-    await fetch(`https://api.telegram.org/bot${botToken}/deleteWebhook`).catch(() => {});
-    console.log("[telegram] polling started (no webhook set; no HTTPS required).");
-    poll();
-  }).catch(() => {});
+  poll();
 }
 var POLLING_INTERVAL_MS = 1000, GET_UPDATES_TIMEOUT = 30;
 var init_telegram = __esm(() => {
@@ -30286,7 +30817,7 @@ async function startServer() {
     server = Bun.serve({
       port: PORT,
       hostname: HOST,
-      idleTimeout: 120,
+      idleTimeout: 255,
       routes: wrapRouteHandlers(createRoutes(), dashboardSecret),
       fetch(req, server2) {
         const url = new URL(req.url);
@@ -30337,7 +30868,7 @@ async function startServer() {
     }
     throw err;
   }
-  console.log(`Agent OS server running at ${server.url}`);
+  console.info(`Agent OS server running at ${server.url}`);
   startTelegramPolling(memoryStore);
 }
 var PORT, DASHBOARD_DIST, HOST, EVENT_TYPES, wsClients, MEMORY_DB_PATH, memoryStore;