@cjhyy/code-shell-core 0.9.5 → 0.9.7

package/dist/tool-system/builtin/mcp-tools.js

@@ -24,7 +24,7 @@ export const mcpToolDef = {
         required: ["server", "tool"],
     },
 };
-export async function mcpToolExecute(args) {
+export async function mcpToolExecute(args, ctx) {
     const server = args.server;
     const tool = args.tool;
     const toolArgs = args.arguments ?? {};
@@ -33,12 +33,12 @@ export async function mcpToolExecute(args) {
     const signal = args.__signal;
     try {
         const { MCPManager } = await import("../mcp-manager.js");
-        const manager = MCPManager.getInstance();
-        const result = await manager.callTool(server, tool, toolArgs, signal);
+        const manager = MCPManager.forContext(ctx);
+        const result = await manager.callTool(server, tool, toolArgs, signal, ctx);
         return typeof result === "string" ? result : JSON.stringify(result, null, 2);
     }
     catch (err) {
-        return `MCP tool error: ${err.message}`;
+        return { ok: false, error: `MCP tool error: ${err.message}` };
     }
 }
 // ─── ListMcpResources — list available MCP resources ────────────
@@ -55,7 +55,7 @@ export const listMcpResourcesToolDef = {
         },
     },
 };
-export async function listMcpResourcesTool(args) {
+export async function listMcpResourcesTool(args, ctx) {
     const server = args.server ?? "";
     // The executor injects the session's allowed-server set (see executor.ts).
     // When no explicit server filter is given, we must only enumerate resources
@@ -64,11 +64,11 @@ export async function listMcpResourcesTool(args) {
     const allowed = args.__allowedMcpServers;
     try {
         const { MCPManager } = await import("../mcp-manager.js");
-        const manager = MCPManager.getInstance();
+        const manager = MCPManager.forContext(ctx);
         // Forward the run's abort signal (registry injects __signal) so Stop cancels
         // promptly instead of waiting out the SDK's default request timeout.
         const signal = args.__signal;
-        let resources = await manager.listResources(server || undefined, signal);
+        let resources = await manager.listResources(server || undefined, signal, ctx);
         if (allowed && resources) {
             resources = resources.filter((r) => {
                 // Resource entries may carry the owning server on `serverName`/`server`;
@@ -106,14 +106,14 @@ export const readMcpResourceToolDef = {
         required: ["server", "uri"],
     },
 };
-export async function readMcpResourceTool(args) {
+export async function readMcpResourceTool(args, ctx) {
     const server = args.server;
     const uri = args.uri;
     try {
         const { MCPManager } = await import("../mcp-manager.js");
-        const manager = MCPManager.getInstance();
+        const manager = MCPManager.forContext(ctx);
         const signal = args.__signal;
-        const content = await manager.readResource(server, uri, signal);
+        const content = await manager.readResource(server, uri, signal, ctx);
         return typeof content === "string" ? content : JSON.stringify(content, null, 2);
     }
     catch (err) {

package/dist/tool-system/builtin/send-message-to-session.js

@@ -3,7 +3,9 @@ export const sendMessageToSessionToolDef = {
     name: SEND_MESSAGE_TO_SESSION_TOOL_NAME,
     description: "Send a message to another host-authorized Session in the current project. " +
         "Use this exactly like a person sending a message in that Session: the message becomes the target Session's next user turn and queues or starts its work. " +
-        "When you have later additions, call this tool again with another message. The call creates no persistent relationship or automatic subscription.",
+        "The result reports whether this turn is queued, started, or already completed. " +
+        "For queued or started turns, that turn's answer or failure is returned to this Session automatically; do not poll by sending the task again. " +
+        "When you have later additions, call this tool again with another message. This does not subscribe to unrelated future target turns.",
     inputSchema: {
         type: "object",
         properties: {
@@ -54,8 +56,22 @@ export async function sendMessageToSessionTool(args, ctx) {
     if (message.length > 48_000)
         return "Error: message exceeds 48000 characters.";
     try {
-        const target = await service.send({ targetSessionId, message });
-        return `Message sent to "${target.title}" (${target.sessionId}); its Session has queued the turn.`;
+        const target = await service.send({
+            targetSessionId,
+            message,
+            ...(ctx?.signal ? { signal: ctx.signal } : {}),
+        });
+        const receipt = target.receipt;
+        const label = `"${target.title}" (${target.sessionId})`;
+        if (!receipt) {
+            // Compatibility with custom hosts that implement the original router.
+            return `Message accepted by ${label}. This host did not provide execution status or automatic reply delivery.`;
+        }
+        if (receipt.status === "completed") {
+            return `Message ${receipt.messageId} completed in ${label}.\n\n${receipt.result?.text ?? ""}`;
+        }
+        const status = receipt.status === "started" ? "started" : "queued (not yet confirmed started)";
+        return `Message ${receipt.messageId} accepted by ${label}; status: ${status}. This turn's answer or failure will be returned to this Session automatically.`;
     }
     catch (error) {
         return `Error: ${error instanceof Error ? error.message : String(error)}`;

package/dist/tool-system/builtin/tool-search.js

@@ -6,6 +6,8 @@
  * saving context by not loading all MCP tool schemas upfront.
  */
 import { isRegisteredMcpToolAllowed } from "../mcp-tool-policy.js";
+import { browserDiscoveryScore, isBuiltinBrowserTool } from "../browser-discovery.js";
+import { PLAN_MODE_ALLOWED_TOOLS } from "../plan-mode-allowlist.js";
 export const toolSearchToolDef = {
     name: "ToolSearch",
     description: "Search only the tools available in the current Session context by name or keyword. " +
@@ -59,8 +61,18 @@ export async function toolSearchTool(args, ctx) {
     // its server is in this session's allowedMcpServers. Undefined set = no
     // gating (sub-agents / hosts that don't populate it).
     const visible = (tool) => {
-        if (tool.source !== "mcp")
-            return true;
+        if (ctx.disabledBuiltins?.has(tool.name))
+            return false;
+        if (ctx.allowedToolNames && !ctx.allowedToolNames.has(tool.name))
+            return false;
+        if (ctx.planMode && !PLAN_MODE_ALLOWED_TOOLS.has(tool.name))
+            return false;
+        if (tool.source !== "mcp") {
+            if (isBuiltinBrowserTool(tool) && !ctx.browser)
+                return false;
+            const guard = ctx.toolRegistry.getAvailabilityGuard(tool.name);
+            return !guard || !ctx.toolVisibility || guard(ctx.toolVisibility);
+        }
         const allowed = ctx.allowedMcpServers;
         return ((!allowed || allowed.has(tool.serverName ?? "")) &&
             isRegisteredMcpToolAllowed(tool, ctx.mcpToolPolicies));
@@ -124,7 +136,7 @@ function searchDetailedTools(allTools, query, maxResults) {
     const keywords = queryLower.split(/\s+/);
     // Score each tool
     const scored = allTools.map((tool) => {
-        let score = 0;
+        let score = browserDiscoveryScore(tool, query);
         const nameLower = tool.name.toLowerCase();
         const descLower = tool.description.toLowerCase();
         for (const kw of keywords) {

package/dist/tool-system/context.d.ts

@@ -23,6 +23,7 @@ import type { SessionWorkspace } from "../types.js";
 import type { ApprovalRouter } from "./permission.js";
 import type { ChildWriterLease, LiveChildControl } from "./builtin/agent-registry.js";
 import type { McpToolPolicy } from "./mcp-tool-policy.js";
+import type { SessionContextNotes } from "../context/notes.js";
 /**
  * Narrow view of the owning Engine that tools are allowed to call back into.
  * Defined here (in the low-level tool-system) rather than importing the
@@ -189,12 +190,16 @@ export interface SubAgentSpawnResult {
  */
 export interface ToolVisibilityContext {
     cwd: string;
+    /** Resolved native context strategy; omitted for external runtimes. */
+    contextStrategy?: "summary" | "notes";
     workspace?: import("../workspace/workspace-context.js").WorkspaceContext;
     hasGoal: boolean;
     /** Resolved Session identity for per-session extension-tool visibility. */
     sessionId?: string;
     settingsScope?: import("../settings/manager.js").SettingsScope;
     host?: string;
+    /** A browser bridge is wired for this run, independent of the host's name. */
+    hasBrowserAutomation?: boolean;
     isSubAgent?: boolean;
     behaviorProfile?: string;
     /** Host-authorized targets available to the cross-Session messaging builtin. */
@@ -231,6 +236,10 @@ export interface ToolRunYieldController {
 export interface ToolContext {
     /** Active working directory for this Engine. */
     cwd: string;
+    /** Resolved strategy for the current session's model context. */
+    contextStrategy?: "summary" | "notes";
+    /** Session-local working notes and history; never a cross-session memory store. */
+    contextNotes?: Pick<SessionContextNotes, "save" | "requestRollover" | "search" | "read">;
     /**
      * True when this call belongs to an external Agent Runtime rather than the
      * native Engine loop.

package/dist/tool-system/executor.js

@@ -409,14 +409,16 @@ export class ToolExecutor {
         }
         if (decision === "ask") {
             const reason = permissionAskReason(hookResult.decision === "ask" ? hookResult.messages : undefined, permHook.decision === "ask" ? permHook.messages : undefined);
-            const approved = await this.permission.handleAsk(call.toolName, call.args, reason, {
+            const approval = await this.permission.handleAskResult(call.toolName, call.args, reason, {
                 sessionId: this.toolCtx?.sessionId,
             });
-            if (!approved) {
+            if (!approval.approved) {
                 return {
                     id: call.id,
                     toolName: call.toolName,
-                    error: `Permission denied by user for tool: ${call.toolName}`,
+                    error: approval.failure && approval.failure !== "denied"
+                        ? `Permission approval ${approval.failure} for tool: ${call.toolName}${approval.reason ? `. ${approval.reason}` : ""}`
+                        : `Permission denied by user for tool: ${call.toolName}${approval.reason ? `. ${approval.reason}` : ""}`,
                     isError: true,
                 };
             }

package/dist/tool-system/mcp-compat.d.ts

@@ -0,0 +1,3 @@
+import type { Tool as McpTool } from "@modelcontextprotocol/sdk/types.js";
+export declare function adaptMcpToolSchema(implementation: string | undefined, tool: McpTool): McpTool["inputSchema"];
+export declare function normalizeMcpToolArgs(implementation: string | undefined, tool: McpTool | undefined, args: Record<string, unknown>): Record<string, unknown>;

package/dist/tool-system/mcp-compat.js

@@ -0,0 +1,51 @@
+/** Compatibility for Chrome DevTools' optional output/context selectors.
+ * A blank selector is not an output filename or an intentional isolated context.
+ * Match the server implementation AND its declared tool shape; an unrelated
+ * tool's empty text, input path, or required parameter must remain untouched. */
+function optionalChromeSelectors(implementation, tool) {
+    if (implementation !== "chrome_devtools")
+        return [];
+    const properties = tool.inputSchema.properties;
+    const required = new Set(tool.inputSchema.required ?? []);
+    if (!properties)
+        return [];
+    const expected = {
+        take_snapshot: { selectors: ["filePath"], signature: { verbose: "boolean" } },
+        take_screenshot: { selectors: ["filePath"], signature: { format: "string" } },
+        evaluate_script: { selectors: ["filePath"], signature: { function: "string" } },
+        get_network_request: {
+            selectors: ["requestFilePath", "responseFilePath"],
+            signature: { reqid: "number" },
+        },
+        new_page: { selectors: ["isolatedContext"], signature: { url: "string" } },
+    };
+    const contract = expected[tool.name];
+    if (!contract ||
+        Object.entries(contract.signature).some(([key, type]) => properties[key]?.type !== type))
+        return [];
+    return contract.selectors.filter((key) => properties[key]?.type === "string" && !required.has(key));
+}
+export function adaptMcpToolSchema(implementation, tool) {
+    const selectors = optionalChromeSelectors(implementation, tool);
+    if (!selectors.length)
+        return tool.inputSchema;
+    const properties = { ...tool.inputSchema.properties };
+    for (const key of selectors) {
+        const property = properties[key];
+        properties[key] = {
+            ...property,
+            minLength: Math.max(typeof property.minLength === "number" ? property.minLength : 0, 1),
+            description: `${property.description ?? ""} Omit this optional field when unused; do not send an empty string.`,
+        };
+    }
+    return { ...tool.inputSchema, properties };
+}
+export function normalizeMcpToolArgs(implementation, tool, args) {
+    const normalized = { ...args };
+    if (tool)
+        for (const key of optionalChromeSelectors(implementation, tool)) {
+            if (normalized[key] === "")
+                delete normalized[key];
+        }
+    return normalized;
+}

package/dist/tool-system/mcp-manager.d.ts

@@ -8,6 +8,8 @@ import type { MCPServerConfig, RegisteredTool } from "../types.js";
 import type { CredentialType } from "../credentials/types.js";
 import { ToolRegistry } from "./registry.js";
 import { type CredentialAccess } from "../credentials/access.js";
+import { type McpWorkspaceScope } from "./mcp-workspace.js";
+export type { McpWorkspaceScope } from "./mcp-workspace.js";
 interface MCPResourceInfo {
     uri: string;
     name: string;
@@ -78,7 +80,7 @@ export declare function spillMcpImage(serverName: string, toolName: string, base
 }): Promise<string>;
 export declare function wrapMcpOutput(serverName: string, toolName: string, body: string): string;
 export declare function stripInternalToolArgs(args: Record<string, unknown>): Record<string, unknown>;
-export declare function buildRegisteredTool(serverName: string, tool: McpTool): RegisteredTool;
+export declare function buildRegisteredTool(serverName: string, tool: McpTool, implementation?: string): RegisteredTool;
 /**
  * Per-server outcome of a connectAll() sweep (see the optional onServerEvent
  * parameter). The engine forwards these onto the `notification` hook so hosts
@@ -95,26 +97,21 @@ export declare class MCPManager {
     private connections;
     private registeredToolsByServer;
     private desiredServerNames;
-    /**
-     * In-flight connect()s keyed by server name. When the broadcast config
-     * reload (server.ts forEachSession → every session's refreshRuntimeConfig)
-     * calls connectAll for the SAME `added` server on this ONE shared pool, K
-     * concurrent connect(name) calls would each start a fresh handshake because
-     * `connections.has(name)` only becomes true AFTER the handshake completes —
-     * a thundering herd of duplicate connections racing to set(). Coalescing by
-     * name here collapses them to a SINGLE underlying connection; the late
-     * callers await the same promise and return. Cleared in finally so a failed
-     * connect can be retried later.
-     */
+    /** Concurrent handshakes share only an identical server + cwd + root scope. */
     private connecting;
     /** Per-owner (engine) desired server sets — see reconcile()'s shared-pool note. */
     private desiredByOwner;
+    private scopeByOwner;
+    private connectionKeysByOwner;
+    private connectionGeneration;
     constructor(toolRegistry: ToolRegistry);
     static getInstance(): MCPManager;
+    /** Resolve generic MCP builtins through the current run, never another pool. */
+    static forContext(workspace?: McpWorkspaceScope): MCPManager;
     /**
      * Connect to all configured MCP servers and register their tools.
      */
-    connectAll(servers: Record<string, MCPServerConfig>, owner?: unknown, onServerEvent?: (event: McpServerLifecycleEvent) => void): Promise<void>;
+    connectAll(servers: Record<string, MCPServerConfig>, owner?: unknown, onServerEvent?: (event: McpServerLifecycleEvent) => void, workspace?: McpWorkspaceScope): Promise<void>;
     reconcile(servers: Record<string, MCPServerConfig>, owner?: unknown): Promise<void>;
     /**
      * Remove one owner from the shared desired-server pool and disconnect servers
@@ -123,48 +120,52 @@ export declare class MCPManager {
      * worker shutdown.
      */
     unregisterOwner(owner: unknown): Promise<void>;
+    private pruneUnusedScopedConnections;
+    private managedConnectionKeys;
     private enabledServerNames;
     /** Union of every registered owner's desired set; null when none registered. */
     private unionDesired;
     /**
      * Connect to a single MCP server.
      *
-     * Coalesces concurrent calls for the same `name`: an already-connected server
-     * returns immediately, and a connect already in flight for this name is
-     * awaited rather than restarted (#5 — thundering-herd guard on the shared
-     * pool). The actual handshake lives in `performConnect`.
+     * Calls for the same server and canonical workspace scope share one pending
+     * handshake. Other workspace scopes always get their own transport.
      */
-    connect(name: string, config: MCPServerConfig): Promise<void>;
+    connect(name: string, config: MCPServerConfig, workspace?: McpWorkspaceScope): Promise<void>;
     /**
      * Perform the actual handshake + tool discovery for one server. Separated
      * from `connect` so the coalescing/dedup logic stays in one place. Override
      * `connect` (not this) in test doubles that want to count handshakes.
      */
-    protected performConnect(name: string, config: MCPServerConfig): Promise<void>;
+    protected performConnect(name: string, config: MCPServerConfig, workspace?: McpWorkspaceScope): Promise<void>;
     /**
      * Discover tools from an MCP server and register them.
      */
     private discoverTools;
+    private scopeForContext;
+    private findConnection;
+    private connectionForScope;
+    /** Refresh an engine's fork after pool discovery; retain all non-MCP tools. */
+    syncToolsToRegistry(registry: ToolRegistry, workspace?: McpWorkspaceScope, allowedServers?: ReadonlySet<string>): void;
+    private executeRegisteredTool;
     /**
      * Disconnect all MCP servers.
      */
     disconnectAll(): Promise<void>;
     disconnect(name: string): Promise<void>;
-    /**
-     * List connected servers.
-     */
+    private disconnectConnection;
+    /** Names remain stable even when several isolated workspace transports exist. */
     listServers(): string[];
     /**
      * Call a tool on a specific MCP server.
      */
-    callTool(serverName: string, toolName: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<unknown>;
+    callTool(serverName: string, toolName: string, args: Record<string, unknown>, signal?: AbortSignal, workspace?: McpWorkspaceScope): Promise<unknown>;
     /**
      * List resources from MCP servers.
      */
-    listResources(serverName?: string, signal?: AbortSignal): Promise<MCPResourceInfo[]>;
+    listResources(serverName?: string, signal?: AbortSignal, workspace?: McpWorkspaceScope): Promise<MCPResourceInfo[]>;
     /**
      * Read a resource from an MCP server.
      */
-    readResource(serverName: string, uri: string, signal?: AbortSignal): Promise<string>;
+    readResource(serverName: string, uri: string, signal?: AbortSignal, workspace?: McpWorkspaceScope): Promise<string>;
 }
-export {};