feat(web-shell): let the creator send later Turns to a bound Session

The server now admits later Turns from a Workspace-bound Session's creator, but the Managed panel still hid the composer for every bound Session and the Java provider forced canSend to false. - WebShellSessionCapabilities gains workspaceTurns, computed per Session and caller with the same rule the submit path enforces (opt-in on, caller can read, caller created the Session). The contract and the generated WebShell types describe it. - The Java provider sends for a bound Session only when the service reports workspaceTurns, and reports it in the summary only when true. - The Managed panel shows the composer for such a Session; cancel stays hidden for bound Sessions. - HostedPublicWorkspaceIT checks the capability per caller through the WebShell route; the contract test's WebShell capability shape and provider/page tests cover the client.
yiliang114 · Oct 8, 2026 · Sep 30, 2026 · Sep 30, 2026 · Sep 30, 2026 · Sep 30, 2026
commit 1dc0d0c3307aed0e2e26d1c37ba64c43746f3290
diff --git a/.../managed-agent-server/src/main/java/com/alibaba/qwen/code/managedagent/api/ApiModels.java b/.../managed-agent-server/src/main/java/com/alibaba/qwen/code/managedagent/api/ApiModels.java
@@ -73,7 +73,8 @@ public record SessionCapabilities(boolean items, boolean snapshots,
             boolean tasks) {
     }
 
