@cerebriline/core 4.100.240

package/dist/extensions/plugin/plugin-sandbox.d.ts

@@ -0,0 +1,82 @@
+import type { AgentConfig, PluginSetupContext, WorkspaceInfo } from "@cerebriline/shared";
+import type { PluginLoadDiagnostics } from "./plugin-load-report";
+import type { PluginTargeting } from "./plugin-targeting";
+export declare const CLINE_PLUGIN_IDLE_TIMEOUT_MS_ENV = "CLINE_PLUGIN_IDLE_TIMEOUT_MS";
+export declare const DEFAULT_PLUGIN_SANDBOX_IDLE_TIMEOUT_MS: number;
+export type SandboxedPluginSetupContext = Pick<PluginSetupContext, "session" | "client" | "user" | "workspaceInfo" | "logger">;
+export interface PluginSandboxOptions extends PluginTargeting {
+    pluginPaths: string[];
+    exportName?: string;
+    /**
+     * Max wall time for plugin module imports. Defaults to 4000 ms; falls back
+     * to the `CLINE_PLUGIN_IMPORT_TIMEOUT_MS` env var when this option is not
+     * set, allowing slower hosts (Windows cold-start, CI without warm caches)
+     * to raise the ceiling without touching code.
+     */
+    importTimeoutMs?: number;
+    hookTimeoutMs?: number;
+    contributionTimeoutMs?: number;
+    /**
+     * Reclaim the plugin subprocess after this much time with no calls in
+     * flight. Defaults to 30 minutes and can be overridden with
+     * `CLINE_PLUGIN_IDLE_TIMEOUT_MS`.
+     */
+    idleTimeoutMs?: number;
+    onEvent?: (event: {
+        name: string;
+        payload?: unknown;
+    }) => void;
+    /**
+     * The session's working directory. Forwarded to the sandbox subprocess so
+     * that `process.cwd()` returns the correct path inside the sandbox even
+     * when `--cwd` was passed without calling `process.chdir()` on the host.
+     */
+    cwd?: string;
+    /**
+     * Structured workspace and git metadata (branch, commit, remotes) generated
+     * at session startup. Forwarded to plugins via PluginSetupCtx.workspaceInfo
+     * so they can inspect git state without running their own commands.
+     */
+    workspaceInfo?: WorkspaceInfo;
+    session?: SandboxedPluginSetupContext["session"];
+    client?: SandboxedPluginSetupContext["client"];
+    user?: SandboxedPluginSetupContext["user"];
+    /** Enables a logger bridge that forwards sandbox log calls to the host. */
+    logger?: SandboxedPluginSetupContext["logger"];
+    /**
+     * Enables the telemetry bridge (`ctx.telemetry`) for sandboxed plugins.
+     * Set only when the host has a live telemetry service to route
+     * `plugin_telemetry` events into, so plugin feature-detection of
+     * `ctx.telemetry` means "someone is listening" in both execution modes.
+     */
+    telemetryAvailable?: boolean;
+}
+/**
+ * Pick the bootstrap the sandbox subprocess should run.
+ *
+ * Sibling compiled candidates always match the running host build, so they
+ * win. When the host runs from source (the `.ts` bootstrap exists next to
+ * this module), the sandbox must run that SAME source bootstrap: the
+ * wrapper/executable fallbacks locate compiled bootstraps from a separately
+ * installed CLI package (e.g. a published version in the package-manager
+ * cache), and mixing that code with a source host silently breaks plugin
+ * loading because its module resolution points at the other installation's
+ * layout. Those fallbacks exist only for compiled hosts
+ * (`bun build --compile`) where import.meta points inside the binary and no
+ * sibling file exists on real disk.
+ */
+export declare function selectBootstrapCandidate(options: {
+    siblingCandidates: string[];
+    sourceBootstrapPath: string;
+    installedCandidates: Array<string | undefined>;
+    exists?: (path: string) => boolean;
+}): {
+    file: string;
+} | {
+    sourcePath: string;
+};
+export declare function loadSandboxedPlugins(options: PluginSandboxOptions): Promise<{
+    extensions: AgentConfig["extensions"];
+    pluginPaths: string[];
+    shutdown: () => Promise<void>;
+} & PluginLoadDiagnostics>;

package/dist/extensions/plugin/plugin-targeting.d.ts

@@ -0,0 +1,6 @@
+import type { PluginManifest } from "@cerebriline/shared";
+export interface PluginTargeting {
+    providerId?: string;
+    modelId?: string;
+}
+export declare function matchesPluginManifestTargeting(manifest: PluginManifest | undefined, targeting: PluginTargeting | undefined): boolean;

package/dist/extensions/plugin-sandbox-bootstrap.js

