Method handleFrame

apps/kimi-web/src/api/daemon/ws.ts:263–388

(rawFrame: WireServerFrame)

  // ---------------------------------------------------------------------------

  private handleFrame(rawFrame: WireServerFrame): void {
    // WireServerFrame union contains WireAck (payload: unknown) which prevents
    // TypeScript from narrowing .payload in each case arm. Cast once here.
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    const frame = rawFrame as any;
    switch ((rawFrame as { type: string }).type) {
      case 'server_hello':
        this.onServerHello();
        break;

      case 'ping':
        this.send({ type: 'pong', payload: { nonce: frame.payload.nonce } });
        break;

      case 'resync_required': {
        const sid = frame.payload.session_id as string;
        const epoch = frame.payload.epoch as string | undefined;
        // Adopt the announced cursor so the next reconnect handshake doesn't
        // re-trigger the same resync before the snapshot reload lands.
        this.subscriptions.set(sid, { seq: frame.payload.current_seq, epoch });
        this.handlers.onResync(sid, frame.payload.current_seq, epoch);
        break;
      }

      case 'error': {
        // A session-scoped error (has top-level session_id) is a real agent-core
        // 'error' event — e.g. a 403 from the model provider — whose message
        // must surface in the conversation. A connection-level control error
        // (no session_id) goes to onError.
        const sid = (frame as { session_id?: unknown }).session_id;
        if (typeof sid === 'string' && this.handlers.onRawAgentEvent) {
          this.handlers.onRawAgentEvent({
            type: 'error',
            seq: frame.seq,
            session_id: sid,
            timestamp: frame.timestamp,
            payload: frame.payload,
          });
        } else {
          this.handlers.onError(frame.payload.code, frame.payload.msg, frame.payload.fatal);
        }
        break;
      }

      case 'ack':
        // ack frames are fire-and-forget for now (no request tracking)
        break;

      case 'terminal_output': {
        const sessionId = frame.session_id as string;
        const terminalId = frame.terminal_id as string;
        const seq = frame.seq as number;
        const key = terminalKey(sessionId, terminalId);
        const existing = this.terminalAttachments.get(key);
        if (existing) {
          this.terminalAttachments.set(key, {
            ...existing,
            lastSeq: Math.max(existing.lastSeq, seq),