-    public record WebShellSessionCapabilities(boolean tasks) {
+    public record WebShellSessionCapabilities(boolean tasks,
+            boolean workspaceTurns) {
     }
 
     @JsonInclude(JsonInclude.Include.NON_NULL)

diff --git a/...-server/src/main/java/com/alibaba/qwen/code/managedagent/service/ManagedAgentService.java b/...-server/src/main/java/com/alibaba/qwen/code/managedagent/service/ManagedAgentService.java
@@ -66,10 +66,6 @@ public class ManagedAgentService {
     private static final Pattern TURN_CURSOR = Pattern.compile(
             "^(0|[1-9][0-9]{0,18}):([A-Za-z0-9_-]{1,64})$");
     private static final int TURN_ID_MAX_LENGTH = 64;
-    // Every Session serves its task list and detail; the tasks come from the
-    // Stage H records its Session store holds (H0c).
-    private static final WebShellSessionCapabilities WEB_SHELL_CAPABILITIES =
-            new WebShellSessionCapabilities(true);
     // Catch-up reads of a stream use pages of this size.
     static final int STREAM_PAGE = 100;
     // A context stays ready until cwd changes arrive (W2).
@@ -302,7 +298,7 @@ public PublicSession getPublicSession(String tenantId, String actorId,
     public WebShellSession getWebShellSession(String tenantId, String actorId,
             String sessionId) {
         return webShellSession(requireReadableSession(tenantId, actorId,
-                sessionId));
+                sessionId), actorId);
     }
 
     public PublicList<PublicSession> listPublicSessions(String tenantId,
@@ -327,8 +323,8 @@ public WebShellPage<WebShellSession> listWebShellSessions(
                 decoded == null ? null : decoded.updatedAt(),
                 decoded == null ? null : decoded.sessionId(), limit);
         return new WebShellPage<>(page.sessions().stream()
-                .map(this::webShellSession).toList(), nextCursor(page),
-                page.hasMore());
+                .map(session -> webShellSession(session, actorId)).toList(),
+                nextCursor(page), page.hasMore());
     }
 
     /**
@@ -483,7 +479,8 @@ private PublicSession publicSession(SessionRecord session) {
                 publicWorkspace(session));
     }
 
-    private WebShellSession webShellSession(SessionRecord session) {
+    private WebShellSession webShellSession(SessionRecord session,
+            String actorId) {
         TurnRecord latestTurn = store.findLatestTurn(session.tenantId(),
                 session.sessionId()).orElse(null);
         EventRecord environmentEvent = store.findLatestEnvironmentEvent(
@@ -494,7 +491,10 @@ private WebShellSession webShellSession(SessionRecord session) {
                 latestTurn == null ? null : webShellTurn(latestTurn),
                 webShellEnvironment(environmentEvent),
                 session.lastSequence(), webShellWorkspace(session),
-                WEB_SHELL_CAPABILITIES);
+                // Every Session serves its task list and detail; the tasks
+                // come from the Stage H records its Session store holds (H0c).
+                new WebShellSessionCapabilities(true,
+                        maySubmitWorkspaceTurn(session, actorId)));
     }
 
     private static WebShellWorkspace webShellWorkspace(SessionRecord session) {
@@ -643,15 +643,20 @@ String lifecycleDigest(String sessionId, String operation) {
     // Everyone else keeps the existing refusal.
     private void requireSubmitter(String tenantId, String actorId,
             String sessionId) {
-        SessionRecord session = store.requireSession(tenantId, sessionId);
-        if (session.workspace() != null
+        if (!maySubmitWorkspaceTurn(store.requireSession(tenantId, sessionId),
+                actorId)) {
+            requireLegacyWorkspace(tenantId, actorId, sessionId);
+        }
+    }
+
+    private boolean maySubmitWorkspaceTurn(SessionRecord session,
+            String actorId) {
+        return session.workspace() != null
                 && harness.isWorkspaceFilesAvailable()
-                && workspaces.canRead(tenantId, actorId,
+                && workspaces.canRead(session.tenantId(), actorId,
                         session.workspace().getWorkspaceId())
-                && workspaces.createdSession(tenantId, actorId, sessionId)) {
-            return;
-        }
-        requireLegacyWorkspace(tenantId, actorId, sessionId);
+                && workspaces.createdSession(session.tenantId(), actorId,
+                        session.sessionId());
     }
 
     void requireLegacyWorkspace(String tenantId, String actorId,

diff --git a/...ava/managed-agent-server/src/main/resources/openapi/managed-agent-public-api.openapi.json b/...ava/managed-agent-server/src/main/resources/openapi/managed-agent-public-api.openapi.json
@@ -3870,6 +3870,11 @@
             "default": false,
             "x-qwen-implementation-status": "planned"
           },
+          "workspaceTurns": {
+            "type": "boolean",
+            "default": false,
+            "description": "True when the caller may submit later Turns to this Workspace-bound Session: the deployment enables Workspace files and the caller created the Session. False for every other caller and for unbound Sessions, which do not use it."
+          },
           "tasks": {
             "type": "boolean"
           }

diff --git a/...gent-server/src/test/java/com/alibaba/qwen/code/managedagent/HostedPublicWorkspaceIT.java b/...gent-server/src/test/java/com/alibaba/qwen/code/managedagent/HostedPublicWorkspaceIT.java
@@ -152,6 +152,12 @@ void publicCreationRunsFilesThroughProductionWorkspaceBinding() throws Exception
             assertThat(request("POST", "/v1/agents/sessions/" + session + "/events", later,
                     "reader-later-" + workspace, "reader", 409).path("error").path("code").asText())
                     .isEqualTo("workspace_unavailable");
+            // WebShell advertises the same rule, per caller.
+            for (String caller : List.of("actor", "reader")) {
+                assertThat(request("POST", "/api/agent/web-shell/v1/sessions/get", Map.of("sessionId", session),
+                        null, caller, 200).path("capabilities").path("workspaceTurns").asBoolean())
+                        .as(caller).isEqualTo("actor".equals(caller));
+            }
             String laterTurn = request("POST", "/v1/agents/sessions/" + session + "/events", later,
                     "later-" + workspace, "actor", 202).path("turn_id").asText();
             assertThat(laterTurn).isNotBlank();

diff --git a/...-server/src/test/java/com/alibaba/qwen/code/managedagent/ManagedAgentApiContractTest.java b/...-server/src/test/java/com/alibaba/qwen/code/managedagent/ManagedAgentApiContractTest.java
@@ -1176,8 +1176,8 @@ void bothSurfacesReportTheSameSession() throws Exception {
                 assertThat(other.get("lastSequence").asLong())
                         .isPositive()
                         .isEqualTo(session.get("last_event_id").asLong());
-                assertThat(other.get("capabilities"))
-                        .isEqualTo(json("{\"tasks\":true}"));
+                assertThat(other.get("capabilities")).isEqualTo(json(
+                        "{\"tasks\":true,\"workspaceTurns\":false}"));
             }
         }
 

diff --git a/packages/web-shell/client/components/managed/ManagedSessionsPage.test.tsx b/packages/web-shell/client/components/managed/ManagedSessionsPage.test.tsx
@@ -231,6 +231,31 @@ describe('ManagedSessionsPage', () => {
     expect(container.textContent).not.toContain('Preparing environment');
   });
 
+  it('lets the creator send a later Turn to a bound Session', async () => {
+    mocks.client.getSession.mockResolvedValue(
+      summary('bound', {
+        activeTurnId: undefined,
+        workspace: { workspaceId: 'ws-a', cwdRelative: 'services/api' },
+        capabilities: { canSend: true, canCancel: false, workspaceTurns: true },
+      }),
+    );
+    mocks.client.submitPrompt.mockResolvedValue({
+      sessionId: 'bound',
+      turnId: 'p2',
+    });
+    await render('bound');
+
+    expect(container.querySelector('textarea')).not.toBeNull();
+    await input('Run it again');
+    await click('Send');
+
+    expect(mocks.client.submitPrompt).toHaveBeenCalledWith(
+      'bound',
+      { text: 'Run it again' },
+      expect.objectContaining({ idempotencyKey: expect.any(String) }),
+    );
+  });
+
   async function click(label: string) {
     const button = [...container.querySelectorAll('button')].find(
       (item) => item.textContent === label,

diff --git a/packages/web-shell/client/components/managed/ManagedSessionsPage.tsx b/packages/web-shell/client/components/managed/ManagedSessionsPage.tsx
@@ -489,7 +489,7 @@ function ManagedSessionsContent({
             }
             loading={detail.loading}
           />
-          {!summary?.workspace &&
+          {(!summary?.workspace || summary.capabilities.workspaceTurns) &&
           (!provider.workspaceBinding || (sessionId && summary)) ? (
             <form
               className="flex shrink-0 flex-col gap-2"

diff --git a/packages/web-shell/client/components/managed/generated/managed-agent-api.ts b/packages/web-shell/client/components/managed/generated/managed-agent-api.ts
@@ -354,6 +354,11 @@ export interface components {
             capabilities?: components["schemas"]["WebShellSessionCapabilities"];
         };
         WebShellSessionCapabilities: {
+            /**
+             * @description True when the caller may submit later Turns to this Workspace-bound Session: the deployment enables Workspace files and the caller created the Session. False for every other caller and for unbound Sessions, which do not use it.
+             * @default false
+             */
+            workspaceTurns: boolean;
             tasks: boolean;
         };
         WebShellSessionPage: {

diff --git a/packages/web-shell/client/components/managed/java-managed-agent-provider.test.ts b/packages/web-shell/client/components/managed/java-managed-agent-provider.test.ts
@@ -445,4 +445,39 @@ describe('createJavaManagedAgentProvider', () => {
     expect(transcript.olderCursor).toBeUndefined();
     expect(transcript.lastEventId).toBe(4);
   });
+
+  it('lets a bound Session send only when the service allows its caller', async () => {
+    const bound = {
+      sessionId: 'bound-1',
+      status: 'ACTIVE',
+      createdAt: 1,
+      updatedAt: 1,
+      lastSequence: 3,
+      workspace: { workspaceId: 'ws-a', cwdRelative: '.' },
+    };
+    const provider = createJavaManagedAgentProvider({
+      baseUrl: 'https://product.example',
+      fetch: vi
+        .fn<typeof fetch>()
+        .mockResolvedValueOnce(
+          jsonResponse({
+            ...bound,
+            capabilities: { tasks: true, workspaceTurns: true },
+          }),
+        )
+        .mockResolvedValueOnce(
+          jsonResponse({
+            ...bound,
+            capabilities: { tasks: true, workspaceTurns: false },
+          }),
+        ),
+    });
+
+    expect(
+      (await provider.getSession('bound-1', { clientId: 'c' })).capabilities,
+    ).toEqual({ canSend: true, canCancel: false, workspaceTurns: true });
+    expect(
+      (await provider.getSession('bound-1', { clientId: 'c' })).capabilities,
+    ).toEqual({ canSend: false, canCancel: false });
+  });
 });