@@ -0,0 +1 @@
+import{createRequire as XQ}from"node:module";var YQ=XQ(import.meta.url);import{normalizePluginManifest as DQ}from"@cerebriline/shared";function P(Q=process){Q.once("disconnect",()=>Q.exit(0))}import{existsSync as _,readFileSync as O}from"node:fs";import{builtinModules as ZQ,createRequire as R}from"node:module";import{dirname as J,extname as I,isAbsolute as $Q,resolve as q}from"node:path";import{fileURLToPath as m}from"node:url";import{PLUGIN_FILE_EXTENSIONS as GQ}from"@cerebriline/shared";var d=J(m(import.meta.url)),KQ=R(import.meta.url),qQ=q(d,"..","..","..","..",".."),T=wQ(qQ),WQ=["@cerebriline/sdk","@cerebriline/agents","@cerebriline/core","@cerebriline/core/hub","@cerebriline/core/hub/daemon-entry","@cerebriline/core/telemetry","@cerebriline/llms","@cerebriline/llms/browser","@cerebriline/shared","@cerebriline/shared/automation","@cerebriline/shared/browser","@cerebriline/shared/storage","@cerebriline/shared/db","@cerebriline/shared/types"],k=new Set(ZQ.flatMap((Q)=>[Q,Q.replace(/^node:/,"")])),B=new Set(GQ),_Q=["development","node","import","require","default"];function wQ(Q){let U={},X={"@cerebriline/sdk":q(Q,"packages/sdk/src/index.ts"),"@cerebriline/agents":q(Q,"packages/agents/src/index.ts"),"@cerebriline/core":q(Q,"packages/core/src/index.ts"),"@cerebriline/llms":q(Q,"packages/llms/src/index.ts"),"@cerebriline/shared":q(Q,"packages/shared/src/index.ts"),"@cerebriline/shared/storage":q(Q,"packages/shared/src/storage/index.ts"),"@cerebriline/shared/db":q(Q,"packages/shared/src/db/index.ts")};for(let[Z,$]of Object.entries(X))if(_($))U[Z]=$;for(let Z of["agents","core","llms","shared"]){let $=q(Q,"packages",Z),G=q($,"package.json");if(!_(G))continue;try{let Y=JSON.parse(O(G,"utf8"));if(typeof Y.name!=="string"||!Y.exports)continue;if(typeof Y.exports==="string"){let K=q($,Y.exports);if(_(K))U[Y.name]=K;continue}if(typeof Y.exports!=="object")continue;for(let[K,A]of Object.entries(Y.exports)){let L=AQ($,A);if(!L)continue;let w=K==="."?Y.name:`${Y.name}/${K.replace(/^\.\//,"")}`;U[w]=L}}catch{}}return U}function AQ(Q,U){let X=v(U);if(!X)return null;let Z=u(Q,X);for(let $ of Z)if(_($))return $;return null}function v(Q,U=new Set){if(typeof Q==="string")return Q;if(!Q||typeof Q!=="object")return null;if(U.has(Q))return null;U.add(Q);let X=Q;for(let Z of _Q){let $=v(X[Z],U);if($)return $}return null}function u(Q,U){let X=U.replace(/^\.\//,""),Z=[q(Q,U)];if(X.startsWith("dist/")){let $=X.replace(/^dist\//,"src/").replace(/\.(mjs|cjs|js)$/,"");return[q(Q,`${$}.ts`),q(Q,`${$}.tsx`),q(Q,`${$}.mts`),q(Q,`${$}.cts`),...Z]}return Z}function LQ(Q){return Object.fromEntries(Object.entries(Q).sort(([U],[X])=>X.length-U.length))}function N(Q){return!(Q.startsWith(".")||Q.startsWith("/")||Q.startsWith("file:")||Q.startsWith("data:")||Q.startsWith("http:")||Q.startsWith("https:"))}function C(Q){if(Q.startsWith("@")){let[U,X]=Q.split("/",3);return X?`${U}/${X}`:Q}return Q.split("/",1)[0]??Q}function FQ(Q){let U=C(Q);if(Q===U)return".";return`.${Q.slice(U.length)}`}function c(Q){return C(Q).startsWith("@cline/")}function y(Q,U){let X=C(U),Z=J(Q);while(!0){let $=q(Z,"node_modules",X);if(_($)||_(q($,"package.json")))return!0;let G=q(Z,"..");if(G===Z)return!1;Z=G}}function h(Q){return b(Q)!==null}function b(Q){try{return KQ.resolve(Q)}catch{}return JQ(Q)}function JQ(Q){let U=C(Q),X=l(U);if(!X)return null;let Z=q(X,"package.json");try{let $=JSON.parse(O(Z,"utf8")),G=FQ(Q),Y=G==="."&&typeof $.exports==="string"?$.exports:$.exports&&typeof $.exports==="object"&&Object.hasOwn($.exports,G)?$.exports[G]:void 0,K=v(Y)??(G==="."&&typeof $.main==="string"?$.main:null);if(!K)return null;let A=q(X,K),L=[A,...u(X,K).filter((w)=>w!==A)];for(let w of L)if(_(w))return w;return null}catch{return null}}function zQ(){let Q=[d],U=process.env.CLINE_WRAPPER_PATH?.trim();if(U)Q.push(J(J(U)));let X=process.execPath?.trim();if(X)Q.push(J(X));return[...new Set(Q.map((Z)=>q(Z)))]}function CQ(Q,U){let X=Q;while(!0){let Z=q(X,"package.json");if(_(Z))try{if(JSON.parse(O(Z,"utf8")).name===U)return X}catch{}let $=q(X,"node_modules",U,"package.json");if(_($))return J($);let G=q(X,"..");if(G===X)return null;X=G}}function l(Q){for(let U of zQ()){let X=CQ(U,Q);if(X)return X}return null}function OQ(Q){let X=J(Q);for(let Z=0;Z<4;Z++){let $=q(X,"package.json");if(_($))try{let Y=JSON.parse(O($,"utf8"));return Y!=null&&typeof Y==="object"&&"cline"in Y}catch{return!1}let G=q(X,"..");if(G===X)return!1;X=G}return!1}function g(Q,U){let X=U.startsWith("file:")?m(U):$Q(U)?U:q(J(Q),U);if(_(X)&&B.has(I(X)))return X;for(let Z of B){let $=`${X}${Z}`;if(_($))return $}for(let Z of B){let $=q(X,`index${Z}`);if(_($))return $}return null}function n(Q){let U=new Set,X=[/\bimport\s+(?:type\s+)?[^"'`]*?\bfrom\s*["'`]([^"'`]+)["'`]/g,/\bexport\s+[^"'`]*?\bfrom\s*["'`]([^"'`]+)["'`]/g,/\bimport\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g,/\brequire\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g];for(let Z of X)for(let $ of Q.matchAll(Z)){let G=$[1];if(G)U.add(G)}return[...U]}function jQ(Q){return I(Q)!==".ts"}function o(Q,U,X=new Set){if(X.has(Q)||!_(Q))return;if(X.add(Q),!B.has(I(Q)))return;let Z=O(Q,"utf8"),$=jQ(Q);for(let G of n(Z)){if(G.startsWith("node:")||k.has(G))continue;if(N(G)){if(!$)continue;if(Object.hasOwn(T,G)||Object.hasOwn(T,C(G))||y(Q,G)||c(G)&&h(G)||U&&h(G))continue;throw Error(`Cannot find module '${C(G)}'`)}let Y=g(Q,G);if(Y)o(Y,U,X)}}function p(Q,U=new Set,X=new Set){if(U.has(Q)||!_(Q))return X;if(U.add(Q),!B.has(I(Q)))return X;let Z=O(Q,"utf8");for(let $ of n(Z)){if(X.add($),N($))continue;let G=g(Q,$);if(G)p(G,U,X)}return X}function BQ(Q,U){let X=R(Q),Z={},$=p(Q),G=new Set(WQ);for(let[Y,K]of Object.entries(T)){try{X.resolve(Y);continue}catch{}Z[Y]=K}for(let Y of $)if(N(Y)&&(c(Y)||U))G.add(Y);for(let Y of G){if(Object.hasOwn(Z,Y)||y(Q,Y))continue;let K=b(Y);if(K)Z[Y]=K}if(!U)return Z;for(let Y of $){if(!N(Y)||Object.hasOwn(Z,Y)||y(Q,Y)||Y.startsWith("node:")||k.has(Y))continue;let K=b(Y);if(K)Z[Y]=K}return Z}function IQ(Q){let U=I(Q);return U===".ts"||U===".tsx"||U===".mts"||U===".cts"}var z;function HQ(){if(z!==void 0)return z;let Q=l("jiti");if(!Q)return z=null,null;let U=q(Q,"dist","babel.cjs");if(!_(U))return z=null,null;try{let Z=R(U)(U);z=typeof Z==="function"?Z:null}catch{z=null}return z}async function s(Q,U={}){let X=!OQ(Q);o(Q,X);let Z=BQ(Q,X),$=LQ(Z),G=await import("jiti"),Y=typeof G==="function"?G:typeof G.default==="function"?G.default:void 0;if(!Y)throw Error("Unable to load jiti");let K=Object.entries($).filter(([,W])=>IQ(W)).map(([W])=>W),A=HQ(),L=A?(W)=>A({...W,interopDefault:!0}):void 0;return await Y(Q,{alias:$,cache:U.useCache,requireCache:U.useCache,esmResolve:!0,interopDefault:!1,nativeModules:[...k],transformModules:K,tryNative:!1,...L?{transform:L}:{}}).import(Q,{})}function i(Q,U){if(!Q)return!0;if(Q.providerIds?.length){if(!U?.providerId||!Q.providerIds.includes(U.providerId))return!1}if(Q.modelIds?.length){if(!U?.modelId||!Q.modelIds.includes(U.modelId))return!1}return!0}function F(Q){return typeof Q==="object"&&Q!==null}function r(Q){return Array.isArray(Q)&&Q.every((U)=>typeof U==="string")}function NQ(Q,U){if(!F(Q))throw Error(`Invalid plugin module: ${U}`);if(typeof Q.name!=="string"||!Q.name)throw Error(`Invalid plugin name: ${U}`);if(!F(Q.manifest))throw Error(`Invalid plugin manifest: ${U}`);if(Object.hasOwn(Q.manifest,"providerIds")&&!r(Q.manifest.providerIds))throw Error(`Invalid plugin manifest.providerIds: ${U}`);if(Object.hasOwn(Q.manifest,"modelIds")&&!r(Q.manifest.modelIds))throw Error(`Invalid plugin manifest.modelIds: ${U}`)}function SQ(Q){if(!F(Q))throw Error("Plugin setup context must be an object");if(Q.session!==void 0&&!F(Q.session))throw Error("Plugin setup context session must be an object");if(Q.client!==void 0&&!F(Q.client))throw Error("Plugin setup context client must be an object");if(Q.user!==void 0&&!F(Q.user))throw Error("Plugin setup context user must be an object");if(Q.workspaceInfo!==void 0&&!F(Q.workspaceInfo))throw Error("Plugin setup context workspaceInfo must be an object");if(Q.automation!==void 0&&!F(Q.automation))throw Error("Plugin setup context automation must be an object");if(Q.automation!==void 0&&typeof Q.automation.ingestEvent!=="function")throw Error("Plugin setup context automation.ingestEvent must be a function");if(Q.logger!==void 0&&!F(Q.logger))throw Error("Plugin setup context logger must be an object")}var t=0,S=new Map,f=new Map;function MQ(Q){let U=Q instanceof Error?Q.message:String(Q),X=Q instanceof Error?Q.stack:void 0;return{message:U,stack:X}}function x(Q,U,X,Z){if(!process.send)return;process.send({type:"response",id:Q,ok:U,result:X,error:Z})}function V(Q,U){if(!process.send)return;process.send({type:"event",name:Q,payload:U})}globalThis.__clinePluginHost={emitEvent:V};globalThis.__clineSessionEnv={cwd:void 0,workspaceInfo:void 0};function a(Q){if(!Q||typeof Q!=="object")return{};return Q}function M(Q){if(!Q||typeof Q!=="object")return;let U={...Q};if(U.error instanceof Error)U.error={name:U.error.name,message:U.error.message,stack:U.error.stack};return U}function VQ(Q){let U=(X,Z,$)=>{V("plugin_log",{level:X,pluginName:Q,message:Z,metadata:M($)})};return{debug:(X,Z)=>U("debug",X,Z),log:(X,Z)=>U("log",X,Z),error:(X,Z)=>U("error",X,Z)}}function EQ(Q){let U=($)=>{V("plugin_telemetry",{pluginName:Q,...$})},X=($)=>(G,Y,K,A,L)=>{U({kind:"metric",metric:$,name:G,value:Y,attributes:M(K),description:A,required:L})},Z=()=>{};return{capture:($)=>{U({kind:"event",event:$?.event,properties:M($?.properties)})},captureRequired:($,G)=>{U({kind:"event",event:$,properties:M(G),required:!0})},recordCounter:X("counter"),recordHistogram:X("histogram"),recordGauge:X("gauge"),isEnabled:()=>!0,setDistinctId:Z,setMetadata:Z,updateMetadata:Z,setCommonProperties:Z,updateCommonProperties:Z,flush:async()=>{},dispose:async()=>{}}}function j(Q,U){let X=`${Q}:${U}`,Z=(f.get(X)??0)+1;return f.set(X,Z),`${Q}_${U}_${Z}`}function TQ(Q){let U=typeof Q.eventType==="string"?Q.eventType.trim():"",X=typeof Q.source==="string"?Q.source.trim():"";if(!U)throw Error("Automation event type contribution requires eventType");if(!X)throw Error("Automation event type contribution requires source");return{...Q,eventType:U,source:X,examples:Q.examples?[...Q.examples]:void 0,metadata:Q.metadata?a(Q.metadata):void 0}}function H(Q){let U=S.get(Q);if(!U)throw Error(`Unknown sandbox plugin id: ${Q}`);return U}async function yQ(Q){let U;try{let X=await s(Q.pluginPath);if(U=X.default??X[Q.exportName],NQ(U,Q.pluginPath),U.manifest=DQ(U.manifest),!i(U.manifest,Q.targeting))return{type:"skipped"};let Z={tools:[],commands:[],rules:[],messageBuilders:[],providers:[],automationEventTypes:[],mcpServers:[],shortcuts:[],flags:[]},$={tools:new Map,commands:new Map,rules:new Map,messageBuilders:new Map},G={registerTool:(Y)=>{let K=j(Q.pluginId,"tool");$.tools.set(K,Y.execute),Z.tools.push({id:K,name:Y.name,description:Y.description,inputSchema:Y.inputSchema,timeoutMs:Y.timeoutMs,retryable:Y.retryable})},registerCommand:(Y)=>{let K=j(Q.pluginId,"command");if(typeof Y.handler==="function")$.commands.set(K,Y.handler);Z.commands.push({id:K,name:Y.name,description:Y.description})},registerRule:(Y)=>{let K=j(Q.pluginId,"rule");if(typeof Y.content==="function"){$.rules.set(K,Y.content),Z.rules.push({id:K,ruleId:Y.id,source:Y.source,hasContentHandler:!0});return}Z.rules.push({id:K,ruleId:Y.id,content:Y.content,source:Y.source})},registerMessageBuilder:(Y)=>{let K=j(Q.pluginId,"builder");$.messageBuilders.set(K,Y.build),Z.messageBuilders.push({id:K,name:Y.name})},registerProvider:(Y)=>{Z.providers.push({id:j(Q.pluginId,"provider"),name:Y.name,description:Y.description,metadata:a(Y.metadata)})},registerAutomationEventType:(Y)=>{Z.automationEventTypes.push({id:j(Q.pluginId,"automation_event"),...TQ(Y)})},registerMcpServer:(Y)=>{Z.mcpServers.push(Y)}};if(typeof U.setup==="function")try{let Y={...Q.setupCtxBase,...Q.telemetryEnabled?{telemetry:EQ(U.name)}:{},...Q.loggerEnabled?{logger:VQ(U.name)}:{},...U.manifest.capabilities.includes("automationEvents")?{automation:{ingestEvent:(K)=>{V("automation_event",K)}}}:{}};SQ(Y),await U.setup(G,Y)}catch(Y){return{type:"failure",failure:{pluginPath:Q.pluginPath,pluginName:U.name,phase:"setup",message:Y instanceof Error?Y.message:String(Y),stack:Y instanceof Error?Y.stack:void 0}}}return{type:"loaded",state:{plugin:U,handlers:$},descriptor:{pluginId:Q.pluginId,pluginPath:Q.pluginPath,name:U.name,manifest:U.manifest,hooks:U.hooks?Object.entries(U.hooks).filter(([,Y])=>typeof Y==="function").map(([Y])=>Y):void 0,contributions:Z}}}catch(X){return{type:"failure",failure:{pluginPath:Q.pluginPath,pluginName:U?.name,phase:"load",message:X instanceof Error?X.message:String(X),stack:X instanceof Error?X.stack:void 0}}}}async function bQ(Q){if(S.clear(),t=0,f.clear(),Q.cwd)try{process.chdir(Q.cwd)}catch{}let U=globalThis.__clineSessionEnv;if(U)U.cwd=Q.cwd,U.workspaceInfo=Q.workspaceInfo;let X=[],Z=[],$=[],G=Q.exportName||"plugin",Y=new Map,K={providerId:Q.providerId,modelId:Q.modelId},A={session:Q.session,client:Q.client,user:Q.user,workspaceInfo:Q.workspaceInfo},L=await Promise.all((Q.pluginPaths||[]).map((w)=>{let W=`plugin_${++t}`;return yQ({pluginPath:w,pluginId:W,exportName:G,targeting:K,setupCtxBase:A,loggerEnabled:Q.loggerEnabled,telemetryEnabled:Q.telemetryEnabled})}));for(let w of L){if(w.type==="skipped")continue;if(w.type==="failure"){Z.push(w.failure);continue}let{descriptor:W,state:e}=w,E=Y.get(W.name);if(E!==void 0){let D=X[E];if(!D)Y.delete(W.name);else{$.push({type:"duplicate_plugin_override",pluginName:W.name,pluginPath:W.pluginPath,overriddenPluginPath:D.pluginPath,message:`Plugin "${W.name}" from ${W.pluginPath} overrides ${D.pluginPath}`}),S.delete(D.pluginId),X.splice(E,1),Y.clear();for(let[QQ,UQ]of X.entries())Y.set(UQ.name,QQ)}}S.set(W.pluginId,e),Y.set(W.name,X.length),X.push(W)}return{plugins:X,failures:Z,warnings:$}}async function RQ(Q){let X=H(Q.pluginId).plugin.hooks?.[Q.hookName];if(typeof X!=="function")return;return await X(Q.payload)}async function kQ(Q){let X=H(Q.pluginId).handlers.tools.get(Q.contributionId);if(typeof X!=="function")throw Error("Unknown sandbox tool contribution");return await X(Q.input,Q.context)}async function vQ(Q){let X=H(Q.pluginId).handlers.commands.get(Q.contributionId);if(typeof X!=="function")return"";return await X(Q.input)}async function xQ(Q){let X=H(Q.pluginId).handlers.messageBuilders.get(Q.contributionId);if(typeof X!=="function")return[];return await X(Q.messages)}async function fQ(Q){let X=H(Q.pluginId).handlers.rules.get(Q.contributionId);if(typeof X!=="function")return"";return await X()}var PQ={initialize:bQ,invokeHook:RQ,executeTool:kQ,executeCommand:vQ,buildMessages:xQ,resolveRuleContent:fQ};P();process.on("message",async(Q)=>{if(!Q||Q.type!=="call")return;let U=PQ[Q.method];if(!U){x(Q.id,!1,void 0,{message:`Unknown method: ${String(Q.method)}`});return}try{let X=await U(Q.args||{});x(Q.id,!0,X)}catch(X){x(Q.id,!1,void 0,MQ(X))}});

package/dist/extensions/tools/ask-lsp.d.ts

@@ -0,0 +1,150 @@
+import { type AgentTool } from "@cerebriline/shared";
+/**
+ * Hand the model the workspace's language servers.
+ *
+ * VS Code already runs a language server for every language in the workspace,
+ * and those servers already know what every symbol means: where it is defined,
+ * everywhere it is used, what its type is, which classes implement it. None of
+ * that reached the model. It had regex search — `search_codebase` — and a regex
+ * cannot tell a definition from a mention, a method on this class from a method
+ * with the same name on another, or a live reference from one inside a comment.
+ *
+ * So the model compensates by reading. It greps a name, gets forty hits, reads
+ * six files to work out which one is the definition, and spends the turns on
+ * work the editor had already done and would have answered instantly. This is
+ * free capability that was sitting one `executeCommand` away.
+ *
+ * Position resolution is the part that makes it usable. Every LSP request is
+ * addressed by line and character, and a model almost never has those — it has
+ * a name it read in a file. So `symbol` is the primary way to ask, and the
+ * position is found on the model's behalf; line/character are accepted too, for
+ * when it does know.
+ *
+ * The name is `ask_lsp` because `code_intel` was not carrying what the tool is.
+ * Asked afterwards what `code_intel` had been, models that had *used it* did
+ * not know it was the LSP and did not expect it to be — with the first line of
+ * the description saying so, in the same request. A name is read every time and
+ * retained; a description is read once. `ask_lsp` also cannot prefix-match an
+ * MCP server's `lsp__*` tools, which a model in a workspace that has one was
+ * observed merging with ours.
+ *
+ * The provider interface below keeps its `CodeIntel*` names. It is the editor's
+ * code-intelligence surface, which this tool is one consumer of, and no model
+ * ever sees it.
+ */
+export declare const ASK_LSP_TOOL_NAME = "ask_lsp";
+export declare const ASK_LSP_OPERATIONS: readonly ["definition", "references", "implementations", "type_definition", "hover", "document_symbols", "workspace_symbols", "callers"];
+export type AskLspOperation = (typeof ASK_LSP_OPERATIONS)[number];
+export declare const ASK_LSP_TOOL_DESCRIPTION = "Ask the language servers \u2014 the LSP \u2014 about a symbol. If you are reaching for an LSP tool or an MCP server that wraps one, this is it: the same protocol, already running against this workspace and its open files, with no server to start. This answers questions a text search cannot, because it understands the code: it distinguishes a definition from a mention, and this class's method from another class's method of the same name.\n\nUse this before falling back to `search_codebase` for anything about a symbol. It is faster, exact, and does not need you to read files to interpret the result.\n\nReach for it the moment you are about to do one of these by hand:\n- search for a name to find where it is defined -> `definition`\n- search for a name to find what uses it, or what would break -> `references` or `callers`\n- open a file just to read a signature, type or doc comment -> `hover`\n- scroll a file, or count brackets, to work out its structure -> `document_symbols`\n- grep the repo to find which file something lives in -> `workspace_symbols`\n\nOperations:\n- `definition` \u2014 where a symbol is defined.\n- `references` \u2014 every place it is actually used.\n- `implementations` \u2014 the classes or functions implementing an interface or abstract method.\n- `type_definition` \u2014 where the type of an expression is defined.\n- `hover` \u2014 the signature, type and documentation, as an editor shows on hover.\n- `document_symbols` \u2014 an outline of one file: its classes, functions and methods.\n- `workspace_symbols` \u2014 find a symbol by name across the whole project when you do not know which file it is in.\n- `callers` \u2014 what calls this function.\n\nHow to address a symbol:\n- Usually: `path` plus `symbol` \u2014 the name as it appears in that file.\n- If you know the exact position: `path`, `line` and `character` (both 1-based).\n- If you do not know the file: `symbol` alone, with `operation: \"workspace_symbols\"`.\n\nOutput: plain text, one result per line as `file:line:column` followed by that source line, so you can go straight to the one you want rather than reading each candidate. `hover` returns the signature and documentation as text instead, and `document_symbols` and `workspace_symbols` name each symbol's kind.\n\nAn empty answer is a real answer once the symbol resolved: for `definition`, `references`, `implementations`, `type_definition`, `callers` and `hover` the server understood the symbol and nothing matched, so a text search for the same question will not find more. `workspace_symbols` is the exception, and says so when it comes back empty: it reads a project-wide index that covers the languages a server is installed for and does not index script embedded in `.html` or other template files, so nothing there is not proof of nothing anywhere. And when the file does not parse, every answer about it opens with that line \u2014 while it is there, the server is answering from a partial parse and you are reading guesses.";
+/** Exported for the same reason as `CHECK_FILE_TOOL_INPUT_SCHEMA`. */
+export declare const ASK_LSP_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly operation: {
+            readonly type: "string";
+            readonly enum: readonly ["definition", "references", "implementations", "type_definition", "hover", "document_symbols", "workspace_symbols", "callers"];
+            readonly description: "What to ask the language server.";
+        };
+        readonly path: {
+            readonly type: "string";
+            readonly description: "File the symbol appears in. Absolute, or relative to the working directory.";
+        };
+        readonly symbol: {
+            readonly type: "string";
+            readonly description: "The symbol's name, as written in that file. The usual way to address a symbol.";
+        };
+        readonly line: {
+            readonly type: "number";
+            readonly description: "1-based line, if you know the exact position.";
+        };
+        readonly character: {
+            readonly type: "number";
+            readonly description: "1-based column, if you know the exact position.";
+        };
+    };
+    readonly required: readonly ["operation"];
+};
+/** A location in a file. Lines and characters are 0-based, as LSP has them. */
+export interface CodeIntelLocation {
+    filePath: string;
+    line: number;
+    character: number;
+}
+export interface CodeIntelSymbol {
+    name: string;
+    /** "class", "function", "method", … — whatever the server calls it. */
+    kind: string;
+    location: CodeIntelLocation;
+    /** The class or module the symbol sits in, when the server says. */
+    containerName?: string;
+}
+/**
+ * Everything this tool needs from the editor.
+ *
+ * An interface rather than direct `vscode` calls so the tool's behaviour — the
+ * position resolution, the fallbacks, the rendering — is testable without an
+ * extension host. `check-file-tool.ts` is built the same way.
+ */
+export interface CodeIntelProvider {
+    /** Locate a name inside one file, for the position-addressed requests. */
+    findSymbolPosition(filePath: string, symbol: string): Promise<CodeIntelLocation | undefined>;
+    definitions(at: CodeIntelLocation): Promise<CodeIntelLocation[]>;
+    typeDefinitions(at: CodeIntelLocation): Promise<CodeIntelLocation[]>;
+    implementations(at: CodeIntelLocation): Promise<CodeIntelLocation[]>;
+    references(at: CodeIntelLocation): Promise<CodeIntelLocation[]>;
+    hover(at: CodeIntelLocation): Promise<string | undefined>;
+    documentSymbols(filePath: string): Promise<CodeIntelSymbol[]>;
+    workspaceSymbols(query: string): Promise<CodeIntelSymbol[]>;
+    callers(at: CodeIntelLocation): Promise<CodeIntelSymbol[]>;
+    /** The source line, so a result is readable without opening the file. */
+    readLine(filePath: string, line: number): Promise<string | undefined>;
+    /**
+     * The whole file, for the parse check that qualifies every answer about it.
+     *
+     * Optional because it arrived after the two hosts did, and a provider that
+     * cannot read the file should lose the warning rather than the answer.
+     */
+    readFile?(filePath: string): Promise<string | undefined>;
+}
+export interface AskLspToolOptions {
+    cwd: string;
+    provider: CodeIntelProvider;
+    /**
+     * Where a failed request goes. Injected rather than imported: this tool is
+     * shared by the extension and the CLI, and each has its own logger.
+     */
+    onError?: (message: string, error: unknown) => void;
+}
+interface AskLspInput {
+    operation?: unknown;
+    path?: unknown;
+    symbol?: unknown;
+    /**
+     * Accepted as a spelling of `symbol`. `search_codebase` sits next to this
+     * tool and takes `queries`, so a model reaching for a name-search here
+     * reasonably guesses `query` -- observed doing exactly that, which cost a
+     * turn and a fall back to a text search for a question the language server
+     * had already been asked.
+     */
+    query?: unknown;
+    line?: unknown;
+    character?: unknown;
+}
+export interface ParsedAskLspRequest {
+    operation: AskLspOperation;
+    filePath?: string;
+    symbol?: string;
+    /** 0-based, converted from the 1-based numbers the description asks for. */
+    line?: number;
+    character?: number;
+}
+/**
+ * Read a request, or say what is missing from it.
+ *
+ * Returns a message rather than throwing: an unusable call should cost the
+ * model one sentence telling it what to send, not a tool error it has to
+ * interpret.
+ */
+export declare function parseAskLspRequest(input: AskLspInput | undefined): ParsedAskLspRequest | string;
+export declare function createAskLspTool(options: AskLspToolOptions): AgentTool;
+export {};

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

