feat(core): apply session tool and MCP selections to the running agent

`agent_config.tools` and `agent_config.mcp_servers` were accepted by the
profile route and then dropped. They now persist to session metadata and
reach `ToolManager`.

The two fields merge independently, so a patch that supplies only MCP
servers keeps the current builtin tool selection instead of stripping it.
An empty array still clears its own half. `SessionService.update` resumes
an inactive session first, and the selection is applied in one
`setActiveTools` call so the replay record stays complete.

MCP server names go through `mcpServerToolPattern`, which sanitizes the
name the same way qualified tool names are built, so a server called
`My Search` matches its own tools.

Author: elkaix

.changeset/session-capability-wiring.md

@@ -0,0 +1,6 @@
+---
+"@pymodel/agent-core": minor
+"@pymodel/server": minor
+---
+
+Make `agent_config.tools` and `agent_config.mcp_servers` reach the running agent. A session profile update now persists the selection, merges each field independently so supplying one half does not clear the other, resumes an inactive session before the mutation, and applies the result through a single `setActiveTools` call. MCP server names are turned into tool patterns with the shared naming helper, so a server whose name needs sanitizing still matches its tools.

packages/agent-core/src/agent/tool/index.ts

@@ -349,6 +349,16 @@ export class ToolManager {
     this.mcpAccessPatterns = names.filter((name) => isMcpToolName(name));
   }
 
+  patchActiveTools(input: {
+    readonly tools?: readonly string[];
+    readonly mcpPatterns?: readonly string[];
+  }): void {
+    this.setActiveTools([
+      ...(input.tools ?? this.enabledTools),
+      ...(input.mcpPatterns ?? this.mcpAccessPatterns),
+    ]);
+  }
+
   copyLoopToolsFrom(source: ToolManager): void {
     this.loopToolsOverride = source.loopTools;
   }

packages/agent-core/src/mcp/tool-naming.ts

@@ -6,6 +6,7 @@ const MCP_NAME_SEPARATOR = '__';
  * hash suffix so collisions remain extremely unlikely.
  */
 const MAX_QUALIFIED_LENGTH = 64;
