@cerebriline/core 4.100.240

package/dist/extensions/tools/list-files.d.ts

@@ -0,0 +1,128 @@
+import { type AgentTool } from "@cerebriline/shared";
+/**
+ * A tool that answers "what is here?".
+ *
+ * There was no such tool. The model had `read_files`, `search_codebase`,
+ * `editor`, `ask_lsp`, `check_file` and `browser` — everything for working
+ * on a file it could already name, and nothing for finding out what files
+ * exist. So it shelled out. Measured on a live session, the only two shell
+ * commands in the whole run were:
+ *
+ *   run_commands  {"commands": ["dir /s manic_miner.html"]}
+ *   run_commands  {"commands": ["ls"]}
+ *
+ * A recursive scan from whatever directory the shell happened to start in,
+ * then a bare listing of it — the reflex of a model that has been given no
+ * other way to look around, in a session that otherwise never touched a shell.
+ *
+ * Doing it through the shell is worse than doing it here in three ways. It is
+ * unbounded: `dir /s` from the wrong root walks the entire drive. It is
+ * unscoped: the shell's working directory is not the workspace, so the results
+ * can name files the user never opened and the model was never meant to touch.
+ * And it is inconsistent: `ls`, `dir`, `Get-ChildItem` and `find` all format
+ * differently, so the model has to parse whatever the host's shell produced.
+ *
+ * So the host is asked instead, through `WorkspaceLister`. VS Code's answers
+ * from `workspace.findFiles`, which searches the folders the user opened and
+ * nothing else and honours the `files.exclude` and `search.exclude` they have
+ * already set — so `node_modules` and `.git` stay out without anyone naming
+ * them. `createLocalWorkspaceLister` below answers the same questions from the
+ * filesystem, for a host with no editor behind it. The containment check
+ * extends the same guarantee to a plain directory listing whichever lister is
+ * in use. The boundary is enforced here rather than requested in a prompt,
+ * which is the difference between a rule and a suggestion.
+ *
+ * The tool lives in core rather than in the extension because the reflex it
+ * displaces is not VS Code's. A CLI run has the same six tools for working on
+ * a file it can already name and the same nothing for finding out what exists,
+ * and it reaches for `ls` for exactly the same reason.
+ */
+export declare const LIST_FILES_TOOL_NAME = "list_files";
+export declare const LIST_FILES_TOOL_DESCRIPTION = "List the files in the workspace. Use this to find out what exists \u2014 do not run `ls`, `dir`, `find` or `Get-ChildItem` through `run_commands` to look around, because this is scoped to the workspace and those are not.\n\nTwo ways to ask:\n- `path` \u2014 list what is directly inside one directory. Omit it to list the workspace root.\n- `pattern` \u2014 a glob searched across the whole workspace, e.g. `**/*.html`, `src/**/*.ts`, `**/manic_miner.*`. Use this when you know part of a name but not where it lives.\n\nResults are limited to the workspace folders the user opened, and directories the user's settings exclude from search \u2014 `node_modules`, `.git`, build output \u2014 are left out. A path outside the workspace is refused rather than listed.\n\nThis tells you which files exist, not what is in them. To find files by their contents use `search_codebase`, which reports the line each match is on and is the right way to locate the part of a file worth reading.";
+export declare const LIST_FILES_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Directory to list. Absolute, or relative to the workspace root. Defaults to the workspace root.";
+        };
+        readonly pattern: {
+            readonly type: "string";
+            readonly description: "Glob searched across the workspace, e.g. `**/*.html`. Given this, `path` is ignored.";
+        };
+        readonly max_results: {
+            readonly type: "number";
+            readonly description: "Most entries to return. Default 200, maximum 1000.";
+        };
+    };
+    readonly required: readonly [];
+};
+export interface DirectoryEntry {
+    name: string;
+    kind: "file" | "directory";
+    /** Bytes, when the host could say cheaply. */
+    size?: number;
+}
+/**
+ * The workspace operations this tool needs.
+ *
+ * Structural, like `BrowserDriver`: a unit test should be able to check how a
+ * listing is rendered and where the boundary is drawn without standing up the
+ * VS Code API.
+ */
+export interface WorkspaceLister {
+    /** Absolute paths of the folders the user opened. Empty when there are none. */
+    roots(): string[];
+    readDirectory(absolutePath: string): Promise<DirectoryEntry[]>;
+    /** Absolute paths matching a glob, already filtered by the user's excludes. */
+    findFiles(pattern: string, maxResults: number): Promise<string[]>;
+}
+export interface ListFilesToolOptions {
+    cwd: string;
+    createLister: () => WorkspaceLister | Promise<WorkspaceLister>;
+    /**
+     * Files read this session, so a fruitless workspace search can say what it
+     * could not have covered instead of asserting the file does not exist.
+     */
+    getReadPaths?: () => string[];
+}
+/**
+ * Whether `candidate` is inside `root`, as this platform judges paths.
+ *
+ * Compared segment-wise rather than by prefix: `/repo/testing` starts with the
+ * string `/repo/test` without being inside it.
+ */
+export declare function isWithin(root: string, candidate: string): boolean;
+/** Clamp a caller-supplied limit into something a conversation can hold. */
+export declare function normalizeMaxResults(value: unknown): number;
+/**
+ * Render one directory's contents.
+ *
+ * Directories first and marked with a trailing separator, because the next
+ * question is almost always "which of these do I descend into".
+ */
+export declare function renderDirectory(displayPath: string, entries: DirectoryEntry[], limit: number): string;
+/** Render a glob search, as paths relative to the root they were found under. */
+export declare function renderMatches(pattern: string, absolutePaths: string[], roots: string[], limit: number, readPaths?: string[]): string;
+/**
+ * Translate a glob into a regular expression over slash-separated paths.
+ *
+ * Supports what the description promises and what a model actually writes: a
+ * double star across directories, a single star and `?` within one segment,
+ * `{a,b}` alternation and `[...]` classes.
+ *
+ * A double star followed by a slash matches no directories as readily as many,
+ * so a pattern that opens with one finds a file sitting at the root too. A
+ * model writing it means "anywhere", and the root is anywhere.
+ */
+export declare function globToRegExp(pattern: string): RegExp;
+/**
+ * A lister backed by the filesystem, for a host with no editor to ask.
+ *
+ * One root, because that is what a host without a workspace concept has: the
+ * directory the run was started in. Everything the tool guarantees — the
+ * containment check, the result cap, the excludes — is the same either way,
+ * which is the point of the interface.
+ */
+export declare function createLocalWorkspaceLister(root: string): WorkspaceLister;
+export declare function createListFilesTool(options: ListFilesToolOptions): AgentTool;

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

