Formerly KrillinAI, VideoTranslation and Dubbing Tool for 120+ Languages. Open-source AI workspace for creators, powered by Codex. Video downloader, video translation, create videos, images, audios, and edits with Agents in one place. For your Social Media like YouTube, TikTok, Instagram, etc.
TypeScript agent-skillscodex-clideskop-appdubbingimage-generationlocalizationskillsttsvideo-editingvideo-generationvideo-transcriptionvideo-translation
fix(daemon): bypass Codex runtime for local API translation
Leggett0c1f3e232722
diff --git a/apps/daemon/src/api/server.ts b/apps/daemon/src/api/server.tsindex cd707299..9684be50 100644--- a/apps/daemon/src/api/server.ts+++ b/apps/daemon/src/api/server.ts@@ -162,6 +162,7 @@ import {} from '../codex/credential-storage.js';import { resolveCodexHome } from '../codex/home.js';import { createFollowingLocalCodexHome, synchronizeLocalCodexConfiguration } from '../codex/probe-home.js';+import { readLocalCodexModelConfiguration } from '../codex/local-provider.js';import {createCodexModelCatalog,type CodexModelCatalog@@ -640,6 +641,8 @@ export async function buildServer(input: BuildServerInput) {codexBin,codexHome,cwd: dataDir,+ readLocalConfiguration: () => readLocalCodexModelConfiguration({ codexHome: localCodexHome }),+ readProxy: async () => (await storedCreatorServicesConfigStore.read()).proxy,readConfiguration: createFollowingLocalCodexHome(localCodexHome,join(runtimeDir, 'creator-text-codex'))});diff --git a/apps/daemon/src/codex/local-provider.ts b/apps/daemon/src/codex/local-provider.tsindex cd7599be..7dbcd006 100644--- a/apps/daemon/src/codex/local-provider.ts+++ b/apps/daemon/src/codex/local-provider.ts@@ -15,7 +15,7 @@ export type LocalCodexImageConfiguration =| { authentication: 'chatgpt' };export type LocalCodexModelConfiguration =- | { authentication: 'api_key'; provider: LocalCodexProvider }+ | { authentication: 'api_key'; provider: LocalCodexProvider; wireApi?: 'responses' }| { authentication: 'chatgpt'; model: string };export async function readLocalCodexModelConfiguration(input: {@@ -25,9 +25,12 @@ export async function readLocalCodexModelConfiguration(input: {const image = await readLocalCodexImageConfiguration(input);const config = await readToml(join(input.codexHome, 'config.toml'), true);const model = readString(config.model) || 'codex';+ const providers = readRecord(config.model_providers);+ const provider = readRecord(providers?.[readString(config.model_provider)]);return image.authentication === 'chatgpt'? { authentication: 'chatgpt', model }- : { authentication: 'api_key', provider: { ...image.provider, model } };+ : { authentication: 'api_key', provider: { ...image.provider, model },+ ...(provider?.wire_api === 'responses' ? { wireApi: 'responses' as const } : {}) };}export class LocalCodexProviderError extends Error {diff --git a/apps/daemon/src/creator-services/local-codex-defaults.ts b/apps/daemon/src/creator-services/local-codex-defaults.tsindex f4c59a52..88d78cb2 100644--- a/apps/daemon/src/creator-services/local-codex-defaults.ts+++ b/apps/daemon/src/creator-services/local-codex-defaults.ts@@ -19,7 +19,9 @@ export function createLocalCodexTextModelDefaults(input: {},async read() {const local = await readLocal();- // Codex handles both login modes and the selected provider's wire protocol.+ // Chat-compatible API keys can be used by Krillin directly. Responses-only+ // providers need the HTTP adapter; only ChatGPT login needs the Codex runtime.+ if (local.authentication === 'api_key' && local.wireApi !== 'responses') return local.provider;const gateway = input.readGatewayConfig();if (gateway === undefined) throw new Error('Local Codex text service is not listening');return { ...gateway, model: local.authentication === 'chatgpt' ? local.model : local.provider.model };diff --git a/apps/daemon/src/creator/krillin/codex-llm-gateway.ts b/apps/daemon/src/creator/krillin/codex-llm-gateway.tsindex 62e64a06..9bdfb107 100644--- a/apps/daemon/src/creator/krillin/codex-llm-gateway.ts+++ b/apps/daemon/src/creator/krillin/codex-llm-gateway.ts@@ -1,6 +1,9 @@import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';import { randomBytes, timingSafeEqual } from 'node:crypto';import { resolve } from 'node:path';+import type { LocalCodexModelConfiguration } from '../../codex/local-provider.js';+import { createOfficialFetch } from '../../gateway/official-fetch.js';+import { completeLocalApiRequest, LocalApiCompletionError, type TextChatCompletion } from './local-api-completion.js';import {createCodexAppServerHost,type CodexAppServerHost,@@ -22,9 +25,14 @@ export function createKrillinCodexLlmGateway(input: {cwd: string;createHost?: typeof createCodexAppServerHost;readConfiguration?(): { codexHome: string; version: string };+ readLocalConfiguration?(): Promise<LocalCodexModelConfiguration>;+ readProxy?(): Promise<string>;+ fetcher?: typeof fetch;}) {const token = `ocllm_${randomBytes(32).toString('base64url')}`;const slots: HostSlot[] = Array.from({ length: HOST_POOL_SIZE }, () => ({ busy: false }));+ const fetcher = input.fetcher ?? createOfficialFetch({ readProxy: input.readProxy });+ const apiRequests = new Set<AbortController>();const waiters: Array<{resolve(slot: HostSlot): void;reject(error: Error): void;@@ -44,12 +52,38 @@ export function createKrillinCodexLlmGateway(input: {if (!authorized(request, token)) {return reply.code(401).send({ error: { message: 'Invalid Krillin LLM token' } });}+ if (closing) return reply.code(503).send({ error: { message: 'Local text service is closing' } });const body = readBody(request.body, reply);if (body === undefined) return;const messages = readMessages(body.messages, reply);if (messages === undefined) return;const completionId = `chatcmpl-${randomBytes(12).toString('hex')}`;const stream = body.stream === true;+ const controller = new AbortController();+ apiRequests.add(controller);+ const disconnected = () => { if (!reply.raw.writableFinished) controller.abort(); };+ reply.raw.once('close', disconnected);+ const completeRequest = async (): Promise<TextChatCompletion> => {+ const local = await input.readLocalConfiguration?.();+ if (local?.authentication === 'api_key') {+ const apiBody: Record<string, unknown> = { ...body, messages };+ // Krillin defaults to none. The user-selected policy for local+ // Responses subtitle translation is low; ordinary text requests and+ // the Agent's Codex configuration keep their own reasoning settings.+ if (local.wireApi === 'responses' && body.reasoning_effort === 'none'+ && messages.some(message => message.role === 'system'+ && message.content === 'You are an assistant that helps with subtitle translation.')) {+ apiBody.reasoning_effort = 'low';+ }+ return completeLocalApiRequest({ local, body: apiBody, fetcher,+ signal: AbortSignal.any([controller.signal, AbortSignal.timeout(120_000)]) });+ }+ return chatCompletion(completionId, await runCompletion(messages, readJsonMode(body.response_format)));+ };+ const finish = () => {+ apiRequests.delete(controller);+ reply.raw.removeListener('close', disconnected);+ };if (stream) {reply.hijack();reply.raw.writeHead(200, {@@ -62,31 +96,31 @@ export function createKrillinCodexLlmGateway(input: {const heartbeat = setInterval(() => reply.raw.write(': keep-alive\n\n'), SSE_HEARTBEAT_MS);heartbeat.unref();try {- const content = await runCompletion(messages, readJsonMode(body.response_format));- writeSseCompletion(reply, completionId, content);+ writeSseCompletion(reply, await completeRequest(), record(body.stream_options)?.include_usage === true);} catch (error) {reply.raw.destroy(toError(error));} finally {clearInterval(heartbeat);+ finish();}return;}try {- const content = await runCompletion(messages, readJsonMode(body.response_format));- return chatCompletion(completionId, content);+ return await completeRequest();} catch (error) {- return reply.code(502).send({+ return reply.code(error instanceof LocalApiCompletionError ? error.status : 502).send({error: {message: toError(error).message,type: 'upstream_error',- code: 'codex_completion_failed'+ code: error instanceof LocalApiCompletionError ? error.code : 'codex_completion_failed'}});- }+ } finally { finish(); }});},async close(): Promise<void> {closing = true;+ for (const controller of apiRequests) controller.abort();for (const waiter of waiters.splice(0)) {waiter.reject(new Error('Krillin Codex LLM gateway is closing'));}@@ -186,7 +220,7 @@ async function complete(input: {return content;}-function chatCompletion(id: string, content: string) {+function chatCompletion(id: string, content: string): TextChatCompletion {return {id,object: 'chat.completion',@@ -197,18 +231,20 @@ function chatCompletion(id: string, content: string) {};}-function writeSseCompletion(reply: FastifyReply, id: string, content: string): void {- const created = Math.floor(Date.now() / 1000);+function writeSseCompletion(reply: FastifyReply, completion: TextChatCompletion, includeUsage: boolean): void {+ const { id, created, model } = completion;+ const choice = completion.choices[0]!;const chunk = (delta: Record<string, string>, finishReason: string | null) => ({id,object: 'chat.completion.chunk',created,- model: 'codex',+ model,choices: [{ index: 0, delta, finish_reason: finishReason }]});writeSse(reply, chunk({ role: 'assistant' }, null));- writeSse(reply, chunk({ content }, null));- writeSse(reply, chunk({}, 'stop'));+ writeSse(reply, chunk({ content: choice.message.content }, null));+ writeSse(reply, chunk({}, choice.finish_reason));+ if (includeUsage) writeSse(reply, { id, object: 'chat.completion.chunk', created, model, choices: [], usage: completion.usage });reply.raw.end('data: [DONE]\n\n');}diff --git a/apps/daemon/src/creator/krillin/local-api-completion.ts b/apps/daemon/src/creator/krillin/local-api-completion.tsnew file mode 100644index 00000000..e985f966--- /dev/null+++ b/apps/daemon/src/creator/krillin/local-api-completion.ts@@ -0,0 +1,147 @@+import { randomUUID } from 'node:crypto';+import type { LocalCodexModelConfiguration } from '../../codex/local-provider.js';+import { openAiCompatibleEndpoint } from '../../creator-services/upstream-fetch.js';++type Item = Record<string, unknown>;+export type TextChatCompletion = {+ id: string;+ object: 'chat.completion';+ created: number;+ model: string;+ choices: Array<{ index: number; message: { role: 'assistant'; content: string }; finish_reason: 'stop' | 'length' }>;+ usage: Item;+};++export class LocalApiCompletionError extends Error {+ constructor(readonly status: number, readonly code: string, message: string) {+ super(message);+ }+}++/** Adapt text requests over HTTP without an Agent, tools, threads or a process pool. */+export async function completeLocalApiRequest(input: {+ local: Extract<LocalCodexModelConfiguration, { authentication: 'api_key' }>;+ body: Item;+ fetcher: typeof fetch;+ signal: AbortSignal;+}): Promise<TextChatCompletion> {+ const { provider } = input.local;+ const responses = input.local.wireApi === 'responses';+ const body: Item = responses+ ? { model: input.body.model ?? provider.model, input: input.body.messages, store: false,+ // Codex-compatible providers may require streaming. Buffer only the HTTP+ // response, preserving its completion status and real usage for Krillin.+ stream: true }+ : { ...input.body, model: input.body.model ?? provider.model, stream: false };+ if (responses) {+ const budget = input.body.max_completion_tokens ?? input.body.max_tokens;+ if (budget !== undefined) body.max_output_tokens = budget;+ if (input.body.reasoning_effort !== undefined) body.reasoning = { effort: input.body.reasoning_effort };+ for (const key of ['temperature', 'top_p']) if (input.body[key] !== undefined) body[key] = input.body[key];+ const format = item(input.body.response_format);+ if (format?.type === 'json_object') body.text = { format };+ else if (format?.type === 'json_schema') body.text = { format: { type: 'json_schema', ...item(format.json_schema) } };+ }+ const response = await input.fetcher(openAiCompatibleEndpoint(provider.baseUrl, responses ? 'responses' : 'chat/completions'), {+ method: 'POST', signal: input.signal,+ headers: { authorization: `Bearer ${provider.apiKey}`, 'content-type': 'application/json' },+ body: JSON.stringify(body)+ });+ const fail = (value: unknown, status = 502): never => {+ const error = item(value);+ const message = typeof error?.message === 'string'+ ? error.message.replaceAll(provider.apiKey, '[redacted]').slice(0, 1_000)+ : 'Local model API request failed';+ throw new LocalApiCompletionError(status, typeof error?.code === 'string' ? error.code : 'local_model_api_failed', message);+ };+ if (!response.ok) {+ let value: Item | undefined;+ try { value = item(JSON.parse(await readText(response))); } catch { /* Preserve the HTTP status for non-JSON errors. */ }+ fail(value?.error, response.status);+ }+ if (!responses) {+ const payload = item(JSON.parse(await readText(response)));+ if (payload?.error) fail(payload.error);+ if (!Array.isArray(payload?.choices) || !payload.choices.length) fail(undefined);+ return payload as unknown as TextChatCompletion;+ }++ let payload: Item | undefined;+ let deltas = '';+ if (response.headers.get('content-type')?.includes('text/event-stream')) {+ if (!response.body) fail(undefined);+ const reader = response.body!.getReader();+ const decoder = new TextDecoder();+ let buffer = '';+ let bytes = 0;+ try {+ for (;;) {+ const next = await reader.read();+ bytes += next.value?.byteLength ?? 0;+ if (bytes > MAX_RESPONSE_BYTES) fail({ message: 'Local model API response is too large' });+ buffer += decoder.decode(next.value, { stream: !next.done });+ buffer = buffer.replace(/\r\n/g, '\n');+ if (next.done && buffer.trim()) buffer += '\n\n';+ let boundary: number;+ while ((boundary = buffer.indexOf('\n\n')) >= 0) {+ const frame = buffer.slice(0, boundary); buffer = buffer.slice(boundary + 2);+ const data = frame.split('\n').filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n');+ if (!data || data === '[DONE]') continue;+ const event = item(JSON.parse(data));+ if (event?.type === 'response.output_text.delta' && typeof event.delta === 'string') deltas += event.delta;+ if (event?.type === 'error' || event?.type === 'response.failed') fail(event.error ?? item(event.response)?.error ?? event);+ if (event?.type === 'response.completed' || event?.type === 'response.incomplete') payload = item(event.response);+ }+ if (payload || next.done) break;+ }+ } finally { await reader.cancel().catch(() => undefined); }+ } else {+ payload = item(JSON.parse(await readText(response)));+ }+ if (payload?.error) fail(payload.error);+ if (!payload || !['completed', 'incomplete'].includes(String(payload.status))) {+ fail({ code: 'local_model_incomplete_response', message: 'Local model API ended without a completed response' });+ }+ const result = payload!;+ const incomplete = result.status === 'incomplete';+ if (incomplete && item(result.incomplete_details)?.reason !== 'max_output_tokens') fail(result.incomplete_details);+ const content = Array.isArray(result.output) ? result.output.flatMap(value => {+ const output = item(value);+ return output?.type === 'message' && Array.isArray(output.content)+ ? output.content.flatMap(value => {+ const part = item(value);+ return part?.type === 'output_text' && typeof part.text === 'string' ? [part.text] : [];+ }) : [];+ }).join('') : '';+ const usage = item(result.usage);+ return {+ id: typeof result.id === 'string' ? result.id : `chatcmpl-${randomUUID()}`,+ object: 'chat.completion', created: Math.floor(Date.now() / 1000),+ model: typeof result.model === 'string' ? result.model : String(body.model),+ choices: [{ index: 0, message: { role: 'assistant', content: content || deltas }, finish_reason: incomplete ? 'length' : 'stop' }],+ usage: { prompt_tokens: usage?.input_tokens ?? 0, completion_tokens: usage?.output_tokens ?? 0,+ total_tokens: usage?.total_tokens ?? 0, prompt_tokens_details: usage?.input_tokens_details,+ completion_tokens_details: usage?.output_tokens_details }+ };+}++const MAX_RESPONSE_BYTES = 16 * 1024 * 1024;+async function readText(response: Response): Promise<string> {+ if (!response.body) return '';+ const reader = response.body.getReader();+ const decoder = new TextDecoder();+ let text = ''; let bytes = 0;+ try {+ for (;;) {+ const next = await reader.read();+ bytes += next.value?.byteLength ?? 0;+ if (bytes > MAX_RESPONSE_BYTES) throw new LocalApiCompletionError(502, 'local_model_response_too_large', 'Local model API response is too large');+ text += decoder.decode(next.value, { stream: !next.done });+ if (next.done) return text;+ }+ } finally { await reader.cancel().catch(() => undefined); }+}++function item(value: unknown): Item | undefined {+ return typeof value === 'object' && value !== null && !Array.isArray(value) ? value as Item : undefined;+}diff --git a/apps/daemon/test/integration/creator-local-codex-defaults.test.ts b/apps/daemon/test/integration/creator-local-codex-defaults.test.tsindex 13aee670..a2f41291 100644--- a/apps/daemon/test/integration/creator-local-codex-defaults.test.ts+++ b/apps/daemon/test/integration/creator-local-codex-defaults.test.ts@@ -9,6 +9,7 @@ import { createLocalCodexTextModelDefaults } from '../../src/creator-services/loimport { createKrillinCodexLlmGateway } from '../../src/creator/krillin/codex-llm-gateway.js';import { registerCreatorServicesRoutes } from '../../src/api/routes.creator-services.js';import { createWechatArticleModel } from '../../src/creator/article/model.js';+import { readLocalCodexModelConfiguration } from '../../src/codex/local-provider.js';let root = '';afterEach(async () => { if (root) await rm(root, { recursive: true, force: true }); root = ''; });@@ -34,7 +35,9 @@ describe('local Codex defaults', () => {expect(response.json()).toMatchObject({ config: { llm: { source: 'codex', model: 'local-model' }, image: { provider: 'codex-native' } } });expect(response.body).not.toMatch(/oauth-secret|local-key|bridge-key/);expect(write).not.toHaveBeenCalled();- expect((await store.read()).llm).toMatchObject({ apiKey: 'bridge-key' });+ expect((await store.read()).llm).toMatchObject(authentication === 'chatgpt'+ ? { apiKey: 'bridge-key' }+ : { baseUrl: 'https://local.example/v1', apiKey: 'local-key' });const custom = createDefaultCreatorServicesConfig();custom.llm = { source: 'custom', baseUrl: 'https://manual.example/v1', apiKey: 'manual-key', model: 'manual-model', jsonMode: true };@@ -53,7 +56,7 @@ describe('local Codex defaults', () => {} finally { await server.close(); }});- it.each(['chatgpt', 'api_key'] as const)('runs a regular text task through %s before any save, and never persists temporary bridge credentials', async authentication => {+ it.each(['chatgpt', 'api_key'] as const)('runs a regular text task using %s before any save, and never persists local credentials', async authentication => {root = await mkdtemp(join(tmpdir(), 'creator-local-chatgpt-'));await writeFile(join(root, 'auth.json'), JSON.stringify(authentication === 'chatgpt'? { auth_mode: 'chatgpt', tokens: { access_token: 'oauth-secret' } }@@ -66,14 +69,19 @@ describe('local Codex defaults', () => {const createHost = vi.fn(() => ({ pid: 1, started: Promise.resolve(1), run, isReusable: () => true, close: vi.fn(async () => undefined) }));const gateway = createKrillinCodexLlmGateway({ codexBin: '/fake/codex', codexHome: root, cwd: root, createHost });const server = Fastify();+ const upstream = vi.fn(async () => ({ choices: [{ message: { content: '# Outline' } }] }));+ server.post('/provider/v1/chat/completions', upstream);await gateway.register(server);const origin = await server.listen({ port: 0, host: '127.0.0.1' });+ await writeFile(join(root, 'config.toml'), `model = "local-model"\nopenai_base_url = "${origin}/provider/v1"\n`);const raw = createFileCreatorServicesConfigStore(join(root, 'creator-services.json'));const store = createCreatorServicesConfigStoreWithTextModelFallback(raw, createLocalCodexTextModelDefaults({ codexHome: root, readGatewayConfig: () => gateway.config(origin) }));try {const model = createWechatArticleModel({ configStore: store });await expect(model.generateOutline({ sources: [], topic: { id: 'topic', title: 'Title', angle: '', summary: '' }, writingPrompt: '', templatePrompt: '', signal: new AbortController().signal })).resolves.toBe('# Outline');- expect(run).toHaveBeenCalledOnce();+ expect(run).toHaveBeenCalledTimes(authentication === 'chatgpt' ? 1 : 0);+ expect(createHost).toHaveBeenCalledTimes(authentication === 'chatgpt' ? 1 : 0);+ expect(upstream).toHaveBeenCalledTimes(authentication === 'api_key' ? 1 : 0);await store.write(await store.read());const persisted = await readFile(join(root, 'creator-services.json'), 'utf8');expect(persisted).not.toContain('ocllm_');@@ -82,4 +90,59 @@ describe('local Codex defaults', () => {expect(persisted).not.toContain('local-api-secret');} finally { await gateway.close(); await server.close(); }});++ it('resolves an API key before the local gateway starts, and follows changes without persisting copies', async () => {+ root = await mkdtemp(join(tmpdir(), 'creator-direct-local-'));+ await writeFile(join(root, 'config.toml'), 'model = "first-model"\nopenai_base_url = "https://first.example/v1"\n');+ await writeFile(join(root, 'auth.json'), JSON.stringify({ auth_mode: 'apikey', OPENAI_API_KEY: 'first-key' }));+ const defaults = createLocalCodexTextModelDefaults({ codexHome: root, readGatewayConfig: () => undefined });+ expect(await defaults.read()).toEqual({ baseUrl: 'https://first.example/v1', apiKey: 'first-key', model: 'first-model' });+ await writeFile(join(root, 'config.toml'), 'model = "second-model"\nopenai_base_url = "https://second.example/v1"\n');+ await writeFile(join(root, 'auth.json'), JSON.stringify({ auth_mode: 'apikey', OPENAI_API_KEY: 'second-key' }));+ expect(await defaults.read()).toEqual({ baseUrl: 'https://second.example/v1', apiKey: 'second-key', model: 'second-model' });+ });++ it('uses HTTP for a Responses provider with no Codex host, and uses low reasoning for Krillin subtitles', async () => {+ root = await mkdtemp(join(tmpdir(), 'creator-local-responses-'));+ await writeFile(join(root, 'config.toml'), 'model = "local-model"\nmodel_provider = "local"\n[model_providers.local]\nbase_url = "https://local.example/v1"\nwire_api = "responses"\n');+ await writeFile(join(root, 'auth.json'), JSON.stringify({ auth_mode: 'apikey', OPENAI_API_KEY: 'local-api-secret' }));+ const createHost = vi.fn();+ const fetcher = vi.fn<typeof fetch>(async () => Response.json({ id: 'response-1', model: 'local-model', status: 'completed',+ output: [{ type: 'message', content: [{ type: 'output_text', text: '你好' }] }],+ usage: { input_tokens: 18, output_tokens: 2, total_tokens: 20, output_tokens_details: { reasoning_tokens: 0 } } }));+ const gateway = createKrillinCodexLlmGateway({ codexBin: '/fake/codex', codexHome: root, cwd: root, createHost, fetcher,+ readLocalConfiguration: () => readLocalCodexModelConfiguration({ codexHome: root }) });+ const server = Fastify();+ await gateway.register(server);+ const origin = await server.listen({ port: 0, host: '127.0.0.1' });+ const raw = createFileCreatorServicesConfigStore(join(root, 'creator-services.json'));+ const store = createCreatorServicesConfigStoreWithTextModelFallback(raw, createLocalCodexTextModelDefaults({ codexHome: root, readGatewayConfig: () => gateway.config(origin) }));+ try {+ const config = await store.read();+ const messages = [{ role: 'system', content: 'You are an assistant that helps with subtitle translation.' }, { role: 'user', content: 'Hello' }];+ const response = await fetch(`${config.llm.baseUrl}/chat/completions`, { method: 'POST',+ headers: { authorization: `Bearer ${config.llm.apiKey}`, 'content-type': 'application/json' },+ body: JSON.stringify({ model: config.llm.model, messages, max_tokens: 512, reasoning_effort: 'none' }) });+ expect(response.status).toBe(200);+ expect(await response.json()).toMatchObject({ model: 'local-model', choices: [{ message: { content: '你好' }, finish_reason: 'stop' }],+ usage: { prompt_tokens: 18, completion_tokens: 2, total_tokens: 20, completion_tokens_details: { reasoning_tokens: 0 } } });+ expect(createHost).not.toHaveBeenCalled();+ const [endpoint, request] = fetcher.mock.calls[0]!;+ expect(String(endpoint)).toBe('https://local.example/v1/responses');+ expect(request?.headers).toMatchObject({ authorization: 'Bearer local-api-secret' });+ expect(JSON.parse(String(request?.body))).toEqual({ model: 'local-model', input: messages, store: false, stream: true, max_output_tokens: 512, reasoning: { effort: 'low' } });+ for (const effort of [undefined, 'none', 'high']) {+ await fetch(`${config.llm.baseUrl}/chat/completions`, { method: 'POST',+ headers: { authorization: `Bearer ${config.llm.apiKey}`, 'content-type': 'application/json' },+ body: JSON.stringify({ model: config.llm.model, messages: [{ role: 'user', content: 'Write an outline.' }], reasoning_effort: effort }) });+ const sent = JSON.parse(String(fetcher.mock.calls.at(-1)![1]?.body));+ expect(sent.reasoning).toEqual(effort === undefined ? undefined : { effort });+ }+ expect(createHost).not.toHaveBeenCalled();+ await store.write(config);+ const persisted = await readFile(join(root, 'creator-services.json'), 'utf8');+ expect(persisted).not.toContain('local-api-secret');+ expect(persisted).not.toContain('ocllm_');+ } finally { await gateway.close(); await server.close(); }+ });});diff --git a/apps/daemon/test/unit/codex-local-provider.test.ts b/apps/daemon/test/unit/codex-local-provider.test.tsindex 674654e4..1b01972f 100644--- a/apps/daemon/test/unit/codex-local-provider.test.ts+++ b/apps/daemon/test/unit/codex-local-provider.test.ts@@ -33,6 +33,15 @@ describe('local Codex provider', () => {});});+ it('exposes the selected text protocol without changing the image provider', async () => {+ root = await codexHome(['model = "local-text-model"', 'model_provider = "local"', '[model_providers.local]',+ 'base_url = "https://local.example/v1"', 'wire_api = "responses"', 'experimental_bearer_token = "local-key"']);+ expect(await readLocalCodexModelConfiguration({ codexHome: root, env: {} })).toEqual({ authentication: 'api_key', wireApi: 'responses',+ provider: { baseUrl: 'https://local.example/v1', apiKey: 'local-key', model: 'local-text-model' } });+ expect(await readLocalCodexProvider({ codexHome: root, env: {} })).toEqual({+ baseUrl: 'https://local.example/v1', apiKey: 'local-key', model: 'gpt-image-1' });+ });+it('honors an explicitly selected API mode even if an old OAuth token remains', async () => {root = await codexHome(['openai_base_url = "https://api.example.test/v1"']);await writeFile(join(root, 'auth.json'), JSON.stringify({ auth_mode: 'apikey', OPENAI_API_KEY: 'api-secret', tokens: { access_token: 'old-oauth-secret' } }));diff --git a/apps/daemon/test/unit/krillin-codex-llm-gateway.test.ts b/apps/daemon/test/unit/krillin-codex-llm-gateway.test.tsindex 80418d6b..0bdfeaa9 100644--- a/apps/daemon/test/unit/krillin-codex-llm-gateway.test.ts+++ b/apps/daemon/test/unit/krillin-codex-llm-gateway.test.ts@@ -3,6 +3,59 @@ import { describe, expect, it, vi } from 'vitest';import { createKrillinCodexLlmGateway } from '../../src/creator/krillin/codex-llm-gateway.js';describe('Krillin Codex LLM gateway', () => {+ it('cancels in-flight HTTP requests on close and preserves upstream HTTP failures', async () => {+ const createHost = vi.fn();+ const fetcher = vi.fn<typeof fetch>()+ .mockResolvedValueOnce(Response.json({ error: { code: 'unsupported_value', message: 'none is unsupported' } }, { status: 400 }))+ .mockImplementationOnce(async (_url, options) => new Promise((_resolve, reject) => {+ options?.signal?.addEventListener('abort', () => reject(new Error('Request cancelled')), { once: true });+ }));+ const gateway = createKrillinCodexLlmGateway({ codexBin: '/fake/codex', codexHome: '/unused', cwd: '/unused', createHost, fetcher,+ readLocalConfiguration: async () => ({ authentication: 'api_key', wireApi: 'responses', provider: {+ baseUrl: 'https://local.example/v1', apiKey: 'provider-key', model: 'local-model' } }) });+ const server = Fastify();+ await gateway.register(server);+ const headers = { authorization: `Bearer ${gateway.config('http://localhost').apiKey}` };+ const request = { method: 'POST' as const, url: '/internal/krillin-llm/v1/chat/completions', headers,+ payload: { messages: [{ role: 'user', content: 'Hello' }], reasoning_effort: 'none' } };+ try {+ const rejected = await server.inject(request);+ expect(rejected.statusCode).toBe(400);+ expect(rejected.json()).toMatchObject({ error: { code: 'unsupported_value', message: 'none is unsupported' } });+ const pending = server.inject(request).then(response => response);+ await vi.waitFor(() => expect(fetcher).toHaveBeenCalledTimes(2));+ await gateway.close();+ expect(fetcher.mock.calls[1]![1]?.signal?.aborted).toBe(true);+ expect((await pending).statusCode).toBe(502);+ expect((await server.inject(request)).statusCode).toBe(503);+ expect(createHost).not.toHaveBeenCalled();+ } finally { await gateway.close(); await server.close(); }+ });++ it('runs API-key requests concurrently over HTTP without acquiring Codex process slots', async () => {+ let release!: () => void;+ const barrier = new Promise<void>(resolve => { release = resolve; });+ const fetcher = vi.fn<typeof fetch>(async () => {+ await barrier;+ return Response.json({ status: 'completed', output: [{ type: 'message', content: [{ type: 'output_text', text: '你好' }] }] });+ });+ const createHost = vi.fn();+ const gateway = createKrillinCodexLlmGateway({ codexBin: '/fake/codex', codexHome: '/unused', cwd: '/unused', createHost, fetcher,+ readLocalConfiguration: async () => ({ authentication: 'api_key', wireApi: 'responses', provider: {+ baseUrl: 'https://local.example/v1', apiKey: 'provider-key', model: 'local-model' } }) });+ const server = Fastify();+ await gateway.register(server);+ const config = gateway.config('http://localhost');+ const requests = Array.from({ length: 3 }, () => server.inject({ method: 'POST', url: '/internal/krillin-llm/v1/chat/completions',+ headers: { authorization: `Bearer ${config.apiKey}` }, payload: { messages: [{ role: 'user', content: 'Hello' }], reasoning_effort: 'none' } }).then(response => response));+ try {+ await vi.waitFor(() => expect(fetcher).toHaveBeenCalledTimes(3));+ release();+ expect((await Promise.all(requests)).map(response => response.statusCode)).toEqual([200, 200, 200]);+ expect(createHost).not.toHaveBeenCalled();+ } finally { release(); await gateway.close(); await server.close(); }+ });+it('authenticates and converts a Codex final message to chat completions', async () => {const run = vi.fn((input: { onNotification?(value: Record<string, unknown>): void }) => {input.onNotification?.({diff --git a/apps/daemon/test/unit/krillin-local-api-completion.test.ts b/apps/daemon/test/unit/krillin-local-api-completion.test.tsnew file mode 100644index 00000000..1b9be476--- /dev/null+++ b/apps/daemon/test/unit/krillin-local-api-completion.test.ts@@ -0,0 +1,67 @@+import { describe, expect, it, vi } from 'vitest';+import { completeLocalApiRequest, LocalApiCompletionError } from '../../src/creator/krillin/local-api-completion.js';++const local = { authentication: 'api_key' as const, wireApi: 'responses' as const,+ provider: { baseUrl: 'https://local.example/v1', apiKey: 'provider-secret', model: 'local-model' } };+const body = { model: 'local-model', messages: [{ role: 'user', content: 'Translate Hello into Chinese.' }],+ reasoning_effort: 'none', max_completion_tokens: 512 };+const result = { id: 'response-1', model: 'local-model', status: 'completed',+ output: [{ type: 'message', content: [{ type: 'output_text', text: '你好' }] }],+ usage: { input_tokens: 20, output_tokens: 2, total_tokens: 22,+ input_tokens_details: { cached_tokens: 10 }, output_tokens_details: { reasoning_tokens: 0 } } };++function stream(events: unknown[]) {+ const encoded = new TextEncoder().encode(events.map(value => `data: ${JSON.stringify(value)}\r\n\r\n`).join(''));+ let cursor = 0;+ return new Response(new ReadableStream<Uint8Array>({ pull(controller) {+ if (cursor === encoded.length) { controller.close(); return; }+ // Split UTF-8 characters and CRLF frame boundaries deliberately.+ controller.enqueue(encoded.slice(cursor, cursor + 3)); cursor = Math.min(cursor + 3, encoded.length);+ } }), { headers: { 'content-type': 'text/event-stream' } });+}++describe('Krillin local HTTP model transport', () => {+ it('preserves JSON format, budget and none reasoning without adding Agent instructions', async () => {+ const fetcher = vi.fn<typeof fetch>(async () => Response.json(result));+ const completion = await completeLocalApiRequest({ local, body: { ...body, response_format: { type: 'json_schema',+ json_schema: { name: 'translation', strict: true, schema: { type: 'object' } } } }, fetcher, signal: new AbortController().signal });+ expect(completion).toMatchObject({ choices: [{ message: { content: '你好' }, finish_reason: 'stop' }],+ usage: { prompt_tokens: 20, completion_tokens: 2, total_tokens: 22,+ prompt_tokens_details: { cached_tokens: 10 }, completion_tokens_details: { reasoning_tokens: 0 } } });+ expect(JSON.parse(String(fetcher.mock.calls[0]![1]?.body))).toEqual({ model: 'local-model', input: body.messages,+ store: false, stream: true, max_output_tokens: 512, reasoning: { effort: 'none' },+ text: { format: { type: 'json_schema', name: 'translation', strict: true, schema: { type: 'object' } } } });+ });++ it('accepts completed SSE responses across byte and frame boundaries and retains real usage', async () => {+ const completion = await completeLocalApiRequest({ local, body, signal: new AbortController().signal,+ fetcher: async () => stream([{ type: 'response.created' }, { type: 'response.output_text.delta', delta: '你' },+ { type: 'response.output_text.delta', delta: '好' }, { type: 'response.completed', response: { ...result, output: [] } }]) });+ expect(completion.choices[0]!.message.content).toBe('你好');+ expect(completion.usage.total_tokens).toBe(22);+ });++ it('marks output-budget exhaustion as length so Krillin does not accept a truncated translation', async () => {+ const completion = await completeLocalApiRequest({ local, body, signal: new AbortController().signal,+ fetcher: async () => stream([{ type: 'response.incomplete', response: { ...result, status: 'incomplete',+ incomplete_details: { reason: 'max_output_tokens' } } }]) });+ expect(completion.choices[0]!.finish_reason).toBe('length');+ });++ it.each([+ [{ type: 'response.output_text.delta', delta: 'unfinished' }],+ [{ type: 'response.failed', response: { error: { code: 'upstream_failed', message: 'Failed' } } }],+ [{ type: 'error', code: 'upstream_failed', message: 'Failed' }],+ [{ type: 'response.incomplete', response: { ...result, status: 'incomplete', incomplete_details: { reason: 'content_filter' } } }]+ ])('rejects interrupted or failed responses instead of reporting success (%j)', async (...events) => {+ await expect(completeLocalApiRequest({ local, body, signal: new AbortController().signal,+ fetcher: async () => stream(events) })).rejects.toBeInstanceOf(LocalApiCompletionError);+ });++ it.each([400, 401, 429])('preserves HTTP %i without retrying with reasoning enabled or exposing the API key', async status => {+ const fetcher = vi.fn<typeof fetch>(async () => Response.json({ error: { code: 'upstream_rejected', message: 'Rejected provider-secret' } }, { status }));+ await expect(completeLocalApiRequest({ local, body, fetcher, signal: new AbortController().signal }))+ .rejects.toMatchObject({ status, code: 'upstream_rejected', message: 'Rejected [redacted]' });+ expect(fetcher).toHaveBeenCalledOnce();+ });+});