mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-20 19:16:08 +00:00
7a40225852
A ChatGPT sign-in only ever ran the assistant: parsing's clients call an endpoint with a key, and a plan has none. AI connections now lends the plan as a reader. Each document is one Responses call with the schema as the one tool the model has to call (tool_choice required). The token is read and refreshed per call by ChatgptAuthService, and a sign-in that has to be renewed lends nothing. - ResolvedLlmConfig is a union: ApiLlmConfig (what an admin configures) or PlanLlmConfig (provider chatgpt, a read function, never stored). - ConnectionReadClient sends the text plus photo or scanned pages, and reads the filled shape, or the shape written as text; prose is unreadable. - AiChatClientService.chatgptPlan is the one place that builds the plan's client, for the assistant and for parsing. - Wiki: a ChatGPT sign-in reads bookings on its plan.
240 lines
11 KiB
TypeScript
240 lines
11 KiB
TypeScript
import type { AddonsRepository } from '../../../../src/db/repositories/Addons.repository';
|
|
import type { AddonsService } from '../../../../src/nest/addons/addons.service';
|
|
import { LlmConfigResolver } from '../../../../src/nest/llm-parse/llm-config.resolver';
|
|
import type { SettingsService } from '../../../../src/nest/settings/settings.service';
|
|
import type { ModuleRef } from '@nestjs/core';
|
|
|
|
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
|
|
|
const isAddonEnabled = vi.fn();
|
|
const findById = vi.fn();
|
|
|
|
// The resolver injects SettingsService — a stub instance (same behaviors as
|
|
// before the DI move). Plan 4 Task 1: the addon-row read is now
|
|
// `AddonsRepository.findById`, stubbed the same way — `config` comes back
|
|
// already-parsed (the repository's own `p.json()` column), never a JSON
|
|
// string this test has to stringify.
|
|
const getUserSettings = vi.fn(() => ({}) as Record<string, unknown>);
|
|
const getAdminUserDefaults = vi.fn(() => ({}) as Record<string, unknown>);
|
|
const getDecryptedUserSetting = vi.fn(() => null as string | null);
|
|
const settingsStub = { getUserSettings, getAdminUserDefaults, getDecryptedUserSetting } as unknown as SettingsService;
|
|
|
|
const addonsStub = { isAddonEnabled } as unknown as AddonsService;
|
|
const addonsRepoStub = { findById } as unknown as AddonsRepository;
|
|
// The assistant's connection, offered through the port; unregistered unless a case provides it.
|
|
const forParsing = vi.fn();
|
|
let portRegistered = false;
|
|
const moduleRefStub = {
|
|
get: vi.fn(() => {
|
|
if (!portRegistered) throw new Error('not registered');
|
|
return { forParsing };
|
|
}),
|
|
} as unknown as ModuleRef;
|
|
const resolver = new LlmConfigResolver(settingsStub, addonsRepoStub, addonsStub, moduleRefStub);
|
|
|
|
function setInstanceConfig(config: Record<string, unknown> | undefined) {
|
|
findById.mockResolvedValue(config === undefined ? null : { id: 'llm_parsing', config });
|
|
}
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
isAddonEnabled.mockReturnValue(true);
|
|
setInstanceConfig(undefined);
|
|
getUserSettings.mockReturnValue({});
|
|
getAdminUserDefaults.mockReturnValue({});
|
|
getDecryptedUserSetting.mockReturnValue(null);
|
|
portRegistered = false;
|
|
forParsing.mockResolvedValue(null);
|
|
});
|
|
|
|
describe('resolveLlmConfig', () => {
|
|
it('returns null when the addon is disabled', async () => {
|
|
isAddonEnabled.mockReturnValue(false);
|
|
expect(await resolver.resolve(1)).toBeNull();
|
|
// Gated BEFORE the addon-row read: a disabled addon never even queries it.
|
|
expect(findById).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('uses instance config when present (and decrypts the key)', async () => {
|
|
setInstanceConfig({ provider: 'anthropic', model: 'claude-opus-4-8', apiKey: 'sk-plain', vision: 'on' });
|
|
expect(await resolver.resolve(1)).toEqual({
|
|
provider: 'anthropic',
|
|
model: 'claude-opus-4-8',
|
|
baseUrl: undefined,
|
|
apiKey: 'sk-plain',
|
|
vision: 'on',
|
|
});
|
|
expect(findById).toHaveBeenCalledWith('llm_parsing');
|
|
});
|
|
|
|
it('reads the instance vision setting as auto when it is missing, unknown, or only the old multimodal flag', async () => {
|
|
for (const extra of [{}, { vision: 'maybe' }, { multimodal: false }, { multimodal: true }]) {
|
|
setInstanceConfig({ provider: 'local', model: 'qwen3.5:4b', ...extra });
|
|
expect((await resolver.resolve(1))?.vision).toBe('auto');
|
|
}
|
|
setInstanceConfig({ provider: 'local', model: 'qwen3.5:4b', vision: 'off' });
|
|
expect((await resolver.resolve(1))?.vision).toBe('off');
|
|
});
|
|
|
|
it('instance config with a base URL still wins for a plain user (#1772 does not touch it)', async () => {
|
|
setInstanceConfig({ provider: 'local', model: 'nuextract', baseUrl: 'http://ollama:11434' });
|
|
expect(await resolver.resolve(7)).toMatchObject({ provider: 'local', baseUrl: 'http://ollama:11434' });
|
|
});
|
|
|
|
it('falls back to per-user config when instance config is incomplete', async () => {
|
|
setInstanceConfig({ provider: 'anthropic' }); // no model → not usable
|
|
getUserSettings.mockReturnValue({ llm_provider: 'anthropic', llm_model: 'claude-sonnet', llm_multimodal: true });
|
|
getDecryptedUserSetting.mockReturnValue('user-key');
|
|
expect(await resolver.resolve(7)).toEqual({
|
|
provider: 'anthropic',
|
|
model: 'claude-sonnet',
|
|
baseUrl: undefined,
|
|
apiKey: 'user-key',
|
|
vision: 'on',
|
|
});
|
|
expect(getDecryptedUserSetting).toHaveBeenCalledWith(7, 'llm_api_key');
|
|
});
|
|
|
|
it('returns null when neither instance nor user config is usable', async () => {
|
|
getUserSettings.mockReturnValue({ llm_provider: 'openai' }); // no model
|
|
expect(await resolver.resolve(1)).toBeNull();
|
|
});
|
|
|
|
it('returns null when the addon row has no config at all', async () => {
|
|
setInstanceConfig(undefined);
|
|
expect(await resolver.resolve(1)).toBeNull();
|
|
});
|
|
|
|
// #1772: the endpoint is instance configuration, so it may only come from an
|
|
// admin-controlled source, whoever is asking.
|
|
it('#1772: picking local personally gets no config at all (no silent reroute)', async () => {
|
|
getUserSettings.mockReturnValue({
|
|
llm_provider: 'local',
|
|
llm_model: 'nuextract',
|
|
llm_base_url: 'http://192.168.1.5:11434',
|
|
});
|
|
expect(await resolver.resolve(7)).toBeNull();
|
|
});
|
|
|
|
it('#1772: a personal OpenAI config survives but loses its own base URL', async () => {
|
|
getUserSettings.mockReturnValue({
|
|
llm_provider: 'openai',
|
|
llm_model: 'gpt-4o-mini',
|
|
llm_base_url: 'http://192.168.1.5:11434',
|
|
});
|
|
getDecryptedUserSetting.mockReturnValue('sk-user');
|
|
expect(await resolver.resolve(7)).toEqual({
|
|
provider: 'openai',
|
|
model: 'gpt-4o-mini',
|
|
baseUrl: undefined,
|
|
apiKey: 'sk-user',
|
|
vision: 'off',
|
|
});
|
|
});
|
|
|
|
it('#1772: an admin-set instance default endpoint applies to everyone', async () => {
|
|
// getUserSettings merges the admin defaults in; getAdminUserDefaults is the
|
|
// admin-controlled layer the endpoint is allowed to come from.
|
|
getUserSettings.mockReturnValue({
|
|
llm_provider: 'local',
|
|
llm_model: 'nuextract',
|
|
llm_base_url: 'http://ollama.internal:11434',
|
|
});
|
|
getAdminUserDefaults.mockReturnValue({ llm_provider: 'local', llm_base_url: 'http://ollama.internal:11434' });
|
|
expect(await resolver.resolve(7)).toMatchObject({ provider: 'local', baseUrl: 'http://ollama.internal:11434' });
|
|
});
|
|
|
|
it("#1772: the caller's identity does not change the answer — the resolver never reads anything keyed by it besides the settings service", async () => {
|
|
// An instance has one endpoint. An admin who parked one in their own row is
|
|
// in exactly the same position as anyone else.
|
|
getUserSettings.mockReturnValue({
|
|
llm_provider: 'local',
|
|
llm_model: 'nuextract',
|
|
llm_base_url: 'http://192.168.1.5:11434',
|
|
});
|
|
expect(await resolver.resolve(7)).toBeNull();
|
|
// The addon-row read is a single, userId-independent lookup — called once,
|
|
// with no user-scoped argument.
|
|
expect(findById).toHaveBeenCalledTimes(1);
|
|
expect(findById).toHaveBeenCalledWith('llm_parsing');
|
|
});
|
|
});
|
|
|
|
describe('readLocalServerAccess (#2649)', () => {
|
|
it('answers the saved local server and its decrypted key, before a model is chosen', async () => {
|
|
setInstanceConfig({ provider: 'local', baseUrl: ' https://ollama.example.org/v1 ', apiKey: 'proxy-key' });
|
|
expect(await resolver.readLocalServerAccess()).toEqual({
|
|
baseUrl: 'https://ollama.example.org/v1',
|
|
apiKey: 'proxy-key',
|
|
});
|
|
});
|
|
|
|
it('answers without a key when none is saved, and a blank base URL as the default', async () => {
|
|
setInstanceConfig({ provider: 'local', model: 'nuextract', baseUrl: '' });
|
|
expect(await resolver.readLocalServerAccess()).toEqual({ baseUrl: undefined, apiKey: undefined });
|
|
});
|
|
|
|
it('answers null when the saved provider is not local, or nothing is saved', async () => {
|
|
setInstanceConfig({ provider: 'openai', baseUrl: 'https://api.openai.com/v1', apiKey: 'sk' });
|
|
expect(await resolver.readLocalServerAccess()).toBeNull();
|
|
setInstanceConfig(undefined);
|
|
expect(await resolver.readLocalServerAccess()).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('readInstanceEndpoint', () => {
|
|
it('answers the saved provider, model and address, never the key', async () => {
|
|
setInstanceConfig({ provider: 'local', model: 'qwen3.5:4b', baseUrl: ' http://10.0.0.2:11434 ', apiKey: 'k' });
|
|
expect(await resolver.readInstanceEndpoint()).toEqual({
|
|
provider: 'local',
|
|
model: 'qwen3.5:4b',
|
|
baseUrl: 'http://10.0.0.2:11434',
|
|
});
|
|
});
|
|
|
|
it('answers null when nothing usable is saved', async () => {
|
|
expect(await resolver.readInstanceEndpoint()).toBeNull();
|
|
setInstanceConfig({ provider: 'anthropic', model: '' });
|
|
expect(await resolver.readInstanceEndpoint()).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('the shared AI connection', () => {
|
|
const shared = { provider: 'openai', model: 'gemini-3-flash', apiKey: 'g', baseUrl: 'https://gemini.test/openai' };
|
|
|
|
it('LLMRES-SHARED-001: reads with the assistant connection when parsing has none of its own', async () => {
|
|
portRegistered = true;
|
|
forParsing.mockResolvedValue(shared);
|
|
setInstanceConfig({ vision: 'on' });
|
|
expect(await resolver.resolve(7)).toEqual({ ...shared, vision: 'on' });
|
|
expect(forParsing).toHaveBeenCalledWith(7);
|
|
});
|
|
|
|
it('LLMRES-SHARED-002: an instance config of its own still wins, and the shared one beats a personal one', async () => {
|
|
portRegistered = true;
|
|
forParsing.mockResolvedValue(shared);
|
|
setInstanceConfig({ provider: 'anthropic', model: 'claude-x', apiKey: 'a' });
|
|
expect(await resolver.resolve(1)).toMatchObject({ provider: 'anthropic', model: 'claude-x' });
|
|
expect(forParsing).not.toHaveBeenCalled();
|
|
|
|
setInstanceConfig(undefined);
|
|
getUserSettings.mockReturnValue({ llm_provider: 'openai', llm_model: 'gpt-4o' });
|
|
expect(await resolver.resolve(1)).toMatchObject({ model: 'gemini-3-flash', vision: 'auto' });
|
|
});
|
|
|
|
it('LLMRES-SHARED-004: a lent ChatGPT plan comes through with its reader and the vision setting of parsing', async () => {
|
|
portRegistered = true;
|
|
const read = async () => ({ text: '' });
|
|
forParsing.mockResolvedValue({ provider: 'chatgpt', model: 'gpt-6.1-sol', read });
|
|
setInstanceConfig({ vision: 'on' });
|
|
expect(await resolver.resolve(3)).toEqual({ provider: 'chatgpt', model: 'gpt-6.1-sol', read, vision: 'on' });
|
|
});
|
|
|
|
it('LLMRES-SHARED-003: without the port or a usable connection, the personal config answers', async () => {
|
|
getUserSettings.mockReturnValue({ llm_provider: 'openai', llm_model: 'gpt-4o' });
|
|
expect(await resolver.resolve(1)).toMatchObject({ provider: 'openai', model: 'gpt-4o' });
|
|
portRegistered = true;
|
|
expect(await resolver.resolve(1)).toMatchObject({ provider: 'openai', model: 'gpt-4o' });
|
|
});
|
|
});
|