@@ -0,0 +1,160 @@
+/**
+ * Where a media tool sends its request, and whether it should exist at all.
+ *
+ * `generate_image` had its own answer to this -- a typed URL, a typed model --
+ * and four more tools need one: image edits, transcription, speech and video.
+ * They share everything but the route: the same OpenAI-shaped servers, the same
+ * question of what a server serves, the same `503` while an engine is busy.
+ *
+ * Three kinds of server answer these routes, and they say different amounts:
+ *  - **opencoti** names what is loaded in `features` on `/props`
+ *    (`images_generate_v1`, `images_edit_v1`, `audio_transcriptions_v1`,
+ *    `audio_speech_v1`, `videos_generate_v1`), and its `/v1/models` rows carry
+ *    `capabilities`. One process can serve the LLM and every media kind.
+ *  - **xOllama** answers `/api/xollama`, and its `/v1/models` rows carry
+ *    `input_modalities` / `output_modalities` for models with media.
+ *  - anything else that lists `/v1/models` says nothing, and nothing is not
+ *    "no": such a server is taken to serve whatever it is asked for.
+ *
+ * The owner's rule for which endpoint a tool uses (2026-10-02):
+ *  1. with the "use the configured provider" flag on, the session's own
+ *     opencoti or xOllama provider, when it serves this kind;
+ *  2. otherwise the typed URL;
+ *  3. a typed URL that is empty, or names no model, means the tool is not
+ *     offered.
+ *
+ * A typed endpoint that does not answer is still offered (owner, 2026-10-02):
+ * these servers may be started on request, and a tool left out at session
+ * start stays out for the whole session. The tab's own switch is how a user
+ * says they do not want the tool. What the probe found is a warning, not a
+ * gate.
+ */
+export type MediaKind = "image_generation" | "image_edit" | "transcription" | "speech" | "video";
+export declare const MEDIA_KINDS: readonly MediaKind[];
+export type MediaServer = "opencoti" | "xollama" | "openai";
+export interface MediaEndpoint {
+    /** Base URL, with or without a trailing `/v1`. */
+    baseUrl: string;
+    model: string;
+    apiKey?: string;
+}
+export interface MediaModel {
+    id: string;
+    /** What the server says this model serves. Absent when it says nothing. */
+    kinds?: MediaKind[];
+    /**
+     * The kinds this model is the server's default for: xOllama's
+     * `default_for`, set by whoever runs the server. Only ever kinds it serves.
+     */
+    defaultFor?: MediaKind[];
+}
+export interface MediaEndpointProbe {
+    server: MediaServer;
+    /**
+     * `true` served, `false` the server says it is not, absent unknown. Only
+     * opencoti and xOllama ever say `false`.
+     */
+    kinds: Partial<Record<MediaKind, boolean>>;
+    models: MediaModel[];
+}
+/** `.../v1`, whether or not the user typed it. */
+export declare function normalizeBaseUrl(baseUrl: string): string;
+/** The server's root, under which `/props` and `/api/xollama` live. */
+export declare function mediaServerOrigin(baseUrl: string): string;
+/**
+ * What one `/v1/models` row says it serves, or nothing when it says nothing.
+ *
+ * Capabilities are exact and win. Modalities are xOllama's listing and need
+ * reading: an edit model takes an image and returns one, a transcription model
+ * takes audio and returns text.
+ */
+export declare function mediaKindsOfModelRow(row: unknown): MediaKind[] | undefined;
+export interface MediaProbeOptions {
+    apiKey?: string;
+    fetchImpl?: typeof fetch;
+    signal?: AbortSignal;
+    /** Milliseconds each of the three reads may take. Defaults to 5 seconds. */
+    timeoutMs?: number;
+}
+/**
+ * What answers at `baseUrl` and what it serves, or nothing when nothing does.
+ *
+ * Three reads at once rather than one after another: the picker waits on this,
+ * and two of the three are 404s on any given server.
+ */
+export declare function probeMediaEndpoint(baseUrl: string, options?: MediaProbeOptions): Promise<MediaEndpointProbe | undefined>;
+/**
+ * The models to offer in a picker for one kind: those the server says serve
+ * it, and those it says nothing about.
+ */
+export declare function listMediaModels(probe: MediaEndpointProbe, kind: MediaKind): string[];
+/** The session's own provider, as far as a media tool cares. */
+export interface MediaSessionProvider {
+    providerId: string;
+    baseUrl?: string;
+    apiKey?: string;
+    modelId?: string;
+}
+export interface ResolveMediaEndpointInput {
+    kind: MediaKind;
+    /** The tab's "use the configured opencoti or xOllama provider" flag. */
+    useProvider: boolean;
+    provider?: MediaSessionProvider;
+    /** What the tab holds: the typed URL, and the model named for this kind. */
+    typed?: {
+        baseUrl?: string;
+        model?: string;
+        apiKey?: string;
+    };
+    probe: (baseUrl: string, apiKey: string | undefined) => Promise<MediaEndpointProbe | undefined>;
+}
+export type ResolvedMediaEndpoint = {
+    endpoint: MediaEndpoint;
+    source: "provider" | "typed";
+    /** `unknown` is a typed endpoint that did not answer the probe. */
+    server: MediaServer | "unknown";
+    /** Why a call may fail right now. The tool is offered all the same. */
+    warning?: string;
+} | {
+    disabled: string;
+};
+export declare function resolveMediaEndpoint(input: ResolveMediaEndpointInput): Promise<ResolvedMediaEndpoint>;
+/** `Retry-After` in milliseconds: seconds or a date, bounded, 5 s by default. */
+export declare function retryAfterMs(header: string | null, now?: number): number;
+export interface MediaRequestOptions {
+    fetchImpl?: typeof fetch;
+    /** The caller's cancellation. The only thing that ends the waiting. */
+    signal?: AbortSignal;
+    /**
+     * Milliseconds one attempt may take. Waiting on a busy engine is not
+     * counted: the limit is on the work, not on the queue in front of it.
+     */
+    attemptTimeoutMs?: number;
+    /**
+     * How long to keep asking a busy engine, 30 minutes by default. xOllama
+     * answers `503` only once 16 requests wait or one has waited 10 minutes, so
+     * this is several full queues; past it the `503` is handed back, and the
+     * tool says the engine is still busy rather than that it failed.
+     */
+    maxBusyMs?: number;
+    /** Told each time the engine was busy, before the wait. */
+    onBusy?: (waitMs: number, attempt: number) => void;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+/** An attempt ran past `attemptTimeoutMs`. */
+export declare class MediaRequestTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+/**
+ * One media request, waited out while the engine is busy.
+ *
+ * opencoti and xOllama run one request per engine and answer `503` with
+ * `Retry-After` to the rest. That is the server saying when to come back, not
+ * a failure, so it is not handed to the model as one: the request is sent
+ * again until it is taken, the caller stops, or `maxBusyMs` of waiting has
+ * passed. Nothing else is retried: a `400` is a model that does not do this, a
+ * `404` no such model, a `500` an engine that failed to start. `init` is a function because a
+ * multipart body is spent by the attempt that sent it.
+ */
+export declare function sendMediaRequest(url: string, init: () => RequestInit, options?: MediaRequestOptions): Promise<Response>;

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

@@ -0,0 +1,140 @@
+/**
+ * The media tools as one set, built from one configuration.
+ *
+ * Five tools -- `generate_image`, `edit_image`, `transcribe_audio`,
+ * `synthesize_speech`, `generate_video` -- share one rule for where a request
+ * goes (see `media-endpoint.ts`), and two hosts offer them: the extension from
+ * its settings tabs and the CLI from a file. If each host wrote its own
+ * "which tools, pointed where", the two would drift the first time one of them
+ * changed. So the hosts differ only in how they *read* a `MediaToolsConfig`;
+ * which tools that makes, and where each one goes, is decided here.
+ *
+ * A section that is absent is a tool that is not wanted: it is the host's
+ * "use an endpoint for ..." switch. A section that is present is offered as
+ * soon as it names somewhere to go, whether or not that server answers now.
+ */
+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 VideoGenerationEndpoint } from "./video-generation";
+/** What every media section holds. */
+export interface MediaSectionSettings {
+    /** Use the session's own opencoti or xOllama when it serves this. */
+    useProvider?: boolean;
+    /** Where requests go otherwise. */
+    baseUrl?: string;
+    model?: string;
+    apiKey?: string;
+}
+export interface MediaToolsConfig {
+    /** `generate_image`, and `edit_image` unless `edit` is `false`. */
+    image?: MediaSectionSettings & {
+        /** Default size, as `WIDTHxHEIGHT`. */
+        size?: string;
+        /**
+         * Edits go where generation goes unless this names another endpoint or
+         * model. `false` keeps `generate_image` without `edit_image`.
+         */
+        edit?: false | {
+            baseUrl?: string;
+            model?: string;
+        };
+    };
+    /** `transcribe_audio`. */
+    transcription?: MediaSectionSettings;
+    /** `synthesize_speech`. */
+    speech?: MediaSectionSettings & {
+        voice?: string;
+        format?: string;
+    };
+    /** `generate_video`. */
+    video?: MediaSectionSettings & {
+        size?: string;
+        seconds?: number;
+        format?: string;
+    };
+}
+export declare const MEDIA_TOOL_NAMES: readonly ["generate_image", "edit_image", "transcribe_audio", "synthesize_speech", "generate_video"];
+export type MediaToolName = (typeof MEDIA_TOOL_NAMES)[number];
+interface MediaToolEndpoints {
+    generate_image: ImageGenerationEndpoint;
+    edit_image: ImageGenerationEndpoint;
+    transcribe_audio: TranscriptionEndpoint;
+    synthesize_speech: SpeechEndpoint;
+    generate_video: VideoGenerationEndpoint;
+}
+export type ResolvedMediaTool<T extends MediaToolName = MediaToolName> = (Omit<Exclude<ResolvedMediaEndpoint, {
+    disabled: string;
+}>, "endpoint"> & {
+    endpoint: MediaToolEndpoints[T];
+}) | {
+    disabled: string;
+};
+export type MediaProbe = (baseUrl: string, apiKey: string | undefined) => Promise<MediaEndpointProbe | undefined>;
+/**
+ * One probe per server for half a minute. Five tools resolve at session start,
+ * and on an opencoti serving everything they all ask the same three routes.
+ */
+export declare function createMediaProbeCache(options?: {
+    fetchImpl?: typeof fetch;
+    now?: () => number;
+}): MediaProbe;
+/**
+ * Where one media tool goes, or why it is not offered.
+ *
+ * The endpoint carries the section's defaults (size, voice, format, length),
+ * so what comes back is what the tool's `getEndpoint` returns.
+ */
+export declare function resolveMediaTool<T extends MediaToolName>(tool: T, config: MediaToolsConfig, provider: MediaSessionProvider | undefined, probe: MediaProbe): Promise<ResolvedMediaTool<T>>;
+export interface CreateMediaToolsOptions {
+    cwd: string;
+    /**
+     * Read again on every call as well as at session start: a settings tab can
+     * change mid-session, and the probe behind the resolution is cached.
+     */
+    getConfig: () => MediaToolsConfig;
+    /** The provider the session runs on, for the sections that may use it. */
+    provider?: MediaSessionProvider;
+    probe?: MediaProbe;
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    /** Must create the directory: the default paths are under `.cline/`. */
+    writeFile: (absolutePath: string, data: Buffer) => Promise<void>;
+    fetchImpl?: typeof fetch;
+    onError?: (message: string, error: unknown) => void;
+    /** One line per tool: where it goes, or why it was left out. */
+    log?: (message: string) => void;
+}
+/**
+ * The media tools this configuration offers, each pointed where it resolves.
+ *
+ * A tool is left out only when its section is absent or names nowhere to go.
+ * An endpoint that is down, or says it lacks the kind, is offered with a
+ * warning in the log: these servers are started on request.
+ */
+export declare function createMediaTools(options: CreateMediaToolsOptions): Promise<AgentTool[]>;
+/**
+ * A `MediaToolsConfig` from a JSON document, for a host with no settings tabs.
+ *
+ * ```json
+ * {
+ *   "useProvider": true,
+ *   "baseUrl": "http://127.0.0.1:8080",
+ *   "image": { "model": "flux2-klein", "size": "1024x1024" },
+ *   "transcription": true,
+ *   "speech": { "voice": "alloy" },
+ *   "video": { "baseUrl": "http://other:8090", "model": "wan2.1" }
+ * }
+ * ```
+ *
+ * The top-level `useProvider`, `baseUrl` and `apiKey` are what each section
+ * starts from, since one server usually serves them all; a section overrides
+ * them. A section is on when it is an object or `true`. `all: true` switches
+ * every section on that the document does not mention -- the "use whatever the
+ * session's provider serves" setting.
+ */
+export declare function parseMediaToolsConfig(raw: unknown, options?: {
+    all?: boolean;
+    useProvider?: boolean;
+}): MediaToolsConfig;
+export {};

