@linxin666/dsh-remote-web-ui 0.3.5 → 0.3.9

package/src/mobile/views/WorkspaceView.tsx

@@ -1,245 +0,0 @@
-/**
- * Landing level: the workspace roster. The mobile surface opens straight
- * here — no new-session homepage — and every workspace row is a thin
- * fetch from workspace.list (the roster is small; sessions are not loaded
- * until a workspace is opened).
- */
-
-import { useEffect, useState } from 'react'
-import type { WorkspaceView as WorkspaceRow } from '@deepseek-ai/dsh-host-apiproxy/api/workspace'
-import { listWorkspaces, listDirectory, createWorkspace, type DirectoryListing, type DirectoryEntry } from '../api.ts'
-import { errorText } from './App.tsx'
-import { ThemeToggle } from '../theme-toggle.tsx'
-
-/** Props for the directory browser. */
-interface DirectoryBrowserProps {
-  onCancel(): void
-  onPick(workspace: WorkspaceRow): void
-}
-
-/**
- * Render the directory browser for creating a new workspace.
- */
-function DirectoryBrowser({ onCancel, onPick }: DirectoryBrowserProps) {
-  const [listing, setListing] = useState<DirectoryListing | undefined>(undefined)
-  const [error, setError] = useState<string | undefined>(undefined)
-  const [creating, setCreating] = useState(false)
-  const [path, setPath] = useState<string | undefined>(undefined)
-  const [reload, setReload] = useState(0)
-
-  useEffect(() => {
-    let cancelled = false
-    setError(undefined)
-    setListing(undefined)
-    void listDirectory(path).then(
-      (res) => {
-        if (cancelled) return
-        setListing(res)
-      },
-      (reason: unknown) => {
-        if (cancelled) return
-        setError(errorText(reason))
-      },
-    )
-    return () => { cancelled = true }
-  }, [path, reload])
-
-  const handleCreate = async () => {
-    if (listing === undefined || creating) return
-    setCreating(true)
-    setError(undefined)
-    try {
-      const result = await createWorkspace(listing.path)
-      onPick(result.workspace)
-    } catch (reason: unknown) {
-      setCreating(false)
-      setError(errorText(reason))
-    }
-  }
-
-  return (
-    <div className="mobile dir-browser">
-      <header className="mobile-header">
-        <button type="button" className="mobile-headerAction" onClick={onCancel}>返回</button>
-        <h1 className="mobile-title">选择目录</h1>
-      </header>
-      
-      {listing !== undefined && (
-        <div className="dir-crumbs">
-          {listing.crumbs.map((crumb, idx) => (
-            <span key={crumb.path}>
-              <button
-                type="button"
-                className="dir-crumb"
-                onClick={() => setPath(crumb.path)}
-              >
-                {crumb.name || '/'}
-              </button>
-              {idx < listing.crumbs.length - 1 && <span className="dir-crumb-separator">/</span>}
-            </span>
-          ))}
-        </div>
-      )}
-
-      {error !== undefined ? (
-        <div className="mobile-empty">
-          <p className="mobile-error">{error}</p>
-          <button type="button" className="mobile-button" onClick={() => setReload(n => n + 1)}>重试</button>
-        </div>
-      ) : listing === undefined ? (
-        <div className="mobile-empty">
-          <p className="mobile-muted">加载中…</p>
-        </div>
-      ) : (
-        <ul className="mobile-list">
-          {listing.entries.length === 0 ? (
-            <div className="mobile-empty dir-empty">
-              <p className="mobile-muted">空目录</p>
-            </div>
-          ) : (
-            listing.entries.map((entry: DirectoryEntry) => (
-              <li key={entry.path}>
-                <button
-                  type="button"
-                  className={`mobile-row dir-entry ${entry.hidden ? 'dir-entry-hidden' : ''}`}
-                  onClick={() => setPath(entry.path)}
-                >
-                  <span className="mobile-rowTitle">{entry.name}</span>
-                </button>
-              </li>
-            ))
-          )}
-        </ul>
-      )}
-
-      <div className="dir-select">
-        <button
-          type="button"
-          className="mobile-button"
-          disabled={listing === undefined || creating}
-          onClick={() => void handleCreate()}
-        >
-          {creating ? '创建中…' : '选择此目录'}
-        </button>
-      </div>
-    </div>
-  )
-}
-
-/** Props for the workspace roster. */
-export interface WorkspaceViewProps {
-  /** Workspace carried by the pairing link; opened after the roster loads. */
-  initialWorkspaceId?: string
-  /** Open one workspace's session list. */
-  onPick(workspace: WorkspaceRow): void
-}
-
-/**
- * Render the workspace roster.
- * @param props - the pick action.
- * @returns the roster.
- */
-export function WorkspaceView({ initialWorkspaceId, onPick }: WorkspaceViewProps) {
-  const [items, setItems] = useState<WorkspaceRow[] | undefined>(undefined)
-  const [error, setError] = useState<string | undefined>(undefined)
-  // Bumped by the retry button to re-run the roster fetch effect.
-  const [reload, setReload] = useState(0)
-  const [isCreating, setIsCreating] = useState(false)
-
-  useEffect(() => {
-    let cancelled = false
-    void listWorkspaces().then(
-      (rows) => {
-        if (cancelled) return
-        const target = initialWorkspaceId === undefined
-          ? undefined
-          : rows.find(workspace => workspace.workspaceId === initialWorkspaceId)
-        if (target !== undefined) {
-          onPick(target)
-          return
-        }
-        setItems(rows)
-      },
-      (reason: unknown) => {
-        if (cancelled) return
-        setError(errorText(reason))
-      },
-    )
-    return () => { cancelled = true }
-  }, [initialWorkspaceId, onPick, reload])
-
-  if (isCreating) {
-    return (
-      <DirectoryBrowser
-        onCancel={() => setIsCreating(false)}
-        onPick={onPick}
-      />
-    )
-  }
-
-  if (error !== undefined) {
-    return (
-      <div className="mobile">
-        <header className="mobile-header">
-          <h1 className="mobile-title">工作区</h1>
-          <ThemeToggle />
-        </header>
-        <div className="mobile-empty">
-          <p className="mobile-error">加载失败：{error}</p>
-          <button type="button" className="mobile-button" onClick={() => { setError(undefined); setItems(undefined); setReload(n => n + 1) }}>
-            重试
-          </button>
-        </div>
-      </div>
-    )
-  }
-
-  if (items === undefined) {
-    return (
-      <div className="mobile">
-        <header className="mobile-header">
-          <h1 className="mobile-title">工作区</h1>
-          <ThemeToggle />
-        </header>
-        <div className="mobile-empty">
-          <p className="mobile-muted">加载中…</p>
-        </div>
-      </div>
-    )
-  }
-
-  return (
-    <div className="mobile">
-      <header className="mobile-header">
-        <h1 className="mobile-title">工作区</h1>
-        <ThemeToggle />
-      </header>
-      {items.length === 0 ? (
-        <div className="mobile-empty">
-          <p className="mobile-muted">暂无工作区</p>
-        </div>
-      ) : (
-        <ul className="mobile-list">
-          {items.map(workspace => (
-            <li key={workspace.workspaceId}>
-              <button type="button" className="mobile-row" onClick={() => { onPick(workspace) }}>
-                <span className="mobile-rowTitle">{workspace.title}</span>
-                <span className="mobile-rowMeta">{workspace.path}</span>
-                <span className="mobile-chevron">›</span>
-              </button>
-            </li>
-          ))}
-        </ul>
-      )}
-      <div style={{ padding: '16px' }}>
-        <button
-          type="button"
-          className="mobile-button"
-          onClick={() => setIsCreating(true)}
-        >
-          + 新建工作区
-        </button>
-      </div>
-    </div>
-  )
-}

