@sema-agent/core 1.451.0 → 1.452.0

package/dist/tools/task-list.js

@@ -326,22 +326,41 @@ export function createTaskListTools(store) {
                         t.metadata[k] = v;
                 }
             }
+            const ignoredDeps = [];
+            let linkedBlocks = false;
+            let linkedBlockedBy = false;
             for (const b of a.addBlocks ?? []) {
-                if (!t.blocks.includes(b))
-                    t.blocks.push(b);
                 const other = b === id ? t : await tx.get(b);
-                if (other && !other.blockedBy.includes(id)) {
+                if (!other) {
+                    if (!ignoredDeps.includes(b))
+                        ignoredDeps.push(b);
+                    continue;
+                }
+                if (!t.blocks.includes(b)) {
+                    t.blocks.push(b);
+                    linkedBlocks = true;
+                }
+                if (!other.blockedBy.includes(id)) {
                     other.blockedBy.push(id);
+                    linkedBlocks = true;
                     if (other !== t)
                         await tx.set(b, other);
                 }
             }
             for (const b of a.addBlockedBy ?? []) {
-                if (!t.blockedBy.includes(b))
-                    t.blockedBy.push(b);
                 const other = b === id ? t : await tx.get(b);
-                if (other && !other.blocks.includes(id)) {
+                if (!other) {
+                    if (!ignoredDeps.includes(b))
+                        ignoredDeps.push(b);
+                    continue;
+                }
+                if (!t.blockedBy.includes(b)) {
+                    t.blockedBy.push(b);
+                    linkedBlockedBy = true;
+                }
+                if (!other.blocks.includes(id)) {
                     other.blocks.push(id);
+                    linkedBlockedBy = true;
                     if (other !== t)
                         await tx.set(b, other);
                 }
@@ -354,10 +373,13 @@ export function createTaskListTools(store) {
                 a.activeForm !== undefined ? "activeForm" : "",
                 a.owner !== undefined ? "owner" : "",
                 a.metadata ? "metadata" : "",
-                a.addBlocks?.length ? "blocks" : "",
-                a.addBlockedBy?.length ? "blockedBy" : "",
+                linkedBlocks ? "blocks" : "",
+                linkedBlockedBy ? "blockedBy" : "",
             ].filter(Boolean);
-            return { content: `Updated task #${id}${changed.length ? ` ${changed.join(", ")}` : ""}`, details: { type: "task", task: snapTask(t) } };
+            const ignoredNote = ignoredDeps.length
+                ? ` (ignored: no such task ${ignoredDeps.map((x) => `#${x}`).join(", ")})`
+                : "";
+            return { content: `Updated task #${id}${changed.length ? ` ${changed.join(", ")}` : ""}${ignoredNote}`, details: { type: "task", task: snapTask(t) } };
         }),
     };
     const taskList = {
@@ -393,12 +415,12 @@ export function createTaskListTools(store) {
             if (all.length === 0) {
                 return { content: "The task list is empty.", details: { type: "task-list", tasks: [] } };
             }
-            const completed = new Set(all.filter((t) => t.status === "completed").map((t) => t.id));
+            const openIds = new Set(all.filter((x) => x.status !== "completed").map((x) => x.id));
             const lines = all.map((t) => {
-                const liveBlockers = t.blockedBy.filter((b) => !completed.has(b));
+                const liveBlockers = t.blockedBy.filter((b) => openIds.has(b));
                 return `#${t.id} [${t.status}] ${t.subject}${t.owner ? ` (owner: ${t.owner})` : ""}${liveBlockers.length ? ` (blocked by: ${liveBlockers.join(", ")})` : ""}`;
             });
-            const open = all.filter((t) => t.status !== "completed").length;
+            const open = openIds.size;
             return {
                 content: `${lines.join("\n")}\n(${all.length} total, ${open} open)`,
                 details: { type: "task-list", tasks: all.map(snapTask) },

package/dist/tools/web.d.ts

@@ -25,5 +25,7 @@ export interface WebSearchConfig {
         snippet: string;
     }>>;
     maxResults?: number;
+    timeoutMs?: number;
 }
+export declare function clipCodePoints(s: string, max: number): string;
 export declare function createWebSearchTool(config: WebSearchConfig): ToolSpec;

package/dist/tools/web.js

@@ -1,6 +1,7 @@
 import { Type } from "typebox";
-import { defineTool } from "../core/tools.js";
+import { defineTool, errorResult } from "../core/tools.js";
 import { delimitUntrusted, inlineUntrusted } from "../core/untrusted-text.js";
+import { redactSecrets } from "../core/untrusted-egress.js";
 import { isPrivateHost } from "../core/runner/image.js";
 const MAX_REDIRECTS = 10;
 const MAX_URL_LENGTH = 2048;
@@ -229,10 +230,7 @@ export function webFetchToolSpec(config = {}) {
             const { url, prompt } = args;
             const startedAt = Date.now();
             let urlForDetails = url.length > MAX_URL_LENGTH ? url.slice(0, MAX_URL_LENGTH) : url;
-            const failure = (message, extra = {}) => ({
-                content: message,
-                details: { type: "web-fetch", url: urlForDetails, bytes: 0, durationMs: Date.now() - startedAt, ...extra },
-            });
+            const failure = (message, extra = {}) => errorResult(message, { type: "web-fetch", url: urlForDetails, bytes: 0, durationMs: Date.now() - startedAt, ...extra });
             if (url.length > MAX_URL_LENGTH) {
                 return failure(`Error (WebFetch): URL is ${url.length} characters — the limit is ${MAX_URL_LENGTH}.`);
             }
@@ -381,6 +379,7 @@ export function webFetchToolSpec(config = {}) {
                     return {
                         content: `Error (WebFetch): the request was interrupted (aborted) before completion${finalResponse ? " while reading the response body" : ""}. No content was retrieved.`,
                         details: { ...errDetails, aborted: true },
+                        isError: true,
                     };
                 }
                 if (timedOut) {
@@ -391,11 +390,13 @@ export function webFetchToolSpec(config = {}) {
                                 ? `Error (WebFetch): the server responded (HTTP ${connectedMeta.status}) to a redirect hop, but the request stalled while following the redirect — timed out after ${timeoutMs}ms. The host IS reachable; retry only if the stall was likely transient, or fetch the redirect target directly.`
                                 : `Error (WebFetch): timed out after ${timeoutMs}ms while connecting — the host did not respond or the connection stalled before any response arrived. Do not retry the same URL; continue without it or try a different source.`,
                         details: { ...errDetails, timedOut: true },
+                        isError: true,
                     };
                 }
                 return {
                     content: `Error (WebFetch): request failed: ${e instanceof Error ? e.message : String(e)}`,
                     details: errDetails,
+                    isError: true,
                 };
             }
             finally {
@@ -447,6 +448,7 @@ export function webFetchToolSpec(config = {}) {
                         durationMs: Date.now() - startedAt,
                         ...transferStateDetails,
                     },
+                    isError: true,
                 };
             }
             if (bodyBytes) {
@@ -474,6 +476,7 @@ export function webFetchToolSpec(config = {}) {
                             durationMs: Date.now() - startedAt,
                             ...transferStateDetails,
                         },
+                        isError: true,
                     };
                 }
             }
