@columenlabs/lumen-ai 0.1.254 → 0.1.255

package/README.md

@@ -111,7 +111,7 @@ app.all('/api/assistant/*', (c) => routes(c.req.raw));
 - **Who pays.** The person's pick (the shared keys by default) while it has a key for the tier's provider and money left this month under its cap (an admin sets the shared keys' cap per person, `PUT /app`), else the other; with neither the panel says why.
 - **Tools.** Each group is Off, Read, Read + draft or Read + write per person. A tool is a read when its MCP `readOnlyHint` is set. On Read + draft a write only drafts a card, and runs as the person when they press Save, after access is checked again. A group with `readOnly: true` (read tools only) is offered Off or Read alone. Read + write is offered only for a group with `writes: true`: its writes run at once, and with `undo` set each one's line in the chat has Undo, which calls `undo(caller, { tool, args, result })`; the model is told what was undone. Cards drafted one after another show as one stack with Save all. Use `mcpServerTools` (an SDK `McpServer`), `mcpFetchTools` (a server served as a fetch handler, any SDK), `remoteMcpTools` or `plainTools`.
 - **Web.** `fetch` is a plain GET from the Worker (10 s, 2 MB, never the app's own hosts or private addresses). ScrapeQL's own tools join over its MCP API once an admin pastes a Cloudflare Access service token (`PUT /web/scrapeql`). A Worker on ScrapeQL's own Cloudflare account passes its service binding instead, `scrapeql: { url: 'https://scrapeql/mcp', fetch: env.SCRAPEQL.fetch.bind(env.SCRAPEQL) }`: no token is stored, the tools are always on and Settings shows the link with a Test. Each web step carries `web` (`StepWeb`: a search's `query` and `results`, or the page it `read`), so the panel folds a search's results under its line and numbers each page read under the answer as Sources chips; the model marks facts with those numbers ([1]).
-- **Web lookup (a subagent).** `web: { scrapeql, lookup: true }` swaps fetch and ScrapeQL's own tools for one tool, `web__lookup` (`webLookupTools` from `@columenlabs/lumen-ai/subagents`): given a question (and `urls` when the pages are known), it searches with ScrapeQL, has ScrapeQL's `ask` read the best pages (3 by default, `pages` up to 5) and answer in a few sentences each (`answerTokens`, default 300), and returns `{question, sources: [{url, title, answer}], failed}`: about a thousand tokens, never whole pages, so the assistant's context stays small. No model runs in the kit for it; ScrapeQL picks its own cheapest model. Its step carries `web.lookup` and `web.reads`, which the panel folds under a Looked up line and numbers as Sources chips. `fetch.blockHosts` still applies.
+- **Web lookup (a subagent).** `web: { scrapeql, lookup: true }` swaps fetch and ScrapeQL's own tools for one tool, `web__lookup` (`webLookupTools` from `@columenlabs/lumen-ai/subagents`): given a question (and `urls` when the pages are known), it searches with ScrapeQL, has ScrapeQL's `ask` read the best pages (3 by default, `pages` up to 5) and answer in a few sentences each (`answerTokens`, default 300), and returns `{question, sources: [{url, title, answer}], failed}`: about a thousand tokens, never whole pages, so the assistant's context stays small. No model runs in the kit for it; ScrapeQL picks its own cheapest model. Its step carries `web.lookup` and `web.reads`, which the panel folds under a Looked up line and numbers as Sources chips. `fetch.blockHosts` still applies. Until ScrapeQL is reachable (no binding and no Access token saved yet), the web falls back to `fetch` and the lookup rule is left out, so turning lookup on never takes the web away.
 - **Hand off and advice.** The `escalate` tool hands one task to a higher tier (the person sets next, any or only when asked); Anthropic's advisor tool lets a higher tier send a plan, at most two an answer. A hand-off gives up after `HAND_OFF_MS` (4 minutes) and the turn goes on without it.
 - **Chats** run on the agent (`./agent`, `LumenAgent`, below): the app routes `POST /chat` and each chat's reads, cards and Undo to its own agent, and `assistantRoutes` answers `POST /chat` with 410 `moved`. Chats saved by the old turn loop stay readable (`GET /chats`, `GET|DELETE /chats/:id`) until `assistant.purge()` drops them 30 days after their last message.
 - **Screen moves**: while the person's Settings ▸ Screen is Move (the default), the panel sends its page map (`AssistantMessage.screen`: routes, nav pages, Settings sections, cards on screen, rows to open) and `LumenAgent` gives the model a `screen` tool (`./agent` `screen.ts`). Each call's moves (go, settings, chart, open, point) are checked against the map, kept in the chat and streamed as a `screen` event; the panel runs them through `AssistantScreenProvider` (mounted by `LumenShell`) with an Undo chip, and their outcomes go back with the next message (`outcomes`). Nothing is saved by a move.

package/dist/assistant/engine.js

@@ -118,6 +118,7 @@ function openedSummary(t) {
         reads: t.reads.length > 0,
         batch: true,
         web: t.info.some((i) => i.group === 'web'),
+        lookup: t.info.some((i) => i.name === 'web__lookup'),
     };
 }
 export class Assistant {
@@ -827,36 +828,33 @@ export class Assistant {
             for (const source of Array.isArray(s) ? s : [s])
                 sources.push({ group: g.id, access, source, ...(g.writes ? { writes: true } : {}) });
         }
-        const lookup = this.o.web?.lookup;
-        const blockHosts = this.o.web?.fetch ? this.o.web.fetch.blockHosts : undefined;
-        if ((p.web ?? true) && lookup) {
+        if (p.web ?? true) {
             const sq = this.o.web?.scrapeql;
             const token = sq && !sq.fetch ? await this.state.scrapeql() : null;
-            if (sq && (sq.fetch || token))
+            const scrapeql = sq && (sq.fetch || token) ? scrapeqlTools(sq.url, token, sq.fetch ?? this.o.fetch) : null;
+            const lookup = this.o.web?.lookup;
+            if (lookup && scrapeql) {
+                // The one lookup tool. Without ScrapeQL (no binding, no token yet) the web falls back to fetch.
+                const blockHosts = this.o.web?.fetch ? this.o.web.fetch.blockHosts : undefined;
                 sources.push({
                     group: 'web',
                     access: 'read',
-                    source: webLookupTools(scrapeqlTools(sq.url, token, sq.fetch ?? this.o.fetch), {
+                    source: webLookupTools(scrapeql, {
                         ...(blockHosts ? { blockHosts } : {}),
                         ...(typeof lookup === 'object' ? lookup : {}),
                     }),
                 });
-        }
-        else if (p.web ?? true) {
-            if (this.o.web?.fetch !== false)
-                sources.push({
-                    group: 'web',
-                    access: 'read',
-                    source: webFetchTools(this.o.web?.fetch || {}),
-                });
-            const sq = this.o.web?.scrapeql;
-            const token = sq && !sq.fetch ? await this.state.scrapeql() : null;
-            if (sq && (sq.fetch || token))
-                sources.push({
-                    group: 'web',
-                    access: 'read',
-                    source: scrapeqlTools(sq.url, token, sq.fetch ?? this.o.fetch),
-                });
+            }
+            else {
+                if (this.o.web?.fetch !== false)
+                    sources.push({
+                        group: 'web',
+                        access: 'read',
+                        source: webFetchTools(this.o.web?.fetch || {}),
+                    });
+                if (scrapeql)
+                    sources.push({ group: 'web', access: 'read', source: scrapeql });
+            }
         }
         return sources;
     }
@@ -887,7 +885,7 @@ export class Assistant {
             lines.push('No tools are on now: the person can turn them on in Settings ▸ Tools.');
         if (failed)
             lines.push(`${failed} tool source${failed === 1 ? '' : 's'} could not be reached this turn.`);
-        if (fns.web && this.o.web?.lookup)
+        if (fns.lookup)
             lines.push("Web: web__lookup answers one question from the web: give the full question (and urls when you already know the pages); it returns a short answer from each page it read. Look up again with a sharper question rather than asking for whole pages. The person sees each page a lookup read numbered under your answer, in the order returned (the first lookup's sources first, a later lookup's after them): mark a fact with its number, like [1], and never cite a page that is not among the sources.");
         else if (fns.web)
             lines.push('Web: use web__fetch first for APIs and plain pages; the browser tools only for pages that need JavaScript or after a fetch fails. To find pages, search, then read the one to three that answer the question. The person sees each page you read numbered under your answer, in the order you read them (1 for the first page read in this answer): mark a fact you took from a page with its number, like [1], and never cite a page you did not read.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@columenlabs/lumen-ai",
-  "version": "0.1.254",
+  "version": "0.1.255",
   "description": "Lumen's assistant and agent parts: a chat assistant's server (Claude tiers, tools over MCP, the web, hand off, spend caps), serving an MCP server from a Worker, read-only tool sets and metered tool calls.",
   "license": "MIT",
   "type": "module",
@@ -56,8 +56,8 @@
     "@ai-sdk/openai": "4.0.108",
     "@anthropic-ai/sdk": "0.133.0",
     "@cloudflare/think": "0.23.0",
-    "@columenlabs/lumen-ops": "0.1.254",
-    "@columenlabs/lumen-ui-types": "0.1.254",
+    "@columenlabs/lumen-ops": "0.1.255",
+    "@columenlabs/lumen-ui-types": "0.1.255",
     "agents": "0.32.0",
     "ai": "7.0.162",
     "just-bash": "3.6.0",