skyloom 1.18.0 → 1.18.2

package/src/tools/websearch.ts

@@ -44,7 +44,9 @@ export interface WebHttp {
 }
 
 const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36';
-const DEFAULT_TIMEOUT = 15000;
+// Per-request timeout. Kept short so a dead/slow provider fails fast and the
+// waterfall moves on quickly rather than burning 15s each across five providers.
+const DEFAULT_TIMEOUT = 8000;
 
 /** Default HTTP client backed by axios. */
 export const defaultHttp: WebHttp = {
@@ -294,40 +296,54 @@ export interface WebSearchOptions {
   env?: EnvMap;              // defaults to process.env
   http?: WebHttp;           // defaults to axios-backed client
   onProviderError?: (provider: string, error: string) => void;
+  /** Total wall-clock budget for the waterfall; stop trying once exceeded. */
+  budgetMs?: number;
 }
 
 /**
  * Run a web search through the provider waterfall. Returns the first provider
  * that yields results, or a response with an empty result set + the list of
- * providers that were tried.
+ * providers that were tried. A total time budget caps the waterfall so the tool
+ * returns a clear "no results" message instead of being killed by an outer
+ * timeout (which would surface as an opaque "Tool execution timeout").
  */
-export async function webSearch(query: string, opts: WebSearchOptions = {}): Promise<SearchResponse & { tried: string[] }> {
+export async function webSearch(query: string, opts: WebSearchOptions = {}): Promise<SearchResponse & { tried: string[]; errors?: number }> {
   const q = (query || '').trim();
   if (!q) throw new Error('query is required');
   const max = Math.max(1, Math.min(20, Math.floor(opts.max ?? 8)));
   const env = opts.env ?? (process.env as EnvMap);
   const http = opts.http ?? defaultHttp;
   const pinned = (opts.engine || env.SKYLOOM_SEARCH_ENGINE || '').trim();
+  const budgetMs = opts.budgetMs ?? 22000;
+  const start = Date.now();
 
   const providers = resolveProviders(env, pinned);
   const tried: string[] = [];
+  let errors = 0;
   for (const provider of providers) {
+    // Out of time: stop the waterfall and return what we have (a clear empty
+    // result), rather than letting a slow tail provider blow the tool timeout.
+    if (tried.length > 0 && Date.now() - start > budgetMs) break;
     tried.push(provider.id);
     try {
       const res = await provider.run(http, env, q, max);
       if (res.results.length > 0 || res.answer) return { ...res, tried };
     } catch (e: any) {
+      errors++;
       opts.onProviderError?.(provider.id, String(e?.message || e));
     }
   }
-  return { provider: 'none', results: [], tried };
+  return { provider: 'none', results: [], tried, errors };
 }
 
 /** Format a SearchResponse as compact text for an LLM tool result. */
-export function formatSearchResults(res: SearchResponse & { tried?: string[] }): string {
+export function formatSearchResults(res: SearchResponse & { tried?: string[]; errors?: number }): string {
   if (!res.results.length && !res.answer) {
     const tried = res.tried?.length ? ` (tried: ${res.tried.join(', ')})` : '';
-    return `No search results found${tried}. Try a simpler query, or set a search API key (TAVILY_API_KEY / BRAVE_API_KEY / SERPER_API_KEY) for more reliable results.`;
+    const note = res.errors && res.errors > 0
+      ? ' Every provider errored or timed out — likely no/blocked network connectivity or rate limiting in this environment.'
+      : '';
+    return `No search results found${tried}.${note} Try a simpler query, or set a search API key (TAVILY_API_KEY / BRAVE_API_KEY / SERPER_API_KEY) for more reliable results.`;
   }
   const parts: string[] = [];
   if (res.answer) parts.push(`Answer: ${res.answer}\n`);

package/tests/logger.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { getLogger, setLogSink, setLogFile, silenceLogs } from "../src/core/logger";
+
+afterEach(() => { silenceLogs(); }); // never leak to the terminal between tests
+
+describe("logger · sink routing", () => {
+  it("routes log lines to a custom sink instead of stderr", () => {
+    const lines: string[] = [];
+    setLogSink((l) => lines.push(l));
+    getLogger("test-sink").warn("hello_world", { a: 1 });
+    expect(lines.length).toBe(1);
+    const entry = JSON.parse(lines[0]);
+    expect(entry.msg).toBe("hello_world");
+    expect(entry.level).toBe("warn");
+    expect(entry.a).toBe(1);
+  });
+
+  it("silenceLogs discards output (keeps a TUI clean)", () => {
+    let count = 0;
+    setLogSink(() => { count++; });
+    silenceLogs();
+    getLogger("test-silence").error("should_be_dropped");
+    expect(count).toBe(0);
+  });
+
+  it("setLogFile appends log lines to a file, not the terminal", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-log-"));
+    const file = path.join(dir, "sky.log");
+    try {
+      const resolved = setLogFile(file);
+      expect(resolved).toBe(file);
+      getLogger("test-file").warn("to_file", { n: 7 });
+      const content = fs.readFileSync(file, "utf8");
+      expect(content).toContain("to_file");
+      expect(content).toContain('"n":7');
+    } finally {
+      silenceLogs();
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+    }
+  });
+});

package/tests/md_render.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from "vitest";
+import { styleLine, newRenderState, styleBlock, styleInline } from "../src/cli/md_render";
+
+describe("md_render · styleInline", () => {
+  it("renders bold", () => {
+    const out = styleInline("hello **world** ok");
+    expect(out).not.toContain("**");
+    expect(out).toContain("world");
+  });
+  it("renders inline code", () => {
+    const out = styleInline("use `foo.bar()` here");
+    // inline code should preserve content, not contain backticks
+    expect(out).not.toContain("`");
+    expect(out).toContain("foo.bar()");
+  });
+  it("does not re-style content inside backticks", () => {
+    const out = styleInline("` **not bold** `");
+    expect(out).not.toContain("**");
+    expect(out).toContain("not bold");
+  });
+});
+
+describe("md_render · styleLine (block+inline)", () => {
+  it("renders H2 heading", () => {
+    const s = newRenderState();
+    const out = styleLine("## 设计概要", s);
+    expect(out).not.toContain("##");
+    expect(out).toContain("设计概要");
+  });
+  it("renders HR", () => {
+    const s = newRenderState();
+    const out = styleLine("---", s);
+    expect(out).not.toContain("---");
+    expect(out.length).toBeGreaterThan(2);
+  });
+  it("renders unordered list bullets", () => {
+    const s = newRenderState();
+    const out = styleLine("- 性能 · 每秒", s);
+    expect(out).not.toStrictEqual(expect.stringContaining("- ")); // raw hyphen gone
+    expect(out).toContain("性能");
+  });
+  it("renders bold+italic in content lines", () => {
+    const s = newRenderState();
+    const out = styleLine("**粗体** 和 *斜体* 文字", s);
+    expect(out).not.toContain("**");
+    expect(out).not.toContain("*");
+    expect(out).toContain("粗体");
+    expect(out).toContain("斜体");
+  });
+});
+
+describe("md_render · code fences", () => {
+  it("tracks fence state and renders code blocks raw", () => {
+    const s = newRenderState();
+    expect(styleLine("```ts", s)).toContain("```");
+    expect(s.inCodeFence).toBe(true);
+    expect(styleLine("const x = 1;", s)).toContain("const x = 1;");
+    expect(styleLine("```", s)).toContain("```");
+    expect(s.inCodeFence).toBe(false);
+  });
+  it("does not style bold inside a code fence", () => {
+    const s = newRenderState();
+    styleLine("```", s);
+    const out = styleLine("**not bold**", s);
+    expect(out).toContain("**not bold**");
+  });
+});
+
+describe("md_render · styleBlock", () => {
+  it("renders a multi-line markdown block", () => {
+    const out = styleBlock("## H2\n- bullet **bold**\n\n```\ncode\n```\nnormal.");
+    expect(out).not.toMatch(/^\s*##/);
+    expect(out).toContain("H2");
+    expect(out).toContain("bold");
+    expect(out).toContain("code");
+    expect(out).not.toContain("**bold**");
+  });
+});

package/tests/websearch.test.ts

@@ -140,6 +140,30 @@ describe("websearch · waterfall", () => {
     expect(formatSearchResults(res)).toContain("No search results");
   });
 
+  it("flags that all providers errored/timed out for a clear message", async () => {
+    const http = stubHttp([
+      { match: "s.jina.ai", throws: "timeout" },
+      { match: "duckduckgo", throws: "timeout" }, { match: "bing", throws: "timeout" },
+      { match: "baidu", throws: "timeout" }, { match: "sogou", throws: "timeout" },
+    ]);
+    const res = await webSearch("q", { env: {}, http });
+    expect(res.errors).toBeGreaterThan(0);
+    expect(formatSearchResults(res)).toMatch(/errored or timed out/);
+  });
+
+  it("stops the waterfall once the time budget is exceeded", async () => {
+    // jina resolves (empty) but slowly; the budget then cuts off the scrapers.
+    const http = {
+      calls: [] as string[],
+      async getJson(url: string) { this.calls.push(url); await new Promise((r) => setTimeout(r, 30)); return { data: [] }; },
+      async getText(url: string) { this.calls.push(url); return ""; },
+      async postJson(url: string) { this.calls.push(url); return {}; },
+    };
+    const res = await webSearch("q", { env: {}, http: http as any, budgetMs: 5 });
+    expect(res.provider).toBe("none");
+    expect(res.tried).toEqual(["jina"]); // scrapers skipped — out of budget
+  });
+
   it("rejects an empty query", async () => {
     await expect(webSearch("   ", {})).rejects.toThrow(/query/);
   });