Merge commit '3731ebd26e23d84d9188658d0b42e848f62789bf' into batch25-pr-1926

# Conflicts:
#	packages/hosts/cloudflare/src/mcp/agent-session-durable-object.ts

Author: RhysSullivan

.changeset/computer-use-remembered-approvals.md

@@ -0,0 +1,14 @@
+---
+"@executor-js/sdk": patch
+"@executor-js/execution": patch
+"@executor-js/plugin-mcp": patch
+"@executor-js/api": patch
+"@executor-js/react": patch
+"@executor-js/host-mcp": patch
+"@executor-js/cloudflare": patch
+"executor": patch
+---
+
+Carry an approval's persistence choice through elicitation, so Codex Computer Use stops asking to use the same app on every call.
+
+Computer Use offers `persist: ["session", "always"]` in the prompt's terms and remembers the app only when the answer names one. Executor dropped the offer on the way in (the terms projection kept strings only) and the choice on the way out (every adapter rebuilt the reply from `action` and `content`), so each accept was one-time. `ElicitationResponse` now has `meta.persist`; the MCP plugin, the app-server bridge, and the MCP host pass it through; the model-mode `resume` tool and the browser approval page let the approver pick from the offered scopes. Nothing is chosen automatically: a bare accept still approves once.

.changeset/mcp-elicitation-active-deadline.md

@@ -0,0 +1,5 @@
+---
+"@executor-js/plugin-mcp": patch
+---
+
+Exclude time spent waiting for elicitation from the MCP tool invocation deadline.

apps/cloud/src/auth/api.ts