diff --git a/packages/web-shell/client/components/managed/java-managed-agent-provider.ts b/packages/web-shell/client/components/managed/java-managed-agent-provider.ts
@@ -200,6 +200,11 @@ function toSessionSummary(
       turnStatus,
     );
   const sessionActive = session.status.toLowerCase() === 'active';
+  // A bound Session takes later Turns only from the caller the service
+  // allows; everything else about a bound Session stays read-only.
+  const workspaceTurns =
+    Boolean(session.workspace) &&
+    session.capabilities?.workspaceTurns === true;
   const errorCode =
     session.activeTurn?.errorCode ?? session.environment?.errorCode;
   return {
@@ -216,12 +221,14 @@ function toSessionSummary(
     runtimeReady: runtimeState === 'ready',
     runtimeState,
     capabilities: {
-      canSend: sessionActive && !active && !session.workspace,
+      canSend:
+        sessionActive && !active && (!session.workspace || workspaceTurns),
       canCancel:
         sessionActive &&
         active &&
         turnStatus !== 'cancelling' &&
         !session.workspace,
+      ...(workspaceTurns ? { workspaceTurns: true } : {}),
     },
     ...(errorCode ? { failure: { code: errorCode, message: errorCode } } : {}),
   };

diff --git a/packages/web-shell/client/components/managed/managed-agent-provider.ts b/packages/web-shell/client/components/managed/managed-agent-provider.ts
@@ -28,7 +28,12 @@ export interface ManagedAgentSessionSummary {
   phase: ManagedAgentSessionPhase;
   runtimeReady: boolean;
   runtimeState: ManagedAgentRuntimeState;
-  capabilities: { canSend: boolean; canCancel: boolean };
+  capabilities: {
+    canSend: boolean;
+    canCancel: boolean;
+    /** The caller may submit later Turns to this Workspace-bound Session. */
+    workspaceTurns?: boolean;
+  };
   failure?: { code: string; message: string };
 }