@akanjs/cli 3.1.0-rc.12 → 3.1.0-rc.14

package/.build-stamp

@@ -1 +1 @@
-45dc4be5e34b35b9eaac8daa987756f8464382b61a5afdc7f0d60d658b487b2f
+950cf5d3be113577366b2ad2bee64408ec72e632a6e3a15290c14be5cef218fb

package/{CodeAgent-fhrb6xyw.js → CodeAgent-n3tzjm91.js}

@@ -1,8 +1,8 @@
 // @bun
 import {
   CodeAgent2
-} from "./index-zjgs0t7s.js";
-import"./index-ht15pm08.js";
+} from "./index-1djcjcre.js";
+import"./index-dye8pnxx.js";
 import"./index-7md2g9vw.js";
 export {
   CodeAgent2 as CodeAgent

package/{CodeTui-ntnda5dn.js → CodeTui-fnm9ft4d.js}

@@ -5,7 +5,7 @@ import {
   McpTokenStore,
   McpSignIn,
   AkanCodeCompaction2
-} from "./index-ht15pm08.js";
+} from "./index-dye8pnxx.js";
 import {
   CodeTuiLines2,
   CodeTuiAgents2,

package/akanCode.js

@@ -28,7 +28,7 @@ import {
   CodeMailbox2,
   CodeSessionFork2,
   CodeAgent2
-} from "./index-zjgs0t7s.js";
+} from "./index-1djcjcre.js";
 import {
   akanCodeDefaultModel2,
   akanCodeModel2,
@@ -40,7 +40,7 @@ import {
   SubagentPool2,
   akanCodePaths2,
   AkanCodeCompaction2
-} from "./index-ht15pm08.js";
+} from "./index-dye8pnxx.js";
 import"./index-7md2g9vw.js";
 import {
   CodeAgentRpcHost2

package/{code.command-3sxektnr.js → code.command-130bdmhe.js}

@@ -19,7 +19,7 @@ class CodeRunner extends runner("code") {
   async serve(options, listen) {
     await import("./consoleToStderr-h5bryj94.js");
     const [{ CodeAgent }, { CodeAgentRpcHost }, { CodeAgentRpcListener }] = await Promise.all([
-      import("./CodeAgent-fhrb6xyw.js"),
+      import("./CodeAgent-n3tzjm91.js"),
       import("./CodeAgentRpcHost-9g27hmer.js"),
       import("./CodeAgentRpcListener-7p7z5dd7.js")
     ]);
@@ -34,8 +34,8 @@ class CodeRunner extends runner("code") {
   }
   async tui(options, seed) {
     const [{ CodeAgent }, { CodeTui }] = await Promise.all([
-      import("./CodeAgent-fhrb6xyw.js"),
-      import("./CodeTui-ntnda5dn.js")
+      import("./CodeAgent-n3tzjm91.js"),
+      import("./CodeTui-fnm9ft4d.js")
     ]);
     const agentOptions = await CodeRunner.#agentOptions(options, false);
     let resume = options.resume;
@@ -67,7 +67,7 @@ class CodeRunner extends runner("code") {
     }
   }
   async run(prompt, options) {
-    const { CodeAgent } = await import("./CodeAgent-fhrb6xyw.js");
+    const { CodeAgent } = await import("./CodeAgent-n3tzjm91.js");
     const agent = await CodeAgent.create(await CodeRunner.#agentOptions(options, false));
     const printer = new CodeAgentStreamPrinter2({ json: options.json, thinking: options.thinking });
     agent.on((event) => printer.print(event));

package/guidelines/agentRule/agentRule.instruction.md

@@ -180,6 +180,14 @@ pages declaring one name never clash, and a registry kept outside the surface re
   stores its uploads keeps a map beside the transcript keyed on name and size — the same guess `Attachment.same`
   has to make, and the one that is wrong for two crops of one export. So when both sides carry a `ref`, it *is* the
   answer to "the same file twice", and the heuristic is what is left for when they do not.
+- **A tool hands the model a file with `ToolReturn.attach(result, [attachment])`** (`akanjs/store`), which lands in
+  `ToolCallResult.attachments` beside the value — a `result` reaches the model as JSON text, so a URL in it is read
+  as letters and base64 as a wall of them. It takes a user attachment's shape and meets the same `accepts` check and
+  type allow-list; Anthropic carries it inside the `tool_result`, the chat-completions dialect (whose `tool` message
+  holds text alone) in one user message after the turn's tool messages. It is outside the 20,000-character ceiling
+  and held to the 4 MB per-file one, and only the latest turn's ride as bytes: an earlier one becomes a note telling
+  the model to call the tool again while the picture is on screen, since one picture costs over a thousand tokens on
+  every turn it rides.
 - **Speech is one engine contract and the framework's own policy.** `<Agent.Chat voice={engine} />` takes a
   `VoiceEngine` — `listen(handlers)` and `speak(sentence)`, both cancellable — and the chat decides everything
   else: a press-to-talk microphone whose transcript lands in the composer to be corrected, one utterance per
@@ -398,6 +406,10 @@ pages declaring one name never clash, and a registry kept outside the surface re
   renders one editor per row, and at most one of them is ever open, so one name is registered rather than fifty.
   It also means the verb is absent from the catalogue while nothing is open, which is honest — and costs the
   agent nothing, because the catalogue is re-read on the turn that follows the tool call that opened the form.
+- **A shell's `submit<Model>` refuses while an upload is in flight.** `Model.EditModal` (also while its submit is
+  disabled) and `Model.ViewEditModal` disable the button and answer `The <model> form is not ready to submit.` while
+  `<model>FormUploading` is not empty. That key is read `{ agent: false }`, so the refusal is how an agent learns of
+  the upload: call `submit<Model>` again once the file has landed, rather than setting the field a second time.
 
 ## Forms
 - **A form control publishes its own setter, and reading a form publishes one tool that fills several at once.**
@@ -614,14 +626,17 @@ pages declaring one name never clash, and a registry kept outside the surface re
   row, Tab completing its name, and Escape closing the menu and then, pressed again, the panel.
 
 ## Built-In Tools
-- The framework publishes five built-ins on every store surface: `navigate` (internal paths only, the same router
+- The framework publishes six built-ins on every store surface: `navigate` (internal paths only, the same router
   `Link` rides), `goBack` (this session's history — global, because history is not a control a page owns and a page
   that draws no back link is not one you may not leave — a screen that must not be left withholds them with `builtins`,
   not with prose), `readScreen` (the rendered DOM as compact text — headings, links, control values, and `(disabled)`
   on a control or button that has it; the chat's own UI is skipped via `data-agent-ui`, and a password value is never
   read), `readState(key)` (one masked store key — a key that is unknown or that this screen does not read is refused
-  *with the keys it can* read, the way `readScreen` names its sections), and `highlight(target)`. Declaring a hook tool
-  under one of those names shadows the built-in, so reuse them only to mean that. **There is no general-purpose wait**:
+  *with the keys it can* read, the way `readScreen` names its sections), `highlight(target)`, and `viewImage(src)` (one
+  `<img>` on screen, redrawn as a JPEG at most 1568px long and attached to the result — `src` must be one this view
+  shows, as `readScreen({ images: true })` printed it, so the agent cannot have the browser fetch an address of its
+  own, and a `data:` one is refused). Declaring a hook tool under one of those names shadows the built-in, so reuse
+  them only to mean that. **There is no general-purpose wait**:
   a built-in one was reachable on every screen and a model spent it on whatever key it liked, parking turns nobody
   asked to park. Waiting belongs to the screen that knows what is worth waiting for — publish an `st.tool` beside the
   control that starts the work, and let it await the work.
@@ -630,8 +645,8 @@ pages declaring one name never clash, and a registry kept outside the surface re
   awaits `ScreenSettle.wait()` — DOM quiescence, bounded, because the client router hands its promise to nobody —
   and the session awaits it after every tool that did not declare `settle: false` before taking the change report.
   Without it the report describes the moment before the change landed and the `readScreen` that follows reads the
-  page the user left. The reading built-ins (`readScreen`, `readState`, `highlight`) declare it, because a wait
-  costs 120ms of quiet at the very least and they change nothing a resource holds.
+  page the user left. The reading built-ins (`readScreen`, `readState`, `highlight`, `viewImage`) declare it,
+  because a wait costs 120ms of quiet at the very least and they change nothing a resource holds.
   New tools and state from a fresh route are still only listed from the next turn: the catalogue is snapshotted
   when the turn starts.
 - **A tool that waits for its own work costs no model turns; one that returns early costs one round trip per
@@ -665,8 +680,8 @@ pages declaring one name never clash, and a registry kept outside the surface re
 - **An image is always named, and its address rides only when asked for.** `readScreen` prints `[image: <alt>]`,
   and `[image]` for one with no `alt` — dropping the unlabelled one left a card that renders a picture reading
   exactly like a card that renders nothing, and "this page shows no image" is the one answer the screen cannot
-  support. `readScreen({ images: true })` appends `(<src>)` to each, for handing one to a tool that takes a
-  picture; it is off by default because a gallery is one long URL per thumbnail, which is the read's whole budget
+  support. `readScreen({ images: true })` appends `(<src>)` to each, for handing one to `viewImage` or another tool
+  that takes a picture; it is off by default because a gallery is one long URL per thumbnail, which is the read's whole budget
   spent on the part of the screen it can say the least about. A `data:` URL is never printed — that is the bytes
   themselves rather than somewhere to fetch them.
 - **A screen is only aimable if its names are printed.** `readScreen` writes `(#anchor)` beside a heading that

package/guidelines/conventions/conventions.instruction.md

@@ -374,8 +374,8 @@ orchestration in `service`, client state in `store`; `Template` is forms, `Unit`
 ### Calls, Queries, Agents (summaries)
 
 - **Wire (`transportRule`)**: a deadline is the endpoint's `{ timeout: <ms> }` (undeclared, the client quits at
-  30 s; the handler is not cancelled); `{ cache }` only on a `query` with no internal argument, dropped early by
-  `invalidate(endpoint, args?)` on a plugged `EndpointCacheControl`; `{ rateLimit }` per endpoint,
+  30 s; the handler is not cancelled); `{ cache }` only on a `query` with no internal argument, capped at one day,
+  dropped early by `invalidate(endpoint, args?)` on a plugged `EndpointCacheControl`; `{ rateLimit }` per endpoint,
   `option.setRateLimit` per app, `plug(RateLimit)` for a business key. `socketId` names a connection, not a caller. A
   device proves itself with a `MachineToken`. Server to server, `fetch.clone({ origin })` opens no socket
   without `connect: true`, retries through `retry`, and rethrows a remote `Err` as is — never wrapped or re-keyed.
@@ -417,6 +417,10 @@ orchestration in `service`, client state in `store`; `Template` is forms, `Unit`
   `plug(StorageAdaptorRole)` · `use<T>()` only for a legacy `option.ts` singleton · `env(...)` for config.
 - `memory(...)` takes a scalar or model class (`memory(Map, { of: CallStateInput })`); never hand-encode JSON into a
   `String` memory.
+- A file your own code stored through `plug(StorageAdaptorRole)` has its disk path at
+  `storage.resolveLocalPath?.(path, access)` (`fieldRule`): `null` means refused (answer 404, never fall back to
+  `readData()`), `undefined` means the adaptor keeps no local files, and a key that comes from a request passes
+  `access: "public"`. A `File` field is not one: `libs/shared` stores it through its own `StorageApi`.
 - **A new adapter is an `adapt()` singleton in `srvkit/`**, injected with `plug(TheClass)`, key `as const`. Never
   register it in `lib/option.ts` (it self-registers); never construct a `Logger` in it (`this.logger` exists);
   lifecycle work in `override async onInit()`. A per-use value object is a plain class. Legacy

package/guidelines/modelStore/modelStore.instruction.md

@@ -42,6 +42,13 @@ Generate client state coordination for a module. Store connects generated fetch
 - A model whose form holds a large `field.visual` body can pass the 256KB per-draft cap, and a draft over it is
   dropped with a warning rather than truncated.
 
+## File Uploads
+- `upload<Field>On<Model>(fileList, idx?)` is generated for every `File` field. `Field.Img` / `Imgs` / `File` /
+  `Files` handed the generated `set<Field>On<Model>` upload through it, so do not write an upload action.
+- `<model>FormUploading` holds the uploads in flight per field (`{}` when idle). The generated submit paths save
+  nothing until it is empty; a hand-written submit reads `Object.keys(st.use.<model>FormUploading()).length`. Full
+  contract: `fieldRule`.
+
 ## Review Checklist
 - The instruction points to current docs pages, not removed docs routes.
 - Generated examples use current Akan builder APIs and scanner-friendly filenames.

package/guidelines/workspaceRecipes/workspaceRecipes.instruction.md

@@ -571,6 +571,8 @@ akan sync automatically generates APIs across all layers. Only write custom logi
 | `[slice]List`, `[slice]InitList`, `[slice]Insight`, `[slice]Selection`, `hasMoreOf[Slice]` | Slice states |
 | `init[Slice](args)`, `refresh[Slice]()`, `setPageOf[Slice](page)`, `loadMoreOf[Slice]()` | Slice actions |
 | `set[Field]On[Model](value)` | Auto-setters for each model field |
+| `upload[Field]On[Model](fileList, idx?)` | Upload into a `File` field, scoped to the form that started it |
+| `[model]FormUploading` | Pending uploads per `File` field (`{}` when idle); submits save nothing until empty |
 
 **Rule**: Write custom store actions only for toast messages (`msg.loading`/`msg.success`) or multi-step workflows. State fields and CRUD actions are already auto-generated.
 

package/{index-zjgs0t7s.js → index-1djcjcre.js}

@@ -5,7 +5,7 @@ import {
   McpServerConfig,
   McpSignIn,
   AkanCodeCompaction2
-} from "./index-ht15pm08.js";
+} from "./index-dye8pnxx.js";
 import {
   stripAnsi
 } from "./index-7md2g9vw.js";
@@ -319,7 +319,7 @@ import {
   DefaultResourceLoader
 } from "@earendil-works/pi-coding-agent";
 import {
-  codeAgentClip as codeAgentClip5,
+  codeAgentClip as codeAgentClip6,
   codeAgentLabelChars as codeAgentLabelChars2,
   codeAgentRenderAnswer,
   codeAgentSessionName as codeAgentSessionName2
@@ -1396,11 +1396,120 @@ class SessionToolPack2 {
 }
 
 // pkgs/@akanjs/devkit/codeAgent/tools/WebToolPack.ts
-import { codeAgentClip as codeAgentClip3, codeAgentOutputChars as codeAgentOutputChars3 } from "akanjs/common";
+import { isIP } from "net";
+import { codeAgentClip as codeAgentClip4 } from "akanjs/common";
 import { Type as Type6 } from "typebox";
 
+// pkgs/@akanjs/devkit/codeAgent/tools/DeepSeekWeb.ts
+import { codeAgentClip as codeAgentClip3 } from "akanjs/common";
+
+class DeepSeekWeb {
+  static baseUrl = "https://api.deepseek.com/v1/tools";
+  static maxQueryChars = 128;
+  static summaryChars = 600;
+  static #retryable = {
+    search: [408, 429, 500, 502, 503, 504],
+    fetch: [429]
+  };
+  static #attempts = 3;
+  #key;
+  #baseUrl;
+  constructor(key, baseUrl = DeepSeekWeb.baseUrl) {
+    this.#key = key;
+    this.#baseUrl = baseUrl;
+  }
+  static async fromRuntime(runtime, proxied) {
+    if (proxied)
+      return;
+    const key = (await runtime.getAuth("deepseek").catch(() => {
+      return;
+    }))?.auth.apiKey;
+    return key ? new DeepSeekWeb(key) : undefined;
+  }
+  async search(query, count, signal) {
+    if ([...query].length > DeepSeekWeb.maxQueryChars)
+      throw new Error(`DeepSeek search takes at most ${DeepSeekWeb.maxQueryChars} characters; shorten the query.`);
+    const body = await this.#call("search", { query, count }, 20000, signal);
+    const byUrl = new Map;
+    for (const result of body.results ?? []) {
+      const url = DeepSeekWeb.#cleanUrl(result.url);
+      if (!byUrl.has(url))
+        byUrl.set(url, { ...result, url });
+    }
+    return [...byUrl.values()].map((result) => {
+      const date = result.date ? ` \xB7 ${result.date.slice(0, 10)}` : "";
+      const summary = DeepSeekWeb.unescape(result.summary || result.snippet || "").replace(/\s+/g, " ").trim();
+      return `- ${result.title}
+  ${result.url}${date}
+  ${codeAgentClip3(summary, DeepSeekWeb.summaryChars)}`;
+    }).join(`
+`);
+  }
+  async fetch(url, signal) {
+    const page = await this.#call("fetch", { url }, 30000, signal);
+    return { title: page.title ?? "", content: DeepSeekWeb.unescape(page.content ?? "") };
+  }
+  static unescape(markdown) {
+    const escaped = markdown.match(/\\[!-/:-@[-`{-~]/g)?.length ?? 0;
+    const punctuation = markdown.match(/[!-/:-@[-`{-~]/g)?.length ?? 0;
+    if (!escaped || escaped < (punctuation - escaped) / 2)
+      return markdown;
+    return markdown.replace(/\\([!-/:-@[-`{-~])/g, "$1");
+  }
+  async#call(tool, body, timeoutMs, signal) {
+    for (let attempt = 1;; attempt++) {
+      const response = await fetch(`${this.#baseUrl}/${tool}`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${this.#key}`, "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs)
+      });
+      if (response.ok)
+        return await response.json();
+      if (!DeepSeekWeb.#retryable[tool].includes(response.status) || attempt >= DeepSeekWeb.#attempts) {
+        const error = await response.json().catch(() => {
+          return;
+        });
+        throw new Error(`DeepSeek ${tool} answered ${response.status}: ${error?.error?.message ?? response.statusText}`);
+      }
+      await DeepSeekWeb.#wait(DeepSeekWeb.#delayOf(response, attempt), signal);
+    }
+  }
+  static #delayOf(response, attempt) {
+    const retryAfter = Number(response.headers.get("retry-after"));
+    return Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter, 5) * 1000 : 1000 * 2 ** (attempt - 1);
+  }
+  static #wait(ms, signal) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(resolve, ms);
+      signal?.addEventListener("abort", () => {
+        clearTimeout(timer);
+        resolve();
+      }, { once: true });
+    });
+  }
+  static #cleanUrl(url) {
+    try {
+      const parsed = new URL(url);
+      for (const name of [...parsed.searchParams.keys()])
+        if (name.startsWith("utm_"))
+          parsed.searchParams.delete(name);
+      if (/^#\d+$/.test(parsed.hash))
+        parsed.hash = "";
+      return parsed.toString();
+    } catch {
+      return url;
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/tools/WebToolPack.ts
 class WebToolPack2 {
+  static pageChars = 1e4;
+  static maxResults = 10;
+  static #rememberedPages = 16;
   #options;
+  #pages = new Map;
   constructor(options) {
     this.#options = options;
   }
@@ -1439,7 +1548,7 @@ class WebToolPack2 {
     const names = [];
     if (this.#options.profile.tools.web.fetch)
       names.push("web_fetch");
-    if (this.#options.profile.tools.web.search && WebToolPack2.#provider())
+    if (this.#options.profile.tools.web.search && this.#searcher())
       names.push("web_search");
     return names;
   }
@@ -1451,58 +1560,124 @@ class WebToolPack2 {
   #register(pi) {
     if (this.#options.profile.tools.web.fetch)
       this.#registerFetch(pi);
-    const provider = WebToolPack2.#provider();
-    if (this.#options.profile.tools.web.search && provider)
-      this.#registerSearch(pi, provider);
+    const searcher = this.#searcher();
+    if (this.#options.profile.tools.web.search && searcher)
+      this.#registerSearch(pi, searcher);
   }
   #registerFetch(pi) {
     const allowHosts = this.#options.profile.network.allowHosts;
     pi.registerTool({
       name: "web_fetch",
       label: "Fetch",
-      description: "Fetch a URL and return its readable text. HTML is stripped to text; the result is truncated.",
+      description: `Fetch a URL and return its readable text, ${WebToolPack2.pageChars} characters at a time. A longer page ends with the offset that continues it.`,
       promptSnippet: "web_fetch: fetch a URL and return its readable text",
-      parameters: Type6.Object({ url: Type6.String({ description: "Absolute http(s) URL." }) }),
-      execute: async (_id, params) => {
+      parameters: Type6.Object({
+        url: Type6.String({ description: "Absolute http(s) URL." }),
+        offset: Type6.Optional(Type6.Number({ description: "Character offset a previous call named, to read on." }))
+      }),
+      execute: async (_id, params, signal) => {
         const refusal = WebToolPack2.#refuseHost(params.url, allowHosts);
         if (refusal)
           return { content: [{ type: "text", text: refusal }], details: undefined, isError: true };
-        const response = await fetch(params.url, { signal: AbortSignal.timeout(20000), redirect: "follow" });
-        const text = WebToolPack2.#readable(await response.text());
+        const offset = Math.max(0, Math.floor(params.offset ?? 0));
+        const cached = offset ? this.#pages.get(params.url) : undefined;
+        const page = cached ?? await this.#read(params.url, signal);
+        if (page.ok)
+          this.#remember(params.url, page);
         return {
-          content: [
-            { type: "text", text: `${response.status} ${params.url}
-
-${codeAgentClip3(text, codeAgentOutputChars3)}` }
-          ],
+          content: [{ type: "text", text: WebToolPack2.#window(params.url, page, offset) }],
           details: undefined,
-          isError: !response.ok
+          isError: !page.ok
         };
       }
     });
   }
-  #registerSearch(pi, provider) {
+  #registerSearch(pi, searcher) {
+    const hint = searcher.name === "deepseek" ? ` Keep the query within ${DeepSeekWeb.maxQueryChars} characters; site:, -site: and quoted phrases work.` : "";
     pi.registerTool({
       name: "web_search",
       label: "Search",
-      description: `Search the web (${provider.name}) and return the top results as title, url and snippet.`,
+      description: `Search the web (${searcher.name}) and return the top results as title, url and summary.${hint}`,
       promptSnippet: "web_search: search the web and return titles, urls and snippets",
       parameters: Type6.Object({
         query: Type6.String(),
-        count: Type6.Optional(Type6.Number({ description: "How many results, default 5." }))
+        count: Type6.Optional(Type6.Number({ description: `How many results, default 5, at most ${WebToolPack2.maxResults}.` }))
       }),
-      execute: async (_id, params) => {
-        const key = process.env[provider.envKey] ?? "";
-        const results = await provider.search(key, params.query, params.count ?? 5);
-        return {
-          content: [{ type: "text", text: codeAgentClip3(results || "(no results)", codeAgentOutputChars3) }],
-          details: undefined
-        };
+      execute: async (_id, params, signal) => {
+        const count = Math.min(Math.max(Math.round(params.count ?? 5), 1), WebToolPack2.maxResults);
+        try {
+          const results = await searcher.search(params.query, count, signal);
+          return {
+            content: [{ type: "text", text: codeAgentClip4(results || "(no results)", WebToolPack2.pageChars) }],
+            details: undefined
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { content: [{ type: "text", text: message }], details: undefined, isError: true };
+        }
       }
     });
   }
-  static #provider() {
-    return WebToolPack2.providers.find((provider) => !!process.env[provider.envKey]);
+  #searcher() {
+    const provider = WebToolPack2.providers.find((entry) => !!process.env[entry.envKey]);
+    if (provider)
+      return {
+        name: provider.name,
+        search: (query, count) => provider.search(process.env[provider.envKey] ?? "", query, count)
+      };
+    const deepseek = this.#options.deepseek;
+    return deepseek ? { name: "deepseek", search: (query, count, signal) => deepseek.search(query, count, signal) } : undefined;
+  }
+  async#read(url, signal) {
+    const deepseek = this.#options.deepseek;
+    if (deepseek && !WebToolPack2.#isLocal(new URL(url).hostname)) {
+      try {
+        const page = await deepseek.fetch(url, signal);
+        return { status: 200, ok: true, title: page.title, text: page.content };
+      } catch (error) {
+        if (signal?.aborted)
+          throw error;
+      }
+    }
+    const response = await fetch(url, {
+      signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(20000)]) : AbortSignal.timeout(20000),
+      redirect: "follow"
+    });
+    return { status: response.status, ok: response.ok, title: "", text: WebToolPack2.#readable(await response.text()) };
+  }
+  #remember(url, page) {
+    this.#pages.delete(url);
+    this.#pages.set(url, page);
+    const oldest = this.#pages.keys().next().value;
+    if (this.#pages.size > WebToolPack2.#rememberedPages && oldest)
+      this.#pages.delete(oldest);
+  }
+  static #window(url, page, offset) {
+    const head = [`${page.status} ${url}`, page.title].filter(Boolean).join(`
+`);
+    const total = page.text.length;
+    if (offset && offset >= total)
+      return `${head}
+
+Offset ${offset} is past the end; the page has ${total} characters.`;
+    const end = Math.min(offset + WebToolPack2.pageChars, total);
+    const rest = end < total ? `
+
+[characters ${offset}\u2013${end} of ${total}; offset ${end} reads on]` : "";
+    return `${head}
+
+${page.text.slice(offset, end)}${rest}`;
+  }
+  static #isLocal(hostname) {
+    const host = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    const family = isIP(host);
+    if (family === 6)
+      return host === "::1" || /^(f[cd]|fe[89ab])/.test(host);
+    if (family === 4) {
+      const [a = 0, b = 0] = host.split(".").map(Number);
+      return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168;
+    }
+    return !host.includes(".") || /\.(localhost|local|internal|lan|home\.arpa)$/.test(host);
   }
   static #refuseHost(url, allowHosts) {
     let parsed;
@@ -1534,7 +1709,7 @@ class AkanCodePlugins2 {
     });
     const dispose = () => mcp?.close();
     const mcpStatus = mcp?.status ?? [];
-    const web = new WebToolPack2({ profile: options.profile });
+    const web = new WebToolPack2({ profile: options.profile, deepseek: options.deepseek });
     const sessions = new SessionToolPack2({
       workspaceRoot: options.workspace.workspaceRoot,
       cwd: options.cwd,
@@ -1669,9 +1844,9 @@ class CodeAgentAsks2 {
 
 // pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentEventMapper.ts
 import {
-  codeAgentClip as codeAgentClip4,
+  codeAgentClip as codeAgentClip5,
   codeAgentLabelChars,
-  codeAgentOutputChars as codeAgentOutputChars4
+  codeAgentOutputChars as codeAgentOutputChars3
 } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/codeAgent/agent/stringArg.ts
@@ -1731,7 +1906,7 @@ class CodeAgentEventMapper2 {
             type: "tool_progress",
             turnId: this.#turnId,
             toolCallId: event.toolCallId,
-            text: codeAgentClip4(CodeAgentEventMapper2.#renderToolText(event.partialResult), codeAgentLabelChars)
+            text: codeAgentClip5(CodeAgentEventMapper2.#renderToolText(event.partialResult), codeAgentLabelChars)
           }
         ];
       case "tool_execution_end":
@@ -1802,8 +1977,8 @@ class CodeAgentEventMapper2 {
       turnId: this.#turnId,
       tool,
       outcome: reason ? "blocked" : event.isError ? "error" : "ok",
-      output: codeAgentClip4(full, codeAgentOutputChars4),
-      truncated: full.length > codeAgentOutputChars4
+      output: codeAgentClip5(full, codeAgentOutputChars3),
+      truncated: full.length > codeAgentOutputChars3
     };
   }
   noteOutcome(reason) {
@@ -1832,7 +2007,7 @@ class CodeAgentEventMapper2 {
       name,
       op: toolOps[name] ?? "other",
       ...path ? { path } : {},
-      title: codeAgentClip4(`${name}${CodeAgentEventMapper2.#renderArgs(args)}`, codeAgentLabelChars)
+      title: codeAgentClip5(`${name}${CodeAgentEventMapper2.#renderArgs(args)}`, codeAgentLabelChars)
     };
   }
   #mapDelta(event) {
@@ -1859,7 +2034,7 @@ class CodeAgentEventMapper2 {
     if (!entries.length)
       return "";
     const rendered = entries.map(([key, value]) => `${key}=${CodeAgentEventMapper2.#renderArgValue(value)}`).join(" ");
-    return `(${codeAgentClip4(rendered, 120)})`;
+    return `(${codeAgentClip5(rendered, 120)})`;
   }
   static #renderArgValue(value) {
     if (Array.isArray(value))
@@ -1868,7 +2043,7 @@ class CodeAgentEventMapper2 {
       const keys = Object.keys(value).length;
       return `{${keys} key${keys === 1 ? "" : "s"}}`;
     }
-    return codeAgentClip4(String(value), 60);
+    return codeAgentClip5(String(value), 60);
   }
   static #renderContent(content) {
     if (typeof content === "string")
@@ -2320,7 +2495,8 @@ class CodeAgent2 {
     const agent = new CodeAgent2(options.profile);
     const autoCompactAt = AkanCodeCompaction2.normalize(options.autoCompactAt);
     const settingsManager = AkanCodeServices2.settings();
-    const modelRuntime = await AkanCodeServices2.runtime(workspaceRoot, CodeAgentProxy.fromEnv(options.profile));
+    const proxy = CodeAgentProxy.fromEnv(options.profile);
+    const modelRuntime = await AkanCodeServices2.runtime(workspaceRoot, proxy);
     const model = await akanCodeModel2(modelRuntime, options.model);
     const compaction = settingsManager.getCompactionSettings(model);
     const modelWarnings = akanCodeModelWarnings2(model, compaction.reserveTokens + compaction.keepRecentTokens);
@@ -2330,6 +2506,7 @@ class CodeAgent2 {
       profile: options.profile,
       apps: options.apps ?? [],
       canSeeImages: akanCodeModelSupportsImages2(model),
+      deepseek: await DeepSeekWeb.fromRuntime(modelRuntime, !!proxy),
       depth: options.depth ?? 0,
       ...options.subagentSpend ? { subagentSpend: options.subagentSpend } : {},
       currentSessionId: () => agent.sessionId,
@@ -2724,7 +2901,7 @@ Continue the task.`);
       approvalId,
       toolCallId,
       name,
-      summary: codeAgentClip5(summary, codeAgentLabelChars2),
+      summary: codeAgentClip6(summary, codeAgentLabelChars2),
       policy: this.#profile.approval
     };
     this.#emit({ type: "approval", request });

package/{index-ht15pm08.js → index-dye8pnxx.js}

@@ -179,7 +179,7 @@ class SubagentPool2 {
     }
   }
   async#run(id, kind, prompt, signal) {
-    const { CodeAgent } = await import("./CodeAgent-fhrb6xyw.js");
+    const { CodeAgent } = await import("./CodeAgent-n3tzjm91.js");
     const budget = this.#options.parent.tools.subagent;
     const child = SubagentPool2.childOf(this.#options.parent, kind);
     const agent = await CodeAgent.create({

package/index.js

@@ -15,7 +15,7 @@ import path from "path";
 var commandModules = {
   workspace: async () => (await import("./workspace.command-6qfgq4b4.js")).WorkspaceCommand,
   agent: async () => (await import("./agent.command-3qxf4xcj.js")).AgentCommand,
-  code: async () => (await import("./code.command-3sxektnr.js")).CodeCommand,
+  code: async () => (await import("./code.command-130bdmhe.js")).CodeCommand,
   application: async () => (await import("./application.command-m1kcd7jf.js")).ApplicationCommand,
   library: async () => (await import("./library.command-erp2f56n.js")).LibraryCommand,
   localRegistry: async () => (await import("./localRegistry.command-y176p558.js")).LocalRegistryCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/cli",
-  "version": "3.1.0-rc.12",
+  "version": "3.1.0-rc.14",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -39,7 +39,7 @@
     "@earendil-works/pi-tui": "1.3.0",
     "@inquirer/prompts": "^8.7.3",
     "@tailwindcss/node": "^4.3.3",
-    "akanjs": "3.1.0-rc.12",
+    "akanjs": "3.1.0-rc.14",
     "chalk": "^6.0.1",
     "commander": "^15.0.0",
     "dayjs": "^1.11.23",