Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

9.0 KB
Raw Blame
import type {
  ThreadErrorCode,
  ThreadServerFrame,
} from '@inkeep/open-knowledge-core/acp/thread-protocol';
import { parseThreadClientFrame } from '@inkeep/open-knowledge-core/acp/thread-protocol';
import type { PinoLogger } from '../logger.ts';
import { type AcpThreadManager, ThreadOpError } from './thread-manager.ts';

interface ThreadSocket {
  send(data: string): void;
  close(code?: number, reason?: string): void;
  on(event: 'message', listener: (data: unknown) => void): void;
  on(event: 'close', listener: () => void): void;
  on(event: 'error', listener: (err: Error) => void): void;
}

export function attachAcpThreadSocket(
  ws: ThreadSocket,
  manager: AcpThreadManager,
  log: PinoLogger,
): void {
  const subscriptions = new Map<string, (frame: ThreadServerFrame) => void>();

  const send = (frame: ThreadServerFrame): void => {
    try {
      ws.send(JSON.stringify(frame));
    } catch (err) {
      log.warn({ err }, '[acp-thread-socket] send failed');
    }
  };

  const sendError = (
    code: Parameters<typeof errorFrame>[0],
    message: string,
    extra?: { reqId?: string; threadId?: string },
  ): void => send(errorFrame(code, message, extra));

  ws.on('message', (data) => {
    const raw =
      typeof data === 'string' ? data : Buffer.isBuffer(data) ? data.toString('utf8') : '';
    const frame = parseThreadClientFrame(raw);
    if (frame === null) {
      sendError('bad-frame', 'unrecognized frame');
      return;
    }
    void (async () => {
      try {
        switch (frame.op) {
          case 'list': {
            send({ op: 'threads', threads: manager.listThreads() });
            return;
          }
          case 'create': {
            const info = await manager.createThread({
              agent: frame.agent,
              prompt: frame.prompt,
              attachments: frame.attachments,
              docName: frame.docName,
              titleHint: frame.titleHint,
              settings: frame.settings,
            });
            send({ op: 'created', reqId: frame.reqId, info });
            await subscribeTo(info.threadId, 0);
            return;
          }
          case 'subscribe': {
            await subscribeTo(frame.threadId, frame.sinceSeq ?? 0, true);
            return;
          }
          case 'resume': {
            const info = await manager.resumeThread(
              frame.threadId,
              frame.prompt,
              frame.attachments,
            );
            send({ op: 'resumed', reqId: frame.reqId, info });
            await subscribeTo(frame.threadId, 0);
            return;
          }
          case 'retry': {
            const info = await manager.retryThread(frame.threadId);
            send({ op: 'retried', reqId: frame.reqId, info });
            return;
          }
          case 'terminal_auth_launch': {
            const launch = manager.terminalAuthLaunch(frame.threadId, frame.methodId);
            send({ op: 'terminal_auth_launch_ready', reqId: frame.reqId, launch });
            return;
          }
          case 'authenticate': {
            const info = await manager.authenticateThread(frame.threadId, frame.methodId);
            send({ op: 'authenticated', reqId: frame.reqId, info });
            return;
          }
          case 'delete': {
            const sink = subscriptions.get(frame.threadId);
            if (sink !== undefined) {
              manager.unsubscribe(frame.threadId, sink);
              subscriptions.delete(frame.threadId);
            }
            await manager.deleteThread(frame.threadId);
            send({ op: 'threads', threads: manager.listThreads() });
            return;
          }
          case 'unsubscribe': {
            const sink = subscriptions.get(frame.threadId);
            if (sink !== undefined) {
              manager.unsubscribe(frame.threadId, sink);
              subscriptions.delete(frame.threadId);
            }
            return;
          }
          case 'prompt': {
            manager.sendPrompt(frame.threadId, frame.content, frame.attachments);
            return;
          }
          case 'steer': {
            manager.steerPrompt(frame.threadId, frame.content, frame.attachments);
            return;
          }
          case 'queue_edit': {
            const applied = manager.editQueued(frame.threadId, frame.id, frame.content);
            if (frame.reqId !== undefined) {
              if (applied) {
                send({ op: 'queue_edited', reqId: frame.reqId, threadId: frame.threadId });
              } else {
                sendError('not-ready', 'queued message already dispatched', {
                  reqId: frame.reqId,
                  threadId: frame.threadId,
                });
              }
            }
            return;
          }
          case 'queue_hold': {
            manager.holdQueued(frame.threadId, frame.id, frame.held);
            return;
          }
          case 'queue_remove': {
            manager.removeQueued(frame.threadId, frame.id);
            return;
          }
          case 'queue_send_now': {
            manager.sendQueuedNow(frame.threadId, frame.id);
            return;
          }
          case 'set_chat_grant': {
            manager.setChatGrant(frame.threadId, frame.grant, frame.enabled);
            return;
          }
          case 'permission_response': {
            manager.respondPermission(frame.threadId, frame.requestId, frame.outcome);
            return;
          }
          case 'runtime_consent_response': {
            manager.respondRuntimeConsent(frame.threadId, frame.requestId, frame.outcome);
            return;
          }
          case 'pi_bridge_consent_response': {
            manager.respondPiBridgeConsent(frame.threadId, frame.requestId, frame.outcome);
            return;
          }
          case 'cancel': {
            manager.cancel(frame.threadId);
            return;
          }
          case 'set_mode': {
            manager.setMode(frame.threadId, frame.modeId);
            return;
          }
          case 'rename': {
            const info = await manager.renameThread(frame.threadId, frame.title);
            if (!subscriptions.has(frame.threadId)) send({ op: 'info', info });
            return;
          }
          case 'set_config_option': {
            manager.setConfigOption(frame.threadId, frame.configId, frame.value);
            return;
          }
          case 'set_context_window': {
            const info = await manager.setContextWindow(frame.threadId, frame.tokens);
            send({ op: 'context_window_set', reqId: frame.reqId, info });
            return;
          }
          case 'close': {
            const sink = subscriptions.get(frame.threadId);
            if (sink !== undefined) {
              manager.unsubscribe(frame.threadId, sink);
              subscriptions.delete(frame.threadId);
            }
            await manager.closeThread(frame.threadId);
            send({ op: 'threads', threads: manager.listThreads() });
            return;
          }
        }
      } catch (err) {
        if (err instanceof ThreadOpError) {
          sendError(err.code, err.message, {
            reqId: 'reqId' in frame ? frame.reqId : undefined,
            threadId: 'threadId' in frame ? frame.threadId : undefined,
          });
        } else {
          log.error({ err, op: frame.op }, '[acp-thread-socket] frame handling failed');
          sendError('internal', 'internal error', {
            reqId: 'reqId' in frame ? (frame as { reqId?: string }).reqId : undefined,
            threadId: 'threadId' in frame ? frame.threadId : undefined,
          });
        }
      }
    })();
  });

  const subscribeTo = async (
    threadId: string,
    sinceSeq: number,
    replace = false,
  ): Promise<void> => {
    const existing = subscriptions.get(threadId);
    if (existing !== undefined) {
      if (!replace) return;
      manager.unsubscribe(threadId, existing);
      subscriptions.delete(threadId);
    }
    const sink = (frame: ThreadServerFrame): void => {
      if (subscriptions.get(threadId) === sink) send(frame);
    };
    subscriptions.set(threadId, sink);
    try {
      await manager.subscribe(threadId, sinceSeq, sink);
      if (subscriptions.get(threadId) !== sink) manager.unsubscribe(threadId, sink);
    } catch (err) {
      manager.unsubscribe(threadId, sink);
      if (subscriptions.get(threadId) !== sink) {
        if (!(err instanceof ThreadOpError)) {
          log.error({ err, threadId }, '[acp-thread-socket] superseded subscription failed');
        }
        return;
      }
      subscriptions.delete(threadId);
      if (err instanceof ThreadOpError) {
        sendError(err.code, err.message, { threadId });
      } else {
        throw err;
      }
    }
  };

  ws.on('close', () => {
    for (const [threadId, sink] of subscriptions) {
      manager.unsubscribe(threadId, sink);
    }
    subscriptions.clear();
  });
  ws.on('error', (err) => {
    log.warn({ err }, '[acp-thread-socket] socket error');
  });
}

function errorFrame(
  code: ThreadErrorCode,
  message: string,
  extra?: { reqId?: string; threadId?: string },
): ThreadServerFrame {
  return { op: 'error', code, message, ...extra };
}