package/dist/extensions/tools/model-tool-routing.d.ts

@@ -0,0 +1,33 @@
+import type { CoreAgentMode } from "../../types/config";
+import type { DefaultToolName, DefaultToolsConfig } from "./types";
+export interface ToolRoutingRule {
+    /**
+     * Optional rule label for debugging and logs.
+     */
+    name?: string;
+    /**
+     * Which mode the rule applies to.
+     * @default "any"
+     */
+    mode?: CoreAgentMode | "any";
+    /**
+     * Case-insensitive substrings that must match the model ID.
+     * When omitted/empty, the rule is not constrained by model ID.
+     */
+    modelIdIncludes?: string[];
+    /**
+     * Case-insensitive substrings that must match the provider ID.
+     * When omitted/empty, the rule is not constrained by provider ID.
+     */
+    providerIdIncludes?: string[];
+    /**
+     * Enable these tools when the rule matches.
+     */
+    enableTools?: DefaultToolName[];
+    /**
+     * Disable these tools when the rule matches.
+     */
+    disableTools?: DefaultToolName[];
+}
+export declare const DEFAULT_MODEL_TOOL_ROUTING_RULES: ToolRoutingRule[];
+export declare function resolveToolRoutingConfig(providerId: string, modelId: string, mode: CoreAgentMode, rules: ToolRoutingRule[] | undefined): Partial<DefaultToolsConfig>;

