Preserve isTerminal in Java fluent copies, add Node isTerminal wire tests

Resolves the rebase onto main where both sides added an eighth tool
option: main added metadata and this branch added isTerminal.

- Java ToolDefinition now carries metadata and isTerminal as separate
  record components, keeps the seven- and eight-argument convenience
  constructors, and threads isTerminal through every fluent copy method
  so it is no longer dropped by .metadata()/.defer()/etc.
- Adds ToolDefinition.isTerminal(boolean) so lambda-defined tools can
  set it, matching the other flags.
- Adds the missing Node regression tests asserting isTerminal is
  forwarded on both session.create and session.resume, and omitted when
  unset.
- Applies the repo rust formatter to the new is_terminal test.

Author: examon

java/src/main/java/com/github/copilot/rpc/ToolDefinition.java

@@ -95,8 +95,7 @@ public record ToolDefinition(@JsonProperty("name") String name, @JsonProperty("d
         @JsonProperty("metadata") Map<String, Object> metadata, @JsonProperty("isTerminal") Boolean isTerminal) {
 
     /**
-     * Creates a tool definition without a {@code metadata} bag or terminality
-     * hint.
+     * Creates a tool definition without a {@code metadata} bag or terminality hint.
      * <p>
      * Convenience overload equivalent to the canonical constructor with
      * {@code metadata} and {@code isTerminal} set to {@code null}.
@@ -393,8 +392,8 @@ public ToolDefinition metadata(Map<String, Object> value) {
      * Returns a copy with the {@code isTerminal} flag set.
      *
      * @param value
-     *            {@code true} to end the agent turn after a successful call to
-     *            this tool
+     *            {@code true} to end the agent turn after a successful call to this
+     *            tool
      * @return a new {@code ToolDefinition} with the flag applied
      * @since 1.0.7
      */

nodejs/test/client.test.ts

@@ -714,6 +714,68 @@ describe("CopilotClient", () => {
         expect(createPayload.tools[0].metadata).toBeUndefined();
     });
 
+    it("forwards tool isTerminal in session.create and session.resume", async () => {
+        const client = new CopilotClient();
+        await client.start();
+        onTestFinished(() => client.forceStop());
+
+        const spy = vi
+            .spyOn((client as any).connection!, "sendRequest")
+            .mockImplementation(async (method: string, params: any) => {
+                if (method === "session.create") return { sessionId: params.sessionId };
+                if (method === "session.resume") return { sessionId: params.sessionId };
+                throw new Error(`Unexpected method: ${method}`);
+            });
+
+        const tool = {
+            name: "clear_context",
+            description: "Clears the conversation",
+            parameters: { type: "object", properties: {} },
+            isTerminal: true,
+        };
+
+        const session = await client.createSession({
+            onPermissionRequest: approveAll,
+            tools: [tool],
+        });
+        await client.resumeSession(session.sessionId, {
+            onPermissionRequest: approveAll,
+            tools: [tool],
+        });
+
+        const createPayload = spy.mock.calls.find(
+            ([method]) => method === "session.create"
+        )![1] as any;
+        const resumePayload = spy.mock.calls.find(
+            ([method]) => method === "session.resume"
+        )![1] as any;
+        expect(createPayload.tools[0].isTerminal).toBe(true);
+        expect(resumePayload.tools[0].isTerminal).toBe(true);
+    });
+
+    it("omits tool isTerminal from session.create when unset", async () => {
+        const client = new CopilotClient();
+        await client.start();
+        onTestFinished(() => client.forceStop());
+
+        const spy = vi
+            .spyOn((client as any).connection!, "sendRequest")
+            .mockImplementation(async (method: string, params: any) => {
+                if (method === "session.create") return { sessionId: params.sessionId };
+                throw new Error(`Unexpected method: ${method}`);
+            });
+
+        await client.createSession({
+            onPermissionRequest: approveAll,
+            tools: [{ name: "my_tool", description: "a tool" }],
+        });
+
+        const createPayload = spy.mock.calls.find(
+            ([method]) => method === "session.create"
+        )![1] as any;
+        expect(createPayload.tools[0].isTerminal).toBeUndefined();
+    });
+
     it("forwards new session options in session.create and session.resume", async () => {
         const client = new CopilotClient();
         await client.start();

rust/src/types.rs

@@ -7547,7 +7547,10 @@ mod is_terminal_tests {
             ..Default::default()
         };
         let value = serde_json::to_value(&tool).expect("tool serializes");
-        assert_eq!(value.get("isTerminal"), Some(&serde_json::Value::Bool(true)));
+        assert_eq!(
+            value.get("isTerminal"),
+            Some(&serde_json::Value::Bool(true))
+        );
     }
 
     #[test]