fix(web-shell): defer assistant footer during background agent work

packages/sdk-typescript/src/daemon/DaemonHttpError.ts

@@ -23,3 +23,55 @@ export class DaemonHttpError extends Error {
     this.body = body;
   }
 }
+
+// Kept local (instead of reusing `isRecord` from `acpTransportUtils.ts` or
+// `ui/utils.ts`) so this leaf module stays dependency-free: those modules
+// pull the ACP route table / UI helpers into the budgeted browser bundles.
+function getErrorBodyRecord(
+  body: unknown,
+): Record<string, unknown> | undefined {
+  return typeof body === 'object' && body !== null && !Array.isArray(body)
+    ? (body as Record<string, unknown>)
+    : undefined;
+}
+
+/**
+ * Type guard for the daemon's `GET /session/:id/subagents/:toolCallId` 404
+ * contract: `{ code: 'session_not_found', sessionId, toolCallId? }`. Pass
+ * `toolCallId` to require the body to identify that specific missing agent
+ * (a session-level 404 carries no identifying `toolCallId`); omit it to
+ * accept both.
+ */
+export function isSubagentSessionNotFound(
+  error: unknown,
+  toolCallId?: string,
+): boolean {
+  if (!(error instanceof DaemonHttpError) || error.status !== 404) {
+    return false;
+  }
+  const body = getErrorBodyRecord(error.body);
+  if (body?.['code'] !== 'session_not_found') return false;
+  return toolCallId === undefined || body['toolCallId'] === toolCallId;
+}
+
+/**
+ * Type guard for the session-level variant of that same 404 contract: the
+ * daemon could not find the parent session itself, so the body carries
+ * `code: 'session_not_found'` with no identifying `toolCallId` (an
+ * explicitly `null` id is treated the same as an absent one).
+ *
+ * A missing parent session is not the only producer: a multi-workspace
+ * daemon answers this same shape while the owning workspace entry is
+ * merely not active (for example draining before removal, or transitioning
+ * to a replacement runtime), which the daemon treats as reversible. Treat
+ * this error as recoverable, not as proof the session is permanently gone.
+ */
+export function isSessionLevelNotFound(error: unknown): boolean {
+  if (!(error instanceof DaemonHttpError) || error.status !== 404) {
+    return false;
+  }
+  const body = getErrorBodyRecord(error.body);
+  if (body?.['code'] !== 'session_not_found') return false;
+  const toolCallId = body['toolCallId'];
+  return toolCallId === undefined || toolCallId === null;
+}

packages/sdk-typescript/src/daemon/index.ts

@@ -23,6 +23,10 @@ export {
   type RestoreSessionRequest,
   type SubscribeOptions,
 } from './DaemonClient.js';
+export {
+  isSessionLevelNotFound,
+  isSubagentSessionNotFound,
+} from './DaemonHttpError.js';
 // Transport abstraction layer
 export { DaemonTransportClosedError } from './DaemonTransport.js';
 export type {

packages/sdk-typescript/test/unit/isSubagentSessionNotFound.test.ts

@@ -0,0 +1,161 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, it } from 'vitest';
+import {
+  DaemonHttpError,
+  isSessionLevelNotFound,
+  isSubagentSessionNotFound,
+} from '../../src/daemon/DaemonHttpError.js';
+
+const missingAgentBody = {
+  code: 'session_not_found',
+  sessionId: 'session-1',
+  toolCallId: 'call-1',
+};
+
+describe('isSubagentSessionNotFound', () => {
+  it('matches a 404 whose body identifies the missing agent', () => {
+    expect(
+      isSubagentSessionNotFound(
+        new DaemonHttpError(404, missingAgentBody, 'not found'),
+        'call-1',
+      ),
+    ).toBe(true);
+  });
+
+  it('matches a session-level 404 when no toolCallId is required', () => {
+    expect(
+      isSubagentSessionNotFound(
+        new DaemonHttpError(
+          404,
+          { code: 'session_not_found', sessionId: 'session-1' },
+          'not found',
+        ),
+      ),
+    ).toBe(true);
+  });
+
+  it.each([
+    ['non-DaemonHttpError', new Error('not found'), 'call-1'],
+    [
+      'non-404 status',
+      new DaemonHttpError(500, missingAgentBody, 'server error'),
+      'call-1',
+    ],
+    [
+      'missing code',
+      new DaemonHttpError(404, { toolCallId: 'call-1' }, 'not found'),
+      'call-1',
+    ],
+    [
+      'wrong code',
+      new DaemonHttpError(
+        404,
+        { ...missingAgentBody, code: 'workspace_not_found' },
+        'not found',
+      ),
+      'call-1',
+    ],
+    [
+      'missing toolCallId in body',
+      new DaemonHttpError(
+        404,
+        { code: 'session_not_found', sessionId: 'session-1' },
+        'not found',
+      ),
+      'call-1',
+    ],
+    [
+      'null toolCallId in body',
+      new DaemonHttpError(
+        404,
+        { code: 'session_not_found', sessionId: 'session-1', toolCallId: null },
+        'not found',
+      ),
+      'call-1',
+    ],
+    [
+      'mismatched toolCallId',
+      new DaemonHttpError(404, missingAgentBody, 'not found'),
+      'call-other',
+    ],
+  ])('rejects %s', (_label, error, toolCallId) => {
+    expect(isSubagentSessionNotFound(error, toolCallId as string)).toBe(false);
+  });
+
+  it('rejects non-object bodies', () => {
+    expect(
+      isSubagentSessionNotFound(
+        new DaemonHttpError(404, 'session_not_found', 'not found'),
+        'call-1',
+      ),
+    ).toBe(false);
+  });
+});
+
+describe('isSessionLevelNotFound', () => {
+  it('matches a 404 whose body has no toolCallId', () => {
+    expect(
+      isSessionLevelNotFound(
+        new DaemonHttpError(
+          404,
+          { code: 'session_not_found', sessionId: 'session-1' },
+          'not found',
+        ),
+      ),
+    ).toBe(true);
+  });
+
+  it('matches a 404 whose body carries a null toolCallId', () => {
+    expect(
+      isSessionLevelNotFound(
+        new DaemonHttpError(
+          404,
+          {
+            code: 'session_not_found',
+            sessionId: 'session-1',
+            toolCallId: null,
+          },
+          'not found',
+        ),
+      ),
+    ).toBe(true);
+  });
+
+  it('rejects an agent-level 404', () => {
+    expect(
+      isSessionLevelNotFound(
+        new DaemonHttpError(404, missingAgentBody, 'not found'),
+      ),
+    ).toBe(false);
+  });
+
+  it('rejects a 404 whose body carries a different code', () => {
+    expect(
+      isSessionLevelNotFound(
+        new DaemonHttpError(
+          404,
+          { code: 'workspace_not_found', sessionId: 'session-1' },
+          'not found',
+        ),
+      ),
+    ).toBe(false);
+  });
+
+  it('rejects non-404 and non-matching errors', () => {
+    expect(
+      isSessionLevelNotFound(
+        new DaemonHttpError(
+          500,
+          { code: 'session_not_found', sessionId: 'session-1' },
+          'server error',
+        ),
+      ),
+    ).toBe(false);
+    expect(isSessionLevelNotFound(new Error('not found'))).toBe(false);
+  });
+});