Add unstable model selection to the TS SDK (#126)

* Remove unneeded casts

Signed-off-by: Ben Brandt <benjamin.j.brandt@gmail.com>

* Add unstable model selection to TS SDK

Signed-off-by: Ben Brandt <benjamin.j.brandt@gmail.com>

* Add missing method on client connection

* prep release

---------

Signed-off-by: Ben Brandt <benjamin.j.brandt@gmail.com>

Author: benbrandt

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.4.5 (2025-10-02)
+
+### Protocol
+
+- No changes
+
+### Typescript
+
+- **Unstable** initial support for model selection.
+
 ## 0.4.4 (2025-09-30)
 
 ### Protocol

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "agent-client-protocol"
 authors = ["Zed <hi@zed.dev>"]
-version = "0.4.4"
+version = "0.4.5"
 edition = "2024"
 license = "Apache-2.0"
 description = "A protocol for standardizing communication between code editors and AI coding agents"

Cargo.toml

@@ -1,6 +1,6 @@
 {
   "name": "@zed-industries/agent-client-protocol",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "publishConfig": {
     "access": "public"
   },

package-lock.json

@@ -820,7 +820,7 @@ pub struct AgentMethodNames {
     pub session_cancel: &'static str,
     /// Method for selecting a model for a given session.
     #[cfg(feature = "unstable")]
-    pub model_select: &'static str,
+    pub session_set_model: &'static str,
 }
 
 /// Constant containing all agent method names.
@@ -833,7 +833,7 @@ pub const AGENT_METHOD_NAMES: AgentMethodNames = AgentMethodNames {
     session_prompt: SESSION_PROMPT_METHOD_NAME,
     session_cancel: SESSION_CANCEL_METHOD_NAME,
     #[cfg(feature = "unstable")]
-    model_select: SESSION_SET_MODEL_METHOD_NAME,
+    session_set_model: SESSION_SET_MODEL_METHOD_NAME,
 };
 
 /// Method name for the initialize request.

package.json

@@ -2,12 +2,12 @@
   "agentMethods": {
     "authenticate": "authenticate",
     "initialize": "initialize",
-    "model_select": "session/set_model",
     "session_cancel": "session/cancel",
     "session_load": "session/load",
     "session_new": "session/new",
     "session_prompt": "session/prompt",
-    "session_set_mode": "session/set_mode"
+    "session_set_mode": "session/set_mode",
+    "session_set_model": "session/set_model"
   },
   "clientMethods": {
     "fs_read_text_file": "fs/read_text_file",

rust/agent.rs

@@ -49,43 +49,45 @@ export class AgentSideConnection {
       switch (method) {
         case schema.AGENT_METHODS.initialize: {
           const validatedParams = schema.initializeRequestSchema.parse(params);
-          return agent.initialize(validatedParams as schema.InitializeRequest);
+          return agent.initialize(validatedParams);
         }
         case schema.AGENT_METHODS.session_new: {
           const validatedParams = schema.newSessionRequestSchema.parse(params);
-          return agent.newSession(validatedParams as schema.NewSessionRequest);
+          return agent.newSession(validatedParams);
         }
         case schema.AGENT_METHODS.session_load: {
           if (!agent.loadSession) {
             throw RequestError.methodNotFound(method);
           }
           const validatedParams = schema.loadSessionRequestSchema.parse(params);
-          return agent.loadSession(
-            validatedParams as schema.LoadSessionRequest,
-          );
+          return agent.loadSession(validatedParams);
         }
         case schema.AGENT_METHODS.session_set_mode: {
           if (!agent.setSessionMode) {
             throw RequestError.methodNotFound(method);
           }
           const validatedParams =
             schema.setSessionModeRequestSchema.parse(params);
-          const result = await agent.setSessionMode(
-            validatedParams as schema.SetSessionModeRequest,
-          );
+          const result = await agent.setSessionMode(validatedParams);
           return result ?? {};
         }
         case schema.AGENT_METHODS.authenticate: {
           const validatedParams =
             schema.authenticateRequestSchema.parse(params);
-          const result = await agent.authenticate(
-            validatedParams as schema.AuthenticateRequest,
-          );
+          const result = await agent.authenticate(validatedParams);
           return result ?? {};
         }
         case schema.AGENT_METHODS.session_prompt: {
           const validatedParams = schema.promptRequestSchema.parse(params);
-          return agent.prompt(validatedParams as schema.PromptRequest);
+          return agent.prompt(validatedParams);
+        }
+        case schema.AGENT_METHODS.session_set_model: {
+          if (!agent.setSessionModel) {
+            throw RequestError.methodNotFound(method);
+          }
+          const validatedParams =
+            schema.setSessionModelRequestSchema.parse(params);
+          return agent.setSessionModel(validatedParams);
         }
         default:
           if (method.startsWith("_")) {
@@ -108,7 +110,7 @@ export class AgentSideConnection {
       switch (method) {
         case schema.AGENT_METHODS.session_cancel: {
           const validatedParams = schema.cancelNotificationSchema.parse(params);
-          return agent.cancel(validatedParams as schema.CancelNotification);
+          return agent.cancel(validatedParams);
         }
         default:
           if (method.startsWith("_")) {
@@ -223,10 +225,10 @@ export class AgentSideConnection {
   async createTerminal(
     params: schema.CreateTerminalRequest,
   ): Promise<TerminalHandle> {
-    const response = (await this.#connection.sendRequest(
-      schema.CLIENT_METHODS.terminal_create,
-      params,
-    )) as schema.CreateTerminalResponse;
+    const response = await this.#connection.sendRequest<
+      schema.CreateTerminalRequest,
+      schema.CreateTerminalResponse
+    >(schema.CLIENT_METHODS.terminal_create, params);
 
     return new TerminalHandle(
       response.terminalId,
@@ -399,59 +401,43 @@ export class ClientSideConnection implements Agent {
         case schema.CLIENT_METHODS.fs_write_text_file: {
           const validatedParams =
             schema.writeTextFileRequestSchema.parse(params);
-          return client.writeTextFile?.(
-            validatedParams as schema.WriteTextFileRequest,
-          );
+          return client.writeTextFile?.(validatedParams);
         }
         case schema.CLIENT_METHODS.fs_read_text_file: {
           const validatedParams =
             schema.readTextFileRequestSchema.parse(params);
-          return client.readTextFile?.(
-            validatedParams as schema.ReadTextFileRequest,
-          );
+          return client.readTextFile?.(validatedParams);
         }
         case schema.CLIENT_METHODS.session_request_permission: {
           const validatedParams =
             schema.requestPermissionRequestSchema.parse(params);
-          return client.requestPermission(
-            validatedParams as schema.RequestPermissionRequest,
-          );
+          return client.requestPermission(validatedParams);
         }
         case schema.CLIENT_METHODS.terminal_create: {
           const validatedParams =
             schema.createTerminalRequestSchema.parse(params);
-          return client.createTerminal?.(
-            validatedParams as schema.CreateTerminalRequest,
-          );
+          return client.createTerminal?.(validatedParams);
         }
         case schema.CLIENT_METHODS.terminal_output: {
           const validatedParams =
             schema.terminalOutputRequestSchema.parse(params);
-          return client.terminalOutput?.(
-            validatedParams as schema.TerminalOutputRequest,
-          );
+          return client.terminalOutput?.(validatedParams);
         }
         case schema.CLIENT_METHODS.terminal_release: {
           const validatedParams =
             schema.releaseTerminalRequestSchema.parse(params);
-          const result = await client.releaseTerminal?.(
-            validatedParams as schema.ReleaseTerminalRequest,
-          );
+          const result = await client.releaseTerminal?.(validatedParams);
           return result ?? {};
         }
         case schema.CLIENT_METHODS.terminal_wait_for_exit: {
           const validatedParams =
             schema.waitForTerminalExitRequestSchema.parse(params);
-          return client.waitForTerminalExit?.(
-            validatedParams as schema.WaitForTerminalExitRequest,
-          );
+          return client.waitForTerminalExit?.(validatedParams);
         }
         case schema.CLIENT_METHODS.terminal_kill: {
           const validatedParams =
             schema.killTerminalCommandRequestSchema.parse(params);
-          const result = await client.killTerminal?.(
-            validatedParams as schema.KillTerminalCommandRequest,
-          );
+          const result = await client.killTerminal?.(validatedParams);
           return result ?? {};
         }
         default:
@@ -478,9 +464,7 @@ export class ClientSideConnection implements Agent {
         case schema.CLIENT_METHODS.session_update: {
           const validatedParams =
             schema.sessionNotificationSchema.parse(params);
-          return client.sessionUpdate(
-            validatedParams as schema.SessionNotification,
-          );
+          return client.sessionUpdate(validatedParams);
         }
         default:
           // Handle extension notifications (any method starting with '_')
@@ -598,6 +582,24 @@ export class ClientSideConnection implements Agent {
     );
   }
 
+  /**
+   * **UNSTABLE**
+   *
+   * This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Select a model for a given session.
+   */
+  async setSessionModel(
+    params: schema.SetSessionModelRequest,
+  ): Promise<schema.SetSessionModelResponse> {
+    return (
+      (await this.#connection.sendRequest(
+        schema.AGENT_METHODS.session_set_mode,
+        params,
+      )) ?? {}
+    );
+  }
+
   /**
    * Authenticates the client using the specified authentication method.
    *
@@ -771,7 +773,7 @@ class Connection {
       }
     } else if ("id" in message) {
       // It's a response
-      this.#handleResponse(message as AnyResponse);
+      this.#handleResponse(message);
     } else {
       console.error("Invalid message", { message });
     }
@@ -1215,6 +1217,16 @@ export interface Agent {
   setSessionMode?(
     params: schema.SetSessionModeRequest,
   ): Promise<schema.SetSessionModeResponse | void>;
+  /**
+   * **UNSTABLE**
+   *
+   * This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Select a model for a given session.
+   */
+  setSessionModel?(
+    params: schema.SetSessionModelRequest,
+  ): Promise<schema.SetSessionModelResponse | void>;
   /**
    * Authenticates the client using the specified authentication method.
    *

schema/meta.json

@@ -267,7 +267,7 @@ class ExampleAgent implements acp.Agent {
   }
 }
 
-const input = Writable.toWeb(process.stdout) as WritableStream;
+const input = Writable.toWeb(process.stdout);
 const output = Readable.toWeb(process.stdin) as ReadableStream<Uint8Array>;
 
 const stream = acp.ndJsonStream(input, output);

typescript/acp.ts

@@ -106,7 +106,7 @@ async function main() {
   });
 
   // Create streams to communicate with the agent
-  const input = Writable.toWeb(agentProcess.stdin!) as WritableStream;
+  const input = Writable.toWeb(agentProcess.stdin!);
   const output = Readable.toWeb(
     agentProcess.stdout!,
   ) as ReadableStream<Uint8Array>;