@cerebriline/core 4.100.247 → 4.100.249

package/dist/extensions/context/capped-thinking.d.ts

@@ -169,6 +169,20 @@ type PrepareTurnResult = {
     messages?: readonly MessageWithMetadata[];
 } | undefined;
 type PrepareTurn = (context: never) => PrepareTurnResult | Promise<PrepareTurnResult>;
+/** A request answered by the conversation itself, or `undefined` to decline. */
+type ConversationAsk = (systemPrompt: string, request: string, maxTokens: number, what: string) => Promise<string | undefined>;
+/**
+ * The discarded turn's notes, asked of the conversation as its next turn
+ * where that can be done (`DiscardedTurnInput.continueConversation`).
+ *
+ * Declines -- and the note is asked for in a request of its own, as before --
+ * when the runtime offered no way to continue, when a separate summarizer
+ * model is configured (it is not the conversation's model), when the provider
+ * keeps no prefix to share, and when the instruction and its answer do not fit
+ * in what the last request left of the window. A continuation that fails or
+ * says nothing declines too: a note is never lost to the attempt.
+ */
+export declare function createConversationAsk(input: DiscardedTurnInput, config: CappedThinkingCondenserConfig, providerConfig: ProviderConfig): ConversationAsk | undefined;
 /**
  * Condense reasoning that is about to be thrown away rather than sent again.
  *

package/dist/extensions/context/compaction-shared.d.ts

@@ -112,6 +112,39 @@ export type MeasureContextTokens = (message: MessageWithMetadata, index: number)
  * the context as it stands, which is the question the reservation is asking.
  */
 export declare function resolveObservedOutputTokens(messages: readonly MessageWithMetadata[], measure: MeasureContextTokens, sampleTurns?: number): number | undefined;
+/**
+ * What a compaction written as the conversation's next turn needs on top of
+ * the conversation: its instruction and its summary.
+ *
+ * One function because two things ask it. The trigger asks before the fact,
+ * so that compaction starts while this still fits; the continuation asks at
+ * the moment it would start, and steps aside when it does not. Harness run
+ * 0432 (2026-10-11) is what two different answers cost: the trigger waited
+ * for 90% of an 85,106-token window, the writer's request then measured
+ * 92,738, and each such compaction fell back to a summary that did not fit
+ * beside the conversation either, released the conversation's window and made
+ * the next turn read its whole prompt again.
+ */
+export declare const CONTINUATION_WRITER_INSTRUCTION_TOKENS = 3072;
+export declare function resolveContinuationWriterRoomTokens(contextWindow: number | undefined): number;
+/**
+ * What the conversation has gained since its last request was measured: the
+ * newest assistant message and the results that followed it.
+ *
+ * The provider's count is of the request that produced that message, so it
+ * holds neither. In run 0432 the count was 78,895 and the conversation the
+ * writer had to continue was about 90,000.
+ */
+export declare function resolvePendingTurnTokens(messages: readonly MessageWithMetadata[], measure: MeasureContextTokens): number;
+/**
+ * How much one turn adds to the conversation, from this session's own turns:
+ * an assistant message and everything up to the next one.
+ *
+ * Read the way {@link resolveObservedOutputTokens} reads output, for the same
+ * reason: the newest turns count in full, and past them a single large turn is
+ * an outlier and the second largest sets the figure.
+ */
+export declare function resolveObservedTurnGrowthTokens(messages: readonly MessageWithMetadata[], measure: MeasureContextTokens, sampleTurns?: number): number | undefined;
 /**
  * The largest prompt that still leaves the model room to answer.
  *
@@ -150,6 +183,19 @@ export declare function resolveCompactionTriggerTokens(input: {
     modelMaxTokens?: number;
     /** The high-water output of recent turns, from {@link resolveObservedOutputTokens}. */
     observedOutputTokens?: number;