@@ -571,20 +574,36 @@ export function makeWebFetchSummarizer(brain, model) {
         return text;
     };
 }
+const DEFAULT_SEARCH_TIMEOUT_MS = 30_000;
+const SEARCH_ERROR_EXCERPT_CHARS = 2048;
+const SEARCH_TITLE_MAX_CHARS = 300;
+const SEARCH_SNIPPET_MAX_CHARS = 1_000;
+const SEARCH_BODY_MAX_CHARS = 100_000;
+export function clipCodePoints(s, max) {
+    const cps = [...s];
+    return cps.length > max ? cps.slice(0, max).join("") + "…" : s;
+}
 function hostMatchesDomain(host, domain) {
-    const d = domain.toLowerCase().replace(/^\*\./, "").replace(/^\.+|\.+$/g, "");
-    if (!d)
+    const norm = (s) => s.toLowerCase().replace(/^\*\./, "").replace(/^\.+|\.+$/g, "");
+    const h = norm(host);
+    const d = norm(domain);
+    if (!d || !h)
         return false;
-    return host === d || host.endsWith("." + d);
+    return h === d || h.endsWith("." + d);
 }
 function webSearchResultAllowed(url, allowed, blocked) {
     let host;
     try {
-        host = new URL(url).hostname.toLowerCase();
+        const u = new URL(url);
+        if (u.protocol !== "http:" && u.protocol !== "https:")
+            return false;
+        host = u.hostname.toLowerCase();
     }
     catch {
-        return !(allowed && allowed.length);
+        return false;
     }
+    if (!host)
+        return false;
     if (blocked && blocked.some((d) => hostMatchesDomain(host, d)))
         return false;
     if (allowed && allowed.length && !allowed.some((d) => hostMatchesDomain(host, d)))
@@ -612,27 +631,94 @@ export function createWebSearchTool(config) {
         effect: "read",
         execute: async (args, ctx) => {
             const { query, allowed_domains, blocked_domains } = args;
+            const startedAt = Date.now();
+            const failCard = (extra = {}) => ({
+                type: "web-search",
+                query,
+                results: [],
+                durationSeconds: (Date.now() - startedAt) / 1000,
+                searchCount: 0,
+                ...extra,
+            });
             if (allowed_domains?.length && blocked_domains?.length) {
-                return "Error: Cannot specify both allowed_domains and blocked_domains in the same request";
+                return errorResult("Error: Cannot specify both allowed_domains and blocked_domains in the same request", failCard());
             }
-            const startedAt = Date.now();
+            const timeoutMs = config.timeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS;
+            const ac = new AbortController();
+            const timer = setTimeout(() => ac.abort(), timeoutMs);
+            const onOuterAbort = () => ac.abort();
+            if (ctx.signal?.aborted)
+                ac.abort();
+            else
+                ctx.signal?.addEventListener("abort", onOuterAbort, { once: true });
+            const TIMED_OUT = Symbol("websearch-timeout");
+            const abortedFrame = () => errorResult("Error (WebSearch): the search was interrupted (aborted) before completion. No results were retrieved.", failCard({ aborted: true }));
+            const timedOutFrame = () => errorResult(`Error (WebSearch): the search backend did not respond within ${timeoutMs}ms. The tool stopped waiting; the backend may still be executing the request.`, failCard({ timedOut: true }));
             let results;
             try {
-                results = await config.search(query, ctx.signal, { allowedDomains: allowed_domains, blockedDomains: blocked_domains });
+                const work = Promise.resolve(config.search(query, ac.signal, { allowedDomains: allowed_domains, blockedDomains: blocked_domains }));
+                work.catch(() => { });
+                let fireDeadline;
+                const deadline = new Promise((res) => {
+                    fireDeadline = () => res(TIMED_OUT);
+                });
+                const deadlineTimer = setTimeout(() => fireDeadline(), timeoutMs);
+                deadlineTimer.unref?.();
+                try {
+                    const raced = await Promise.race([work, deadline]);
+                    if (raced === TIMED_OUT) {
+                        return ctx.signal?.aborted ? abortedFrame() : timedOutFrame();
+                    }
+                    results = raced;
+                }
+                finally {
+                    clearTimeout(deadlineTimer);
+                }
             }
             catch (e) {
-                return `Error (WebSearch): ${e instanceof Error ? e.message : String(e)}`;
+                if (ctx.signal?.aborted)
+                    return abortedFrame();
+                if (ac.signal.aborted)
+                    return timedOutFrame();
+                const msg = redactSecrets(e instanceof Error ? e.message : String(e)).trim();
+                const headline = "Error (WebSearch): the search backend failed.";
+                return errorResult(msg
+                    ? `${headline} The backend's error text follows:\n\n${delimitUntrusted("WebSearch backend error", msg, SEARCH_ERROR_EXCERPT_CHARS)}`
+                    : headline, failCard());
             }
-            results = results.filter((r) => webSearchResultAllowed(r.url, allowed_domains, blocked_domains)).slice(0, max);
-            const body = results.map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet}`).join("\n");
-            const fenced = delimitUntrusted(`WebSearch ${JSON.stringify(query)}`, body || "(no results)");
-            const modelText = `${fenced}\n\nREMINDER: You MUST include the sources above in your response to the user using markdown hyperlinks.`;
+            finally {
+                clearTimeout(timer);
+                ctx.signal?.removeEventListener("abort", onOuterAbort);
+            }
+            const usable = results.filter((r) => webSearchResultAllowed(r.url));
+            const droppedUnusable = results.length - usable.length;
+            results = usable.filter((r) => webSearchResultAllowed(r.url, allowed_domains, blocked_domains)).slice(0, max);
+            let clipped = false;
+            const shown = results.map((r) => {
+                const title = clipCodePoints(r.title, SEARCH_TITLE_MAX_CHARS);
+                const url = clipCodePoints(r.url, MAX_URL_LENGTH);
+                const snippet = clipCodePoints(r.snippet, SEARCH_SNIPPET_MAX_CHARS);
+                if (title !== r.title || url !== r.url || snippet !== r.snippet)
+                    clipped = true;
+                return { title, url, snippet };
+            });
+            const body = shown.map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet}`).join("\n");
+            if (body.length > SEARCH_BODY_MAX_CHARS)
+                clipped = true;
+            const fenced = delimitUntrusted(`WebSearch ${JSON.stringify(query)}`, body || "(no results)", SEARCH_BODY_MAX_CHARS);
+            const dropNote = droppedUnusable > 0
+                ? `\n\n[WebSearch: ${droppedUnusable} result(s) returned by the backend were dropped — their URL was not a usable http(s) link]`
+                : "";
+            const clipNote = clipped
+                ? "\n\n[WebSearch: one or more result fields exceeded the display limits and were truncated — treat the text above as an excerpt, not the backend's full result.]"
+                : "";
+            const modelText = `${fenced}${dropNote}${clipNote}\n\nREMINDER: You MUST include the sources above in your response to the user using markdown hyperlinks.`;
             return {
                 content: modelText,
                 details: {
                     type: "web-search",
                     query,
-                    results: [{ tool_use_id: ctx.toolCallId, content: results.map((r) => ({ title: r.title, url: r.url })) }],
+                    results: [{ tool_use_id: ctx.toolCallId, content: shown.map((r) => ({ title: r.title, url: r.url })) }],
                     durationSeconds: (Date.now() - startedAt) / 1000,
                     searchCount: 1,
                 },

package/dist/tools/worktree.js

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { Type } from "typebox";
-import { defineTool } from "../core/tools.js";
+import { defineTool, errorResult } from "../core/tools.js";
 import { addWorktree, pruneWorktrees, WORKTREE_PARENT } from "../core/git-worktree-env.js";
 const ENTER_DESCRIPTION = "Use this tool ONLY when explicitly instructed to work in a worktree — either by the user directly, or by " +
     "project instructions. This tool creates an isolated git worktree and switches the current session into it.\n" +
@@ -113,20 +113,20 @@ export function createWorktreeTools(env, opts) {
         execute: async (args) => {
             const { name, path, baseRef } = args;
             if (path !== undefined && name !== undefined) {
-                return "Error (EnterWorktree): `name` and `path` are mutually exclusive — `path` enters an existing worktree, `name` creates a new one.";
+                return errorResult("Error (EnterWorktree): `name` and `path` are mutually exclusive — `path` enters an existing worktree, `name` creates a new one.");
             }
             if (path !== undefined && baseRef !== undefined) {
-                return "Error (EnterWorktree): `baseRef` only applies when creating a new worktree — an existing worktree entered via `path` keeps whatever state it has.";
+                return errorResult("Error (EnterWorktree): `baseRef` only applies when creating a new worktree — an existing worktree entered via `path` keeps whatever state it has.");
             }
             if (session.current && path === undefined) {
-                return (`Error (EnterWorktree): already in a worktree session (${session.current.worktreeDir}). ` +
+                return errorResult(`Error (EnterWorktree): already in a worktree session (${session.current.worktreeDir}). ` +
                     "Use ExitWorktree to leave it before creating a new worktree, or pass `path` to switch into an " +
                     "existing worktree of this repository.");
             }
             const probe = await env.exec("git rev-parse --is-inside-work-tree", { cwd: repoRoot });
             if (!probe.ok || probe.value.exitCode !== 0) {
                 const detail = probe.ok ? (probe.value.stderr || probe.value.stdout).trim().split("\n")[0] : String(probe.error);
-                return (`Error (EnterWorktree): the working directory ${repoRoot} is not a git repository` +
+                return errorResult(`Error (EnterWorktree): the working directory ${repoRoot} is not a git repository` +
                     `${detail ? ` (${detail})` : ""}. This deployment has no VCS-agnostic worktree extension point, ` +
                     "so worktree isolation is unavailable here.");
             }
@@ -134,31 +134,31 @@ export function createWorktreeTools(env, opts) {
                 const candidate = resolve(cwdRef.current, path);
                 const top = await env.exec("git rev-parse --show-toplevel", { cwd: candidate });
                 if (!top.ok || top.value.exitCode !== 0) {
-                    return `Error (EnterWorktree): ${candidate} is not an accessible git worktree (cannot resolve its top-level directory).`;
+                    return errorResult(`Error (EnterWorktree): ${candidate} is not an accessible git worktree (cannot resolve its top-level directory).`);
                 }
                 const target = top.value.stdout.trim();
                 const list = await env.exec("git worktree list --porcelain", { cwd: repoRoot });
                 if (!list.ok || list.value.exitCode !== 0) {
-                    return "Error (EnterWorktree): could not read `git worktree list` for this repository.";
+                    return errorResult("Error (EnterWorktree): could not read `git worktree list` for this repository.");
                 }
                 const registered = list.value.stdout
                     .split("\n")
                     .filter((l) => l.startsWith("worktree "))
                     .map((l) => l.slice("worktree ".length).trim());
                 if (!registered.includes(target)) {
-                    return (`Error (EnterWorktree): ${target} is not a registered worktree of this repository ` +
+                    return errorResult(`Error (EnterWorktree): ${target} is not a registered worktree of this repository ` +
                         "(it does not appear in `git worktree list`).");
                 }
                 if (target === registered[0]) {
-                    return `Error (EnterWorktree): ${target} is the main working tree, not a linked worktree — nothing to enter.`;
+                    return errorResult(`Error (EnterWorktree): ${target} is the main working tree, not a linked worktree — nothing to enter.`);
                 }
                 if (target !== repoRoot && !target.startsWith(repoRoot.endsWith("/") ? repoRoot : `${repoRoot}/`)) {
-                    return (`Error (EnterWorktree): the worktree ${target} lives outside the task root ${repoRoot}; ` +
+                    return errorResult(`Error (EnterWorktree): the worktree ${target} lives outside the task root ${repoRoot}; ` +
                         "file containment stays anchored at the task root, so it cannot be entered from this session.");
                 }
                 const head = await env.exec("git rev-parse HEAD", { cwd: target });
                 if (!head.ok || head.value.exitCode !== 0) {
-                    return `Error (EnterWorktree): cannot resolve HEAD of the worktree ${target}.`;
+                    return errorResult(`Error (EnterWorktree): cannot resolve HEAD of the worktree ${target}.`);
                 }
                 const previous = session.current;
                 const originalCwd = previous ? previous.originalCwd : cwdRef.current;
@@ -172,7 +172,7 @@ export function createWorktreeTools(env, opts) {
             }
             const base = await resolveBaseCommit(env, repoRoot, baseRef ?? "fresh");
             if ("error" in base)
-                return `Error (EnterWorktree): ${base.error}.`;
+                return errorResult(`Error (EnterWorktree): ${base.error}.`);
             let createdDir;
             try {
                 const { worktreeDir } = await addWorktree(env, {
@@ -187,7 +187,7 @@ export function createWorktreeTools(env, opts) {
                 createdDir = worktreeDir;
             }
             catch (e) {
-                return `Error (EnterWorktree): ${e instanceof Error ? e.message : String(e)}`;
+                return errorResult(`Error (EnterWorktree): ${e instanceof Error ? e.message : String(e)}`);
             }
             session.current = {
                 worktreeDir: createdDir,
@@ -227,7 +227,7 @@ export function createWorktreeTools(env, opts) {
             const discardChanges = raw.discardChanges ?? raw.discard_changes;
             const wantsRemove = raw.action === "remove";
             if (keep === true && discardChanges === true) {
-                return "Error (ExitWorktree): `keep: true` and `discardChanges: true` contradict each other — pick one.";
+                return errorResult("Error (ExitWorktree): `keep: true` and `discardChanges: true` contradict each other — pick one.");
             }
             if (!session.current) {
                 return ("No-op: there is no active EnterWorktree session to exit. This tool only operates on the " +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "1.451.0",
+  "version": "1.452.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",