support structured agent questions via ACP forms

package.json

@@ -48,9 +48,10 @@
   },
   "dependencies": {
     "@aaif/goose-sdk": "workspace:*",
-    "@agentclientprotocol/sdk": "^0.19.0",
+    "@agentclientprotocol/sdk": "^1.3.0",
     "@daypicker/react": "^10.0.1",
     "@mcp-ui/client": "7.1.1",
+    "@noble/hashes": "2.3.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/api-logs": "0.221.0",
     "@opentelemetry/core": "2.10.0",

scripts/check-i18n-strings.mjs

@@ -7,6 +7,7 @@ const CHECKED_PATHS = [
   "src/features/agents",
   "src/features/automations",
   "src/features/chat/ui",
+  "src/features/elicitation",
   "src/features/experiments",
   "src/features/home",
   "src/features/projects",

sdk/README.md

@@ -135,3 +135,20 @@ const result = await client.someMethod({ ... });
 ```
 
 See the [main documentation](../../README.md) for more details.
+
+## Upgrading to `@agentclientprotocol/sdk` 1.x
+
+`GooseClient` is built on the 1.x client app builder. Two exports changed, both
+because the upstream SDK changed, not by choice here:
+
+- **`unstable_setSessionModel` is gone.** ACP 1.x no longer defines the method,
+  so there is nothing to call. Set the model through
+  `setSessionConfigOption` instead.
+- **`ClientSideConnection` is now `ClientConnection`, and is exported as a type
+  only.** The 1.x builder owns connection construction, so there is no runtime
+  class to re-export. Build a connection with `new GooseClient(...)`.
+
+`GooseClientCallbacks` still covers the whole ACP `Client` surface. Only
+`requestPermission` and `sessionUpdate` are required; every other member is
+optional and is registered when you supply it, so implementing a capability is
+enough to start receiving it.

sdk/package.json

@@ -45,10 +45,10 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@agentclientprotocol/sdk": "^0.19.0"
+    "@agentclientprotocol/sdk": "^1.3.0"
   },
   "devDependencies": {
-    "@agentclientprotocol/sdk": "^0.19.0",
+    "@agentclientprotocol/sdk": "^1.3.0",
     "@hey-api/openapi-ts": "^0.99.0",
     "@types/node": "^26.2.0",
     "prettier": "^3.9.6",

sdk/src/goose-client.ts

@@ -1,6 +1,8 @@
 import {
-  ClientSideConnection,
+  client,
+  methods,
   type Client,
+  type ClientConnection,
   type Stream,
   type InitializeRequest,
   type InitializeResponse,
@@ -23,23 +25,161 @@ import {
   type ListSessionsResponse,
   type ResumeSessionRequest,
   type ResumeSessionResponse,
-  type SetSessionModelRequest,
-  type SetSessionModelResponse,
+  type CreateElicitationRequest,
+  type CreateElicitationResponse,
+  type MaybePromise,
 } from "@agentclientprotocol/sdk";
+import { z } from "zod";
 import { GooseExtClient } from "./generated/client.gen.js";
 import { createHttpStream } from "./http-stream.js";
 
+export type GooseClientCallbacks = Omit<
+  Client,
+  "extMethod" | "extNotification" | "unstable_createElicitation"
+> & {
+  unstable_createElicitation?: (
+    params: CreateElicitationRequest,
+    signal: AbortSignal,
+    /** JSON-RPC id of this request, for correlating concurrent questions. */
+    requestId?: string | number,
+  ) => Promise<CreateElicitationResponse>;
+  extensionRequests?: Record<
+    string,
+    (
+      params: Record<string, unknown>,
+      signal: AbortSignal,
+      requestId?: string | number,
+    ) => MaybePromise<Record<string, unknown>>
+  >;
+  extensionNotifications?: Record<
+    string,
+    (params: Record<string, unknown>) => MaybePromise<void>
+  >;
+};
+
+const extensionParamsSchema = z.record(z.string(), z.unknown());
+
 export class GooseClient {
-  private conn: ClientSideConnection;
+  private conn: ClientConnection;
   private ext: GooseExtClient;
 
-  constructor(toClient: () => Client, streamOrUrl: Stream | string) {
+  constructor(
+    toClient: () => GooseClientCallbacks,
+    streamOrUrl: Stream | string,
+  ) {
     const stream =
       typeof streamOrUrl === "string"
         ? createHttpStream(streamOrUrl)
         : streamOrUrl;
-    this.conn = new ClientSideConnection(toClient, stream);
-    this.ext = new GooseExtClient(this.conn);
+    const callbacks = toClient();
+    let app = client({ name: "berd" })
+      .onRequest(methods.client.session.requestPermission, ({ params }) =>
+        callbacks.requestPermission(params),
+      )
+      .onNotification(methods.client.session.update, ({ params }) =>
+        callbacks.sessionUpdate(params),
+      );
+    const createElicitation = callbacks.unstable_createElicitation;
+    if (createElicitation) {
+      app = app.onRequest(
+        methods.client.elicitation.create,
+        ({ params, signal, requestId }) =>
+          createElicitation(
+            params,
+            signal,
+            typeof requestId === "string" || typeof requestId === "number"
+              ? requestId
+              : undefined,
+          ),
+      );
+    }
+    // Every other Client method is optional, so register exactly the ones the
+    // consumer supplied. Without this a caller can implement a capability, see
+    // it type-check, and never be called.
+    const { readTextFile, writeTextFile } = callbacks;
+    if (readTextFile) {
+      app = app.onRequest(methods.client.fs.readTextFile, ({ params }) =>
+        readTextFile(params),
+      );
+    }
+    if (writeTextFile) {
+      app = app.onRequest(
+        methods.client.fs.writeTextFile,
+        async ({ params }) => (await writeTextFile(params)) ?? {},
+      );
+    }
+    const {
+      createTerminal,
+      terminalOutput,
+      releaseTerminal,
+      waitForTerminalExit,
+      killTerminal,
+      unstable_completeElicitation: completeElicitation,
+    } = callbacks;
+    if (createTerminal) {
+      app = app.onRequest(methods.client.terminal.create, ({ params }) =>
+        createTerminal(params),
+      );
+    }
+    if (terminalOutput) {
+      app = app.onRequest(methods.client.terminal.output, ({ params }) =>
+        terminalOutput(params),
+      );
+    }
+    if (releaseTerminal) {
+      app = app.onRequest(
+        methods.client.terminal.release,
+        async ({ params }) => (await releaseTerminal(params)) ?? {},
+      );
+    }
+    if (waitForTerminalExit) {
+      app = app.onRequest(methods.client.terminal.waitForExit, ({ params }) =>
+        waitForTerminalExit(params),
+      );
+    }
+    if (killTerminal) {
+      app = app.onRequest(
+        methods.client.terminal.kill,
+        async ({ params }) => (await killTerminal(params)) ?? {},
+      );
+    }
+    if (completeElicitation) {
+      app = app.onNotification(
+        methods.client.elicitation.complete,
+        ({ params }) => completeElicitation(params),
+      );
+    }
+    for (const [method, handler] of Object.entries(
+      callbacks.extensionRequests ?? {},
+    )) {
+      app = app.onRequest(
+        method,
+        extensionParamsSchema,
+        ({ params, signal, requestId }) =>
+          handler(
+            params,
+            signal,
+            typeof requestId === "string" || typeof requestId === "number"
+              ? requestId
+              : undefined,
+          ),
+      );
+    }
+    for (const [method, handler] of Object.entries(
+      callbacks.extensionNotifications ?? {},
+    )) {
+      app = app.onNotification(method, extensionParamsSchema, ({ params }) =>
+        handler(params),
+      );
+    }
+    this.conn = app.connect(stream);
+    this.ext = new GooseExtClient({
+      extMethod: (method, params) =>
+        this.conn.agent.request<
+          Record<string, unknown>,
+          Record<string, unknown>
+        >(method, params),
+    });
   }
 
   get signal(): AbortSignal {
@@ -51,68 +191,68 @@ export class GooseClient {
   }
 
   initialize(params: InitializeRequest): Promise<InitializeResponse> {
-    return this.conn.initialize(params);
+    return this.conn.agent.request(methods.agent.initialize, params);
   }
 
   newSession(params: NewSessionRequest): Promise<NewSessionResponse> {
-    return this.conn.newSession(params);
+    return this.conn.agent.request(methods.agent.session.new, params);
   }
 
   loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse> {
-    return this.conn.loadSession(params);
+    return this.conn.agent.request(methods.agent.session.load, params);
   }
 
   prompt(params: PromptRequest): Promise<PromptResponse> {
-    return this.conn.prompt(params);
+    return this.conn.agent.request(methods.agent.session.prompt, params);
   }
 
   cancel(params: CancelNotification): Promise<void> {
-    return this.conn.cancel(params);
+    return this.conn.agent.notify(methods.agent.session.cancel, params);
   }
 
   authenticate(params: AuthenticateRequest): Promise<AuthenticateResponse> {
-    return this.conn.authenticate(params);
+    return this.conn.agent.request(methods.agent.authenticate, params);
   }
 
   setSessionMode(
     params: SetSessionModeRequest,
   ): Promise<SetSessionModeResponse> {
-    return this.conn.setSessionMode(params);
+    return this.conn.agent.request(methods.agent.session.setMode, params);
   }
 
   setSessionConfigOption(
     params: SetSessionConfigOptionRequest,
   ): Promise<SetSessionConfigOptionResponse> {
-    return this.conn.setSessionConfigOption(params);
+    return this.conn.agent.request(
+      methods.agent.session.setConfigOption,
+      params,
+    );
   }
 
   unstable_forkSession(
     params: ForkSessionRequest,
   ): Promise<ForkSessionResponse> {
-    return this.conn.unstable_forkSession(params);
+    return this.conn.agent.request(methods.agent.session.fork, params);
   }
 
   listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse> {
-    return this.conn.listSessions(params);
+    return this.conn.agent.request(methods.agent.session.list, params);
   }
 
   unstable_resumeSession(
     params: ResumeSessionRequest,
   ): Promise<ResumeSessionResponse> {
-    return this.conn.unstable_resumeSession(params);
-  }
-
-  unstable_setSessionModel(
-    params: SetSessionModelRequest,
-  ): Promise<SetSessionModelResponse> {
-    return this.conn.unstable_setSessionModel(params);
+    return this.conn.agent.request(methods.agent.session.resume, params);
   }
 
   extMethod(
     method: string,
     params: Record<string, unknown>,
   ): Promise<Record<string, unknown>> {
-    return this.conn.extMethod(method, params);
+    return this.conn.agent.request<
+      Record<string, unknown>,
+      Record<string, unknown>
+    >(method, params);
   }
 
   get goose(): GooseExtClient {