+    /**
+     * Set where compaction would be written as the conversation's next turn.
+     * The trigger then also holds back what that turn needs, so compaction
+     * starts while it still fits: the writer's own room, what the conversation
+     * has gained since the count the trigger compares was taken, and one more
+     * turn like this session's.
+     */
+    continuation?: {
+        /** {@link resolvePendingTurnTokens}; 0 when the compared count is current. */
+        pendingTokens: number;
+        /** {@link resolveObservedTurnGrowthTokens}. */
+        turnGrowthTokens?: number;
+    };
 }): number;
 export interface FileOperationSummary {
     readFiles: string[];

package/dist/extensions/context/continuation-compaction.d.ts

@@ -186,6 +186,12 @@ export interface CompactionContinuation {
      * where the engine books.
      */
     fresh(purpose: "retrospective" | "synthesizer", systemPrompt: string, request: string, maxTokens: number, providerConfig: ProviderConfig, reservation?: PPrimeReservation): Promise<ContinuationCallResult>;
+    /**
+     * Whether a retrospective of about `chars` characters would run as the
+     * session's own next turn. It has to be asked for before {@link release}
+     * then: afterwards there is no session to continue.
+     */
+    retrospectiveFitsInSession(chars: number, maxTokens: number): boolean;
     /**
      * Give the session's cells back: the critics, P', P, then the session's
      * own slot. Idempotent; run before the synthesizer, and again by
@@ -216,6 +222,12 @@ export interface PrepareContinuationInput {
     requestTokens: number;
     /** The last request's own prompt count, when one was measured. */
     observedRequestTokens?: number;
+    /**
+     * What the conversation has gained since `requestTokens` was counted: the
+     * newest assistant message and the results after it. 0 when the count is
+     * an estimate of the conversation as it stands.
+     */
+    pendingTokens?: number;
     reasoning: ContinuationReasoning;
     /** A summarizer model of its own is configured: it cannot continue this one. */
     separateSummarizer: boolean;
@@ -238,6 +250,12 @@ export interface PrepareContinuationInput {
 }
 /** Whether a failed call is the server saying "not now". */
 export declare function isInfraFault(error: unknown): boolean;
+/**
+ * Why compaction on this connection is never written as a continuation, or
+ * `undefined` when it can be. The part of the answer that does not depend on
+ * the turn, so the trigger can ask it before there is a compaction to prepare.
+ */
+export declare function continuationCompactionExcluded(config: ProviderConfig, separateSummarizer: boolean): string | undefined;
 /**
  * Whether compaction on this connection can run as a continuation, and in
  * which shape. `undefined` continuation with the reason when it cannot.

package/dist/extensions/tools/icon-generation.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Icons: several proposals to choose from, then every file an icon is.
+ *
+ * `generate_image` can draw an icon, and the first person to use it for one
+ * was pleased that it could. What it left him with was one PNG at the size the
+ * model draws, when an icon is a choice between candidates and then a dozen
+ * files: an `.ico` holding seven sizes, an `.icns`, and the PNGs a web page and
+ * a phone ask for by size.
+ *
+ * So this is two steps under one name. With a `prompt` it draws several
+ * proposals and shows them on one numbered sheet, for the user to pick from.
+ * With `pick` it writes the chosen one out in every format. The model asks the
+ * question in between: choosing is the user's part.
+ */
+import { type AgentTool } from "@cerebriline/shared";
+import { type ImageGenerationEndpoint } from "./image-generation";
+import { type RenderDriver } from "./render-image";
+export declare const GENERATE_ICON_TOOL_NAME = "generate_icon";
+export declare const GENERATE_ICON_TOOL_DESCRIPTION = "Make an icon for an application, a site or a file type: several proposals for the user to choose from, then the chosen one saved in every format an icon needs. Two steps, one call each.\n\n1. Proposals. Give `prompt`: what the icon shows and the feeling it should have (\"a paper plane, friendly, blue on white\"). Several candidates are drawn and returned on one numbered sheet, each saved as its own file. Show the user the sheet and ask which one they want (`ask_question`, with the numbers as the options); do not choose for them. If none is right, call again with a changed prompt.\n2. Files. Give `pick`: the path of the chosen proposal (or of any square image in the workspace), and `path`: where the icon belongs, without an extension, e.g. `assets/icon`. That writes `assets/icon.ico`, `assets/icon.icns`, `assets/icon.png` and `assets/icon-<size>.png` for the usual sizes.\n\nArguments:\n- `prompt` \u2014 step 1: the subject and the mood. The rules of an icon (one centred subject, bold shapes, no text) are added for you.\n- `count` \u2014 step 1: how many proposals, 1 to 6. Optional, default 4.\n- `style` \u2014 step 1: e.g. `flat vector`, `glossy 3D`, `line art`, `pixel art`. Optional, default flat vector.\n- `pick` \u2014 step 2: workspace path of the image to make the icon from.\n- `path` \u2014 step 2: where to save, without an extension.\n- `formats` \u2014 step 2: which of `ico`, `icns`, `png`, `webp` to write. Optional, default `ico,icns,png`.\n- `sizes` \u2014 step 2: the PNG sizes to write beside the main one. Optional, default `16,32,48,64,128,180,192,256,512`.\n- `background` \u2014 step 2: a CSS colour to put behind the icon. Optional; left as the proposal has it.\n\nEach proposal costs what an image costs: seconds to a minute, and money on a hosted backend.";
+export declare const GENERATE_ICON_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly prompt: {
+            readonly type: "string";
+            readonly description: "Step 1: what the icon shows, and its mood.";
+        };
+        readonly count: {
+            readonly type: "number";
+            readonly description: "Step 1: how many proposals, 1 to 6. Default 4.";
+        };
+        readonly style: {
+            readonly type: "string";
+            readonly description: "Step 1: the drawing style. Default flat vector.";
+        };
+        readonly pick: {
+            readonly type: "string";
+            readonly description: "Step 2: workspace path of the chosen image.";
+        };
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Step 2: where the icon is saved, without an extension, e.g. assets/icon.";
+        };
+        readonly formats: {
+            readonly type: "string";
+            readonly description: "Step 2: any of ico, icns, png, webp. Default ico,icns,png.";
+        };
+        readonly sizes: {
+            readonly type: "string";
+            readonly description: "Step 2: PNG sizes to write beside the main one.";
+        };
+        readonly background: {
+            readonly type: "string";
+            readonly description: "Step 2: a CSS colour behind the icon. Optional.";
+        };
+    };
+    readonly required: readonly [];
+};
+export interface GenerateIconToolOptions {
+    cwd: string;
+    getEndpoint: () => ImageGenerationEndpoint | undefined | Promise<ImageGenerationEndpoint | undefined>;
+    createDriver: () => RenderDriver | Promise<RenderDriver>;
+    fileExists: (absolutePath: string) => Promise<boolean>;
+    writeFile: (absolutePath: string, data: Buffer) => Promise<void>;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+    now?: () => number;
+    onError?: (message: string, error: unknown) => void;
+}
+/** The prompt an icon is drawn from: the subject, then what makes it an icon. */
+export declare function buildIconPrompt(subject: string, style: string, index: number): string;
+/** The proposals on one sheet, each under its number. */
+export declare function buildProposalSheet(fileUrls: string[]): string;
+/** Create the `generate_icon` tool. */
+export declare function createGenerateIconTool(options: GenerateIconToolOptions): AgentTool;