package/dist/extensions/tools/presets.d.ts

@@ -0,0 +1,154 @@
+/**
+ * AgentTool Presets
+ *
+ * Pre-configured tool combinations for common use cases.
+ */
+import type { AgentMode, AgentTool, ToolPolicy } from "@cerebriline/shared";
+import type { CreateDefaultToolsOptions, DefaultToolsConfig } from "./types";
+export interface ToolPresetConfig extends DefaultToolsConfig {
+    enableSpawnAgent?: boolean;
+    enableAgentTeams?: boolean;
+}
+/**
+ * Preset configurations for common use cases
+ */
+export declare const ToolPresets: {
+    /**
+     * Act mode (full development tools)
+     * Good for coding assistants and task automation
+     */
+    readonly act: {
+        readonly enableReadFiles: true;
+        readonly enableSearch: true;
+        readonly enableBash: true;
+        readonly enableWebFetch: true;
+        readonly enableApplyPatch: false;
+        readonly enableEditor: true;
+        readonly enableGrep: true;
+        readonly enableSed: true;
+        readonly enableAwk: true;
+        readonly enableExtractDocument: true;
+        readonly enableSkills: true;
+        readonly enableAskQuestion: true;
+        readonly enableSubmitAndExit: false;
+        readonly enableSpawnAgent: true;
+        readonly enableAgentTeams: true;
+    };
+    /**
+     * Plan mode (read-only)
+     * Good for analysis and documentation agents. Shell access stays enabled
+     * for read-only investigation; file-editing commands are hard-blocked by
+     * the plan-mode command-guard hook the runtime builder registers.
+     */
+    readonly plan: {
+        readonly enableReadFiles: true;
+        readonly enableSearch: true;
+        readonly enableBash: true;
+        readonly enableWebFetch: true;
+        readonly enableApplyPatch: false;
+        readonly enableEditor: false;
+        readonly enableGrep: true;
+        readonly enableSed: true;
+        readonly enableAwk: true;
+        readonly enableExtractDocument: true;
+        readonly enableSkills: true;
+        readonly enableAskQuestion: true;
+        readonly enableSubmitAndExit: false;
+        readonly enableSpawnAgent: true;
+        readonly enableAgentTeams: true;
+    };
+    /**
+     * Search-focused tools (read_files + search_codebase)
+     * Good for code exploration and analysis agents
+     */
+    readonly search: {
+        readonly enableReadFiles: true;
+        readonly enableSearch: true;
+        readonly enableBash: false;
+        readonly enableWebFetch: false;
+        readonly enableApplyPatch: false;
+        readonly enableEditor: false;
+        readonly enableGrep: true;
+        readonly enableSed: false;
+        readonly enableAwk: true;
+        readonly enableExtractDocument: true;
+        readonly enableSkills: false;
+        readonly enableAskQuestion: false;
+        readonly enableSubmitAndExit: false;
+        readonly enableSpawnAgent: true;
+        readonly enableAgentTeams: true;
+    };
+    /**
+     * Minimal tools for focused tasks
+     */
+    readonly minimal: {
+        readonly enableReadFiles: false;
+        readonly enableSearch: false;
+        readonly enableBash: true;
+        readonly enableWebFetch: false;
+        readonly enableApplyPatch: false;
+        readonly enableEditor: false;
+        readonly enableGrep: false;
+        readonly enableSed: false;
+        readonly enableAwk: false;
+        readonly enableExtractDocument: false;
+        readonly enableSkills: false;
+        readonly enableAskQuestion: false;
+        readonly enableSubmitAndExit: false;
+        readonly enableSpawnAgent: true;
+        readonly enableAgentTeams: false;
+    };
+    /**
+     * YOLO mode (automation-focused tools + no approval required)
+     * Good for trusted local automation workflows.
+     */
+    readonly yolo: {
+        readonly enableReadFiles: true;
+        readonly enableSearch: false;
+        readonly enableBash: true;
+        readonly enableWebFetch: false;
+        readonly enableApplyPatch: false;
+        readonly enableEditor: true;
+        readonly enableGrep: true;
+        readonly enableSed: true;
+        readonly enableAwk: true;
+        readonly enableExtractDocument: true;
+        readonly enableSkills: false;
+        readonly enableAskQuestion: false;
+        readonly enableSubmitAndExit: true;
+        readonly enableSpawnAgent: false;
+        readonly enableAgentTeams: false;
+    };
+};
+/**
+ * Type for preset names
+ */
+export type ToolPresetName = keyof typeof ToolPresets;
+export declare function resolveToolPresetName(options: {
+    mode?: AgentMode;
+}): ToolPresetName;
+/**
+ * AgentTool policy preset names
+ */
+export type ToolPolicyPresetName = "default" | "yolo";
+/**
+ * Build tool policies for a preset.
+ * `yolo` guarantees tool policies are enabled and auto-approved.
+ */
+export declare function createToolPoliciesWithPreset(presetName: ToolPolicyPresetName): Record<string, ToolPolicy>;
+/**
+ * Create default tools using a preset configuration
+ *
+ * @example
+ * ```typescript
+ * const tools = createDefaultToolsWithPreset("plan", {
+ *   executors: {
+ *     readFile: async ({ path }) => fs.readFile(path, "utf-8"),
+ *     search: async (query, cwd) => searchFiles(query, cwd),
+ *     webFetch: async (url, prompt) => fetchAndAnalyze(url, prompt),
+ *   },
+ *   cwd: "/path/to/project",
+ * })
+ * ```
+ */
+export declare function createDefaultToolsWithPreset(presetName: ToolPresetName, options: Omit<CreateDefaultToolsOptions, keyof DefaultToolsConfig> & Partial<DefaultToolsConfig>): AgentTool[];