Skip to content

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.ts
index 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.ts
index 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-definitio
import 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.ts
index 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.ts
new file mode 100644
index 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);
+ });
+});