@@ -115,6 +115,7 @@ const McpSessionExecutionParams = {
 const ResumeMcpExecutionBody = Schema.Struct({
   action: Schema.Literals(["accept", "decline", "cancel"]),
   content: Schema.optional(Schema.Unknown),
+  persist: Schema.optional(Schema.String),
 });
 
 const McpPausedExecutionResponse = Schema.Struct({

apps/cloud/src/auth/handlers.ts

@@ -704,6 +704,9 @@ export const CloudSessionAuthHandlers = HttpApiBuilder.group(
               {
                 action: payload.action,
                 content: payload.content as Record<string, unknown> | undefined,
+                ...(payload.action === "accept" && payload.persist !== undefined
+                  ? { meta: { persist: payload.persist } }
+                  : {}),
               },
             ),
           );

apps/cloud/src/mcp/session-build-semaphore.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, beforeEach } from "@effect/vitest";
+import { describe, expect, it, beforeEach, afterEach, vi } from "@effect/vitest";
 
 import {
   acquireBuildSlot,
@@ -13,6 +13,10 @@ describe("session-build-semaphore", () => {
     resetBuildSlotsForTest();
   });
 
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
   it("grants up to the cap immediately, with no wait", async () => {
     const results = await Promise.all([
       acquireBuildSlot().promise,
@@ -214,6 +218,7 @@ describe("session-build-semaphore", () => {
   });
 
   it("proceeds without a slot when the queue wait exceeds the timeout, and does not count it as active", async () => {
+    vi.useFakeTimers();
     await Promise.all([
       acquireBuildSlot().promise,
       acquireBuildSlot().promise,
@@ -223,6 +228,10 @@ describe("session-build-semaphore", () => {
     expect(currentActiveBuildsForTest()).toBe(4);
 
     const timedOutHandle = acquireBuildSlot(10);
+    await vi.advanceTimersByTimeAsync(9);
+    expect(currentQueueLengthForTest()).toBe(1);
+    expect(currentActiveBuildsForTest()).toBe(4);
+    await vi.advanceTimersByTimeAsync(1);
     const result = await timedOutHandle.promise;
 
     expect(result).toEqual({ acquired: false, waitMs: expect.any(Number), timedOut: true });

apps/cloud/src/routes/app/resume.$executionId.tsx

@@ -37,13 +37,17 @@ function CloudMcpResumeApproval(props: { executionId: string; mcpSessionId: stri
       executionId: string,
       action: "accept" | "decline" | "cancel",
       content?: Record<string, unknown>,
+      persist?: string,
     ) =>
       doResume({
         params: {
           mcpSessionId: props.mcpSessionId,
           executionId,
         },
-        payload: action === "accept" ? { action, content: content ?? {} } : { action },
+        payload:
+          action === "accept"
+            ? { action, content: content ?? {}, ...(persist === undefined ? {} : { persist }) }
+            : { action },
       }),
     [doResume, props.mcpSessionId],
   );

e2e/scenarios/mcp-approval-persistence.test.ts

@@ -0,0 +1,80 @@
+import { randomBytes } from "node:crypto";
+import { expect } from "@effect/vitest";
+import { Effect } from "effect";
+import { composePluginApi } from "@executor-js/api/server";
+import { mcpHttpPlugin } from "@executor-js/plugin-mcp/api";
+import { makeElicitationMcpServer, serveMcpServer } from "@executor-js/plugin-mcp/testing";
+import { AuthTemplateSlug, ConnectionName, IntegrationSlug } from "@executor-js/sdk/shared";
+
+import { scenario } from "../src/scenario";
+import { Api, Browser, Mcp, Target } from "../src/services";
+import { parseBrowserApproval } from "../src/surfaces/mcp";
+import { visit } from "../src/surfaces/browser";
+
+const api = composePluginApi([mcpHttpPlugin()] as const);
+
+scenario(
+  "MCP · browser approval preserves the chosen lifetime and defaults to once",
+  { timeout: 180_000 },
+  Effect.scoped(
+    Effect.gen(function* () {
+      const target = yield* Target;
+      const browser = yield* Browser;
+      const mcp = yield* Mcp;
+      const { client: makeClient } = yield* Api;
+      const identity = yield* target.newIdentity();
+      const client = yield* makeClient(api, identity);
+      const slug = IntegrationSlug.make(`approval_terms_${randomBytes(4).toString("hex")}`);
+      const server = yield* serveMcpServer(makeElicitationMcpServer);
+      yield* client.mcp.addServer({
+        payload: {
+          transport: "remote",
+          name: "Approval terms",
+          endpoint: server.url,
+          slug,
+          remoteTransport: "streamable-http",
+        },
+      });
+      yield* Effect.gen(function* () {
+        yield* client.connections.create({
+          payload: {
+            owner: "org",
+            name: ConnectionName.make("main"),
+            integration: slug,
+            template: AuthTemplateSlug.make("none"),
+            value: "",
+          },
+        });
+        const session = mcp.session(identity, { elicitationMode: "browser" });
+        yield* session.listTools();
+        for (const scope of ["session", "always", ""] as const) {
+          const paused = yield* session.call("execute", {
+            code: `return await tools.${slug}.org.main.remembered_echo({value:"browser"});`,
+          });
+          const approval = parseBrowserApproval(paused);
+          const [resumed] = yield* Effect.all(
+            [
+              session.awaitResume(approval.executionId),
+              browser.session(identity, async ({ page, step }) => {
+                await step(`Approve ${scope || "once"} through the console`, async () => {
+                  await visit(page, approval.approvalUrl);
+                  const choice = page.getByLabel("Remember this approval");
+                  await choice.waitFor();
+                  expect(await choice.inputValue(), "every approval starts as one-time").toBe("");
+                  if (scope !== "") await choice.selectOption(scope);
+                  await page.getByRole("button", { name: "Approve", exact: true }).click();
+                  await page.getByText("Approve sent").waitFor();
+                });
+              }),
+            ],
+            { concurrency: "unbounded" },
+          );
+          expect(resumed.ok).toBe(true);
+          expect(resumed.text, "the chosen lifetime reaches the upstream MCP server").toContain(
+            `approved:browser:${scope || "once"}`,
+          );
+        }
+      }).pipe(Effect.ensuring(client.mcp.removeServer({ params: { slug } }).pipe(Effect.orDie)));
+    }),
+  ),
+);

e2e/selfhost/mcp-elicitation-deadline.test.ts

@@ -0,0 +1,86 @@
+import { randomBytes } from "node:crypto";
+import { expect } from "@effect/vitest";
+import { Effect, Schema } from "effect";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { composePluginApi } from "@executor-js/api/server";
+import { mcpHttpPlugin } from "@executor-js/plugin-mcp/api";
+import { serveMcpServer } from "@executor-js/plugin-mcp/testing";
+import { AuthTemplateSlug, ConnectionName, IntegrationSlug } from "@executor-js/sdk/shared";
+
+import { scenario } from "../src/scenario";
+import { Api, Mcp, Target } from "../src/services";
+
+const api = composePluginApi([mcpHttpPlugin()] as const);
+const decodeExecutionId = Schema.decodeUnknownSync(Schema.String);
+
+scenario(
+  "MCP · delayed approval preserves the chosen lifetime beyond the active-work deadline",
+  { timeout: 180_000 },
+  Effect.scoped(
+    Effect.gen(function* () {
+      const target = yield* Target;
+      const mcp = yield* Mcp;
+      const { client: makeClient } = yield* Api;
+      const identity = yield* target.newIdentity();
+      const client = yield* makeClient(api, identity);
+      const slug = IntegrationSlug.make(`deadline_${randomBytes(4).toString("hex")}`);
+      const server = yield* serveMcpServer(() => {
+        const upstream = new McpServer({ name: "Human approval", version: "1" });
+        upstream.registerTool("approve", { inputSchema: {} }, async () => {
+          const reply = await upstream.server.elicitInput(
+            {
+              mode: "form",
+              message: "Approve the delayed call?",
+              requestedSchema: { type: "object", properties: {} },
+              _meta: { persist: ["session", "always"] },
+            },
+            { timeout: 150_000 },
+          );
+          return {
+            content: [
+              { type: "text", text: `decision:${reply.action}:${reply._meta?.persist ?? "once"}` },
+            ],
+          };
+        });
+        return upstream;
+      });
+      yield* client.mcp.addServer({
+        payload: {
+          transport: "remote",
+          name: "Human approval",
+          endpoint: server.url,
+          slug,
+          remoteTransport: "streamable-http",
+        },
+      });
+      yield* Effect.gen(function* () {
+        yield* client.connections.create({
+          payload: {
+            owner: "org",
+            name: ConnectionName.make("main"),
+            integration: slug,
+            template: AuthTemplateSlug.make("none"),
+            value: "",
+          },
+        });
+        const session = mcp.session(identity, { elicitationMode: "model" });
+        yield* session.listTools();
+        const paused = yield* session.call("execute", {
+          code: `return await tools.${slug}.org.main.approve({});`,
+        });
+        expect(paused.text).toContain("executionId:");
+        // Cross the production 60-second active-work deadline. This is the
+        // behavior under test: a human waiting must consume none of that budget.
+        yield* Effect.sleep("65 seconds");
+        const executionId = decodeExecutionId(/\bexecutionId:\s*(\S+)/.exec(paused.text)?.[1]);
+        const completed = yield* session.call("resume", {
+          executionId,
+          action: "accept",
+          persist: "session",
+        });
+        expect(completed.ok).toBe(true);
+        expect(completed.text).toContain("decision:accept:session");
+      }).pipe(Effect.ensuring(client.mcp.removeServer({ params: { slug } }).pipe(Effect.orDie)));
+    }),
+  ),
+);

e2e/vitest.config.ts

@@ -48,6 +48,7 @@ export default defineConfig({
       project("cloudflare", {
         include: [
           "scenarios/browser-approval.test.ts",
+          "scenarios/mcp-approval-persistence.test.ts",
           "scenarios/microsoft-graph-full.test.ts",
           "scenarios/toolkits-mcp.test.ts",
           "cloudflare/**/*.test.ts",

packages/core/api/src/executions/api.ts

@@ -44,6 +44,10 @@ const ExecuteResponse = Schema.Union([CompletedResult, PausedResult]);
 const ResumeRequest = Schema.Struct({
   action: Schema.Literals(["accept", "decline", "cancel"]),
   content: Schema.optional(Schema.Unknown),
+  /** How long an accepted approval lasts, when the paused interaction's
+   *  terms offer a choice (`interaction.meta.persist` lists the scopes).
+   *  Omitted, the approval is for this call only. */
+  persist: Schema.optional(Schema.String),
 });
 
 const ResumeResponse = Schema.Union([CompletedResult, PausedResult]);