A self-improving RLM agent for coding workflows and long-running autonomous tasks.
Rust
rebind built-in tools to the live extension runner (#299)
ktcc83ff23a3c2
diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.tsindex 40cbde3fd3..8e15397fcb 100644--- a/packages/coding-agent/src/core/agent-session.ts+++ b/packages/coding-agent/src/core/agent-session.ts@@ -3446,6 +3446,8 @@ export class AgentSession {);const runner = this._extensionRunner;const wrappedExtensionTools = wrapRegisteredTools(allCustomTools, runner);+ // Resolve the runner at call time so a rebuild/reload rebinds built-in tools to the+ // live runner instead of wedging them on the invalidated one's stale-ctx guard.const wrappedBuiltInTools = wrapRegisteredTools(Array.from(this._baseToolDefinitions.values()).filter((definition) => isAllowedTool(definition.name))@@ -3453,7 +3455,7 @@ export class AgentSession {definition,sourceInfo: createSyntheticSourceInfo(`<builtin:${definition.name}>`, { source: "builtin" }),})),- runner,+ () => this._extensionRunner,);const toolRegistry = new Map(wrappedBuiltInTools.map((tool) => [tool.name, tool]));diff --git a/packages/coding-agent/src/core/extensions/wrapper.ts b/packages/coding-agent/src/core/extensions/wrapper.tsindex 9b9d281c46..3a852f0e97 100644--- a/packages/coding-agent/src/core/extensions/wrapper.ts+++ b/packages/coding-agent/src/core/extensions/wrapper.ts@@ -10,21 +10,29 @@ import { wrapToolDefinition, wrapToolDefinitions } from "../tools/tool-definitioimport type { ExtensionRunner } from "./runner.js";import type { RegisteredTool } from "./types.js";+type RunnerSource = ExtensionRunner | (() => ExtensionRunner);++function toRunnerGetter(source: RunnerSource): () => ExtensionRunner {+ return typeof source === "function" ? source : () => source;+}+/*** Wrap a RegisteredTool into an AgentTool.* Uses the runner's createContext() for consistent context across tools and event handlers.*/-export function wrapRegisteredTool(registeredTool: RegisteredTool, runner: ExtensionRunner): AgentTool {- return wrapToolDefinition(registeredTool.definition, () => runner.createContext());+export function wrapRegisteredTool(registeredTool: RegisteredTool, runner: RunnerSource): AgentTool {+ const getRunner = toRunnerGetter(runner);+ return wrapToolDefinition(registeredTool.definition, () => getRunner().createContext());}/*** Wrap all registered tools into AgentTools.* Uses the runner's createContext() for consistent context across tools and event handlers.*/-export function wrapRegisteredTools(registeredTools: RegisteredTool[], runner: ExtensionRunner): AgentTool[] {+export function wrapRegisteredTools(registeredTools: RegisteredTool[], runner: RunnerSource): AgentTool[] {+ const getRunner = toRunnerGetter(runner);return wrapToolDefinitions(registeredTools.map((registeredTool) => registeredTool.definition),- () => runner.createContext(),+ () => getRunner().createContext(),);}diff --git a/packages/coding-agent/src/core/tools/ipython.ts b/packages/coding-agent/src/core/tools/ipython.tsindex c47a30ab22..2f63cb96a7 100644--- a/packages/coding-agent/src/core/tools/ipython.ts+++ b/packages/coding-agent/src/core/tools/ipython.ts@@ -375,10 +375,16 @@ export function createIpythonToolDefinition(executionMode: "sequential",parameters: ipythonSchema,execute: async (_toolCallId, params, signal, onUpdate, ctx) => {+ // Cosmetic; ctx.ui can throw on a stale ctx, but must never fail the cell.+ const setWorkingMessage = (message?: string) => {+ try {+ ctx?.ui.setWorkingMessage(message);+ } catch {}+ };let reportedStartupProgress = false;const reportStartupProgress: KernelBootstrapProgressHandler = (message) => {reportedStartupProgress = true;- ctx?.ui.setWorkingMessage(message);+ setWorkingMessage(message);onUpdate?.({content: [{ type: "text", text: message }],details: { status: "starting" },@@ -424,7 +430,7 @@ export function createIpythonToolDefinition(};} finally {if (reportedStartupProgress) {- ctx?.ui.setWorkingMessage();+ setWorkingMessage();}}},diff --git a/packages/coding-agent/test/extension-tool-wrapper-rebind.test.ts b/packages/coding-agent/test/extension-tool-wrapper-rebind.test.tsnew file mode 100644index 0000000000..e074ddea40--- /dev/null+++ b/packages/coding-agent/test/extension-tool-wrapper-rebind.test.ts@@ -0,0 +1,65 @@+import { describe, expect, it } from "vitest";+import type { ExtensionRunner } from "../src/core/extensions/runner.js";+import type { RegisteredTool } from "../src/core/extensions/types.js";+import { wrapRegisteredTools } from "../src/core/extensions/wrapper.js";++const STALE = "This extension ctx is stale after session replacement or reload.";++// Minimal stand-in for a runner whose createContext() throws once invalidated,+// mirroring assertActive() on the real ExtensionRunner's guarded ctx getters.+function makeRunner(id: string): ExtensionRunner & { invalidate(): void } {+ let stale = false;+ return {+ createContext() {+ if (stale) throw new Error(STALE);+ return { id } as unknown as ReturnType<ExtensionRunner["createContext"]>;+ },+ invalidate() {+ stale = true;+ },+ } as unknown as ExtensionRunner & { invalidate(): void };+}++function toolThatReturnsCtxId(): RegisteredTool {+ return {+ definition: {+ name: "probe",+ label: "probe",+ description: "returns the ctx id",+ parameters: { type: "object", properties: {} } as never,+ execute: async (_id: string, _params: unknown, _signal: AbortSignal, _onUpdate: unknown, ctx: unknown) => ({+ content: [{ type: "text", text: (ctx as { id: string }).id }],+ }),+ },+ sourceInfo: { source: "builtin" },+ } as unknown as RegisteredTool;+}++describe("wrapRegisteredTools runner rebinding", () => {+ it("resolves the current runner at execute time when given a getter", async () => {+ let runner = makeRunner("first");+ const [tool] = wrapRegisteredTools([toolThatReturnsCtxId()], () => runner);++ const first = await tool.execute("c1", {}, new AbortController().signal);+ expect((first.content[0] as { text: string }).text).toBe("first");++ // Session rebuild: old runner invalidated, a fresh one takes its place.+ runner.invalidate();+ runner = makeRunner("second");++ const second = await tool.execute("c2", {}, new AbortController().signal);+ expect((second.content[0] as { text: string }).text).toBe("second");+ });++ it("stays wedged on a stale runner when bound to a fixed instance (old behavior)", async () => {+ const runner = makeRunner("only");+ const [tool] = wrapRegisteredTools([toolThatReturnsCtxId()], runner);++ await expect(tool.execute("c1", {}, new AbortController().signal)).resolves.toBeTruthy();++ runner.invalidate();+ // The ctx is resolved synchronously as an execute() argument, so a stale runner+ // throws at call time rather than rejecting.+ expect(() => tool.execute("c2", {}, new AbortController().signal)).toThrow(STALE);+ });+});