#上线前检查

import { createOpenAiAdapter } from '@volcengine/chatkit/adapters/openai';

/** 换成自己取令牌的办法：过期了就刷新，返回当前有效的那个。 */
declare const getAccessToken: () => Promise<string>;

export const adapter = createOpenAiAdapter({
  // 凭据会过期时在函数里每次现取，不用重建适配器
  run: async ({ body }) =>
    fetch('/api/chat/completions', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${await getAccessToken()}` },
      body: JSON.stringify(body),
    }),
});

import { createOpenAiAdapter } from '@volcengine/chatkit/adapters/openai';

/**
 * 应用里用的适配器。发请求的函数从参数进来：应用里用浏览器的 fetch，测试里换成假后端。
 */
export const createChatAdapter = (request: typeof fetch = fetch) => {
  const send = (method: string, path: string, body?: unknown) =>
    request(`/api/chat${path}`, {
      method,
      headers: { 'Content-Type': 'application/json' },
      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
    });

  return createOpenAiAdapter({
    run: ({ sessionId, runId, body }) => send('POST', `/sessions/${sessionId}/runs`, { run_id: runId, ...body }),
    regenerate: ({ sessionId, runId, targetRunId, body }) =>
      send('POST', `/sessions/${sessionId}/runs`, { run_id: runId, replace_from: targetRunId, ...body }),
    abort: ({ sessionId, runId }) => send('POST', `/sessions/${sessionId}/runs/${runId}/cancel`, {}),
    history: ({ sessionId }) => send('GET', `/sessions/${sessionId}/messages`),
  });
};

import { runAdapterConformance } from '@volcengine/chatkit/testing';
import { describe, expect, it } from 'vitest';

import { createChatAdapter } from './chat-adapter';
import { createFakeBackend } from './fake-backend';

// 每个用例都会要一个全新的适配器；kind 指定这一次后端要表现出的行为
runAdapterConformance(
  'chat',
  {
    createAdapter: kind => createChatAdapter(createFakeBackend(kind)),
    makeInput: text => ({ content: [{ type: 'text' as const, text }] }),
    capabilities: {
      // 没有注册浏览器里执行的工具，工具调用的用例不跑
      tools: false,
      // 给了 regenerate 和 sessions，把对应的用例打开
      regenerate: true,
    },
  },
  { describe, it, expect }
);

import type { OpenAiHistory, OpenAiHistoryMessage, OpenAiHistoryRun } from '@volcengine/chatkit/adapters/openai';
interface BackendSession {
  id: string;
  title?: string;
  created_at?: number;
  updated_at?: number;
}
import type { ConformanceScenario } from '@volcengine/chatkit/testing';

/**
 * 假后端：按后端约定的格式应答，数据存在内存里。
 * 响应的内容要和真实后端一致，最好直接从真实后端录下来。
 */
const encoder = new TextEncoder();
const json = (value: unknown, status = 200): Response => new Response(JSON.stringify(value), { status });
const chunk = (delta: object, finish: string | null = null): string =>
  `data: ${JSON.stringify({ choices: [{ index: 0, delta, finish_reason: finish }] })}\n\n`;

/** 事件流，每个事件带事件编号。给了 signal 时流一直开着，直到请求被取消。 */
const stream = (frames: string[], signal?: AbortSignal): Response =>
  new Response(
    new ReadableStream<Uint8Array>({
      start(controller) {
        frames.forEach((frame, index) => controller.enqueue(encoder.encode(`id: e${index + 1}\n${frame}`)));
        if (!signal) {
          controller.close();
          return;
        }
        signal.addEventListener('abort', () => controller.error(new DOMException('aborted', 'AbortError')), {
          once: true,
        });
      },
    }),
    { status: 200, headers: { 'Content-Type': 'text/event-stream' } }
  );

export const createFakeBackend = (kind: ConformanceScenario): typeof fetch => {
  let sessions: BackendSession[] = [];
  let messages: OpenAiHistoryMessage[] = [];
  let runs: OpenAiHistoryRun[] = [];
  let sequence = 0;

  const startRun = (body: {
    run_id: string;
    replace_from?: string;
    messages: { role: string; content: unknown }[];
  }) => {
    if (body.replace_from) {
      // 被重做的那一轮和它之后的内容作废
      const from = messages.findIndex(message => message.run_id === body.replace_from);
      if (from >= 0) messages = messages.slice(0, from);
      const at = runs.findIndex(run => run.id === body.replace_from);
      if (at >= 0) runs = runs.slice(0, at);
    }
    const input = body.messages.at(-1)?.content;
    const next = () => `m${(sequence += 1)}`;
    messages.push({ id: next(), run_id: body.run_id, role: 'user', content: typeof input === 'string' ? input : '' });
    if (kind === 'fail') {
      runs.push({ id: body.run_id, status: 'failed', error: { code: 'rate_limit_exceeded', message: '限流了' } });
      return json({ error: { code: 'rate_limit_exceeded', type: 'requests', message: '限流了' } }, 429);
    }
    if (kind === 'slow') {
      messages.push({ id: next(), run_id: body.run_id, role: 'assistant', content: '处理中' });
      runs.push({ id: body.run_id, status: 'interrupted' });
      return undefined;
    }
    messages.push({ id: next(), run_id: body.run_id, role: 'assistant', content: '这是回答' });
    runs.push({ id: body.run_id, status: 'completed', last_event_id: 'e4' });
    return stream([chunk({ content: '这是' }), chunk({ content: '回答' }), chunk({}, 'stop'), 'data: [DONE]\n\n']);
  };

  return async (input, init) => {
    const path = String(input).replace('/api/chat', '');
    const method = init?.method ?? 'GET';
    const body = typeof init?.body === 'string' ? JSON.parse(init.body) : undefined;
    const sessionId = /^\/sessions\/([^/]+)/.exec(path)?.[1];

    if (method === 'POST' && /\/runs$/.test(path)) {
      return startRun(body) ?? stream([chunk({ content: '处理中' })], init?.signal ?? undefined);
    }
    if (method === 'POST' && /\/cancel$/.test(path)) return new Response(null, { status: 204 });
    if (method === 'GET' && /\/messages$/.test(path)) return json({ messages, runs } satisfies OpenAiHistory);
    if (method === 'GET' && path === '/sessions') return json({ sessions, has_more: false });
    if (method === 'POST' && path === '/sessions') {
      const session = { id: `s-${(sequence += 1)}`, title: body?.title, updated_at: Date.now() };
      sessions = [session, ...sessions];
      return json(session);
    }
    if (method === 'PATCH' && sessionId) {
      sessions = sessions.map(session => (session.id === sessionId ? { ...session, title: body.title } : session));
      return new Response(null, { status: 204 });
    }
    if (method === 'DELETE' && sessionId) {
      sessions = sessions.filter(session => session.id !== sessionId);
      return new Response(null, { status: 204 });
    }
    return json({ error: { code: 'not_found', message: `没有这个接口：${method} ${path}` } }, 404);
  };
};

import { createOpenAiAdapter } from '@volcengine/chatkit/adapters/openai';
import type { AdapterFailureCause } from '@volcengine/chatkit/core';

export const adapter = createOpenAiAdapter({
  run: ({ body }) =>
    fetch('/api/chat/completions', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(body),
    }),
  // 能力函数抛错或返回非成功状态时各上报一次
  onError: (content, error, extra) => {
    // 是哪个能力、后端给的状态码、原始的错误内容在 cause 里
    const cause = (error instanceof Error ? error.cause : undefined) as AdapterFailureCause | undefined;
    console.error('[chat]', content, cause?.capability, cause?.status, cause?.detail, extra);
  },
});