File size: 7,807 Bytes
4e23b01 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 | import { mkdtemp, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { IConfigService } from '@moonshot-ai/agent-core-v2';
import { IFeatureManager } from '@moonshot-ai/agent-core-v2/app/feature/featureManager';
import { getFeatureRecipes } from '@moonshot-ai/agent-core-v2/features/featureRegistry';
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
import { type RunningServer, startServer } from '../src/start';
import { TEST_HOST_IDENTITY } from './helpers/hostIdentity';
import { authedFetch } from './helpers/auth';
interface MetaBody {
code: number;
data: { experimental_flags?: Record<string, boolean> };
}
describe('/api/v1/meta experimental_flags', () => {
let server: RunningServer | undefined;
let home: string | undefined;
beforeAll(async () => {
home = await mkdtemp(join(tmpdir(), 'kimi-server-v2-meta-'));
server = await startServer({
hostIdentity: TEST_HOST_IDENTITY,
host: '127.0.0.1',
port: 0,
homeDir: home,
logLevel: 'silent',
});
});
beforeEach(() => {
vi.stubEnv('KIMI_CODE_EXPERIMENTAL_FLAG', '0');
vi.stubEnv('KIMI_CODE_EXPERIMENTAL_TOOL_SELECT', undefined);
});
afterEach(async () => {
vi.unstubAllEnvs();
});
afterAll(async () => {
if (server !== undefined) {
await server.close();
server = undefined;
}
if (home !== undefined) {
await rm(home, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
home = undefined;
}
});
async function boot(toml?: string): Promise<string> {
await writeFile(join(home as string, 'config.toml'), toml ?? '', 'utf-8');
await (server as RunningServer).core.accessor.get(IConfigService).reload();
return `http://127.0.0.1:${(server as RunningServer).port}`;
}
async function getMetaFlags(base: string): Promise<Record<string, boolean>> {
const res = await authedFetch(server as RunningServer, base, '/api/v1/meta');
expect(res.status).toBe(200);
const body = (await res.json()) as MetaBody;
expect(body.code).toBe(0);
expect(body.data.experimental_flags).toBeDefined();
return body.data.experimental_flags as Record<string, boolean>;
}
it('reports registered flags as off by default', async () => {
const base = await boot();
const flags = await getMetaFlags(base);
expect(flags['tool-select']).toBe(false);
});
it('reports a config-enabled flag from the very first response', async () => {
const base = await boot('[experimental]\ntool-select = true\n');
const flags = await getMetaFlags(base);
expect(flags['tool-select']).toBe(true);
});
it('reflects a flag enabled via its KIMI_CODE_EXPERIMENTAL_* env var', async () => {
vi.stubEnv('KIMI_CODE_EXPERIMENTAL_TOOL_SELECT', '1');
const base = await boot();
const flags = await getMetaFlags(base);
expect(flags['tool-select']).toBe(true);
});
it('flips live when the [experimental] config section is written via POST /config', async () => {
const base = await boot();
expect((await getMetaFlags(base))['tool-select']).toBe(false);
const res = await authedFetch(server as RunningServer, base, '/api/v1/config', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ experimental: { 'tool-select': true } }),
});
expect(res.status).toBe(200);
expect((await getMetaFlags(base))['tool-select']).toBe(true);
});
it('keeps an env-forced flag on when the config section disables it', async () => {
vi.stubEnv('KIMI_CODE_EXPERIMENTAL_TOOL_SELECT', '1');
const base = await boot();
const res = await authedFetch(server as RunningServer, base, '/api/v1/config', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ experimental: { 'tool-select': false } }),
});
expect(res.status).toBe(200);
expect((await getMetaFlags(base))['tool-select']).toBe(true);
});
});
describe('/api/v1/meta web_title', () => {
let server: RunningServer | undefined;
let home: string | undefined;
afterEach(async () => {
if (server !== undefined) {
await server.close();
server = undefined;
}
if (home !== undefined) {
await rm(home, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
home = undefined;
}
});
async function bootWithWebTitle(
webTitle?: string,
): Promise<{ base: string; body: { data: { web_title?: string } } }> {
home = await mkdtemp(join(tmpdir(), 'kimi-server-v2-meta-title-'));
server = await startServer({
hostIdentity: TEST_HOST_IDENTITY,
host: '127.0.0.1',
port: 0,
homeDir: home,
logLevel: 'silent',
webTitle,
});
const base = `http://127.0.0.1:${server.port}`;
const res = await authedFetch(server, base, '/api/v1/meta');
expect(res.status).toBe(200);
const body = (await res.json()) as { code: number; data: { web_title?: string } };
expect(body.code).toBe(0);
return { base, body };
}
it('surfaces the boot-time webTitle as web_title', async () => {
const { body } = await bootWithWebTitle('My Dev Box');
expect(body.data.web_title).toBe('My Dev Box');
});
it('omits web_title when no webTitle was passed', async () => {
const { body } = await bootWithWebTitle();
expect(body.data.web_title).toBeUndefined();
});
});
describe('/api/v1/meta features', () => {
let server: RunningServer | undefined;
let home: string | undefined;
interface FeatureWire {
name: string;
state: string;
meta: Record<string, unknown>;
}
beforeAll(async () => {
home = await mkdtemp(join(tmpdir(), 'kimi-server-v2-meta-features-'));
server = await startServer({
hostIdentity: TEST_HOST_IDENTITY,
host: '127.0.0.1',
port: 0,
homeDir: home,
logLevel: 'silent',
});
});
afterAll(async () => {
if (server !== undefined) {
await server.close();
server = undefined;
}
if (home !== undefined) {
await rm(home, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
home = undefined;
}
});
async function boot(): Promise<string> {
return `http://127.0.0.1:${(server as RunningServer).port}`;
}
async function getMetaFeatures(base: string): Promise<FeatureWire[]> {
const res = await authedFetch(server as RunningServer, base, '/api/v1/meta');
expect(res.status).toBe(200);
const body = (await res.json()) as { code: number; data: { features?: FeatureWire[] } };
expect(body.code).toBe(0);
expect(body.data.features).toBeDefined();
return body.data.features as FeatureWire[];
}
it('lists every registered built-in feature as Active with an empty meta', async () => {
const base = await boot();
const features = await getMetaFeatures(base);
const expected = getFeatureRecipes()
.map((recipe) => recipe.name)
.sort();
expect(features.map((feature) => feature.name).sort()).toEqual(expected);
for (const feature of features) {
expect(feature.state).toBe('Active');
expect(feature.meta).toEqual({});
}
});
it('drops a feature from the response after it is unprovided at runtime', async () => {
const base = await boot();
const before = await getMetaFeatures(base);
expect(before.some((feature) => feature.name === 'plan')).toBe(true);
await (server as RunningServer).core.accessor.get(IFeatureManager).unprovideUnit('plan');
const after = await getMetaFeatures(base);
expect(after.some((feature) => feature.name === 'plan')).toBe(false);
expect(after).toHaveLength(before.length - 1);
});
});
|