package/dist/extensions/tools/image-generation.d.ts

@@ -38,7 +38,7 @@ export type ToolOutput = string | Array<{
     mediaType: string;
 }>;
 export declare const GENERATE_IMAGE_TOOL_NAME = "generate_image";
-export declare const GENERATE_IMAGE_TOOL_DESCRIPTION = "Generate an image from a text description and save it into the workspace. Use it for visual work you would otherwise have to ask the user to do elsewhere: an app icon, a placeholder texture or sprite, a logo, a background, or a mockup of a layout or theme you are about to build.\n\nThe image is written to a file and, if you can see images, returned to you as well \u2014 so you can look at what you made and generate again with a changed prompt if it is wrong.\n\nArguments:\n- `prompt` \u2014 what to draw. Describe the subject, the style and the background. Say \"flat vector icon, solid background, no text\" rather than \"an icon\": these models render text badly, so ask for lettering only when you must.\n- `path` \u2014 where to save it, relative to the workspace. Optional; defaults to a file under `.cline/generated-images/`. Give a real path when the image is an asset the project will use.\n- `size` \u2014 `WxH` in pixels, e.g. `1024x1024`. Optional, and the backend may round it.\n\nThis costs real time \u2014 seconds to a minute per image \u2014 and on a hosted backend it costs money. Generate one image and look at it before generating variations.";
+export declare const GENERATE_IMAGE_TOOL_DESCRIPTION = "Generate an image from a text description and save it into the workspace. Use it for visual work you would otherwise have to ask the user to do elsewhere: an app icon, a placeholder texture or sprite, a logo, a background, an illustration or a photograph.\n\nIt paints pixels: it cannot write legible text, and a picture of an interface or a diagram made this way has garbled labels. For a screen, a mockup, a workflow diagram, a chart or anything else with words in it, write it as HTML, SVG or Mermaid and use `render_image` when you have it.\n\nThe image is written to a file and, if you can see images, returned to you as well \u2014 so you can look at what you made and generate again with a changed prompt if it is wrong.\n\nArguments:\n- `prompt` \u2014 what to draw. Describe the subject, the style and the background. Say \"flat vector icon, solid background, no text\" rather than \"an icon\": these models render text badly, so ask for lettering only when you must.\n- `path` \u2014 where to save it, relative to the workspace. Optional; defaults to a file under `.cline/generated-images/`. Give a real path when the image is an asset the project will use.\n- `size` \u2014 `WxH` in pixels, e.g. `1024x1024`. Optional, and the backend may round it.\n\nThis costs real time \u2014 seconds to a minute per image \u2014 and on a hosted backend it costs money. Generate one image and look at it before generating variations.";
 export declare const GENERATE_IMAGE_TOOL_INPUT_SCHEMA: {
     readonly type: "object";
     readonly properties: {
@@ -172,6 +172,30 @@ export declare function saveAndReportImage(input: {
         emitUpdate?: (update: unknown) => void;
     } | undefined;
 }): Promise<ToolOutput>;
+/**
+ * One image from the endpoint, or why not, in words for the model.
+ *
+ * Shared by every tool that asks for a picture: the wire format, the busy
+ * retry and the reading of the answer are the same whatever it is for.
+ * A timeout and an unreachable server are thrown, as the request throws them.
+ */
+export declare function requestGeneratedImage(input: {
+    endpoint: ImageGenerationEndpoint;
+    prompt: string;
+    size?: string;
+    fetchImpl: typeof fetch;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    onBusy?: (waitMs: number) => void;
+}): Promise<{
+    image: {
+        data: Buffer;
+        mediaType: string;
+    };
+    revisedPrompt?: string;
+} | {
+    error: string;
+}>;
 /**
  * Create the `generate_image` tool.
  *

package/dist/extensions/tools/media-tools.d.ts

@@ -17,6 +17,7 @@ import type { AgentTool } from "@cerebriline/shared";
 import { type SpeechEndpoint, type TranscriptionEndpoint } from "./audio-tools";
 import { type ImageGenerationEndpoint } from "./image-generation";
 import { type MediaEndpointProbe, type MediaSessionProvider, type ResolvedMediaEndpoint } from "./media-endpoint";
+import type { RenderDriver } from "./render-image";
 import { type VideoGenerationEndpoint } from "./video-generation";
 /** What every media section holds. */
 export interface MediaSectionSettings {
@@ -100,6 +101,13 @@ export interface CreateMediaToolsOptions {
     readFile: (absolutePath: string) => Promise<Buffer>;
     /** Must create the directory: the default paths are under `.cline/`. */
     writeFile: (absolutePath: string, data: Buffer) => Promise<void>;
+    /**
+     * The host's browser, where it has one. With it and `fileExists`,
+     * `generate_icon` is offered beside `generate_image`: drawing the proposals
+     * is the endpoint's work, and writing an `.ico` from one is the browser's.
+     */
+    createRenderDriver?: () => RenderDriver | Promise<RenderDriver>;
+    fileExists?: (absolutePath: string) => Promise<boolean>;
     fetchImpl?: typeof fetch;
     onError?: (message: string, error: unknown) => void;
     /** One line per tool: where it goes, or why it was left out. */

package/dist/extensions/tools/render-image.d.ts

@@ -0,0 +1,139 @@
+/**
+ * A tool that draws what the model writes.
+ *
+ * `generate_image` paints pixels, and pixels that look like an interface are
+ * not one: asked for "rendered images showing the workflow of the
+ * application", a model on xOllama produced two dashboards whose tabs read
+ * "Dasihorad" and "Documets" (2026-10-12). No prompt mends that. The models
+ * that cannot draw a word can write one, and they write HTML, CSS, SVG and
+ * diagram notation well. So this tool takes the source and a real browser
+ * renders it: every label is the text that was typed, and a screen can be
+ * built from the application's own markup and stylesheet.
+ *
+ * The picture is as large as what was drawn unless a size is asked for. The
+ * first diagram rendered the other way was 1180 by 370 pixels in a fixed 1280
+ * by 800 capture, a third of it empty.
+ */
+import { type AgentTool } from "@cerebriline/shared";
+export declare const RENDER_IMAGE_TOOL_NAME = "render_image";
+export declare const RENDER_IMAGE_TOOL_DESCRIPTION = "Render HTML, SVG or a Mermaid diagram that you write into an image file in the workspace. Use it for anything with text or structure in it: application screens and mockups, workflow and architecture diagrams, charts, annotated figures. An image model cannot write legible text or draw a real interface; this draws exactly what you write.\n\nThe image is saved and, if you can see images, returned to you, so you can check the layout and render again.\n\n- `source` \u2014 what to draw: HTML with its CSS (a fragment or a whole document), an SVG document, or Mermaid notation (`flowchart LR`, `sequenceDiagram`, ...). Relative URLs resolve against the workspace root, so a screen of the application can link the project's own stylesheet and images: reuse its markup and class names with sample data and the picture is the real interface.\n- `kind` \u2014 `html`, `svg` or `mermaid`. Optional; read from the source.\n- `path` \u2014 where to save, relative to the workspace: `.png`, or `.svg` to keep an SVG or Mermaid drawing as vectors. Optional; defaults to a PNG under `.cline/rendered-images/`.\n- `width`, `height` \u2014 page size in CSS pixels. Optional. Leave both out and the image is exactly as large as what was drawn; `width` alone fixes where the layout wraps.\n- `scale` \u2014 pixel density, 1 to 4, default 2.\n- `crop` \u2014 `\"x,y,width,height\"` in CSS pixels, to keep one region of the page.\n- `background` \u2014 a CSS colour, or `transparent`.\n- `theme` \u2014 Mermaid only: `default`, `dark`, `neutral` or `forest`.\n\nA README on GitHub renders a ```mermaid block as it is; render a diagram to a file when it must show somewhere that does not. Remote fonts, scripts and images load only if the machine reaches them quickly: inline what matters.";
+export declare const RENDER_IMAGE_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly source: {
+            readonly type: "string";
+            readonly description: "HTML (with its CSS), an SVG document, or Mermaid notation, written out in full.";
+        };
+        readonly kind: {
+            readonly type: "string";
+            readonly enum: readonly ["html", "svg", "mermaid"];
+            readonly description: "Optional; read from the source when left out.";
+        };
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Where to save, relative to the workspace (.png, or .svg for an SVG or Mermaid drawing). Optional.";
+        };
+        readonly width: {
+            readonly type: "number";
+            readonly description: "Page width in CSS pixels. Optional.";
+        };
+        readonly height: {
+            readonly type: "number";
+            readonly description: "Page height in CSS pixels. Optional; without it the height is what was drawn.";
+        };
+        readonly scale: {
+            readonly type: "number";
+            readonly description: "Pixel density, 1 to 4. Optional, default 2.";
+        };
+        readonly crop: {
+            readonly type: "string";
+            readonly description: "\"x,y,width,height\" in CSS pixels. Optional.";
+        };
+        readonly background: {
+            readonly type: "string";
+            readonly description: "A CSS colour, or \"transparent\". Optional.";
+        };
+        readonly theme: {
+            readonly type: "string";
+            readonly description: "Mermaid only: default, dark, neutral or forest.";
+        };
+    };
+    readonly required: readonly ["source"];
+};
+export type RenderKind = "html" | "svg" | "mermaid";
+export interface RenderRegion {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** One render, as the host's browser is asked for it. */
+export interface RenderRequest {
+    /** A whole HTML document. */
+    html: string;
+    /** The folder relative URLs in it resolve against. */
+    baseDir: string;
+    /** Present for a diagram: the browser draws it before the capture. */
+    mermaid?: {
+        theme: string;
+    };
+    /** The page's width; what a layout wraps at. */
+    width: number;
+    /** The page's height. Absent: as tall as what was drawn. */
+    height?: number;
+    /** No size was asked for: capture what was drawn and nothing around it. */
+    fitContent: boolean;
+    scale: number;
+    crop?: RenderRegion;
+    transparent: boolean;
+    /** Also hand back the drawing as SVG text, where the page holds one. */
+    wantSvg: boolean;
+    /** What the capture is encoded as. Absent: PNG. */
+    format?: "png" | "jpeg" | "webp";
+    /** 1 to 100, for the two formats that have one. */
+    quality?: number;
+    signal?: AbortSignal;
+}
+export interface RenderResult {
+    /** The capture, in the format asked for. */
+    data: Buffer;
+    /** The captured region, in CSS pixels. */
+    width: number;
+    height: number;
+    svg?: string;
+}
+/** The host's browser. Structural, as the browser tool's driver is. */
+export interface RenderDriver {
+    render(request: RenderRequest): Promise<RenderResult>;
+}
+export interface RenderImageToolOptions {
+    cwd: string;
+    /** Built on first use: a session that never renders never starts a browser. */
+    createDriver: () => RenderDriver | Promise<RenderDriver>;
+    writeFile: (absolutePath: string, data: Buffer) => Promise<void>;
+    onError?: (message: string, error: unknown) => void;
+}
+/** The id of the element a fragment is measured by. */
+export declare const RENDER_ROOT_ID = "cerebriline-render-root";
+/** What a source is, when the call does not say. */
+export declare function detectRenderKind(source: string): RenderKind;
+/** A fenced block's contents, when the source arrives wrapped in one. */
+export declare function unfence(source: string): string;
+/** `"x,y,width,height"`, or the same four as a list. */
+export declare function parseCrop(value: unknown): RenderRegion | undefined;
+/**
+ * The page a source is rendered as.
+ *
+ * A whole document goes in as it is. Anything else is set in a page with no
+ * margin, inside one inline block the capture is measured by: a block-level
+ * wrapper would be as wide as the page whatever it held.
+ */
+export declare function buildRenderDocument(input: {
+    kind: RenderKind;
+    source: string;
+    background?: string;
+    /** The folder relative URLs resolve against: the workspace. */
+    baseDir?: string;
+}): string;
+/** Create the `render_image` tool. */
+export declare function createRenderImageTool(options: RenderImageToolOptions): AgentTool;

package/dist/extensions/tools/transform-image.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Resize, crop and convert an image that is already a file.
+ *
+ * Asked for by the first person to generate images with this in earnest: "the
+ * harness needs the ability to dynamically change the image size", and to crop.
+ * An image model draws at the sizes it knows, a README wants 1200 pixels across
+ * and an installer wants an `.ico`, and until now the model's only way from one
+ * to the other was a shell command for a program that might not be installed.
+ *
+ * The work is done by the browser `render_image` already uses: it decodes
+ * every format a page can show and encodes the three that matter. So there is
+ * no image library here, and nothing new to ship.
+ */
+import { type AgentTool } from "@cerebriline/shared";
+import { type RenderDriver, type RenderRegion, type RenderResult } from "./render-image";
+export declare const TRANSFORM_IMAGE_TOOL_NAME = "transform_image";
+export declare const TRANSFORM_IMAGE_TOOL_DESCRIPTION = "Resize, crop or convert an image file in the workspace and save the result as a new file. Use it to change an image's dimensions, cut a region out of it, change its format, or make an icon file from it. The source is never modified.\n\n- `image` \u2014 workspace path of the source: PNG, JPEG, WebP, GIF, BMP, AVIF, ICO or SVG.\n- `path` \u2014 where to save, relative to the workspace. The extension chooses the format: `.png`, `.jpg`, `.webp`, `.ico` or `.icns`. Optional; defaults to a file beside the source with the new size in its name.\n- `width`, `height` \u2014 the new size in pixels. Give one and the other follows the proportions.\n- `fit` \u2014 with both given: `inside` (default; the whole image, within the box, proportions kept), `cover` (fills the box, the overflow cut off), `pad` (the whole image, padded to exactly the box) or `stretch`.\n- `crop` \u2014 `\"x,y,width,height\"` in pixels of the source, taken before resizing.\n- `background` \u2014 a CSS colour for padding and for what was transparent. Optional; transparency is kept where the format has it, and JPEG gets white.\n- `quality` \u2014 1 to 100 for `.jpg` and `.webp`, default 90.\n- `sizes` \u2014 for `.ico` and `.icns`, the sizes to hold, e.g. `\"16,32,48,256\"`. Optional; the usual set when left out.";
+export declare const TRANSFORM_IMAGE_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly image: {
+            readonly type: "string";
+            readonly description: "Workspace path of the source image.";
+        };
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Where to save (.png, .jpg, .webp, .ico or .icns), relative to the workspace. Optional.";
+        };
+        readonly width: {
+            readonly type: "number";
+            readonly description: "New width in pixels. Optional.";
+        };
+        readonly height: {
+            readonly type: "number";
+            readonly description: "New height in pixels. Optional.";
+        };
+        readonly fit: {
+            readonly type: "string";
+            readonly enum: readonly ["inside", "cover", "pad", "stretch"];
+            readonly description: "How the image meets a box of both sizes. Optional.";
+        };
+        readonly crop: {
+            readonly type: "string";
+            readonly description: "\"x,y,width,height\" in source pixels. Optional.";
+        };
+        readonly background: {
+            readonly type: "string";
+            readonly description: "A CSS colour. Optional.";
+        };
+        readonly quality: {
+            readonly type: "number";
+            readonly description: "1 to 100, for .jpg and .webp. Optional.";
+        };
+        readonly sizes: {
+            readonly type: "string";
+            readonly description: "For .ico and .icns: sizes to hold, e.g. \"16,32,48,256\".";
+        };
+    };
+    readonly required: readonly ["image"];
+};
+export type ImageFit = "inside" | "cover" | "pad" | "stretch";
+export interface TransformPlan {
+    /** The part of the source that is drawn. */
+    sx: number;
+    sy: number;
+    sw: number;
+    sh: number;
+    /** The size of the result. */
+    width: number;
+    height: number;
+    /** Where the source lands in it. */
+    dx: number;
+    dy: number;
+    dw: number;
+    dh: number;
+}
+/**
+ * Where a source of this size goes in a result of that one.
+ *
+ * Written to stand alone, with nothing declared outside it and no function
+ * inside it: the page that draws the image runs this same text.
+ */
+export declare function planTransform(sourceWidth: number, sourceHeight: number, crop: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null, width: number | null, height: number | null, fit: string): TransformPlan | null;
+export interface TransformSpec {
+    crop?: RenderRegion;
+    width?: number;
+    height?: number;
+    fit: ImageFit;
+    /** Painted under the image, over the whole result. */
+    background?: string;
+}
+/** The page that draws one image at its new size. */
+export declare function buildTransformDocument(sourceUrl: string, spec: TransformSpec): string;
+/** One image, drawn at a new size by the host's browser. */
+export declare function transformWithDriver(driver: RenderDriver, input: {
+    sourcePath: string;
+    baseDir: string;
+    spec: TransformSpec;
+    format?: "png" | "jpeg" | "webp";
+    quality?: number;
+    signal?: AbortSignal;
+}): Promise<RenderResult>;
+/** An `.ico`: a directory of images, each one a PNG. */
+export declare function encodeIco(images: {
+    size: number;
+    png: Buffer;
+}[]): Buffer;
+/** An `.icns`: the same idea, with a name per size. */
+export declare function encodeIcns(images: {
+    size: number;
+    png: Buffer;
+}[]): Buffer;
+export declare const ICO_SIZES: number[];
+export declare const ICNS_SIZES: number[];
+/** The sizes an icon file is asked to hold, or why not those. */
+export declare function parseIconSizes(value: unknown, container: "ico" | "icns"): number[] | {
+    error: string;
+};
+/** Every size of an icon, from one source, as square PNGs. */
+export declare function renderIconSizes(driver: RenderDriver, input: {
+    sourcePath: string;
+    baseDir: string;
+    sizes: number[];
+    crop?: RenderRegion;
+    background?: string;
+    signal?: AbortSignal;
+}): Promise<{
+    size: number;
+    png: Buffer;
+}[]>;
+export declare class UnreadableImageError extends Error {
+    constructor();
+}
+export interface TransformImageToolOptions {
+    cwd: string;
+    createDriver: () => RenderDriver | Promise<RenderDriver>;
+    /** Whether the source is there: the browser says nothing useful about a missing file. */
+    fileExists: (absolutePath: string) => Promise<boolean>;
+    writeFile: (absolutePath: string, data: Buffer) => Promise<void>;
+    onError?: (message: string, error: unknown) => void;
+}
+/** Create the `transform_image` tool. */
+export declare function createTransformImageTool(options: TransformImageToolOptions): AgentTool;

package/dist/hub/client/index.d.ts

@@ -61,6 +61,19 @@ export declare class HubCommandError extends Error {
 }
 export declare function isHubCommandTimeoutError(error: unknown, command?: HubCommandEnvelope["command"]): boolean;
 export declare function rememberRecoverableLocalHubUrl(url: string, authToken?: string): string;
+/**
+ * Keep a local hub's token for the connections this process makes to it,
+ * without marking the hub as one this process may restart.
+ *
+ * A hub on an explicit endpoint (`CLINE_HUB_PORT`, or a host/port the caller
+ * passed) is not "recoverable", and that used to mean its token was not kept
+ * either. The caller that had just started it got back a URL, connected with
+ * no token and was refused: "WebSocket connection to
+ * 'ws://127.0.0.1:25499/hub' failed: Connection ended", on every first start
+ * (solidPC and eleven2go, 2026-10-11, three of three). The second start
+ * worked because it found the discovery record, which carries the token.
+ */
+export declare function rememberLocalHubAuthToken(url: string, authToken?: string): void;
 export declare class NodeHubClient {
     private readonly options;
     private socket;