package/src/mobile-api.ts

@@ -1,418 +0,0 @@
-/**
- * The mobile surface's data channel: `/m/api` proxies the host ApiProxy
- * service for the standalone phone page. The phone's RPC calls ride THIS
- * prefix instead of the connection plugin's `/api` — so the tunneled Host
- * never needs to enter the connection trust fence (a distributable plugin
- * cannot change that fence), and this plugin's own pairing gate is the
- * access control instead.
- *
- * Security model:
- * - Every request must carry a live paired-device cookie (the same gate
- *   semantic as the LAN fence), enforced before any host call.
- * - Only an explicit allowlist of methods is proxied ON THIS PREFIX. The
- *   allowlist constrains the /m/api proxy alone: the same paired-device
- *   cookie also passes the global api/gate, so a paired device is a
- *   full-control credential for the host /api surface outside the SDK's
- *   loopback-pinned privileged set (settings/credentials/agentPreset/host
- *   actions/llm.discoverModels). Pairing is full device trust.
- * - `session.list` is paged here (the host API returns everything; this
- *   layer slices stable pages) so the phone never transfers the whole list.
- * - The live mux stream is bridged over Server-Sent Events on the same
- *   prefix (one-directional push; answers to questions/approvals ride the
- *   unary channel), gated identically.
- */
-
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import type { WebRoute } from '@deepseek-ai/dsh-host-webserver'
-import type { ApiProxy } from '@deepseek-ai/dsh-host-apiproxy'
-import type { RpcRequest } from '@deepseek-ai/dsh-host-apiproxy/api/rpc'
-import { RpcId } from '@deepseek-ai/dsh-host-apiproxy/api/rpc'
-import type { PendingTracker } from './mobile-pending.ts'
-import type { PairingService } from './pairing.ts'
-import { readBoundedJson, writeJson } from './http.ts'
-import { readCookie } from './gate.ts'
-
-/**
- * Methods the phone surface may call. Everything else is refused HERE — but
- * note the paired-device cookie also passes the global api/gate for the full
- * ApiProxy surface (gate.ts), so a paired phone is a full-control credential:
- * the allowlist only constrains this /m/api proxy, not the cookie's reach.
- * stop() revokes every device; the loopback panel can also revoke one
- * device at a time.
- */
-const MOBILE_ALLOWLIST = new Set([
-  'host.listDirectory',
-  'workspace.create',
-  'workspace.list',
-  'agentPreset.list',
-  'session.create',
-  'session.list',
-  'session.history',
-  'session.search',
-  'session.prompt',
-  'session.models',
-  'session.selectModel',
-  'session.rename',
-  'session.cancel',
-])
-
-/**
- * Locally answered display-preference method (the phone's read-only
- * surface preferences; never proxied to the host ApiProxy and never a
- * settings-domain write).
- */
-const MOBILE_PREFERENCES_METHOD = 'mobile.preferences'
-const MOBILE_PENDING_METHOD = 'mobile.pending'
-const MOBILE_RESPOND_METHOD = 'mobile.respond'
-/** Execute a slash command through the host command registry (#1125). */
-const MOBILE_COMMAND_METHOD = 'mobile.command'
-
-/** One session.list page (thin phones load incrementally). */
-const SESSION_PAGE_SIZE = 20
-/** SSE keep-alive ping cadence for the live mux stream (single connection). */
-const DEFAULT_EVENTS_HEARTBEAT_MS = 15_000
-
-/** Encode one list position as an opaque continuation cursor. */
-function sessionListCursor(updatedAt: number, sessionId: string): string {
-  return `${updatedAt}:${sessionId}`
-}
-
-/** Parse a cursor; malformed cursors mean "start over" (safe failure mode). */
-function parseSessionListCursor(cursor: string): { updatedAt: number; sessionId: string } | undefined {
-  const separator = cursor.indexOf(':')
-  if (separator < 0) return undefined
-  const updatedAt = Number(cursor.slice(0, separator))
-  if (!Number.isFinite(updatedAt)) return undefined
-  return { updatedAt, sessionId: cursor.slice(separator + 1) }
-}
-
-/** Whether a row comes strictly after the cursor position. */
-function afterCursor(row: { updatedAt: number; sessionId: string }, position: { updatedAt: number; sessionId: string }): boolean {
-  return row.updatedAt < position.updatedAt
-    || (row.updatedAt === position.updatedAt && row.sessionId > position.sessionId)
-}
-
-/** Route-family dependencies. */
-export interface MobileApiDeps {
-  /** The pairing service (device gate + cookie name). */
-  service: PairingService
-  /** The host ApiProxy service (injected by the plugin). */
-  apiProxy: ApiProxy
-  /** The pending tracker. */
-  pendingTracker: PendingTracker
-  /** The resolved mobile composer preference (live per request). */
-  mobileEnterToSend: () => boolean
-  /** SSE keep-alive ping cadence for the mux stream (default 15000 ms; test seam). */
-  eventsHeartbeatMs?: number
-  /**
-   * Optional command dispatcher for executing slash commands on the mobile
-   * surface. When absent, `mobile.command` returns an error; the mobile UI
-   * can still fall back to `session.prompt` (which sends the line to the
-   * model, not the command registry).
-   */
-  commandDispatcher?: {
-    execute(
-      sessionId: string,
-      line: string,
-      signal: AbortSignal,
-    ): Promise<{ ok: true; result: unknown } | { error: string }>
-  }
-}
-
-/** Mobile API route paths. */
-export const MOBILE_API_PATHS = {
-  events: '/m/api/events.mux',
-} as const
-
-/** The mobile-api prefix (every other path under it is a method name). */
-const MOBILE_API_PREFIX = '/m/api'
-/** Method extraction: the prefix plus one slash. */
-const MOBILE_API_METHOD_PREFIX = `${MOBILE_API_PREFIX}/`
-
-/**
- * Build the mobile data-channel routes.
- * @param deps - pairing service + apiProxy.
- * @returns the routes to register on webServer.
- */
-export function makeMobileApiRoutes(deps: MobileApiDeps): WebRoute[] {
-  const { service, apiProxy, mobileEnterToSend } = deps
-  const eventsHeartbeatMs = deps.eventsHeartbeatMs ?? DEFAULT_EVENTS_HEARTBEAT_MS
-
-  /**
-   * Refresh the paired device's presence and report whether it is live.
-   * The mobile surface (unlike the desktop Web UI) has no `/api/pair/heartbeat`
-   * sender, so any activity on the mobile channel — a gated RPC, or the live
-   * SSE stream staying open — must count as presence. Without this, an
-   * idle-but-connected phone ages past `offlineAfterMs` and the desktop panel
-   * wrongly reports it as disconnected.
-   */
-  const touchDeviceFor = (req: IncomingMessage): boolean => {
-    const deviceId = readCookie(req.headers.cookie, service.config.cookieName)
-    if (deviceId === undefined) return false
-    return service.touchDevice(deviceId)
-  }
-
-  /** The phone gate: a live paired-device cookie, or nothing else proceeds. */
-  const gateOk = (req: IncomingMessage): boolean => {
-    return touchDeviceFor(req)
-  }
-
-  const handleMethod = async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
-    if (req.method !== 'POST') {
-      res.writeHead(405)
-      res.end()
-      return
-    }
-    if (!gateOk(req)) {
-      writeJson(res, 403, { ok: false, error: { code: 'unpaired', message: 'mobile session is not paired' } })
-      return
-    }
-    const pathname = new URL(req.url ?? '/', 'http://x').pathname
-    if (!pathname.startsWith(MOBILE_API_METHOD_PREFIX)) {
-      writeJson(res, 404, { ok: false, error: { code: 'not-found', message: 'unknown mobile api path' } })
-      return
-    }
-    const method = pathname.slice(MOBILE_API_METHOD_PREFIX.length)
-    const local = method === MOBILE_PREFERENCES_METHOD 
-      || method === MOBILE_PENDING_METHOD 
-      || method === MOBILE_RESPOND_METHOD
-      || method === MOBILE_COMMAND_METHOD
-    if (!MOBILE_ALLOWLIST.has(method) && !local) {
-      writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: `method ${method} is not exposed to the mobile surface` } })
-      return
-    }
-    let envelope: unknown
-    try {
-      envelope = await readBoundedJson(req, 64 * 1024)
-    } catch {
-      writeJson(res, 400, { ok: false, error: { code: 'bad-request', message: 'invalid json body' } })
-      return
-    }
-    const parsed = envelope as { rpcId?: unknown; payload?: unknown }
-    const rpcId = typeof parsed?.rpcId === 'string' ? parsed.rpcId : ''
-    if (rpcId === '') {
-      writeJson(res, 400, { ok: false, error: { code: 'bad-request', message: 'missing rpcId' } })
-      return
-    }
-    if (local) {
-      if (method === MOBILE_PREFERENCES_METHOD) {
-        writeJson(res, 200, {
-          type: 'server-response',
-          rpcId,
-          result: { ok: true, value: { mobileEnterToSend: mobileEnterToSend() } },
-        })
-      } else if (method === MOBILE_PENDING_METHOD) {
-        const payload = parsed.payload as any
-        writeJson(res, 200, {
-          type: 'server-response',
-          rpcId,
-          result: { ok: true, value: deps.pendingTracker.pending(payload?.sessionId) },
-        })
-      } else if (method === MOBILE_RESPOND_METHOD) {
-        const payload = parsed.payload as any
-        try {
-          const receipt = await apiProxy.respond({
-            type: 'client-response',
-            rpcId: RpcId(payload.rpcId),
-            result: { ok: true, value: payload.response },
-          })
-          writeJson(res, 200, {
-            type: 'server-response',
-            rpcId,
-            result: { ok: true, value: receipt },
-          })
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error)
-          writeJson(res, 200, {
-            type: 'server-response',
-            rpcId,
-            result: { ok: false, error: { code: 'internal', message } },
-          })
-        }
-      } else if (method === MOBILE_COMMAND_METHOD) {
-        const payload = parsed.payload as { sessionId?: string; line?: string } | undefined
-        const sessionId = payload?.sessionId
-        const line = payload?.line
-        if (typeof sessionId !== 'string' || typeof line !== 'string') {
-          writeJson(res, 200, {
-            type: 'server-response',
-            rpcId,
-            result: { ok: false, error: { code: 'bad-request', message: 'missing sessionId or line' } },
-          })
-        } else if (deps.commandDispatcher === undefined) {
-          writeJson(res, 200, {
-            type: 'server-response',
-            rpcId,
-            result: { ok: false, error: { code: 'unavailable', message: 'command dispatcher is not available' } },
-          })
-        } else {
-          try {
-            const abort = new AbortController()
-            res.on('close', () => { if (!res.writableEnded) abort.abort() })
-            const outcome = await deps.commandDispatcher.execute(sessionId, line, abort.signal)
-            if ('error' in outcome) {
-              writeJson(res, 200, {
-                type: 'server-response',
-                rpcId,
-                result: { ok: false, error: { code: outcome.error, message: outcome.error } },
-              })
-            } else {
-              writeJson(res, 200, {
-                type: 'server-response',
-                rpcId,
-                result: { ok: true, value: { matched: true, result: outcome.result } },
-              })
-            }
-          } catch (error) {
-            const message = error instanceof Error ? error.message : String(error)
-            writeJson(res, 200, {
-              type: 'server-response',
-              rpcId,
-              result: { ok: false, error: { code: 'internal', message } },
-            })
-          }
-        }
-      }
-      return
-    }
-    try {
-      // Cancel the host-side work when the phone goes away mid-call (the
-      // response stream closing before we answer means nobody is listening).
-      const abort = new AbortController()
-      res.on('close', () => { if (!res.writableEnded) abort.abort() })
-      const response = await dispatch(apiProxy, method, parsed?.payload, rpcId, abort.signal)
-      writeJson(res, 200, response)
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error)
-      writeJson(res, 200, {
-        type: 'server-response',
-        rpcId,
-        result: { ok: false, error: { code: 'internal', message } },
-      })
-    }
-  }
-
-  /** Bridge the host mux stream over SSE: one `data:` frame per mux frame. */
-  const handleEvents = async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
-    if (req.method !== 'GET') {
-      res.writeHead(405)
-      res.end()
-      return
-    }
-    if (!gateOk(req)) {
-      writeJson(res, 403, {
-        ok: false,
-        error: { code: 'unpaired', message: 'mobile session is not paired' },
-      })
-      return
-    }
-    res.writeHead(200, {
-      'content-type': 'text/event-stream; charset=utf-8',
-      'cache-control': 'no-cache',
-      connection: 'keep-alive',
-    })
-    const controller = new AbortController()
-    let closed = false
-    const heartbeat = setInterval(() => {
-      if (closed) return
-      // An open SSE stream proves the phone is still live even while the agent
-      // idles (no RPC traffic), so refresh presence alongside the transport
-      // keepalive — otherwise an idle phone drifts to "disconnected".
-      touchDeviceFor(req)
-      try {
-        res.write(': ping\n\n')
-      } catch {
-        // The write failed; the close handler tears the subscription down.
-      }
-    }, eventsHeartbeatMs)
-    const onClose = (): void => {
-      if (closed) return
-      closed = true
-      controller.abort()
-      clearInterval(heartbeat)
-    }
-    res.on('close', onClose)
-    req.on('close', onClose)
-    try {
-      const frames = apiProxy.events.mux({ rpcId: RpcId(`mobile-mux-${Date.now().toString(36)}`), payload: {} }, controller.signal)
-      for await (const frame of frames) {
-        if (closed) break
-        deps.pendingTracker.onFrame(frame as any)
-        res.write(`data: ${JSON.stringify(frame)}\n\n`)
-      }
-    } catch {
-      // The stream ended or errored; the EventSource reconnects.
-    } finally {
-      controller.abort()
-      clearInterval(heartbeat)
-    }
-    if (!closed) res.end()
-  }
-
-  return [
-    { kind: 'prefix', path: MOBILE_API_PREFIX, handler: handleMethod },
-    { kind: 'exact', path: MOBILE_API_PATHS.events, handler: handleEvents },
-  ]
-}
-
-/** Dispatch one allowlisted method through the host ApiProxy. */
-async function dispatch(apiProxy: ApiProxy, method: string, payload: unknown, rpcId: string, signal?: AbortSignal): Promise<unknown> {
-  const request: RpcRequest<unknown> = { rpcId: RpcId(rpcId), payload }
-  if (method === 'session.list') {
-    const full = await apiProxy.sessions.list(request as never)
-    // The error path must carry the same 'server-response' envelope the
-    // success path builds, or the phone's callUnary throws a transport error
-    // and masks the real business error.
-    if (!full.result.ok) return { type: 'server-response' as const, rpcId, result: full.result }
-    const items = full.result.value.items as Array<{ updatedAt: number; sessionId: string }>
-    const cursor = (payload as { cursor?: string } | undefined)?.cursor
-    // Every call pages (the first call with no cursor IS the first page):
-    // the phone must never transfer the whole session list at once.
-    // One stable page over (updatedAt desc, sessionId asc); pages never skip
-    // or repeat a row while the list changes between calls.
-    items.sort((a, b) => b.updatedAt - a.updatedAt
-      || (a.sessionId < b.sessionId ? -1 : a.sessionId > b.sessionId ? 1 : 0))
-    const position = cursor === undefined ? undefined : parseSessionListCursor(cursor)
-    const from = position === undefined ? 0 : items.findIndex(row => afterCursor(row, position))
-    const start = from < 0 ? items.length : from
-    const page = items.slice(start, start + SESSION_PAGE_SIZE)
-    const last = page[page.length - 1]
-    const nextCursor = last !== undefined && start + page.length < items.length
-      ? sessionListCursor(last.updatedAt, last.sessionId)
-      : undefined
-    return {
-      type: 'server-response',
-      rpcId,
-      result: {
-        ok: true,
-        value: {
-          items: page,
-          hasMore: nextCursor !== undefined,
-          ...(nextCursor !== undefined ? { nextCursor } : {}),
-        },
-      },
-    }
-  }
-  // The ApiProxy unary methods resolve to the internal response shape
-  // ({ rpcId, result }) without the transport envelope the phone's callUnary
-  // requires — wrap every pass-through in the same 'server-response'
-  // envelope session.list builds above.
-  const wrap = (response: { rpcId: string; result: unknown }): unknown => ({
-    type: 'server-response' as const,
-    rpcId,
-    result: response.result,
-  })
-  if (method === 'workspace.list') return wrap(await apiProxy.workspace.list(request as never))
-  if (method === 'workspace.create') return wrap(await apiProxy.workspace.create(request as never))
-  if (method === 'host.listDirectory') return wrap(await apiProxy.host.listDirectory(request as never, signal ?? new AbortController().signal))
-  if (method === 'agentPreset.list') return wrap(await apiProxy.agentPresets.list(request as never))
-  if (method === 'session.create') return wrap(await apiProxy.sessions.create(request as never))
-  if (method === 'session.history') return wrap(await apiProxy.sessions.history(request as never))
-  if (method === 'session.search') return wrap(await apiProxy.sessions.search(request as never, signal ?? new AbortController().signal))
-  if (method === 'session.prompt') return wrap(await apiProxy.sessions.prompt(request as never))
-  if (method === 'session.models') return wrap(await apiProxy.sessions.models(request as never))
-  if (method === 'session.selectModel') return wrap(await apiProxy.sessions.selectModel(request as never))
-  if (method === 'session.rename') return wrap(await apiProxy.sessions.rename(request as never))
-  if (method === 'session.cancel') return wrap(await apiProxy.sessions.cancel(request as never))
-  throw new Error(`unhandled allowlisted method ${method}`)
-}