+const MAX_HASH_SUFFIX_LENGTH = 10;
 
 /**
  * Replace any character outside the safe ASCII set with `_`, then collapse
@@ -22,6 +23,11 @@ export function isMcpToolName(name: string): boolean {
   return name.startsWith(MCP_NAME_PREFIX);
 }
 
+export function mcpServerToolPattern(serverName: string): string {
+  const prefix = `${MCP_NAME_PREFIX}${sanitizeMcpNamePart(serverName)}${MCP_NAME_SEPARATOR}`;
+  return `${prefix.slice(0, MAX_QUALIFIED_LENGTH - MAX_HASH_SUFFIX_LENGTH)}*`;
+}
+
 /**
  * Produce the qualified MCP tool name used inside the agent and on the wire.
  * If the result would exceed {@link MAX_QUALIFIED_LENGTH}, a deterministic

packages/agent-core/src/services/session/session.ts

@@ -122,6 +122,8 @@ export function toProtocolSession(
     metadata: mergedMetadata,
     agent_config: {
       model: '',
+      tools: meta?.agentConfig?.tools?.slice(),
+      mcp_servers: meta?.agentConfig?.mcpServers?.slice(),
     },
     usage: emptySessionUsage(),
     permission_rules: [],

packages/agent-core/src/services/session/sessionService.ts

@@ -44,6 +44,8 @@ const DEFAULT_UNDO_MESSAGE_PAGE_SIZE = 50;
 const MAX_UNDO_MESSAGE_PAGE_SIZE = 100;
 const CHILD_SESSION_KIND = 'child';
 
+type ToolSelectionPatch = NonNullable<SessionMeta['agentConfig']>;
+
 function asJsonObject(value: Record<string, unknown>): JsonObject {
   return value as unknown as JsonObject;
 }
@@ -250,6 +252,10 @@ export class SessionService extends Disposable implements ISessionService {
       } catch {
       }
     }
+    const toolPatch = this.toToolPatch(input.agent_config);
+    if (toolPatch !== undefined) {
+      await this.persistToolSelection(summary.id, toolPatch);
+    }
     const meta = await this.tryGetMeta(summary.id);
     const session = this._patchSessionStatus(
       toProtocolSession(summary, meta, await this.tryResolveWorkspaceId(summary.workDir)),
@@ -315,6 +321,7 @@ export class SessionService extends Disposable implements ISessionService {
     if (summary === undefined) {
       throw new SessionNotFoundError(id);
     }
+    await this.core.rpc.resumeSession({ sessionId: id });
 
     if (input.title !== undefined) {
       await this.core.rpc.renameSession({ sessionId: id, title: input.title });
@@ -330,6 +337,10 @@ export class SessionService extends Disposable implements ISessionService {
 
     const ac = input.agent_config;
     if (ac !== undefined) {
+      const toolPatch = this.toToolPatch(ac);
+      if (toolPatch !== undefined) {
+        await this.persistToolSelection(id, toolPatch);
+      }
       const patch: AgentStatePatch = {};
       if (ac.model !== undefined && ac.model !== '') patch.model = ac.model;
       if (ac.thinking !== undefined) patch.thinking = ac.thinking;
@@ -359,6 +370,30 @@ export class SessionService extends Disposable implements ISessionService {
     );
   }
 
+  private toToolPatch(
+    agentConfig: SessionCreate['agent_config'],
+  ): ToolSelectionPatch | undefined {
+    if (agentConfig?.tools === undefined && agentConfig?.mcp_servers === undefined) {
+      return undefined;
+    }
+    return {
+      tools: agentConfig.tools,
+      mcpServers: agentConfig.mcp_servers,
+    };
+  }
+
+  private async persistToolSelection(id: string, patch: ToolSelectionPatch): Promise<void> {
+    await this.core.rpc.updateSessionMetadata({
+      sessionId: id,
+      metadata: {
+        agentConfig: {
+          tools: patch.tools,
+          mcpServers: patch.mcpServers,
+        },
+      },
+    });
+  }
+
   async fork(id: string, input: SessionFork): Promise<Session> {
     const source = await this.get(id);
     const title = input.title ?? `Fork: ${source.title || source.id}`;

packages/agent-core/src/session/index.ts

@@ -213,6 +213,10 @@ export interface SessionMeta {
   lastPrompt?: string;
   forkedFrom?: string;
   agents: Record<string, AgentMeta>;
+  agentConfig?: {
+    readonly tools?: readonly string[];
+    readonly mcpServers?: readonly string[];
+  };
   custom: Record<string, any>;
 }
 
@@ -238,6 +242,13 @@ const SessionMetaSchema = z
     lastPrompt: z.string().optional(),
     forkedFrom: z.string().optional(),
     agents: z.record(z.string(), AgentMetaSchema),
+    agentConfig: z
+      .object({
+        tools: z.array(z.string()).optional(),
+        mcpServers: z.array(z.string()).optional(),
+      })
+      .strict()
+      .optional(),
     custom: z.record(z.string(), z.unknown()),
   })
   .strict();

packages/agent-core/src/session/rpc.ts

@@ -1,5 +1,6 @@
 import { ErrorCodes, PythinkerError } from '#/errors';
 import { convertMCPContentBlock } from '#/mcp/output';
+import { mcpServerToolPattern } from '#/mcp/tool-naming';
 import type {
   ActivateSkillPayload,
   AdvisorStatus,
@@ -71,13 +72,33 @@ export class SessionAPIImpl implements PromisableMethods<SessionAPI> {
         'sessionFormatVersion cannot be updated',
       );
     }
+    const incoming = payload.metadata.agentConfig;
+    const previous = this.session.metadata.agentConfig;
+    const agentConfig =
+      incoming === undefined
+        ? previous
+        : {
+            tools: incoming.tools ?? previous?.tools,
+            mcpServers: incoming.mcpServers ?? previous?.mcpServers,
+          };
     this.session.metadata = {
       ...this.session.metadata,
       ...payload.metadata,
+      agentConfig,
       agents: this.session.metadata.agents,
       sessionFormatVersion: this.session.metadata.sessionFormatVersion,
     };
     await this.session.writeMetadata();
+    if (
+      incoming !== undefined &&
+      (incoming.tools !== undefined || incoming.mcpServers !== undefined)
+    ) {
+      const agent = await this.session.ensureAgentResumed('main');
+      agent.tools.patchActiveTools({
+        tools: incoming.tools,
+        mcpPatterns: incoming.mcpServers?.map(mcpServerToolPattern),
+      });
+    }
   }
 
   getSessionMetadata(_payload: EmptyPayload): SessionMeta {

packages/agent-core/test/mcp/tool-naming.test.ts

@@ -1,6 +1,12 @@
+import picomatch from 'picomatch';
 import { describe, expect, it } from 'vitest';
 
-import { isMcpToolName, qualifyMcpToolName, sanitizeMcpNamePart } from '../../src/mcp/tool-naming';
+import {
+  isMcpToolName,
+  mcpServerToolPattern,
+  qualifyMcpToolName,
+  sanitizeMcpNamePart,
+} from '../../src/mcp/tool-naming';
 
 describe('sanitizeMcpNamePart', () => {
   it('passes alphanumeric, underscore, and dash through unchanged', () => {
@@ -62,3 +68,22 @@ describe('isMcpToolName', () => {
     expect(isMcpToolName('mcp_one_underscore__no')).toBe(false);
   });
 });
+
+describe('mcpServerToolPattern', () => {
+  it.each(['My Search', 'files[*]'])('matches qualified tools for server %s', (serverName) => {
+    const pattern = mcpServerToolPattern(serverName);
+    expect(picomatch.isMatch(qualifyMcpToolName(serverName, 'lookup'), pattern)).toBe(true);
+    expect(pattern).not.toContain('[');
+    expect(pattern).not.toContain(']');
+  });
+
+  it('matches qualified tools when the server prefix is truncated', () => {
+    const serverName = 'long server '.repeat(8);
+    expect(
+      picomatch.isMatch(
+        qualifyMcpToolName(serverName, 'lookup'),
+        mcpServerToolPattern(serverName),
+      ),
+    ).toBe(true);
+  });
+});