@@ -0,0 +1,156 @@
+/**
+ * Two tools that cross between text and sound.
+ *
+ * `transcribe_audio` turns a recording in the workspace into text, and
+ * `synthesize_speech` turns text into an audio file there. A meeting recording
+ * that has to become notes, a voice-over for a demo, a prompt for a phone menu:
+ * each one used to leave the session, like an image did before
+ * `generate_image`.
+ *
+ * The wire format is the OpenAI audio API -- `POST {endpoint}/audio/
+ * transcriptions` (multipart) and `POST {endpoint}/audio/speech` (JSON, bytes
+ * back) -- which opencoti and xOllama serve beside chat and which the hosted
+ * services serve too. The two are separate endpoints because they are often
+ * separate servers: a Whisper box and a TTS box.
+ *
+ * Audio is never re-encoded here. What the engine returns is what is written,
+ * and the file is named from what came back: opencoti b97 answers WAV whatever
+ * was asked, and a `.mp3` holding WAV bytes is a file some players refuse.
+ */
+import { type AgentTool } from "@cerebriline/shared";
+import { type MediaServer } from "./media-endpoint";
+export declare const TRANSCRIBE_AUDIO_TOOL_NAME = "transcribe_audio";
+export declare const SYNTHESIZE_SPEECH_TOOL_NAME = "synthesize_speech";
+export declare const TRANSCRIBE_AUDIO_TOOL_DESCRIPTION = "Transcribe an audio file in the workspace to text. Use it to read a recording you would otherwise have to ask the user to describe: a meeting, a voice note, the audio of a demo.\n\nArguments:\n- `path` \u2014 the audio file, relative to the workspace (wav, mp3, flac, ogg, m4a, webm).\n- `format` \u2014 `text` (the default), `srt` or `vtt` for subtitles with timestamps, or `verbose_json` for segments with start and end times.\n- `language` \u2014 the spoken language as a two-letter code, e.g. `en`. Optional; the model detects it when omitted.\n- `translate` \u2014 true to get the text in English whatever language is spoken. Optional.\n- `prompt` \u2014 names and terms the recording uses, to help spelling. Optional.\n- `output` \u2014 a workspace path to write the transcript to. Optional. Give one for a long recording or for subtitles: the transcript is saved there and only its beginning is returned to you.\n\nOutput: the transcript as plain text. Without `output`, a very long transcript is cut and the cut is stated. A long recording takes minutes.";
+export declare const TRANSCRIBE_AUDIO_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly path: {
+            readonly type: "string";
+            readonly description: "The audio file to transcribe, relative to the workspace.";
+        };
+        readonly format: {
+            readonly type: "string";
+            readonly enum: readonly ["text", "srt", "vtt", "verbose_json"];
+            readonly description: "text (default), srt or vtt for subtitles, verbose_json for timed segments.";
+        };
+        readonly language: {
+            readonly type: "string";
+            readonly description: "The spoken language as a two-letter code, e.g. \"en\". Optional.";
+        };
+        readonly translate: {
+            readonly type: "boolean";
+            readonly description: "True to get the text in English. Optional.";
+        };
+        readonly prompt: {
+            readonly type: "string";
+            readonly description: "Names and terms in the recording, to help spelling. Optional.";
+        };
+        readonly output: {
+            readonly type: "string";
+            readonly description: "Workspace path to write the transcript to. Optional; use it for long recordings and subtitles.";
+        };
+    };
+    readonly required: readonly ["path"];
+};
+export declare const SYNTHESIZE_SPEECH_TOOL_DESCRIPTION = "Turn text into spoken audio and save it as a file in the workspace. Use it for a voice-over, a spoken prompt, or an audio version of something you wrote.\n\nArguments:\n- `text` \u2014 what to say. Write it as it should be spoken: spell out abbreviations and numbers that must be read a particular way.\n- `path` \u2014 where to save it, relative to the workspace. Optional; defaults to a file under `.cline/generated-audio/`. The extension is corrected to match the audio the backend returns.\n- `voice` \u2014 the voice to use. Optional; the configured default is used when omitted. Backends name their own voices, and most accept the OpenAI names (alloy, echo, fable, onyx, nova, shimmer).\n- `speed` \u2014 speaking rate, 1 is normal, e.g. 1.25. Optional.\n- `format` \u2014 `wav`, `mp3`, `flac`, `opus` or `pcm`. Optional, and a backend that cannot encode it returns what it can; the reply says which.\n\nOutput: the saved path, the audio format and its length. You do not hear the result, so say what you asked for when reporting it. A long text takes a while.";
+export declare const SYNTHESIZE_SPEECH_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly text: {
+            readonly type: "string";
+            readonly description: "What to say, written as it should be spoken.";
+        };
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Where to save it, relative to the workspace. Optional; defaults to a file under .cline/generated-audio/.";
+        };
+        readonly voice: {
+            readonly type: "string";
+            readonly description: "The voice. Optional; the configured default otherwise.";
+        };
+        readonly speed: {
+            readonly type: "number";
+            readonly description: "Speaking rate; 1 is normal. Optional.";
+        };
+        readonly format: {
+            readonly type: "string";
+            readonly enum: readonly ["wav", "mp3", "flac", "opus", "pcm"];
+            readonly description: "The audio format to ask for. Optional.";
+        };
+    };
+    readonly required: readonly ["text"];
+};
+export interface TranscriptionEndpoint {
+    /** Base URL, with or without a trailing `/v1`. */
+    baseUrl: string;
+    model: string;
+    apiKey?: string;
+}
+export interface SpeechEndpoint extends TranscriptionEndpoint {
+    /** Default for calls that name no voice. */
+    voice?: string;
+    /** Default for calls that name no format. */
+    format?: string;
+}
+type MaybePromise<T> = T | Promise<T>;
+interface AudioToolBase {
+    cwd: string;
+    fetchImpl?: typeof fetch;
+    onError?: (message: string, error: unknown) => void;
+}
+export interface TranscribeAudioToolOptions extends AudioToolBase {
+    getEndpoint: () => MaybePromise<TranscriptionEndpoint | undefined>;
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    writeFile: (absolutePath: string, data: Buffer) => Promise<void>;
+    /** Milliseconds one transcription may take. Defaults to 15 minutes. */
+    timeoutMs?: number;
+    /** Characters of transcript returned to the model. Defaults to 24,000. */
+    maxReturnedChars?: number;
+}
+export interface SynthesizeSpeechToolOptions extends AudioToolBase {
+    getEndpoint: () => MaybePromise<SpeechEndpoint | undefined>;
+    writeFile: (absolutePath: string, data: Buffer) => Promise<void>;
+    /** Milliseconds one synthesis may take. Defaults to 5 minutes. */
+    timeoutMs?: number;
+}
+/**
+ * What the bytes are, according to the bytes, as a file extension.
+ *
+ * Trusted ahead of the header and the request for the image tool's reason: the
+ * engine decides, and one of them answers WAV to a request for mp3.
+ */
+export declare function sniffAudioExtension(data: Buffer): string | undefined;
+/** The extension the returned audio should carry. */
+export declare function audioExtension(data: Buffer, contentType: string | null, requestedFormat: string | undefined): string;
+/** Seconds of audio in a WAV, from its own header. Nothing for other formats. */
+export declare function wavSeconds(data: Buffer): number | undefined;
+/** A filename that says what was said, for the same reason an image gets one. */
+export declare function defaultSpeechPath(text: string, now: number): string;
+export declare function createTranscribeAudioTool(options: TranscribeAudioToolOptions): AgentTool;
+export declare function createSynthesizeSpeechTool(options: SynthesizeSpeechToolOptions): AgentTool;
+/** What a speech engine says it can do, for a settings picker. */
+export interface SpeechVoices {
+    /** The engine's own voices first, then the OpenAI names it also answers to. */
+    voices: string[];
+    default?: string;
+    /** The `response_format` values the engine encodes. */
+    formats: string[];
+}
+/**
+ * The voices and formats of a speech endpoint, where the server can say.
+ *
+ * The OpenAI API has no route for this, so only the two servers that added one
+ * answer: opencoti in `/props` (`media.tts`), xOllama at
+ * `/api/xollama/media/voices`. Anything else is `undefined`, which is "type
+ * the name", not "no voices".
+ *
+ * Call it when the user asks, not when a pane opens: xOllama starts the speech
+ * engine to answer, and that is seconds of load and gigabytes of memory nobody
+ * asked for.
+ */
+export declare function listSpeechVoices(endpoint: TranscriptionEndpoint, server: MediaServer | "unknown", options?: {
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<SpeechVoices | undefined>;
+export {};

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

@@ -0,0 +1,137 @@
+import { type AgentTool } from "@cerebriline/shared";
+/**
+ * What a driver reports back from one action.
+ *
+ * Declared here rather than imported from the extension's message types: this
+ * tool is shared, and a host that has no webview should not have to model one
+ * to drive a browser. The extension's `BrowserActionResult` is structurally
+ * this, so its `BrowserSession` still satisfies the driver unchanged.
+ */
+export type BrowserActionResult = {
+    screenshot?: string;
+    logs?: string;
+    currentUrl?: string;
+    currentMousePosition?: string;
+};
+/**
+ * A tool that answers "does this page actually work?".
+ *
+ * `check_file` answers that question for a file the editor understands. It has
+ * nothing to say about a page: an `.html` file gets no syntax checking from VS
+ * Code at all, and even a file that parses can throw the moment it runs. The
+ * only component that knows is the browser, and until now the model had no way
+ * to ask one.
+ *
+ * What it did instead was ask the user. Measured across four sessions: the
+ * model finishes an edit, cannot verify it, and either declares success it has
+ * not earned or asks whether the page works — a round trip that costs a human
+ * turn to answer something a headless Chrome answers in two seconds.
+ *
+ * Nothing here is new machinery. `BrowserSession` — puppeteer, Chrome
+ * discovery, remote-debug attach, screenshots, console capture — has been in
+ * the tree the whole time; it was upstream's `browser_action` tool, and the SDK
+ * migration cut the tool while leaving the service, its settings, its webview
+ * menu and its five gRPC handlers in place. This is the wire that was cut.
+ */
+export declare const BROWSER_TOOL_NAME = "browser";
+/**
+ * Written at the failure it replaces, the way `check_file`'s is.
+ *
+ * The reflex being displaced here is not a shell command — it is asking the
+ * user. So the description says, in the place the model is standing when it is
+ * about to ask, that the answer is available without them.
+ */
+export declare const BROWSER_TOOL_DESCRIPTION = "Open a page in a real browser and report what it printed to the console and what it threw. This is how you check that a page works. Do not ask the user whether it works \u2014 open it and read the errors yourself.\n\nUse it after editing any HTML, CSS or JavaScript the page loads, and before reporting a task finished. `check_file` cannot answer this: no language server checks the script inside an `.html` file, and a file that parses can still throw the moment it runs.\n\nActions:\n- `open` \u2014 go to `url` and report the console output. Launches the browser on first use. A local file is a URL: pass the absolute path and it is converted for you.\n- `click` \u2014 click at `coordinate` (\"x,y\" in page pixels, from the screenshot).\n- `type` \u2014 type `text` at the current focus.\n- `scroll_down`, `scroll_up` \u2014 one viewport.\n- `close` \u2014 shut the browser down. Do this when finished with it.\n\nEvery action reports the console messages and uncaught errors produced while it ran, so a syntax error, a failed fetch or a null dereference comes back as text you can act on. `[error]` and `[Page Error]` lines are real failures. A page that says nothing printed nothing \u2014 that is a pass, not a failed call, and for a local file it is checked: a silent console over a file that does not parse is reported as the failure it is, not as a pass.\n\nA parse error from the browser names no line, because the script never ran. For a local file a `Delimiter scan` section follows it and names the line to edit and how many brackets that line is out by \u2014 one line per place the trouble starts, since a file can be broken in several spots at once. Fix every line it lists in one edit and reload once, rather than one edit and one reload per line. Edit those lines instead of counting brackets yourself: counting a whole file by hand costs more thinking than you have, and the scan skips strings, comments and regex literals, which counting does not.\n\nThe browser stays open between calls, so `open` once and then interact. Only one page is open at a time; `open` again to go elsewhere.";
+/**
+ * Exported so the template generator can state this tool's real call shape.
+ *
+ * Same reason `check_file` exports its schema: a model rewriting a prompt
+ * template writes example calls, and an example is copied more readily than a
+ * schema is read.
+ */
+export declare const BROWSER_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: readonly ["open", "click", "type", "scroll_down", "scroll_up", "close"];
+            readonly description: "What to do.";
+        };
+        readonly url: {
+            readonly type: "string";
+            readonly description: "For `open`: the page to load. An absolute file path is accepted and converted to a file URL.";
+        };
+        readonly coordinate: {
+            readonly type: "string";
+            readonly description: "For `click`: \"x,y\" in page pixels.";
+        };
+        readonly text: {
+            readonly type: "string";
+            readonly description: "For `type`: the text to type.";
+        };
+    };
+    readonly required: readonly ["action"];
+};
+export declare const BROWSER_ACTIONS: readonly ["open", "click", "type", "scroll_down", "scroll_up", "close"];
+export type BrowserToolAction = (typeof BROWSER_ACTIONS)[number];
+/**
+ * The subset of `BrowserSession` this tool drives.
+ *
+ * Declared structurally rather than imported: `BrowserSession` reaches for
+ * `StateManager`, telemetry and the host bridge in its constructor, none of
+ * which a unit test should have to stand up to check how a console log is
+ * rendered.
+ */
+export interface BrowserDriver {
+    launchBrowser(): Promise<void>;
+    navigateToUrl(url: string): Promise<BrowserActionResult>;
+    click(coordinate: string): Promise<BrowserActionResult>;
+    type(text: string): Promise<BrowserActionResult>;
+    scrollDown(): Promise<BrowserActionResult>;
+    scrollUp(): Promise<BrowserActionResult>;
+    closeBrowser(): Promise<unknown>;
+}
+export interface BrowserToolOptions {
+    cwd: string;
+    /** Built on first use, so a session that never browses never spawns Chrome. */
+    createDriver: () => BrowserDriver | Promise<BrowserDriver>;
+    /** Injection point for tests; defaults to reading the file off disk. */
+    readFile?: (filePath: string) => Promise<string>;
+    /**
+     * Where a failed action goes. Injected rather than imported: this tool is
+     * shared by the extension and the CLI, and each has its own logger.
+     */
+    onError?: (message: string, error: unknown) => void;
+}
+/**
+ * Turn what a model typed into something a browser will accept.
+ *
+ * Models pass local files three ways — a bare absolute path, a Windows path
+ * with backslashes, and an already-correct `file://` URL — and only the third
+ * works unaided. Rejecting the other two would teach the model to stop using
+ * the tool rather than to write the third.
+ */
+export declare function toNavigableUrl(raw: string, cwd: string): string;
+/**
+ * How a result reads to the model.
+ *
+ * The console block is the point of the tool, so it is labelled and never
+ * silently omitted: "nothing" stated is a result, while nothing printed is
+ * indistinguishable from the tool having failed — and a model that suspects a
+ * tool failed goes back to asking the user.
+ */
+export declare function renderBrowserResult(action: string, result: BrowserActionResult, target?: string): string;
+/**
+ * Split a data URL into the parts an image content block needs.
+ *
+ * `BrowserSession` hands back `data:image/png;base64,…` because that is what
+ * the webview renders. The model's message wants the media type and the
+ * payload apart.
+ */
+export declare function splitDataUrl(dataUrl: string): {
+    data: string;
+    mediaType: string;
+} | undefined;
+/** The local path behind a `file://` URL, or nothing for anything remote. */
+export declare function localPathOf(url: string | undefined): string | undefined;
+export declare function createBrowserTool(options: BrowserToolOptions): AgentTool;