1435 lines
77 KiB
TypeScript
1435 lines
77 KiB
TypeScript
// @vitest-environment node
|
|
import { mkdtemp, readFile, rm } from 'node:fs/promises';
|
|
import { tmpdir } from 'node:os';
|
|
import path from 'node:path';
|
|
import { afterEach, describe, expect, it, vi } from 'vitest';
|
|
import { CodingTeacherService, type TeacherScope } from '../../electron/coding-teacher/service';
|
|
import { TeacherTopicStore } from '../../electron/coding-teacher/store';
|
|
import { compileTeacherContext, estimateTeacherTokens, sourceContext } from '../../electron/coding-teacher/context';
|
|
import { TEACHER_BEHAVIOR_PROMPT } from '../../electron/coding-teacher/behavior-prompt';
|
|
import { streamTeacherReply } from '../../electron/coding-teacher/model-runner';
|
|
import { TeacherError } from '../../electron/coding-teacher/config-client';
|
|
import { consultationDefinition } from '../../electron/coding-teacher/consultation-role';
|
|
import { parseTeacherSuggestions } from '../../electron/coding-teacher/suggestions';
|
|
import {
|
|
createCodingProjectStore,
|
|
createMemoryCodingProjectStorage,
|
|
} from '../../electron/coding-projects/project-store';
|
|
import { CodingProjectService } from '../../electron/coding-projects/project-service';
|
|
import {
|
|
ensureDefaultCodingAgent,
|
|
createCodingProjectConfigV2,
|
|
} from '../../electron/coding-projects/project-config';
|
|
import { InMemoryConversationRuntime } from '../../electron/coding-runtime/in-memory-conversation-runtime';
|
|
import type { ConsultationRole, TeacherDefinition, TeacherRequest, TeacherRequestIntent, TeacherSourceContext, TeacherTopic } from '../../shared/coding-teacher';
|
|
import { TEACHER_CHECK_IN_INTERVAL_MS, TEACHER_UNCHANGED_CHECK_IN_INTERVAL_MS } from '../../shared/coding-teacher';
|
|
import * as teacherCloud from '../../electron/coding-teacher/config-client';
|
|
import * as teacherTransport from '../../electron/utils/proxy-fetch';
|
|
import type { ConversationSnapshot } from '../../shared/coding-conversation-contracts';
|
|
import { parseNianCodeDeepLinkUrl } from '../../electron/main/app-deep-link';
|
|
|
|
const definition: TeacherDefinition = {
|
|
schema_version: 1,
|
|
teacher_id: 'coding-teacher',
|
|
name: '编程老师',
|
|
description: '',
|
|
avatar_id: 'avatar-01',
|
|
welcome_message: '一起学编程',
|
|
suggested_questions: ['为什么？'],
|
|
system_prompt: '通过问题引导思考。',
|
|
skills: [
|
|
{
|
|
id: 'explain',
|
|
name: '讲解',
|
|
description: '',
|
|
enabled: true,
|
|
instructions_markdown: '使用具体的小例子。',
|
|
},
|
|
],
|
|
model: { model_id: 'qwen', reasoning_choice: { mode: 'default' } },
|
|
limits: { max_input_tokens: 8000, max_output_tokens: 1500 },
|
|
};
|
|
const context: TeacherSourceContext = {
|
|
messages: [{ id: 'source-user', role: 'user', text: '创建计数器' }],
|
|
cursor: { workerGeneration: 1, seq: 3 },
|
|
capturedAt: '2026-09-22T00:00:00Z',
|
|
};
|
|
const roots: string[] = [];
|
|
const services: CodingTeacherService[] = [];
|
|
afterEach(async () => {
|
|
await Promise.all(services.splice(0).map((service) => service.dispose()));
|
|
await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
|
|
vi.useRealTimers();
|
|
});
|
|
async function fixture({ durableSource = false, sourceContext = context, liveModel = false, cloudTeacher = false, mockCloud = false, modelInputLimit = definition.limits.max_input_tokens } = {}) {
|
|
const root = await mkdtemp(path.join(tmpdir(), 'coding-teacher-'));
|
|
roots.push(root);
|
|
const projects = new CodingProjectService(
|
|
createCodingProjectStore(createMemoryCodingProjectStorage())
|
|
);
|
|
const created = await projects.createProject({
|
|
projectPath: path.join(root, 'project'),
|
|
identity: { kind: 'create' },
|
|
});
|
|
const source = await projects
|
|
.conversationStore(created.project.path)
|
|
.create({
|
|
agentId: created.config.defaultAgentId!,
|
|
title: '源码会话',
|
|
model: null,
|
|
modelResolution: 'required',
|
|
});
|
|
const scope = { projectId: created.project.id, sourceId: source.id };
|
|
let enabled = true,
|
|
version = 1,
|
|
accountCurrent = true;
|
|
let finish: () => void = () => undefined;
|
|
let reply = '计数器保存一个数字。';
|
|
const run = vi.fn(async (_messages, signal: AbortSignal, onText: (text: string) => void) => {
|
|
onText(reply);
|
|
await new Promise<void>((resolve, reject) => {
|
|
finish = resolve;
|
|
signal.addEventListener('abort', () => reject(new Error('aborted')), { once: true });
|
|
});
|
|
return { inputTokens: 20, outputTokens: 10 };
|
|
});
|
|
let account = {
|
|
id: '11111111-1111-4111-8111-111111111111',
|
|
binding: { accountKey: 'test', epoch: 1 },
|
|
};
|
|
const readSource = vi.fn(async (_scope: TeacherScope) => structuredClone(sourceContext));
|
|
const prepareModel = vi.fn(async () => ({ inputLimit: 8000, run }));
|
|
const prepareCloud = vi.fn((..._args: unknown[]) => ({ inputLimit: 8000, run }));
|
|
const createService = () => new CodingTeacherService({
|
|
projects,
|
|
runtime: new InMemoryConversationRuntime(),
|
|
userDataDir: root,
|
|
account: async () => account,
|
|
assertAccount: () => {
|
|
if (!accountCurrent) throw new TeacherError(401, 'teacher_account_changed', '账号变化');
|
|
},
|
|
availability: async () => ({ enabled, published_version: version, revision: version }),
|
|
catalog: cloudTeacher ? async () => ({ items: [{ teacher_id: 'cloud-teacher', version: 9, is_default: true,
|
|
definition: { ...definition, config_id: 'cloud-teacher', runtime: 'yuxi' as const, system_prompt: '', skills: [],
|
|
yuxi: { agent_slug: 'teacher', agent_version: 2 } } }] }) : undefined,
|
|
version: async (_account, v) => ({
|
|
version: v,
|
|
payload: { ...definition, name: '老师 v' + v, limits: { ...definition.limits, max_input_tokens: modelInputLimit } },
|
|
}),
|
|
preview: async (_account, revision) => {
|
|
if (revision !== 2) throw new TeacherError(409, 'teacher_draft_changed', '草稿变化');
|
|
return { draft_revision: revision, payload: definition };
|
|
},
|
|
readSource: durableSource ? undefined : readSource,
|
|
prepareModel: liveModel ? undefined : prepareModel,
|
|
prepareCloud: mockCloud ? prepareCloud : undefined,
|
|
});
|
|
const service = createService();
|
|
services.push(service);
|
|
return {
|
|
root,
|
|
projects,
|
|
created,
|
|
scope,
|
|
service,
|
|
run,
|
|
readSource,
|
|
prepareModel,
|
|
prepareCloud,
|
|
restart: async () => {
|
|
await service.dispose();
|
|
const restarted = createService();
|
|
services.push(restarted);
|
|
return restarted;
|
|
},
|
|
finish: () => finish(),
|
|
replyWith: (text: string) => { reply = text; },
|
|
disable: () => {
|
|
enabled = false;
|
|
},
|
|
nextVersion: () => {
|
|
version++;
|
|
},
|
|
switchAccount: () => {
|
|
accountCurrent = false;
|
|
},
|
|
useOtherAccount: () => {
|
|
account = {
|
|
id: '99999999-9999-4999-8999-999999999999',
|
|
binding: { accountKey: 'another-account', epoch: 2 },
|
|
};
|
|
},
|
|
};
|
|
}
|
|
describe('cloud coding teacher', () => {
|
|
it('does not change the selected discussion when the companion polls an older topic', async () => {
|
|
const f = await fixture();
|
|
const old = await f.service.create(f.scope);
|
|
const selected = await f.service.create(f.scope);
|
|
expect((await f.service.read(f.scope, old.id, false)).id).toBe(old.id);
|
|
expect((await f.service.list(f.scope)).lastSelectedTopicId).toBe(selected.id);
|
|
});
|
|
it('wires the Yuxi topic through scoped credentials and local tools without a local prompt or model loop', async () => {
|
|
const f = await fixture({ cloudTeacher: true });
|
|
await writeFile(path.join(f.created.project.path, 'counter.ts'), 'let count = 42;');
|
|
vi.spyOn(teacherCloud, 'assertTeacherAccount').mockReturnValue(undefined);
|
|
vi.spyOn(teacherCloud, 'teacherCloudRequest').mockResolvedValue({
|
|
scope: 'makelore-teachers', access_token: 'teacher-test', api_base_url: 'https://teacher.invalid',
|
|
expires_at: Math.floor(Date.now() / 1000) + 120,
|
|
});
|
|
const id = '22222222-2222-4222-8222-222222222222';
|
|
const requests: Array<{ path: string; body: unknown }> = [];
|
|
vi.spyOn(teacherTransport, 'proxyAwareFetch').mockImplementation(async (url, init) => {
|
|
const pathname = new URL(String(url)).pathname.replace('/api/makelore/teachers', '');
|
|
const body = init?.body ? JSON.parse(String(init.body)) : undefined;
|
|
requests.push({ path: pathname, body });
|
|
if (pathname === '/questions') return Response.json({ request_id: 'cloud-question', run_id: 'parent' });
|
|
if (pathname === '/runs/parent') return Response.json({ status: 'interrupted', interrupt: {
|
|
source: 'client_read_tools', context_id: id, calls: [{ tool_call_id: 'read-counter', name: 'read_project_file', arguments: { path: 'counter.ts' } }],
|
|
} });
|
|
if (pathname.endsWith('/tool-results')) return Response.json({ run_id: 'continued' });
|
|
if (pathname === '/runs/continued') return Response.json({ status: 'completed', output: '计数器从 42 开始。' });
|
|
throw new Error('unexpected cloud call: ' + pathname);
|
|
});
|
|
try {
|
|
const topic = await f.service.create(f.scope, undefined, undefined, 9);
|
|
await f.service.send(f.scope, topic.id, { requestId: id, text: '解释项目里的计数器' });
|
|
await vi.waitFor(async () => expect((await f.service.read(f.scope, topic.id)).requests[0].status).toBe('completed'));
|
|
const saved = (await f.service.read(f.scope, topic.id)).requests[0];
|
|
expect(saved.response).toBe('计数器从 42 开始。');
|
|
expect(saved.cloudRequestId).toBe('cloud-question');
|
|
expect(JSON.stringify(requests[0].body)).toContain('创建计数器');
|
|
expect(requests.find(item => item.path.endsWith('/tool-results'))?.body).toMatchObject({
|
|
context_id: id, results: [{ tool_call_id: 'read-counter', status: 'success', content: expect.stringContaining('let count = 42;') }],
|
|
});
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
} finally { vi.restoreAllMocks(); }
|
|
});
|
|
it('connects the scoped service, source context, file tools and model continuation', async () => {
|
|
const f = await fixture({ liveModel: true });
|
|
await writeFile(path.join(f.created.project.path, 'counter.ts'), 'let count = 42;');
|
|
vi.spyOn(teacherCloud, 'assertTeacherAccount').mockReturnValue(undefined);
|
|
vi.spyOn(teacherCloud, 'teacherCloudRequest').mockResolvedValue({
|
|
api_key: 'synthetic', base_url: 'https://teacher.invalid/v1', models: ['qwen'],
|
|
model_capabilities_v2: { schema_version: 2, models: {
|
|
qwen: { input_modalities: ['text'], output_modalities: ['text'], reasoning: { supported: false } },
|
|
} },
|
|
});
|
|
const fetch = vi.spyOn(teacherTransport, 'proxyAwareFetch')
|
|
.mockResolvedValueOnce(new Response('data: ' + JSON.stringify({ choices: [{ delta: {
|
|
tool_calls: [{ index: 0, id: 'read-counter', function: { name: 'read_project_file', arguments: '{"path":"counter.ts"}' } }],
|
|
}, finish_reason: 'tool_calls' }] }) + '\n\n'))
|
|
.mockResolvedValueOnce(new Response('data: {"choices":[{"delta":{"content":"计数器从 42 开始。"},"finish_reason":"stop"}]}\n\n'));
|
|
try {
|
|
const topic = await f.service.create(f.scope);
|
|
await f.service.send(f.scope, topic.id, { requestId: '22222222-2222-4222-8222-222222222222', text: '解释项目里的计数器' });
|
|
await vi.waitFor(async () => expect((await f.service.read(f.scope, topic.id)).requests[0].status).toBe('completed'));
|
|
expect(fetch).toHaveBeenCalledTimes(2);
|
|
const sent = JSON.parse(String(fetch.mock.calls[1][1]?.body));
|
|
expect(JSON.stringify(sent.messages)).toContain('创建计数器');
|
|
expect(sent.messages.at(-1).content).toContain('let count = 42;');
|
|
expect((await f.service.read(f.scope, topic.id)).requests[0].response).toBe('计数器从 42 开始。');
|
|
} finally {
|
|
vi.restoreAllMocks();
|
|
}
|
|
});
|
|
it('retains excerpts of the current question and long project review in the model request', async () => {
|
|
const f = await fixture({ sourceContext: {
|
|
...context,
|
|
messages: [
|
|
{ id: 'current-question', role: 'user', text: '请分析小鸟游戏的设计' },
|
|
{ id: 'current-review', role: 'assistant', text: '资源路径问题。'.repeat(1800) + '最后建议使用时间步长。' },
|
|
],
|
|
} });
|
|
const topic = await f.service.create(f.scope);
|
|
const result = await f.service.send(f.scope, topic.id, {
|
|
requestId: '22222222-2222-4222-8222-222222222222', text: '这个设计有什么问题？',
|
|
});
|
|
const sent = JSON.stringify(f.run.mock.calls[0][0]);
|
|
expect(sent).toContain('请分析小鸟游戏的设计');
|
|
expect(sent).toContain('资源路径问题');
|
|
expect(sent).toContain('最后建议使用时间步长');
|
|
expect(result.requests[0].includedSourceMessageIds).toEqual(['current-question', 'current-review']);
|
|
f.finish();
|
|
});
|
|
|
|
it('persists a fixed version, deduplicates requests, and does not change coding metadata', async () => {
|
|
const f = await fixture();
|
|
const before = await readFile(
|
|
path.join(f.created.project.path, '.makelore/conversations.json'),
|
|
'utf8'
|
|
);
|
|
const topic = await f.service.create(f.scope);
|
|
f.nextVersion();
|
|
const next = await f.service.create(f.scope);
|
|
expect(next.version).toBe(2);
|
|
expect(topic.version).toBe(1);
|
|
const input = { requestId: '22222222-2222-4222-8222-222222222222', text: '解释一下' };
|
|
await f.service.send(f.scope, topic.id, input);
|
|
await f.service.send(f.scope, topic.id, input);
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
await expect(
|
|
f.service.send(f.scope, topic.id, { ...input, text: '不同问题' })
|
|
).rejects.toMatchObject({ code: 'teacher_request_conflict' });
|
|
f.finish();
|
|
await vi.waitFor(async () =>
|
|
expect((await f.service.read(f.scope, topic.id)).requests[0].status).toBe('completed')
|
|
);
|
|
expect(
|
|
await readFile(path.join(f.created.project.path, '.makelore/conversations.json'), 'utf8')
|
|
).toBe(before);
|
|
expect((await f.service.list(f.scope)).items).toHaveLength(2);
|
|
});
|
|
it('honors disable for old topics while keeping readable history', async () => {
|
|
const f = await fixture(),
|
|
topic = await f.service.create(f.scope);
|
|
f.disable();
|
|
await expect(
|
|
f.service.send(f.scope, topic.id, {
|
|
requestId: '22222222-2222-4222-8222-222222222222',
|
|
text: '问题',
|
|
})
|
|
).rejects.toMatchObject({ code: 'teacher_disabled' });
|
|
expect((await f.service.read(f.scope, topic.id)).version).toBe(1);
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
});
|
|
it('cancels partial replies and rejects another concurrent question', async () => {
|
|
const f = await fixture(),
|
|
topic = await f.service.create(f.scope),
|
|
id = '22222222-2222-4222-8222-222222222222';
|
|
await f.service.send(f.scope, topic.id, { requestId: id, text: '问题' });
|
|
await expect(
|
|
f.service.send(f.scope, topic.id, {
|
|
requestId: '33333333-3333-4333-8333-333333333333',
|
|
text: '另一个问题',
|
|
})
|
|
).rejects.toMatchObject({ code: 'teacher_topic_busy' });
|
|
await f.service.cancel(f.scope, topic.id, id);
|
|
await vi.waitFor(async () =>
|
|
expect((await f.service.read(f.scope, topic.id)).requests[0]).toMatchObject({
|
|
status: 'cancelled',
|
|
response: '计数器保存一个数字。',
|
|
})
|
|
);
|
|
});
|
|
it('retains interrupted requests on restart without submitting again', async () => {
|
|
const f = await fixture(),
|
|
topic = await f.service.create(f.scope),
|
|
id = '22222222-2222-4222-8222-222222222222';
|
|
await f.service.send(f.scope, topic.id, { requestId: id, text: '问题' });
|
|
const store = new TeacherTopicStore(
|
|
path.join(
|
|
f.created.project.path,
|
|
'.makelore/teacher-conversations',
|
|
topic.accountId,
|
|
f.scope.sourceId
|
|
)
|
|
);
|
|
expect((await store.read(topic.id)).requests[0].status).toBe('interrupted');
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
await f.service.cancel(f.scope, topic.id, id);
|
|
});
|
|
it('checks exact preview revision and never reads project context for preview', async () => {
|
|
const f = await fixture(),
|
|
scope = { projectId: 'preview', sourceId: 'preview' };
|
|
await expect(f.service.create(scope, 1, 'sample')).rejects.toMatchObject({
|
|
code: 'teacher_draft_changed',
|
|
});
|
|
const topic = await f.service.create(scope, 2, '示例项目的计数器');
|
|
await f.service.send(scope, topic.id, {
|
|
requestId: '22222222-2222-4222-8222-222222222222',
|
|
text: '怎么改进',
|
|
});
|
|
expect(JSON.stringify(f.run.mock.calls[0][0])).toContain('示例项目的计数器');
|
|
expect(JSON.stringify(f.run.mock.calls[0][0])).not.toContain('创建计数器');
|
|
f.finish();
|
|
});
|
|
it('rejects foreign message references before submitting a model request', async () => {
|
|
const f = await fixture(),
|
|
topic = await f.service.create(f.scope);
|
|
await expect(
|
|
f.service.send(f.scope, topic.id, {
|
|
requestId: '22222222-2222-4222-8222-222222222222',
|
|
text: '解释',
|
|
references: [{ kind: 'message', messageId: 'another-source', text: '别的项目' }],
|
|
})
|
|
).rejects.toMatchObject({ code: 'teacher_reference_invalid' });
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
});
|
|
it('cascades source deletion after cancelling its reply, without recreating files', async () => {
|
|
const f = await fixture(),
|
|
topic = await f.service.create(f.scope);
|
|
await f.service.send(f.scope, topic.id, {
|
|
requestId: '22222222-2222-4222-8222-222222222222',
|
|
text: '问题',
|
|
});
|
|
await f.service.removeSource(f.scope.projectId, f.scope.sourceId);
|
|
await expect(f.service.read(f.scope, topic.id)).rejects.toMatchObject({
|
|
code: 'teacher_source_not_found',
|
|
});
|
|
await expect(
|
|
readFile(
|
|
path.join(
|
|
f.created.project.path,
|
|
'.makelore/teacher-conversations',
|
|
topic.accountId,
|
|
f.scope.sourceId,
|
|
topic.id + '.json'
|
|
)
|
|
)
|
|
).rejects.toMatchObject({ code: 'ENOENT' });
|
|
});
|
|
it('fails account changes before dispatch', async () => {
|
|
const f = await fixture(),
|
|
topic = await f.service.create(f.scope);
|
|
f.switchAccount();
|
|
await f.service.send(f.scope, topic.id, {
|
|
requestId: '22222222-2222-4222-8222-222222222222',
|
|
text: '问题',
|
|
});
|
|
await vi.waitFor(async () =>
|
|
expect((await f.service.read(f.scope, topic.id)).requests[0].status).toBe('failed')
|
|
);
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
describe('project teacher and friend consultations', () => {
|
|
const requestId = '22222222-2222-4222-8222-222222222222';
|
|
const nextRequestId = '33333333-3333-4333-8333-333333333333';
|
|
const roles: ConsultationRole[] = ['teacher', 'friend'];
|
|
|
|
it('keeps teacher and friend histories and personas separate without running on open', async () => {
|
|
const f = await fixture();
|
|
const teacherScope = { projectId: f.scope.projectId, sourceId: 'project', role: 'teacher' as const };
|
|
const friendScope = { ...teacherScope, role: 'friend' as const };
|
|
const teacher = await f.service.create(teacherScope);
|
|
const friend = await f.service.create(friendScope);
|
|
expect((await f.service.list(teacherScope)).items.map((item) => item.id)).toEqual([teacher.id]);
|
|
expect((await f.service.list(friendScope)).items.map((item) => item.id)).toEqual([friend.id]);
|
|
expect((await f.service.read(teacherScope, teacher.id)).role).toBe('teacher');
|
|
const onSnapshot = vi.fn();
|
|
const unsubscribe = await f.service.subscribe(friendScope, friend.id, onSnapshot);
|
|
expect(onSnapshot).toHaveBeenCalledOnce();
|
|
unsubscribe();
|
|
expect(f.readSource).not.toHaveBeenCalled();
|
|
expect(f.prepareModel).not.toHaveBeenCalled();
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
await expect(f.service.read(friendScope, teacher.id)).rejects.toMatchObject({ code: 'teacher_topic_not_found' });
|
|
await expect(f.service.read(teacherScope, friend.id)).rejects.toMatchObject({ code: 'teacher_topic_not_found' });
|
|
|
|
await f.service.send(teacherScope, teacher.id, { requestId, text: '我应该怎么想？' });
|
|
await f.service.send(friendScope, friend.id, { requestId, text: '你有什么感受？' });
|
|
const teacherPrompt = f.run.mock.calls[0][0][0].content;
|
|
const friendPrompt = f.run.mock.calls[1][0][0].content;
|
|
expect(teacherPrompt).toContain('引导思考');
|
|
expect(teacherPrompt).toContain('使用具体的小例子');
|
|
expect(friendPrompt).toContain('数字朋友');
|
|
expect(friendPrompt).toContain('不要假装运行、试玩');
|
|
expect(friendPrompt).not.toContain('使用具体的小例子');
|
|
expect(friendPrompt).not.toContain('你是编程老师');
|
|
expect(friend.definition.model).toEqual(teacher.definition.model);
|
|
expect(friend.version).toBe(teacher.version);
|
|
expect((await f.service.read(teacherScope, teacher.id)).requests[0].text).toBe('我应该怎么想？');
|
|
expect((await f.service.read(friendScope, friend.id)).requests[0].text).toBe('你有什么感受？');
|
|
});
|
|
|
|
it('selects the current operation conversation per request and deduplicates retries by source', async () => {
|
|
const f = await fixture();
|
|
const scope = { projectId: f.scope.projectId, sourceId: 'project' };
|
|
const other = await f.projects.conversationStore(f.created.project.path).create({
|
|
agentId: f.created.config.defaultAgentId!, title: '另一个操作对话', model: null, modelResolution: 'required',
|
|
});
|
|
f.readSource.mockImplementation(async (selected) => ({
|
|
...context,
|
|
messages: [{ id: selected.sourceId, role: 'user', text: selected.sourceId === f.scope.sourceId ? '第一段操作' : '第二段操作' }],
|
|
}));
|
|
const topic = await f.service.create(scope);
|
|
const input = { requestId, text: '我这样理解对吗？', sourceConversationId: f.scope.sourceId };
|
|
await Promise.all([f.service.send(scope, topic.id, input), f.service.send(scope, topic.id, input)]);
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
expect(f.readSource).toHaveBeenCalledWith({ ...scope, sourceId: f.scope.sourceId });
|
|
await expect(f.service.send(scope, topic.id, { ...input, sourceConversationId: other.id }))
|
|
.rejects.toMatchObject({ code: 'teacher_request_conflict' });
|
|
let complete!: () => void;
|
|
const completed = new Promise<void>((resolve) => { complete = resolve; });
|
|
const unsubscribe = await f.service.subscribe(scope, topic.id, (snapshot) => {
|
|
if (snapshot.requests[0].status === 'completed') complete();
|
|
});
|
|
f.finish();
|
|
await completed;
|
|
unsubscribe();
|
|
await f.service.send(scope, topic.id, { ...input, requestId: nextRequestId, sourceConversationId: other.id });
|
|
const latest = await f.service.read(scope, topic.id);
|
|
expect(latest.requests.map((request) => request.sourceConversationId)).toEqual([f.scope.sourceId, other.id]);
|
|
expect(latest.requests[1].includedSourceMessageIds).toEqual([other.id]);
|
|
expect(JSON.stringify(f.run.mock.calls[1][0])).toContain('第二段操作');
|
|
expect(JSON.stringify(f.run.mock.calls[1][0])).not.toContain('第一段操作');
|
|
expect(latest.id).toBe(topic.id);
|
|
});
|
|
|
|
it.each(roles)('rejects cross-project sources and isolates %s topics by project and account', async (role) => {
|
|
const f = await fixture();
|
|
const scope = { projectId: f.scope.projectId, sourceId: 'project', role };
|
|
const topic = await f.service.create(scope);
|
|
const other = await f.projects.createProject({ projectPath: path.join(f.root, 'other-project'), identity: { kind: 'create' } });
|
|
const foreign = await f.projects.conversationStore(other.project.path).create({
|
|
agentId: other.config.defaultAgentId!, title: '外部对话', model: null, modelResolution: 'required',
|
|
});
|
|
await expect(f.service.send(scope, topic.id, { requestId, text: '帮我理解', sourceConversationId: foreign.id }))
|
|
.rejects.toMatchObject({ code: 'teacher_source_not_found' });
|
|
expect(f.readSource).not.toHaveBeenCalled();
|
|
expect(f.prepareModel).not.toHaveBeenCalled();
|
|
expect((await f.service.read(scope, topic.id)).requests).toEqual([]);
|
|
const otherScope = { ...scope, projectId: other.project.id };
|
|
expect((await f.service.list(otherScope)).items).toEqual([]);
|
|
await expect(f.service.read(otherScope, topic.id)).rejects.toMatchObject({ code: 'teacher_topic_not_found' });
|
|
f.useOtherAccount();
|
|
expect((await f.service.list(scope)).items).toEqual([]);
|
|
await expect(f.service.read(scope, topic.id)).rejects.toMatchObject({ code: 'teacher_topic_not_found' });
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it.each(roles)('cancels an active %s reply when its operation source is deleted, preserving project history', async (role) => {
|
|
const f = await fixture();
|
|
const scope = { projectId: f.scope.projectId, sourceId: 'project', role };
|
|
const topic = await f.service.create(scope);
|
|
await f.service.send(scope, topic.id, { requestId, text: '问题', sourceConversationId: f.scope.sourceId });
|
|
await f.service.removeSource(f.scope.projectId, f.scope.sourceId);
|
|
const saved = await f.service.read(scope, topic.id);
|
|
expect(saved.requests[0]).toMatchObject({ status: 'cancelled', response: '计数器保存一个数字。' });
|
|
expect((await f.service.list(scope)).items.map((item) => item.id)).toEqual([topic.id]);
|
|
await expect(f.service.send(scope, topic.id, { requestId: nextRequestId, text: '再问一次', sourceConversationId: f.scope.sourceId }))
|
|
.rejects.toMatchObject({ code: 'teacher_source_not_found' });
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
});
|
|
|
|
it.each(roles)('does not dispatch a preparing %s request after its source is deleted', async (role) => {
|
|
const f = await fixture();
|
|
const scope = { projectId: f.scope.projectId, sourceId: 'project', role };
|
|
const topic = await f.service.create(scope);
|
|
let releasePreparation!: () => void;
|
|
f.prepareModel.mockImplementationOnce(async () => {
|
|
await new Promise<void>((resolve) => { releasePreparation = resolve; });
|
|
return { inputLimit: 8000, run: f.run };
|
|
});
|
|
const sending = f.service.send(scope, topic.id, { requestId, text: '问题', sourceConversationId: f.scope.sourceId });
|
|
const rejected = expect(sending).rejects.toMatchObject({ code: 'teacher_source_not_found' });
|
|
await vi.waitFor(() => expect(f.prepareModel).toHaveBeenCalledOnce());
|
|
const deleting = f.service.removeSource(f.scope.projectId, f.scope.sourceId);
|
|
await vi.waitFor(async () => expect(f.service.list(f.scope)).rejects.toMatchObject({ code: 'teacher_source_not_found' }));
|
|
releasePreparation();
|
|
await rejected;
|
|
await deleting;
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
expect((await f.service.read(scope, topic.id)).requests).toEqual([]);
|
|
});
|
|
|
|
it('settles a persisted project request as cancelled if deletion races its initial save', async () => {
|
|
const f = await fixture();
|
|
const scope = { projectId: f.scope.projectId, sourceId: 'project', role: 'friend' as const };
|
|
const topic = await f.service.create(scope);
|
|
let saved!: () => void;
|
|
let releaseSave!: () => void;
|
|
const savedToDisk = new Promise<void>((resolve) => { saved = resolve; });
|
|
const allowSaveReturn = new Promise<void>((resolve) => { releaseSave = resolve; });
|
|
const originalSave = TeacherTopicStore.prototype.save;
|
|
const spy = vi.spyOn(TeacherTopicStore.prototype, 'save').mockImplementation(async function (value) {
|
|
await originalSave.call(this, value);
|
|
if (value.id === topic.id && value.requests[0]?.status === 'preparing') {
|
|
saved();
|
|
await allowSaveReturn;
|
|
}
|
|
});
|
|
try {
|
|
const sending = f.service.send(scope, topic.id, { requestId, text: '问题', sourceConversationId: f.scope.sourceId });
|
|
await savedToDisk;
|
|
const deleting = f.service.removeSource(f.scope.projectId, f.scope.sourceId);
|
|
await vi.waitFor(async () => expect(f.service.list(f.scope)).rejects.toMatchObject({ code: 'teacher_source_not_found' }));
|
|
releaseSave();
|
|
await sending;
|
|
await deleting;
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
expect((await f.service.read(scope, topic.id)).requests[0].status).toBe('cancelled');
|
|
const stored = JSON.parse(await readFile(path.join(
|
|
f.created.project.path, '.makelore/friend-conversations', topic.accountId, 'project', topic.id + '.json'
|
|
), 'utf8'));
|
|
expect(stored.requests[0].status).toBe('cancelled');
|
|
} finally {
|
|
releaseSave();
|
|
spy.mockRestore();
|
|
}
|
|
});
|
|
|
|
it('derives friend configuration without mutating published teacher prompts or skills', () => {
|
|
const original = structuredClone(definition);
|
|
const friend = consultationDefinition(definition, 'friend');
|
|
expect(friend.teacher_id).toBe('coding-friend');
|
|
expect(friend.skills).toEqual([]);
|
|
expect(definition).toEqual(original);
|
|
expect(consultationDefinition(definition, 'teacher')).toBe(definition);
|
|
});
|
|
});
|
|
|
|
describe('teacher contextual discussion entry points', () => {
|
|
const requestId = '22222222-2222-4222-8222-222222222222';
|
|
const nextRequestId = '33333333-3333-4333-8333-333333333333';
|
|
const intro = '我们可以从你刚才想做的计数器聊起。';
|
|
const questions = ['我希望谁来使用这个计数器？', '我怎么知道数字有没有按照想法变化？'];
|
|
const response = JSON.stringify({ intro, questions });
|
|
const newScope = (f: Awaited<ReturnType<typeof fixture>>): TeacherScope => ({
|
|
projectId: f.scope.projectId, sourceId: 'project', role: 'teacher',
|
|
});
|
|
const finishRequest = async (f: Awaited<ReturnType<typeof fixture>>, scope: TeacherScope, id: string) => {
|
|
let complete!: (topic: TeacherTopic) => void;
|
|
const finished = new Promise<TeacherTopic>((resolve) => { complete = resolve; });
|
|
const unsubscribe = await f.service.subscribe(scope, id, (topic) => {
|
|
if (['completed', 'failed', 'cancelled'].includes(topic.requests.at(-1)?.status ?? '')) complete(topic);
|
|
});
|
|
f.finish();
|
|
const topic = await finished;
|
|
unsubscribe();
|
|
return topic;
|
|
};
|
|
|
|
it('validates a completed suggestion response, persists it, and includes it in the next question history', async () => {
|
|
const f = await fixture();
|
|
const scope = newScope(f);
|
|
const topic = await f.service.create(scope);
|
|
f.replyWith('```json\n' + response + '\n```');
|
|
const accepted = await f.service.send(scope, topic.id, {
|
|
requestId, intent: 'suggestions', text: '老师，帮我看看', sourceConversationId: f.scope.sourceId,
|
|
});
|
|
expect(accepted.requests[0]).toMatchObject({ intent: 'suggestions', status: 'running' });
|
|
expect(accepted.requests[0].suggestedQuestions).toBeUndefined();
|
|
expect(JSON.stringify(f.run.mock.calls[0][0])).toContain('创建计数器');
|
|
expect(JSON.stringify(f.run.mock.calls[0][0])).toContain('只返回 JSON 对象');
|
|
const completed = await finishRequest(f, scope, topic.id);
|
|
expect(completed.requests[0]).toMatchObject({
|
|
intent: 'suggestions', text: '老师，帮我看看', status: 'completed', response: intro, suggestedQuestions: questions,
|
|
usage: { inputTokens: 20, outputTokens: 10 },
|
|
});
|
|
const disk = JSON.parse(await readFile(path.join(
|
|
f.created.project.path, '.makelore/teacher-conversations', topic.accountId, 'project', topic.id + '.json'
|
|
), 'utf8'));
|
|
expect(disk.requests[0].suggestedQuestions).toEqual(questions);
|
|
expect(disk.requests[0].response).toBe(intro);
|
|
f.replyWith('你想让谁来使用？');
|
|
await f.service.send(scope, topic.id, { requestId: nextRequestId, text: questions[0] });
|
|
const nextMessages = f.run.mock.calls[1][0];
|
|
const history = nextMessages.filter((message: { role: string }) => message.role === 'assistant');
|
|
expect(history[0].content).toContain(intro);
|
|
for (const question of questions) expect(history[0].content).toContain(question);
|
|
expect(nextMessages.at(-1).content).not.toContain('只返回 JSON 对象');
|
|
expect((await f.service.read(scope, topic.id)).requests[1].intent).toBe('question');
|
|
expect(completed.definition.system_prompt).toBe(definition.system_prompt);
|
|
});
|
|
|
|
it.each(['not JSON', JSON.stringify({ intro, questions: ['只有一个问题？'] })])('fails malformed suggestions without displaying raw output or losing usage: %s', async (invalid) => {
|
|
const f = await fixture();
|
|
const scope = newScope(f);
|
|
const topic = await f.service.create(scope);
|
|
f.replyWith(invalid);
|
|
await f.service.send(scope, topic.id, { requestId, intent: 'suggestions', text: '老师，帮我看看' });
|
|
const completed = await finishRequest(f, scope, topic.id);
|
|
expect(completed.requests[0]).toMatchObject({ status: 'failed', response: '', usage: { inputTokens: 20, outputTokens: 10 } });
|
|
expect(completed.requests[0].suggestedQuestions).toBeUndefined();
|
|
expect(completed.requests[0].error).toContain('请再试一次');
|
|
const disk = JSON.parse(await readFile(path.join(
|
|
f.created.project.path, '.makelore/teacher-conversations', topic.accountId, 'project', topic.id + '.json'
|
|
), 'utf8'));
|
|
expect(disk.requests[0].response).toBe('');
|
|
expect(disk.requests[0].suggestedQuestions).toBeUndefined();
|
|
});
|
|
|
|
it('does not treat a cancelled response as valid suggestions even when its JSON is complete', async () => {
|
|
const f = await fixture();
|
|
const scope = newScope(f);
|
|
const topic = await f.service.create(scope);
|
|
f.replyWith(response);
|
|
await f.service.send(scope, topic.id, { requestId, intent: 'suggestions', text: '老师，帮我看看' });
|
|
await f.service.cancel(scope, topic.id, requestId);
|
|
await vi.waitFor(async () => {
|
|
const request = (await f.service.read(scope, topic.id)).requests[0];
|
|
expect(request).toMatchObject({ status: 'cancelled', response: '' });
|
|
expect(request.suggestedQuestions).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
it('does not parse suggestions after a failed stream or account change', async () => {
|
|
const f = await fixture();
|
|
const scope = newScope(f);
|
|
const topic = await f.service.create(scope);
|
|
f.run.mockImplementationOnce(async (_messages, _signal, onText) => {
|
|
onText(response);
|
|
throw new TeacherError(502, 'teacher_stream_interrupted', '回复中断，请再试一次。');
|
|
});
|
|
await f.service.send(scope, topic.id, { requestId, intent: 'suggestions', text: '老师，帮我看看' });
|
|
await vi.waitFor(async () => {
|
|
const request = (await f.service.read(scope, topic.id)).requests[0];
|
|
expect(request).toMatchObject({ status: 'failed', response: '' });
|
|
expect(request.suggestedQuestions).toBeUndefined();
|
|
});
|
|
const next = await f.service.create(scope);
|
|
f.replyWith(response);
|
|
await f.service.send(scope, next.id, { requestId: nextRequestId, intent: 'suggestions', text: '老师，帮我看看' });
|
|
f.switchAccount();
|
|
f.finish();
|
|
await vi.waitFor(async () => {
|
|
const request = (await f.service.read(scope, next.id)).requests[0];
|
|
expect(request).toMatchObject({ status: 'failed', response: '' });
|
|
expect(request.suggestedQuestions).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
it('retains source-deletion cancellation for suggestions', async () => {
|
|
const f = await fixture();
|
|
const scope = newScope(f);
|
|
const topic = await f.service.create(scope);
|
|
f.replyWith(response);
|
|
await f.service.send(scope, topic.id, { requestId, intent: 'suggestions', text: '老师，帮我看看', sourceConversationId: f.scope.sourceId });
|
|
await f.service.removeSource(f.scope.projectId, f.scope.sourceId);
|
|
const saved = await f.service.read(scope, topic.id);
|
|
expect(saved.requests[0]).toMatchObject({ status: 'cancelled', response: '' });
|
|
expect(saved.requests[0].suggestedQuestions).toBeUndefined();
|
|
});
|
|
|
|
it('adds a one-question guided opening for this round without changing the teacher system instructions', async () => {
|
|
const f = await fixture();
|
|
const scope = newScope(f);
|
|
const topic = await f.service.create(scope);
|
|
f.replyWith('先想一个人：你希望谁来用你的计数器？');
|
|
await f.service.send(scope, topic.id, { requestId, intent: 'guided-help', text: '我也说不清，你带我看看' });
|
|
const completed = await finishRequest(f, scope, topic.id);
|
|
expect(completed.requests[0]).toMatchObject({
|
|
intent: 'guided-help', status: 'completed', response: '先想一个人：你希望谁来用你的计数器？',
|
|
});
|
|
expect(completed.requests[0].suggestedQuestions).toBeUndefined();
|
|
const messages = f.run.mock.calls[0][0];
|
|
expect(messages.at(-1).content).toContain('只发起一个具体、容易回答的交流起点');
|
|
expect(messages[0]).toEqual(compileTeacherContext(definition, context, [], '问题', [], undefined, 'question', undefined, true).messages[0]);
|
|
});
|
|
|
|
it('deduplicates normalized question intent and rejects reuse with another intent', async () => {
|
|
const f = await fixture();
|
|
const scope = newScope(f);
|
|
const topic = await f.service.create(scope);
|
|
const input = { requestId, text: '老师，帮我看看' };
|
|
await f.service.send(scope, topic.id, input);
|
|
await f.service.send(scope, topic.id, { ...input, intent: 'question' });
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
await expect(f.service.send(scope, topic.id, { ...input, intent: 'suggestions' }))
|
|
.rejects.toMatchObject({ code: 'teacher_request_conflict' });
|
|
const second = await f.service.create(scope);
|
|
const suggestions = { requestId: nextRequestId, intent: 'suggestions' as const, text: '老师，帮我看看' };
|
|
await Promise.all([f.service.send(scope, second.id, suggestions), f.service.send(scope, second.id, suggestions)]);
|
|
expect(f.run).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it.each(['suggestions', 'guided-help'] as const)('rejects %s outside the project teacher before preparing a model', async (intent) => {
|
|
const f = await fixture();
|
|
const friendScope = { ...newScope(f), role: 'friend' as const };
|
|
const previewScope = { projectId: 'preview', sourceId: 'preview' };
|
|
const friend = await f.service.create(friendScope);
|
|
const legacy = await f.service.create(f.scope);
|
|
const preview = await f.service.create(previewScope, 2, '示例项目');
|
|
for (const [scope, topic] of [[friendScope, friend], [f.scope, legacy], [previewScope, preview]] as const) {
|
|
await expect(f.service.send(scope, topic.id, { requestId, text: '老师，帮我看看', intent }))
|
|
.rejects.toMatchObject({ code: 'teacher_intent_invalid' });
|
|
expect((await f.service.read(scope, topic.id)).requests).toEqual([]);
|
|
}
|
|
expect(f.prepareModel).not.toHaveBeenCalled();
|
|
expect(f.readSource).not.toHaveBeenCalled();
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it.each(['unknown', '', null, 1, {}])('rejects malformed request intent %j before any model preparation', async (intent) => {
|
|
const f = await fixture();
|
|
const scope = newScope(f);
|
|
const topic = await f.service.create(scope);
|
|
await expect(f.service.send(scope, topic.id, { requestId, text: '老师，帮我看看', intent: intent as TeacherRequestIntent }))
|
|
.rejects.toMatchObject({ code: 'teacher_intent_invalid' });
|
|
expect(f.prepareModel).not.toHaveBeenCalled();
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('budgets the round-specific instructions and honestly starts from ideas with no source', () => {
|
|
const empty = { ...context, messages: [] };
|
|
const ordinary = compileTeacherContext(definition, empty, [], '老师，帮我看看', []);
|
|
const suggestions = compileTeacherContext(definition, empty, [], '老师，帮我看看', [], 8000, 'suggestions');
|
|
expect(suggestions.messages[0]).toEqual(ordinary.messages[0]);
|
|
expect(suggestions.messages.at(-1)?.content).toContain('没有可用上下文时');
|
|
expect(suggestions.messages.at(-1)?.content).toContain('不要编造');
|
|
expect(() => compileTeacherContext(definition, empty, [], '老师，帮我看看', [], estimateTeacherTokens(ordinary.messages), 'suggestions'))
|
|
.toThrow('超过上下文预算');
|
|
});
|
|
|
|
it('trims and deduplicates valid suggestions, accepting plain JSON and standard JSON code fences', () => {
|
|
const raw = JSON.stringify({ intro: ' ' + intro + ' ', questions: [' ' + questions[0], questions[1], questions[0] + ' '] });
|
|
expect(parseTeacherSuggestions(raw)).toEqual({ intro, questions });
|
|
expect(parseTeacherSuggestions('```json\n' + raw + '\n```')).toEqual({ intro, questions });
|
|
expect(parseTeacherSuggestions('```\n' + raw + '\n```')).toEqual({ intro, questions });
|
|
});
|
|
|
|
it.each([
|
|
null,
|
|
[],
|
|
{ intro: '', questions },
|
|
{ intro: ' '.repeat(3), questions },
|
|
{ intro: '字'.repeat(401), questions },
|
|
{ intro, questions: [questions[0]] },
|
|
{ intro, questions: [...questions, '第三个？', '第四个？'] },
|
|
{ intro, questions: [questions[0], questions[0]] },
|
|
{ intro, questions: [questions[0], ''] },
|
|
{ intro, questions: [questions[0], '字'.repeat(121)] },
|
|
{ intro, questions: [questions[0], 1] },
|
|
])('rejects suggestion responses that cannot become two or three short questions: %j', (value) => {
|
|
expect(() => parseTeacherSuggestions(JSON.stringify(value))).toThrow('请再试一次');
|
|
});
|
|
});
|
|
|
|
describe('project teacher check-ins', () => {
|
|
const requestId = '22222222-2222-4222-8222-222222222222';
|
|
const nextRequestId = '33333333-3333-4333-8333-333333333333';
|
|
const thirdRequestId = '44444444-4444-4444-8444-444444444444';
|
|
const projectScope = (f: Awaited<ReturnType<typeof fixture>>): TeacherScope => ({
|
|
projectId: f.scope.projectId, sourceId: 'project', role: 'teacher',
|
|
});
|
|
const input = (f: Awaited<ReturnType<typeof fixture>>, id = requestId) => ({
|
|
requestId: id, sourceConversationId: f.scope.sourceId,
|
|
});
|
|
const settle = async (f: Awaited<ReturnType<typeof fixture>>, topic: TeacherTopic) => {
|
|
f.finish();
|
|
await vi.waitFor(async () => expect((await f.service.read(projectScope(f), topic.id)).requests.at(-1)?.status).toBe('completed'));
|
|
return await f.service.read(projectScope(f), topic.id);
|
|
};
|
|
const startClock = () => {
|
|
vi.useFakeTimers({ toFake: ['Date'] });
|
|
vi.setSystemTime(new Date('2026-09-22T12:00:00Z'));
|
|
};
|
|
|
|
it('continues the selected teacher history with a real configured-model call and no fabricated student turn', async () => {
|
|
const f = await fixture();
|
|
const scope = projectScope(f);
|
|
const selected = await f.service.create(scope);
|
|
await f.service.send(scope, selected.id, { requestId, text: '变量是什么意思？' });
|
|
await settle(f, selected);
|
|
await f.service.create(scope);
|
|
await f.service.read(scope, selected.id);
|
|
f.replyWith('你已经在试着保存数字了。想想这个数字要在什么时候改变？');
|
|
const result = await f.service.checkIn(scope, input(f, nextRequestId));
|
|
expect(result.topic?.id).toBe(selected.id);
|
|
const saved = await settle(f, result.topic!);
|
|
expect(saved.requests.at(-1)).toMatchObject({
|
|
intent: 'check-in', text: '', references: [], sourceConversationId: f.scope.sourceId, status: 'completed',
|
|
});
|
|
expect(saved.requests.at(-1)?.checkInSourceFingerprint).toMatch(/^[a-f0-9]{64}$/);
|
|
const messages = f.run.mock.calls[1][0];
|
|
expect(messages[0].content).toContain('通过问题引导思考');
|
|
expect(messages[0].content).toContain('使用具体的小例子');
|
|
expect(JSON.stringify(messages)).toContain('创建计数器');
|
|
expect(JSON.stringify(messages)).toContain('变量是什么意思');
|
|
expect(messages.at(-1)).toMatchObject({ role: 'system' });
|
|
expect(messages.at(-1).content).toContain('约 120 字');
|
|
expect(messages.at(-1).content).toContain('最多问一个问题');
|
|
expect(messages.at(-1).content).toContain('不能假装');
|
|
expect(f.prepareModel).toHaveBeenLastCalledWith(expect.anything(), selected.definition, expect.objectContaining({
|
|
projectPath: f.created.project.path, source: context, assertCurrent: expect.any(Function),
|
|
}), { finalOnly: false });
|
|
const followup = compileTeacherContext(saved.definition, context, saved.requests, '继续说', []);
|
|
expect(followup.messages.filter((message) => message.role === 'user').map((message) => message.content))
|
|
.toEqual([expect.stringContaining('创建计数器'), expect.stringContaining('变量是什么意思？'), '当前问题：\n继续说']);
|
|
expect(followup.messages.filter((message) => message.role === 'assistant').map((message) => message.content))
|
|
.toContainEqual(expect.stringContaining(saved.requests.at(-1)!.response));
|
|
});
|
|
|
|
it('serializes first-topic creation, returns the same accepted request, and skips a concurrent distinct check-in', async () => {
|
|
const f = await fixture();
|
|
const scope = projectScope(f);
|
|
const [first, duplicate, competing] = await Promise.all([
|
|
f.service.checkIn(scope, input(f)), f.service.checkIn(scope, input(f)),
|
|
f.service.checkIn(scope, input(f, nextRequestId)),
|
|
]);
|
|
expect(first.topic?.id).toBe(duplicate.topic?.id);
|
|
expect(first.topic?.requests).toHaveLength(1);
|
|
expect(competing).toEqual({ topic: null, skipped: 'busy' });
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
expect((await f.service.list(scope)).items).toHaveLength(1);
|
|
expect((await f.service.list(scope)).items[0].title).toBe('和老师聊聊');
|
|
await f.service.create(scope);
|
|
expect((await f.service.checkIn(scope, input(f))).topic?.id).toBe(first.topic?.id);
|
|
await expect(f.service.checkIn(scope, { ...input(f), sourceConversationId: thirdRequestId }))
|
|
.rejects.toMatchObject({ code: 'teacher_request_conflict' });
|
|
});
|
|
|
|
it('enforces project-wide cooldown and ignores cursor churn until completed text changes', async () => {
|
|
startClock();
|
|
const f = await fixture();
|
|
const scope = projectScope(f);
|
|
const first = await f.service.checkIn(scope, input(f));
|
|
await settle(f, first.topic!);
|
|
await f.service.create(scope);
|
|
expect(await f.service.checkIn(scope, input(f, nextRequestId))).toEqual({ topic: null, skipped: 'cooldown' });
|
|
vi.setSystemTime(Date.now() + TEACHER_CHECK_IN_INTERVAL_MS);
|
|
f.readSource.mockResolvedValue({ ...context, cursor: { workerGeneration: 90, seq: 500 } });
|
|
expect(await f.service.checkIn(scope, input(f, nextRequestId))).toEqual({ topic: null, skipped: 'unchanged' });
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
f.readSource.mockResolvedValue({ ...context, messages: [...context.messages, { id: 'new', role: 'assistant', text: '添加了重置按钮。' }] });
|
|
const next = await f.service.checkIn(scope, input(f, nextRequestId));
|
|
expect(next.topic?.id).not.toBe(first.topic?.id);
|
|
expect(f.run).toHaveBeenCalledTimes(2);
|
|
expect(JSON.stringify(f.run.mock.calls[1][0])).toContain('添加了重置按钮');
|
|
});
|
|
|
|
it('uses persisted history for request deduplication, cooldown, and unchanged-source checks after restart', async () => {
|
|
startClock();
|
|
const f = await fixture();
|
|
const scope = projectScope(f);
|
|
const first = await f.service.checkIn(scope, input(f));
|
|
await settle(f, first.topic!);
|
|
const restarted = await f.restart();
|
|
expect((await restarted.checkIn(scope, input(f))).topic?.id).toBe(first.topic?.id);
|
|
expect(await restarted.checkIn(scope, input(f, nextRequestId))).toEqual({ topic: null, skipped: 'cooldown' });
|
|
vi.setSystemTime(Date.now() + TEACHER_CHECK_IN_INTERVAL_MS);
|
|
expect(await restarted.checkIn(scope, input(f, nextRequestId))).toEqual({ topic: null, skipped: 'unchanged' });
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
});
|
|
|
|
it('follows up on unchanged work after fifteen minutes instead of suppressing that source forever', async () => {
|
|
startClock();
|
|
const f = await fixture();
|
|
const scope = projectScope(f);
|
|
const first = await f.service.checkIn(scope, input(f));
|
|
await settle(f, first.topic!);
|
|
const restarted = await f.restart();
|
|
vi.setSystemTime(Date.parse(first.topic!.requests[0].createdAt) + TEACHER_UNCHANGED_CHECK_IN_INTERVAL_MS - 1);
|
|
expect(await restarted.checkIn(scope, input(f, nextRequestId))).toEqual({ topic: null, skipped: 'unchanged' });
|
|
vi.setSystemTime(Date.now() + 1);
|
|
expect((await restarted.checkIn(scope, input(f, nextRequestId))).topic?.id).toBe(first.topic?.id);
|
|
expect(f.run).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it('counts a new teacher discussion as progress even when operation text has not changed', async () => {
|
|
startClock();
|
|
const f = await fixture();
|
|
const scope = projectScope(f);
|
|
const first = await f.service.checkIn(scope, input(f));
|
|
await settle(f, first.topic!);
|
|
await f.service.send(scope, first.topic!.id, { requestId: nextRequestId, sourceConversationId: f.scope.sourceId, text: '我想让宠物跳起来的时候有个小惊喜' });
|
|
await settle(f, first.topic!);
|
|
vi.setSystemTime(Date.now() + TEACHER_CHECK_IN_INTERVAL_MS);
|
|
expect((await f.service.checkIn(scope, input(f, thirdRequestId))).topic?.id).toBe(first.topic?.id);
|
|
expect(f.run).toHaveBeenCalledTimes(3);
|
|
expect(JSON.stringify(f.run.mock.calls[2][0])).toContain('小惊喜');
|
|
});
|
|
|
|
it('can follow an existing teacher discussion before the first completed operation message', async () => {
|
|
const f = await fixture();
|
|
const scope = projectScope(f);
|
|
const topic = await f.service.create(scope);
|
|
await f.service.send(scope, topic.id, { requestId, sourceConversationId: f.scope.sourceId, text: '我想做一个养宠物的游戏' });
|
|
await settle(f, topic);
|
|
f.readSource.mockResolvedValue({ ...context, messages: [] });
|
|
expect((await f.service.checkIn(scope, input(f, nextRequestId))).topic?.id).toBe(topic.id);
|
|
expect(f.run).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it('does not create a topic or call a model without completed source text', async () => {
|
|
const f = await fixture();
|
|
f.readSource.mockResolvedValue({ ...context, messages: [] });
|
|
expect(await f.service.checkIn(projectScope(f), input(f))).toEqual({ topic: null, skipped: 'no-context' });
|
|
expect((await f.service.list(projectScope(f))).items).toEqual([]);
|
|
expect(f.prepareModel).not.toHaveBeenCalled();
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('skips archived or disabled sources and rejects sources outside the project before reading context', async () => {
|
|
const f = await fixture();
|
|
const scope = projectScope(f);
|
|
await expect(f.service.checkIn(scope, { ...input(f), sourceConversationId: thirdRequestId }))
|
|
.rejects.toMatchObject({ code: 'teacher_source_not_found' });
|
|
const conversations = f.projects.conversationStore(f.created.project.path);
|
|
await conversations.patchMetadata(f.scope.sourceId, { archivedAt: new Date().toISOString() });
|
|
expect(await f.service.checkIn(scope, input(f))).toEqual({ topic: null, skipped: 'archived' });
|
|
await conversations.patchMetadata(f.scope.sourceId, { archivedAt: null });
|
|
f.disable();
|
|
expect(await f.service.checkIn(scope, input(f))).toEqual({ topic: null, skipped: 'disabled' });
|
|
expect(f.readSource).not.toHaveBeenCalled();
|
|
expect(f.prepareModel).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('rejects friend, preview, legacy-source scopes and ordinary messages that try to bypass check-in guards', async () => {
|
|
const f = await fixture();
|
|
for (const scope of [{ ...projectScope(f), role: 'friend' as const }, { projectId: 'preview', sourceId: 'preview' }, f.scope]) {
|
|
await expect(f.service.checkIn(scope, input(f))).rejects.toMatchObject({ code: 'teacher_intent_invalid' });
|
|
}
|
|
const scope = projectScope(f);
|
|
const topic = await f.service.create(scope);
|
|
await expect(f.service.send(scope, topic.id, { ...input(f), intent: 'check-in', text: '' }))
|
|
.rejects.toMatchObject({ code: 'teacher_intent_invalid' });
|
|
expect(f.readSource).not.toHaveBeenCalled();
|
|
expect(f.prepareModel).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('waits for manual request preparation and skips while any teacher topic is answering', async () => {
|
|
const f = await fixture();
|
|
const scope = projectScope(f);
|
|
const answering = await f.service.create(scope);
|
|
await f.service.create(scope);
|
|
let releaseSource!: (source: TeacherSourceContext) => void;
|
|
f.readSource.mockImplementationOnce(() => new Promise((resolve) => { releaseSource = resolve; }));
|
|
const manual = f.service.send(scope, answering.id, { requestId, text: '解释一下', sourceConversationId: f.scope.sourceId });
|
|
await vi.waitFor(() => expect(f.readSource).toHaveBeenCalledOnce());
|
|
const check = f.service.checkIn(scope, input(f, nextRequestId));
|
|
releaseSource(context);
|
|
await manual;
|
|
expect(await check).toEqual({ topic: null, skipped: 'busy' });
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
});
|
|
|
|
it('does not persist or run a check-in when the account changes during preparation', async () => {
|
|
const f = await fixture();
|
|
f.prepareModel.mockImplementationOnce(async () => {
|
|
f.switchAccount();
|
|
return { inputLimit: 8000, run: f.run };
|
|
});
|
|
await expect(f.service.checkIn(projectScope(f), input(f))).rejects.toMatchObject({ code: 'teacher_account_changed' });
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
const list = await f.service.list(projectScope(f));
|
|
expect((await f.service.read(projectScope(f), list.items[0].id)).requests).toEqual([]);
|
|
});
|
|
|
|
it('cancels an accepted check-in when its source is deleted and never restarts it', async () => {
|
|
const f = await fixture();
|
|
const scope = projectScope(f);
|
|
const first = await f.service.checkIn(scope, input(f));
|
|
await f.service.removeSource(f.scope.projectId, f.scope.sourceId);
|
|
expect((await f.service.read(scope, first.topic!.id)).requests[0].status).toBe('cancelled');
|
|
expect((await f.service.checkIn(scope, input(f))).topic?.requests[0].status).toBe('cancelled');
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
});
|
|
});
|
|
|
|
it('accepts teacher check-ins through the project endpoint and returns skip results without a model call', async () => {
|
|
const f = await fixture();
|
|
const server = createServer((req, res) => {
|
|
void handleCodingTeacherRoutes(req, res, new URL(req.url!, 'http://localhost'), {
|
|
codingProducts: { teacher: f.service },
|
|
} as HostApiContext);
|
|
});
|
|
await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
|
|
const address = server.address();
|
|
if (!address || typeof address === 'string') throw new Error('no address');
|
|
const url = `http://127.0.0.1:${address.port}/api/coding/projects/${f.scope.projectId}/teacher-check-in`;
|
|
const input = { requestId: '22222222-2222-4222-8222-222222222222', sourceConversationId: f.scope.sourceId };
|
|
const post = () => fetch(url, {
|
|
method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(input),
|
|
});
|
|
try {
|
|
expect((await fetch(url)).status).toBe(405);
|
|
f.readSource.mockResolvedValueOnce({ ...context, messages: [] });
|
|
const skipped = await post();
|
|
expect(skipped.status).toBe(200);
|
|
expect(await skipped.json()).toEqual({ topic: null, skipped: 'no-context' });
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
const accepted = await post();
|
|
expect(accepted.status).toBe(200);
|
|
const result = await accepted.json();
|
|
expect(result.topic.requests[0]).toMatchObject({ intent: 'check-in', text: '', status: 'running' });
|
|
expect((await (await post()).json()).topic.id).toBe(result.topic.id);
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
} finally {
|
|
server.closeAllConnections();
|
|
await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
describe('teacher context and wire contract', () => {
|
|
it('takes only complete user/assistant text and preserves the read cursor', () => {
|
|
const snapshot = {
|
|
nodes: [
|
|
{
|
|
kind: 'message',
|
|
id: 'u',
|
|
role: 'user',
|
|
status: 'complete',
|
|
blocks: [{ kind: 'text', status: 'complete', text: '用户问题' }],
|
|
},
|
|
{
|
|
kind: 'message',
|
|
id: 'a',
|
|
role: 'assistant',
|
|
status: 'complete',
|
|
blocks: [
|
|
{ kind: 'thinking', status: 'complete', text: 'private' },
|
|
{ kind: 'text', status: 'complete', text: '完整回答' },
|
|
],
|
|
},
|
|
{
|
|
kind: 'message',
|
|
id: 'live',
|
|
role: 'assistant',
|
|
status: 'streaming',
|
|
blocks: [{ kind: 'text', status: 'streaming', text: '未完成' }],
|
|
},
|
|
{ kind: 'tool', id: 'tool', args: { password: 'secret' } },
|
|
],
|
|
cursor: { workerGeneration: 2, seq: 10 },
|
|
} as ConversationSnapshot;
|
|
const selected = sourceContext(snapshot);
|
|
expect(selected.messages.map((message) => message.text)).toEqual(['用户问题', '完整回答']);
|
|
expect(selected.cursor).toEqual(snapshot.cursor);
|
|
});
|
|
it('trims old source messages but retains instructions, Skill, explicit quote and question', () => {
|
|
const references = [{ kind: 'code' as const, text: 'count += 1' }];
|
|
const budget = estimateTeacherTokens(compileTeacherContext(
|
|
definition, context, [], '为什么这样？', references
|
|
).messages);
|
|
const compiled = compileTeacherContext(
|
|
definition,
|
|
{
|
|
...context,
|
|
messages: [{ id: 'old', role: 'user', text: 'old'.repeat(4000) }, ...context.messages],
|
|
},
|
|
[],
|
|
'为什么这样？',
|
|
references,
|
|
budget
|
|
);
|
|
const text = JSON.stringify(compiled.messages);
|
|
expect(text).toContain('通过问题引导思考');
|
|
expect(text).toContain('使用具体的小例子');
|
|
expect(text).toContain('count += 1');
|
|
expect(compiled.messages[0].content).toContain(TEACHER_BEHAVIOR_PROMPT);
|
|
expect(compiled.includedSourceMessageIds).toEqual(['source-user']);
|
|
expect(compiled.omittedMessages).toBe(1);
|
|
expect(() => compileTeacherContext(definition, context, [], 'x'.repeat(9000), [])).toThrow(
|
|
'超过上下文预算'
|
|
);
|
|
});
|
|
it('keeps a long previous teacher answer available for a follow-up within the read budget', () => {
|
|
const history: TeacherRequest[] = [{
|
|
id: 'previous', text: '帮我分析', response: '重力的问题。'.repeat(1800) + '建议使用时间步长。',
|
|
references: [], createdAt: 'now', sourceCursor: context.cursor, sourceCapturedAt: 'now',
|
|
includedSourceMessageIds: [], omittedMessages: 0, status: 'completed',
|
|
}];
|
|
const question = '你刚才的建议是什么意思？';
|
|
const fixed = compileTeacherContext(definition, context, [], question, [], undefined, 'question', undefined, true);
|
|
const budget = estimateTeacherTokens(fixed.messages) + 1500;
|
|
const compiled = compileTeacherContext(definition, context, history, question, [], budget, 'question', undefined, true);
|
|
expect(compiled.truncatedMessages).toBeGreaterThan(0);
|
|
expect(estimateTeacherTokens(compiled.messages)).toBeLessThanOrEqual(budget);
|
|
expect(JSON.stringify(compiled.messages)).toContain('创建计数器');
|
|
expect(JSON.stringify(compiled.messages)).toContain('重力的问题');
|
|
expect(JSON.stringify(compiled.messages)).toContain('建议使用时间步长');
|
|
});
|
|
it('sends no tools, ignores reasoning deltas, and requires a terminal stream', async () => {
|
|
const text: string[] = [];
|
|
const fake = vi.fn(
|
|
async () =>
|
|
new Response(
|
|
'data: {"choices":[{"delta":{"reasoning_content":"hidden","content":"答案"}}]}\n\ndata: {"choices":[{"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":10,"completion_tokens":3}}\n\ndata: [DONE]\n\n'
|
|
)
|
|
);
|
|
const usage = await streamTeacherReply(
|
|
{ base_url: 'https://gateway.test/v1', api_key: 'private' },
|
|
'model',
|
|
{},
|
|
1500,
|
|
[{ role: 'user', content: '问题' }],
|
|
new AbortController().signal,
|
|
(delta) => text.push(delta),
|
|
fake
|
|
);
|
|
expect(text).toEqual(['答案']);
|
|
expect(usage).toEqual({ inputTokens: 10, outputTokens: 3 });
|
|
const input = fake.mock.calls[0] as unknown as [string, RequestInit];
|
|
const body = JSON.parse(input[1].body as string);
|
|
expect(body).not.toHaveProperty('tools');
|
|
expect(input[0]).toBe('https://gateway.test/v1/chat/completions');
|
|
await expect(
|
|
streamTeacherReply(
|
|
{ base_url: 'https://gateway.test/v1', api_key: 'private' },
|
|
'model',
|
|
{},
|
|
1500,
|
|
[],
|
|
new AbortController().signal,
|
|
() => undefined,
|
|
async () => new Response('data: {"choices":[{"delta":{"content":"半句"}}]}\n\n')
|
|
)
|
|
).rejects.toMatchObject({ code: 'teacher_stream_interrupted' });
|
|
});
|
|
it('accepts only the exact credential-free preview link', () => {
|
|
expect(
|
|
parseNianCodeDeepLinkUrl('niancode://coding-teacher/preview?draft_revision=2')
|
|
).toMatchObject({ type: 'teacher-preview', draftRevision: 2 });
|
|
expect(
|
|
parseNianCodeDeepLinkUrl('niancode://coding-teacher/preview?draft_revision=2&token=x')
|
|
).toBeNull();
|
|
expect(
|
|
parseNianCodeDeepLinkUrl('niancode://coding-teacher/preview?draft_revision=0')
|
|
).toBeNull();
|
|
});
|
|
it('creates one default and preserves all legacy identities without reviving disabled Agents', () => {
|
|
const base = createCodingProjectConfigV2();
|
|
expect(base.agents).toHaveLength(1);
|
|
expect(ensureDefaultCodingAgent(base)).toBe(base);
|
|
const legacy = {
|
|
...base,
|
|
defaultAgentId: undefined,
|
|
agents: [
|
|
{ ...base.agents[0], id: 'old', enabled: false },
|
|
{ ...base.agents[0], id: 'existing', pinned: true },
|
|
],
|
|
};
|
|
const normalized = ensureDefaultCodingAgent(legacy);
|
|
expect(normalized.defaultAgentId).toBe('existing');
|
|
expect(normalized.agents).toEqual(legacy.agents);
|
|
const disabled = ensureDefaultCodingAgent({ ...legacy, agents: [legacy.agents[0]] });
|
|
expect(disabled.agents[0].enabled).toBe(false);
|
|
expect(disabled.agents).toHaveLength(2);
|
|
});
|
|
});
|
|
import {mkdir, writeFile} from 'node:fs/promises';
|
|
import {readCodingConversationHistory} from '../../electron/coding-projects/conversation-history';
|
|
import {getPiManagedPaths} from '../../electron/coding-runtime/pi/resource-loader';
|
|
it('reads only the durable active branch without starting a worker', async()=>{
|
|
const f=await fixture();
|
|
const metadata=(await f.projects.conversationStore(f.created.project.path).get(f.scope.sourceId))!;
|
|
const folder=path.join(getPiManagedPaths(f.root).sessionsDir,f.scope.projectId);await mkdir(folder,{recursive:true});
|
|
const entries=[
|
|
{type:'session',id:'session'},
|
|
{type:'message',id:'root',parentId:null,message:{role:'user',content:'开始学习'}},
|
|
{type:'message',id:'abandoned',parentId:'root',message:{role:'user',content:'旧分支内容'}},
|
|
{type:'message',id:'active',parentId:'root',message:{role:'user',content:'当前分支内容'}},
|
|
];
|
|
await writeFile(path.join(folder,'session-test.jsonl'),entries.map(entry=>JSON.stringify(entry)).join('\n'));
|
|
const snapshot=await readCodingConversationHistory(f.root,f.scope.projectId,{...metadata,sessionKey:'session-test'});
|
|
expect(sourceContext(snapshot).messages.map(message=>message.text)).toEqual(['开始学习','当前分支内容']);
|
|
expect(snapshot.worker.status).toBe('stopped');
|
|
});
|
|
it('sends durable source history through the real teacher service without a running worker', async () => {
|
|
const f = await fixture({ durableSource: true });
|
|
await f.projects.conversationStore(f.created.project.path).ensureSessionBinding(f.scope.sourceId,
|
|
async () => ({ sessionKey: 'teacher-source', piSessionId: 'teacher-source' }));
|
|
const folder = path.join(getPiManagedPaths(f.root).sessionsDir, f.scope.projectId);
|
|
await mkdir(folder, { recursive: true });
|
|
await writeFile(path.join(folder, 'teacher-source.jsonl'), [
|
|
{ type: 'session', id: 'teacher-source' },
|
|
{ type: 'message', id: 'root', parentId: null, message: { role: 'user', content: '分析小鸟游戏' } },
|
|
{ type: 'message', id: 'other', parentId: 'root', message: { role: 'user', content: '废弃的分支' } },
|
|
{ type: 'message', id: 'active', parentId: 'root', message: { role: 'assistant', content: [{ type: 'text', text: '检查碰撞检测' }] } },
|
|
].map(entry => JSON.stringify(entry)).join('\n'));
|
|
const topic = await f.service.create(f.scope);
|
|
await f.service.send(f.scope, topic.id, { requestId: '22222222-2222-4222-8222-222222222222', text: '老师怎么看？' });
|
|
const sent = JSON.stringify(f.run.mock.calls[0][0]);
|
|
expect(sent).toContain('分析小鸟游戏');
|
|
expect(sent).toContain('检查碰撞检测');
|
|
expect(sent).not.toContain('废弃的分支');
|
|
f.finish();
|
|
});
|
|
import {createServer} from 'node:http';
|
|
import {handleCodingTeacherRoutes} from '../../electron/api/routes/coding-teacher';
|
|
import type {HostApiContext} from '../../electron/api/context';
|
|
it('serves topic acceptance and SSE snapshots without cancelling on stream close',async()=>{
|
|
const f=await fixture();
|
|
const server=createServer((req,res)=>{void handleCodingTeacherRoutes(req,res,new URL(req.url!,'http://localhost'),{codingProducts:{teacher:f.service}} as HostApiContext);});
|
|
await new Promise<void>(resolve=>server.listen(0,'127.0.0.1',resolve));
|
|
const address=server.address();if(!address||typeof address==='string')throw new Error('no address');
|
|
const origin='http://127.0.0.1:'+address.port;
|
|
const base=origin+'/api/coding/projects/'+f.scope.projectId+'/conversations/'+f.scope.sourceId+'/teacher-topics';
|
|
try {
|
|
const created=await fetch(base,{method:'POST',headers:{'Content-Type':'application/json'},body:'{}'});expect(created.status).toBe(201);
|
|
const topic=await created.json();const requestId='22222222-2222-4222-8222-222222222222';
|
|
const accepted=await fetch(base+'/'+topic.id+'/messages',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({requestId,text:'讲解一下'})});expect(accepted.status).toBe(202);
|
|
const stream=await fetch(base+'/'+topic.id+'/events');expect(stream.headers.get('content-type')).toContain('text/event-stream');
|
|
const reader=stream.body!.getReader();const chunk=await reader.read();expect(new TextDecoder().decode(chunk.value)).toContain('event: snapshot');await reader.cancel();
|
|
expect((await f.service.read(f.scope,topic.id)).requests[0].status).toBe('running');
|
|
const cancelled=await fetch(base+'/'+topic.id+'/requests/'+requestId+'/cancel',{method:'POST'});expect(cancelled.status).toBe(200);
|
|
await vi.waitFor(async()=>expect((await f.service.read(f.scope,topic.id)).requests[0].status).toBe('cancelled'));
|
|
expect((await fetch(origin+'/api/coding/teacher/config',{method:'POST'})).status).toBe(405);
|
|
} finally {server.closeAllConnections();await new Promise<void>((resolve,reject)=>server.close(error=>error?reject(error):resolve()));}
|
|
});
|
|
|
|
it.each(['teacher', 'friend'] as const)('routes project-level %s config and topic messages without a source-scoped URL', async (role) => {
|
|
const f = await fixture();
|
|
const server = createServer((req, res) => {
|
|
void handleCodingTeacherRoutes(req, res, new URL(req.url!, 'http://localhost'), {
|
|
codingProducts: { teacher: f.service },
|
|
} as HostApiContext);
|
|
});
|
|
await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
|
|
const address = server.address();
|
|
if (!address || typeof address === 'string') throw new Error('no address');
|
|
const origin = 'http://127.0.0.1:' + address.port;
|
|
const base = `${origin}/api/coding/projects/${f.scope.projectId}/${role}-topics`;
|
|
const post = (url: string, body = {}) => fetch(url, {
|
|
method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
|
|
});
|
|
try {
|
|
const config = await fetch(`${origin}/api/coding/${role}/config`);
|
|
expect(config.status).toBe(200);
|
|
expect((await config.json()).definition.teacher_id).toBe('coding-' + role);
|
|
expect((await post(`${origin}/api/coding/${role}/config`)).status).toBe(405);
|
|
const created = await post(base);
|
|
expect(created.status).toBe(201);
|
|
const topic = await created.json();
|
|
expect(topic).toMatchObject({ role, sourceConversationId: 'project', projectId: f.scope.projectId });
|
|
const listed = await fetch(base);
|
|
expect((await listed.json()).items.map((item: { id: string }) => item.id)).toEqual([topic.id]);
|
|
expect((await fetch(`${base}/${topic.id}`)).status).toBe(200);
|
|
expect(f.run).not.toHaveBeenCalled();
|
|
const requestId = '22222222-2222-4222-8222-222222222222';
|
|
const input = { requestId, text: '我想聊聊', sourceConversationId: f.scope.sourceId };
|
|
expect((await post(`${base}/${topic.id}/messages`, input)).status).toBe(202);
|
|
expect((await post(`${base}/${topic.id}/messages`, input)).status).toBe(202);
|
|
expect(f.run).toHaveBeenCalledOnce();
|
|
const accepted = await fetch(`${base}/${topic.id}`);
|
|
expect((await accepted.json()).requests[0].sourceConversationId).toBe(f.scope.sourceId);
|
|
expect((await post(`${base}/${topic.id}/requests/${requestId}/cancel`)).status).toBe(200);
|
|
await vi.waitFor(async () => expect((await f.service.read({ projectId: f.scope.projectId, sourceId: 'project', role }, topic.id)).requests[0].status).toBe('cancelled'));
|
|
} finally {
|
|
server.closeAllConnections();
|
|
await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
|
|
describe('structured teacher service integration', () => {
|
|
it.each(['suggestions', 'discussion'] as const)('parses only final %s JSON after the real local runner reads a project file', async (format) => {
|
|
const f = await fixture({ liveModel: true, modelInputLimit: 24000 });
|
|
const scope = { ...f.scope, sourceId: 'project', role: 'teacher' as const };
|
|
await writeFile(path.join(f.created.project.path, 'counter.ts'), 'let count = 42;');
|
|
vi.spyOn(teacherCloud, 'assertTeacherAccount').mockReturnValue(undefined);
|
|
vi.spyOn(teacherCloud, 'teacherCloudRequest').mockResolvedValue({
|
|
api_key: 'synthetic', base_url: 'https://teacher.invalid/v1', models: ['qwen'],
|
|
model_capabilities_v2: { schema_version: 2, models: {
|
|
qwen: { input_modalities: ['text'], output_modalities: ['text'], reasoning: { supported: false } },
|
|
} },
|
|
});
|
|
const tool = { kind: 'ideas', title: '计数器', items: [{ id: 'count', text: '从 42 开始计数', state: 'kept' }] };
|
|
const final = format === 'suggestions'
|
|
? { intro: '计数器从 42 开始，我们可以聊聊它怎么变。', questions: ['为什么从 42 开始？', '什么时候改变数字？'] }
|
|
: { reply: '把现在的计数方式放进来了。', quickReplies: [], tool };
|
|
const preamble = format === 'suggestions' ? '我先读取计数器文件。'
|
|
: JSON.stringify({ reply: '这是读取前的想法。', quickReplies: [], tool: { ...tool, title: '尚未核对的草案' } });
|
|
const fetch = vi.spyOn(teacherTransport, 'proxyAwareFetch')
|
|
.mockResolvedValueOnce(new Response('data: ' + JSON.stringify({ choices: [{ delta: {
|
|
content: preamble,
|
|
tool_calls: [{ index: 0, id: 'read-counter', function: { name: 'read_project_file', arguments: '{"path":"counter.ts"}' } }],
|
|
}, finish_reason: 'tool_calls' }] }) + '\n\n'))
|
|
.mockResolvedValueOnce(new Response('data: ' + JSON.stringify({ choices: [{ delta: { content: JSON.stringify(final) }, finish_reason: 'stop' }] }) + '\n\n'));
|
|
try {
|
|
const topic = await f.service.create(scope);
|
|
await f.service.send(scope, topic.id, {
|
|
requestId: crypto.randomUUID(), text: '一起看看计数器。', sourceConversationId: f.scope.sourceId,
|
|
...(format === 'suggestions' ? { intent: 'suggestions' as const } : { presentation: 'discussion-v1' as const }),
|
|
});
|
|
await vi.waitFor(async () => expect((await f.service.read(scope, topic.id)).requests[0].status).toBe('completed'));
|
|
expect(fetch).toHaveBeenCalledTimes(2);
|
|
const continuation = JSON.parse(String(fetch.mock.calls[1][1]?.body));
|
|
expect(continuation.messages.at(-1).content).toContain('let count = 42;');
|
|
const saved = await f.service.read(scope, topic.id);
|
|
if (format === 'suggestions') {
|
|
expect(saved.requests[0].response).toBe(final.intro);
|
|
expect(saved.requests[0].suggestedQuestions).toEqual(final.questions);
|
|
} else {
|
|
expect(saved.requests[0].response).toBe(final.reply);
|
|
expect(saved.requests[0].discussionError).toBeUndefined();
|
|
expect(saved.discussion).toMatchObject({ status: 'offered', content: tool });
|
|
}
|
|
expect(saved.requests[0].response).not.toContain(preamble);
|
|
} finally {
|
|
vi.restoreAllMocks();
|
|
}
|
|
});
|
|
|
|
it.each(['local', 'yuxi'])('%s buffers model JSON, offers once, locks updates, persists state, and never applies a cancelled update', async (runtime) => {
|
|
const f = await fixture({ cloudTeacher: runtime === 'yuxi', mockCloud: runtime === 'yuxi' });
|
|
const scope = { ...f.scope, sourceId: 'project', role: 'teacher' as const };
|
|
const initial = await f.service.create(scope, undefined, undefined, runtime === 'yuxi' ? 9 : undefined);
|
|
const tool = { kind: 'ideas', title: '宠物游戏', items: [{ id: 'dog', text: '养只小狗', state: 'kept' }] };
|
|
f.replyWith(JSON.stringify({ reply: '我们可以先把想法放在一起。', quickReplies: [], tool }));
|
|
const send = (text: string, discussion?: { toolId: string; revision: number }) => f.service.send(scope, initial.id, {
|
|
requestId: crypto.randomUUID(), text, presentation: 'discussion-v1', sourceConversationId: f.scope.sourceId, discussion,
|
|
});
|
|
const pending = await send('想养只小狗');
|
|
expect(runtime === 'yuxi' ? f.prepareCloud : f.prepareModel).toHaveBeenCalledOnce();
|
|
expect(runtime === 'yuxi' ? f.prepareModel : f.prepareCloud).not.toHaveBeenCalled();
|
|
const modelMessages = f.run.mock.calls[0][0] as Array<{ role: string; content: string }>;
|
|
expect(modelMessages[0].content).toContain(TEACHER_BEHAVIOR_PROMPT);
|
|
expect(modelMessages.some(message => message.role === 'system' && message.content.includes('本轮界面协议'))).toBe(true);
|
|
expect(pending.requests[0].response).toBe('');
|
|
expect(pending.discussion).toBeUndefined();
|
|
f.finish();
|
|
await vi.waitFor(async () => expect((await f.service.read(scope, initial.id)).requests[0].status).toBe('completed'));
|
|
const offered = await f.service.read(scope, initial.id);
|
|
expect(offered.discussion?.status).toBe('offered');
|
|
expect(offered.requests[0].response).toBe('我们可以先把想法放在一起。');
|
|
const active = await f.service.updateDiscussion(scope, initial.id, { toolId: offered.discussion!.id, revision: 1, action: 'enter' });
|
|
const context = { toolId: active.discussion!.id, revision: 2 };
|
|
f.replyWith(JSON.stringify({ reply: '把花园也放进来了。', tool: { ...tool, title: '小狗和花园' } }));
|
|
const running = await send('还想种花', context);
|
|
expect(running.discussion?.content.title).toBe('宠物游戏');
|
|
await expect(f.service.updateDiscussion(scope, initial.id, { ...context, action: 'finish' })).rejects.toMatchObject({ code: 'teacher_topic_busy' });
|
|
await f.service.cancel(scope, initial.id, running.requests.at(-1)!.id);
|
|
await vi.waitFor(async () => expect((await f.service.read(scope, initial.id)).requests.at(-1)?.status).toBe('cancelled'));
|
|
expect((await f.service.read(scope, initial.id)).discussion?.content.title).toBe('宠物游戏');
|
|
await send('再把花园加进来', context);
|
|
f.finish();
|
|
await vi.waitFor(async () => expect((await f.service.read(scope, initial.id)).requests.at(-1)?.status).toBe('completed'));
|
|
const completed = await f.service.read(scope, initial.id);
|
|
expect(completed.discussion?.content.title).toBe('小狗和花园');
|
|
expect(completed.discussion?.revision).toBe(3);
|
|
expect(completed.requests[0].discussionSnapshot?.title).toBe('宠物游戏');
|
|
await expect(send('旧版本', context)).rejects.toMatchObject({ code: 'teacher_discussion_changed' });
|
|
const restarted = await f.restart();
|
|
expect((await restarted.read(scope, initial.id)).discussion).toEqual(completed.discussion);
|
|
});
|
|
});
|
|
|
|
|
|
describe('project consultations with selected cloud teachers', () => {
|
|
it.each(['local', 'yuxi'])('retains the friend persona without project tools with a %s teacher model', async (runtime) => {
|
|
const f = await fixture({ cloudTeacher: runtime === 'yuxi', mockCloud: runtime === 'yuxi' });
|
|
const scope = { ...f.scope, sourceId: 'project', role: 'friend' as const };
|
|
const topic = await f.service.create(scope, undefined, undefined, runtime === 'yuxi' ? 9 : undefined);
|
|
expect(topic.definition).toMatchObject({ teacher_id: 'coding-friend', name: '小麦' });
|
|
if (runtime === 'yuxi') expect(topic.definition.runtime).toBe('yuxi');
|
|
await f.service.send(scope, topic.id, {
|
|
requestId: crypto.randomUUID(), text: '你觉得这个作品怎么样？', sourceConversationId: f.scope.sourceId,
|
|
});
|
|
const messages = f.run.mock.calls[0][0] as Array<{ role: string; content: string }>;
|
|
expect(messages[0].content).toContain('数字朋友');
|
|
expect(messages[0].content).not.toContain(TEACHER_BEHAVIOR_PROMPT);
|
|
expect(messages[0].content).toContain('本轮没有项目读取工具');
|
|
if (runtime === 'yuxi') {
|
|
expect(f.prepareModel).not.toHaveBeenCalled();
|
|
expect(f.prepareCloud).toHaveBeenCalledOnce();
|
|
} else {
|
|
expect(f.prepareModel).toHaveBeenCalledWith(expect.anything(), topic.definition, undefined, { finalOnly: false });
|
|
expect(f.prepareCloud).not.toHaveBeenCalled();
|
|
}
|
|
f.finish();
|
|
await vi.waitFor(async () => expect((await f.service.read(scope, topic.id)).requests[0].status).toBe('completed'));
|
|
});
|
|
|
|
it('uses the selected Yuxi topic and read scope for an automatic check-in', async () => {
|
|
const f = await fixture({ cloudTeacher: true, mockCloud: true });
|
|
const scope = { ...f.scope, sourceId: 'project', role: 'teacher' as const };
|
|
const topic = await f.service.create(scope, undefined, undefined, 9);
|
|
const result = await f.service.checkIn(scope, {
|
|
requestId: crypto.randomUUID(), sourceConversationId: f.scope.sourceId,
|
|
});
|
|
expect(result.topic?.id).toBe(topic.id);
|
|
expect(result.topic?.requests[0]).toMatchObject({ intent: 'check-in', sourceConversationId: f.scope.sourceId });
|
|
const messages = f.run.mock.calls[0][0] as Array<{ role: string; content: string }>;
|
|
expect(messages.some(message => message.role === 'system' && message.content.includes('不是学生提问'))).toBe(true);
|
|
expect(messages[0].content).toContain(TEACHER_BEHAVIOR_PROMPT);
|
|
expect(f.prepareCloud.mock.calls[0][3]).toMatchObject({ projectPath: f.created.project.path, source: context });
|
|
expect(f.prepareModel).not.toHaveBeenCalled();
|
|
f.finish();
|
|
await vi.waitFor(async () => expect((await f.service.read(scope, topic.id)).requests[0].status).toBe('completed'));
|
|
});
|
|
});
|