AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.
HTML ai-agentcloudflarecloudflare-d1cloudflare-r2cloudflare-workersdockerelectronevernoteevernote-alternativeknowledge-basemcpnote-takingobsidian-alternativeoffline-firstpersonal-knowledge-basepwaself-hostedsqlitetiptapweb-clipper
import { describe, expect, test } from "bun:test";
import { globSync, readFileSync } from "node:fs";
import { Database } from "bun:sqlite";
import { Hono } from "hono";
import {
AI_ACTIONS,
AiGenerateSchema,
AiTagSuggestionsRequestSchema,
} from "@edgeever/shared";
import { registerAiRoutes } from "./ai-routes.ts";
const auth = {
kind: "user",
actorType: "user",
actorId: "usr_member",
username: "member",
displayName: "Member",
scopes: [],
workspaceId: "ws_member",
role: "member",
};
const environment = {
storage: {
db: {
prepare: () => { throw new Error("Unexpected database access"); },
batch: async () => [],
},
resources: {},
},
EDGE_EVER_AUTH_PASSWORD: "x".repeat(32),
};
class SqliteD1PreparedStatement {
constructor(db, sql, bindings = []) {
this.db = db;
this.sql = sql;
this.bindings = bindings;
}
bind(...bindings) {
return new SqliteD1PreparedStatement(this.db, this.sql, bindings);
}
async all() {
return { results: this.db.query(this.sql).all(...this.bindings), success: true, meta: {} };
}
async first() {
return this.db.query(this.sql).get(...this.bindings) ?? null;
}
async run() {
this.db.query(this.sql).run(...this.bindings);
return { success: true, meta: {} };
}
}
class SqliteD1Database {
constructor(db) {
this.db = db;
}
prepare(sql) {
return new SqliteD1PreparedStatement(this.db, sql);
}
async batch(statements) {
return this.db.transaction(() => statements.map((statement) =>
this.db.query(statement.sql).run(...statement.bindings)))();
}
}
const createDatabaseEnvironment = () => {
const sqlite = new Database(":memory:");
for (const migration of globSync("migrations/*.sql").sort()) {
sqlite.exec(readFileSync(migration, "utf8"));
}
sqlite.query("INSERT INTO workspaces (id, name, is_personal) VALUES (?, ?, 1)")
.run("ws_member", "Member workspace");
return {
sqlite,
environment: {
storage: { db: new SqliteD1Database(sqlite), resources: {} },
EDGE_EVER_AUTH_PASSWORD: "x".repeat(32),
},
};
};
const createApp = ({ currentAuth = auth, demoMode = false, suggestTags, testConnection, generateVideoOutline } = {}) => {
const app = new Hono();
app.use("/api/v1/*", async (context, next) => {
context.set("auth", currentAuth);
await next();
});
registerAiRoutes(app, { isDemoMode: () => demoMode, suggestTags, testConnection, generateVideoOutline });
return app;
};
const validSettings = {
provider: "openai-compatible",
displayName: "Cloud model",
baseUrl: "https://models.example.com/v1",
apiKey: "secret",
isEnabled: true,
initialModelId: "model-a",
};
describe("AI route contracts", () => {
test("speech settings stay encrypted and transcription requires a note-owned resource", async () => {
const app = createApp();
const { environment: databaseEnvironment } = createDatabaseEnvironment();
const saved = await app.request(
"/api/v1/ai/transcription-providers",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ ...validSettings, initialModelId: "whisper-1" }),
},
databaseEnvironment,
);
expect(saved.status).toBe(201);
const settings = await saved.json();
expect(JSON.stringify(settings)).not.toContain("secret");
const credentialPath = `/api/v1/ai/transcription-providers/${settings.providers[0].id}/direct-credential`;
const credential = await app.request(credentialPath, { method: "POST" }, databaseEnvironment);
expect(credential.status).toBe(200);
expect(credential.headers.get("Cache-Control")).toBe("no-store");
expect(await credential.json()).toEqual({ apiKey: "secret" });
const transcript = await app.request(
"/api/v1/memos/missing/resources/missing/transcription-target",
{ method: "POST" },
databaseEnvironment,
);
expect(transcript.status).toBe(404);
const scopedApp = createApp({ currentAuth: { ...auth, kind: "agent", scopes: ["read:resources"] } });
const denied = await scopedApp.request(
"/api/v1/memos/missing/resources/missing/transcription-target",
{ method: "POST" },
databaseEnvironment,
);
expect(denied.status).toBe(403);
const deniedCredential = await scopedApp.request(credentialPath, { method: "POST" }, databaseEnvironment);
expect(deniedCredential.status).toBe(403);
const otherWorkspaceApp = createApp({ currentAuth: { ...auth, workspaceId: "ws_other" } });
const otherWorkspaceCredential = await otherWorkspaceApp.request(credentialPath, { method: "POST" }, databaseEnvironment);
expect(otherWorkspaceCredential.status).toBe(404);
});
test("accepts the shared semantic action catalog with required parameters", () => {
for (const action of AI_ACTIONS) {
const parsed = AiGenerateSchema.safeParse({
action,
title: "Note",
contentMarkdown: "Body",
...(action === "translate" ? { targetLanguage: "en" } : {}),
...(action === "change-tone" ? { tone: "friendly" } : {}),
...(action === "custom" ? { instruction: "Keep every date." } : {}),
});
expect(parsed.success, action).toBe(true);
}
});
test("defaults AI generation to non-streaming and accepts an explicit opt-in", () => {
const input = { action: "summarize", title: "Note", contentMarkdown: "Body" };
expect(AiGenerateSchema.parse(input).stream).toBe(false);
expect(AiGenerateSchema.parse({ ...input, stream: true }).stream).toBe(true);
});
test("allows custom generation from an empty note while source-based actions still require content", async () => {
expect(AiGenerateSchema.safeParse({
action: "custom",
title: "",
contentMarkdown: "",
instruction: "Write a friendly greeting email.",
}).success).toBe(true);
expect(AiGenerateSchema.safeParse({
action: "custom",
promptId: "aiprompt_blank_note_generator",
title: "",
contentMarkdown: "",
}).success).toBe(true);
expect(AiGenerateSchema.safeParse({
action: "summarize",
title: "",
contentMarkdown: "",
}).success).toBe(false);
const app = createApp();
const response = await app.request(
"/api/v1/ai/generate/prepare",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ action: "summarize", title: "", contentMarkdown: "" }),
},
environment,
);
expect(response.status).toBe(400);
expect(await response.json()).toEqual({
error: {
code: "ai_source_required",
message: "Note content is required for this AI action.",
},
});
});
test("validates AI tag suggestion inputs without requiring saved note content", () => {
expect(AiTagSuggestionsRequestSchema.safeParse({
title: "Unsaved title",
contentMarkdown: "",
currentTags: ["draft"],
locale: "en-US",
}).success).toBe(true);
expect(AiTagSuggestionsRequestSchema.safeParse({
title: "",
contentMarkdown: " ",
}).success).toBe(false);
});
test("retired model generation endpoints reject even configured server generators", async()=>{
let called=0;const app=createApp({suggestTags:async()=>{called++;return [];},testConnection:async()=>{called++;return {text:"OK"};},generateVideoOutline:async()=>{called++;return '{}';}});
for(const path of ["/api/v1/ai/tag-suggestions","/api/v1/ai/generate","/api/v1/ai/infographic-agent","/api/v1/ai/providers/provider/test","/api/v1/ai/providers/provider/discover-models","/api/v1/ai/video-outline"]){const res=await app.request(path,{method:"POST",headers:{"content-type":"application/json"},body:"{}"},environment);expect(res.status).toBe(410);expect(await res.json()).toMatchObject({error:{code:"ai_client_required"}});}expect(called).toBe(0);
});
;
test("prepares tag suggestions with model credentials and no provider call", async () => {
const app = createApp();
const { environment: databaseEnvironment } = createDatabaseEnvironment();
const created = await app.request(
"/api/v1/ai/providers",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(validSettings),
},
databaseEnvironment,
);
expect(created.status).toBe(201);
const response = await app.request(
"/api/v1/ai/tag-suggestions/prepare",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ title: "Note", contentMarkdown: "Body about React", currentTags: ["Current"] }),
},
databaseEnvironment,
);
expect(response.status).toBe(200);
const body = await response.json();
expect(body.apiKey).toBe("secret");
expect(body.prompt).toContain("Body about React");
expect(body.currentTags).toEqual(["Current"]);
expect(body.maxOutputTokens).toBe(300);
});
test("defers prompt-specific action and parameter validation to the saved prompt", () => {
expect(AiGenerateSchema.safeParse({
action: "custom",
promptId: "aiprompt_saved",
title: "Note",
contentMarkdown: "Body",
}).success).toBe(true);
expect(AiGenerateSchema.safeParse({
action: "translate",
promptId: "aiprompt_server_resolves_behavior",
title: "Note",
contentMarkdown: "Body",
}).success).toBe(true);
});
test("does not allow API tokens to manage personal AI credentials", async () => {
const app = createApp({ currentAuth: { ...auth, kind: "agent", actorType: "agent" } });
const response = await app.request("/api/v1/ai/settings", {}, environment);
expect(response.status).toBe(403);
expect(await response.json()).toMatchObject({ error: { code: "forbidden" } });
});
test("requires a user session and valid candidates for the infographic agent", async () => {
const payload = { prompt: "做个列表", currentContent: "", candidates: ["list-grid-simple"], history: [] };
const tokenApp = createApp({ currentAuth: { ...auth, kind: "agent", actorType: "agent" } });
const forbidden = await tokenApp.request("/api/v1/ai/infographic-agent/prepare", {
method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(payload),
}, environment);
expect(forbidden.status).toBe(403);
const invalid = await createApp().request("/api/v1/ai/infographic-agent/prepare", {
method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ ...payload, candidates: [] }),
}, environment);
expect(invalid.status).toBe(400);
});
test("keeps demo AI settings immutable", async () => {
const app = createApp({ demoMode: true });
const response = await app.request(
"/api/v1/ai/providers",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(validSettings),
},
environment,
);
expect(response.status).toBe(403);
expect(await response.json()).toMatchObject({ error: { code: "forbidden" } });
});
test("rejects credentials embedded in a Base URL", async () => {
const app = createApp();
const response = await app.request(
"/api/v1/ai/providers",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ ...validSettings, baseUrl: "https://user:[email protected]/v1" }),
},
environment,
);
expect(response.status).toBe(400);
});
test("prepares a direct generation payload without calling the model provider", async () => {
const app = createApp();
const { environment: databaseEnvironment } = createDatabaseEnvironment();
const created = await app.request(
"/api/v1/ai/providers",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(validSettings),
},
databaseEnvironment,
);
expect(created.status).toBe(201);
const response = await app.request(
"/api/v1/ai/generate/prepare",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ action: "summarize", title: "Note", contentMarkdown: "Body" }),
},
databaseEnvironment,
);
expect(response.status).toBe(200);
const body = await response.json();
expect(body.apiKey).toBe("secret");
expect(body.provider).toBe("openai-compatible");
expect(body.baseUrl).toBe("https://models.example.com/v1");
expect(body.modelId).toBe("model-a");
expect(body.prompt).toContain("Body");
expect(body.system).toContain(body.resultBoundary.start);
expect(body.system).toContain(body.resultBoundary.end);
});
test("returns the default model endpoint without the API key", async () => {
const app = createApp();
const { environment: databaseEnvironment } = createDatabaseEnvironment();
const created = await app.request(
"/api/v1/ai/providers",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(validSettings),
},
databaseEnvironment,
);
expect(created.status).toBe(201);
const response = await app.request("/api/v1/ai/direct-target", {}, databaseEnvironment);
expect(response.status).toBe(200);
const body = await response.json();
expect(body).toEqual({
provider: "openai-compatible",
baseUrl: "https://models.example.com/v1",
modelId: "model-a",
});
expect(body.apiKey).toBeUndefined();
});
test("rejects actions outside the shared note-processing catalog", async () => {
const app = createApp();
const response = await app.request(
"/api/v1/ai/generate/prepare",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ action: "continue", title: "Note", contentMarkdown: "Body" }),
},
environment,
);
expect(response.status).toBe(400);
});
test("requires a target language for translation", async () => {
const app = createApp();
const response = await app.request(
"/api/v1/ai/generate/prepare",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ action: "translate", title: "Note", contentMarkdown: "Body" }),
},
environment,
);
expect(response.status).toBe(400);
});
test("resolves saved prompt behavior inside the authenticated workspace", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const now = "2026-08-12T01:00:00.000Z";
sqlite.query(
`INSERT INTO ai_prompt_templates (
id, workspace_id, seed_key, action, parameter_kind, result_mode,
name, description, instruction,
name_customized, description_customized, instruction_customized,
created_at, updated_at
) VALUES (?, ?, NULL, 'custom', 'tone', 'replace', ?, NULL, ?, 1, 1, 1, ?, ?)`,
).run("aiprompt_tone", auth.workspaceId, "Tone prompt", "Use the requested tone.", now, now);
const missingParameter = await app.request(
"/api/v1/ai/generate/prepare",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({
action: "summarize",
promptId: "aiprompt_tone",
title: "Note",
contentMarkdown: "Body",
}),
},
databaseEnvironment,
);
expect(missingParameter.status).toBe(400);
expect(await missingParameter.json()).toMatchObject({ error: { code: "ai_tone_required" } });
const missingPrompt = await app.request(
"/api/v1/ai/generate/prepare",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({
action: "custom",
promptId: "aiprompt_other_workspace",
title: "Note",
contentMarkdown: "Body",
}),
},
databaseEnvironment,
);
expect(missingPrompt.status).toBe(404);
expect(await missingPrompt.json()).toMatchObject({ error: { code: "ai_prompt_not_found" } });
});
test("bounds custom editing instructions", async () => {
const app = createApp();
const response = await app.request(
"/api/v1/ai/generate/prepare",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({
action: "rewrite-proofread",
title: "Note",
contentMarkdown: "Body",
instruction: "x".repeat(2_001),
}),
},
environment,
);
expect(response.status).toBe(400);
});
test("stores multiple models under one OpenRouter-style provider", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const createResponse = await app.request(
"/api/v1/ai/providers",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({
...validSettings,
displayName: "OpenRouter",
baseUrl: "https://openrouter.ai/api/v1/",
initialModelId: "openai/gpt-4.1",
}),
},
databaseEnvironment,
);
const created = await createResponse.json();
expect({ status: createResponse.status, created }).toMatchObject({ status: 201 });
const provider = created.providers[0];
expect(provider).toMatchObject({
displayName: "OpenRouter",
baseUrl: "https://openrouter.ai/api/v1",
isEnabled: true,
});
expect(created.readOnly).toBe(false);
expect(provider.models.map((model) => model.modelId)).toEqual(["openai/gpt-4.1"]);
expect(created.defaultModelId).toBe(provider.models[0].id);
const addResponse = await app.request(
`/api/v1/ai/providers/${provider.id}/models`,
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({
modelId: "anthropic/claude-sonnet-4",
displayName: "Claude Sonnet 4",
}),
},
databaseEnvironment,
);
expect(addResponse.status).toBe(201);
const withTwoModels = await addResponse.json();
expect(withTwoModels.providers[0].models.map((model) => model.modelId)).toEqual([
"openai/gpt-4.1",
"anthropic/claude-sonnet-4",
]);
const disableResponse = await app.request(
`/api/v1/ai/providers/${provider.id}`,
{
method: "PUT",
headers: { "content-type": "application/json" },
body: JSON.stringify({
provider: "openai-compatible",
displayName: "OpenRouter",
baseUrl: "https://openrouter.ai/api/v1",
isEnabled: false,
}),
},
databaseEnvironment,
);
expect(disableResponse.status).toBe(200);
expect((await disableResponse.json()).providers[0].isEnabled).toBe(false);
sqlite.close();
});
test("tests unsaved connection fields without changing the saved provider", async () => {
const testedConnections = [];
const app = createApp({
testConnection: async (config) => {
testedConnections.push(config);
return { text: "OK" };
},
});
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const createResponse = await app.request(
"/api/v1/ai/providers",
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(validSettings),
},
databaseEnvironment,
);
const created = await createResponse.json();
const provider = created.providers[0];
const testResponse = await app.request(
`/api/v1/ai/providers/${provider.id}/direct-credential`,
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({
modelId: "draft-model",
provider: "google",
baseUrl: "https://draft.example.com/v1/",
apiKey: "draft-key",
}),
},
databaseEnvironment,
);
expect(testResponse.status).toBe(200);
expect(testedConnections).toEqual([]);
expect(await testResponse.json()).toEqual({
modelId: "draft-model",
provider: "google",
baseUrl: "https://draft.example.com/v1",
apiKey: "draft-key",
});
expect((await app.request("/api/v1/ai/settings", {}, databaseEnvironment).then((response) => response.json())).providers[0])
.toMatchObject({
provider: validSettings.provider,
baseUrl: validSettings.baseUrl,
});
sqlite.close();
});
test("reports public demo AI settings as read-only", async () => {
const app = createApp({ demoMode: true });
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const response = await app.request("/api/v1/ai/settings", {}, databaseEnvironment);
expect(response.status).toBe(200);
expect(await response.json()).toMatchObject({ readOnly: true });
sqlite.close();
});
});
const videoOutlineBody = (overrides = {}) => ({
platform: "youtube",
title: "Current video",
author: "Channel",
duration: 90,
hasChapters: false,
blocks: [
{ start: 0, text: "Hello world" },
{ start: 45, text: "Second block" },
],
...overrides,
});
describe("video outline", () => {
test("retired video outline endpoint keeps authorization and never returns model credentials", async()=>{
const response=await createApp({currentAuth:null}).request("/api/v1/ai/video-outline",{method:"POST"},environment);expect(response.status).toBe(401);
const res=await createApp().request("/api/v1/ai/video-outline",{method:"POST"},environment);expect(res.status).toBe(410);expect(await res.text()).not.toContain("apiKey");
});
;
test("outline preparation requires a configured model without invoking generation",async()=>{
const {sqlite,environment:env}=createDatabaseEnvironment();const response=await createApp().request("/api/v1/ai/video-outline/prepare",{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify(videoOutlineBody())},env);expect(response.status).toBe(409);expect(await response.json()).toMatchObject({error:{code:"ai_not_configured"}});sqlite.close();
});
test("outline preparation rejects oversized transcripts before loading credentials",async()=>{
const input=videoOutlineBody();input.blocks=Array.from({length:10},(_,i)=>({start:i,text:"x".repeat(6000)}));const res=await createApp().request("/api/v1/ai/video-outline/prepare",{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify(input)},environment);expect(res.status).toBe(413);
});
});
const jsonRequest = (method, body) => ({
method,
headers: { "content-type": "application/json" },
body: JSON.stringify(body),
});
const createProvider = async (app, databaseEnvironment, overrides = {}) => {
const response = await app.request(
"/api/v1/ai/providers",
jsonRequest("POST", { ...validSettings, ...overrides }),
databaseEnvironment,
);
expect(response.status).toBe(201);
return response.json();
};
const transcriptionSettings = {
provider: "openai-compatible",
displayName: "Speech",
baseUrl: "https://speech.example.com/v1",
apiKey: "speech-secret",
isEnabled: true,
};
const createTranscriptionProvider = async (app, databaseEnvironment, overrides = {}) => {
const response = await app.request(
"/api/v1/ai/transcription-providers",
jsonRequest("POST", { ...transcriptionSettings, ...overrides }),
databaseEnvironment,
);
expect(response.status).toBe(201);
return response.json();
};
const auditActionsOf = (sqlite) =>
sqlite.query("SELECT action FROM audit_events ORDER BY rowid").all().map((row) => row.action);
const otherWorkspaceAuth = { ...auth, actorId: "usr_other", workspaceId: "ws_other" };
const agentAuth = { ...auth, kind: "agent", actorType: "agent", scopes: ["ai:generate"] };
describe("speech transcription settings routes", () => {
test("rejects invalid transcription settings with a dedicated error code", async () => {
const response = await createApp().request(
"/api/v1/ai/transcription-providers",
jsonRequest("POST", { ...transcriptionSettings, displayName: "" }),
environment,
);
expect(response.status).toBe(400);
expect(await response.json()).toEqual({
error: {
code: "ai_transcription_request_invalid",
message: "The speech transcription settings are invalid.",
},
});
});
test("requires an interactive user to read transcription settings", async () => {
const response = await createApp({ currentAuth: agentAuth }).request(
"/api/v1/ai/transcription-settings",
{},
environment,
);
expect(response.status).toBe(403);
});
test("refuses transcription credentials and targets in demo mode", async () => {
const app = createApp({ demoMode: true });
const target = await app.request("/api/v1/memos/m/resources/r/transcription-target", { method: "POST" }, environment);
const credential = await app.request(
"/api/v1/ai/transcription-providers/atp_x/direct-credential",
{ method: "POST" },
environment,
);
expect(target.status).toBe(403);
expect(credential.status).toBe(403);
});
test("returns 404 for an unknown speech provider credential", async () => {
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const response = await createApp().request(
"/api/v1/ai/transcription-providers/atp_missing/direct-credential",
{ method: "POST" },
databaseEnvironment,
);
expect(response.status).toBe(404);
expect(await response.json()).toMatchObject({ error: { message: "Speech service not found." } });
sqlite.close();
});
test("fails closed when no credential encryption key is configured", async () => {
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const { EDGE_EVER_AUTH_PASSWORD: _password, ...withoutKey } = databaseEnvironment;
const response = await createApp().request(
"/api/v1/ai/transcription-providers",
jsonRequest("POST", transcriptionSettings),
withoutKey,
);
expect(response.status).toBe(400);
expect(await response.json()).toMatchObject({ error: { code: "ai_encryption_key_missing" } });
expect(sqlite.query("SELECT COUNT(*) AS count FROM ai_transcription_providers").get().count).toBe(0);
sqlite.close();
});
test("manages providers, models and the default model inside one workspace", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
sqlite.query("INSERT INTO workspaces (id, name, is_personal) VALUES (?, ?, 1)").run("ws_other", "Other");
const created = await createTranscriptionProvider(app, databaseEnvironment);
expect(created.providers).toHaveLength(1);
expect(created.providers[0].models).toEqual([]);
expect(created.defaultModelId).toBeNull();
expect(JSON.stringify(created)).not.toContain("speech-secret");
const providerId = created.providers[0].id;
const addModel = await app.request(
`/api/v1/ai/transcription-providers/${providerId}/models`,
jsonRequest("POST", { modelId: "whisper-1" }),
databaseEnvironment,
);
expect(addModel.status).toBe(201);
const withModel = await addModel.json();
const model = withModel.providers[0].models[0];
expect(model).toMatchObject({ modelId: "whisper-1", displayName: "whisper-1" });
// The first model of an enabled service becomes the workspace default.
expect(withModel.defaultModelId).toBe(model.id);
expect(withModel.enabled).toBe(true);
const second = await app.request(
`/api/v1/ai/transcription-providers/${providerId}/models`,
jsonRequest("POST", { modelId: "whisper-large", displayName: "Large" }),
databaseEnvironment,
);
const withTwo = await second.json();
expect(withTwo.defaultModelId).toBe(model.id);
const secondModel = withTwo.providers[0].models.find((entry) => entry.modelId === "whisper-large");
expect(secondModel.displayName).toBe("Large");
const switchDefault = await app.request(
"/api/v1/ai/transcription-default-model",
jsonRequest("PUT", { modelConfigId: secondModel.id }),
databaseEnvironment,
);
expect(switchDefault.status).toBe(200);
expect((await switchDefault.json()).defaultModelId).toBe(secondModel.id);
const clearDefault = await app.request(
"/api/v1/ai/transcription-default-model",
jsonRequest("PUT", { modelConfigId: null }),
databaseEnvironment,
);
expect(clearDefault.status).toBe(200);
expect((await clearDefault.json()).defaultModelId).toBeNull();
// Another workspace can neither see nor select these models.
const otherApp = createApp({ currentAuth: otherWorkspaceAuth });
const foreignDefault = await otherApp.request(
"/api/v1/ai/transcription-default-model",
jsonRequest("PUT", { modelConfigId: secondModel.id }),
databaseEnvironment,
);
expect(foreignDefault.status).toBe(400);
expect(await foreignDefault.json()).toMatchObject({ error: { code: "ai_transcription_default_unavailable" } });
const foreignSettings = await (await otherApp.request("/api/v1/ai/transcription-settings", {}, databaseEnvironment)).json();
expect(foreignSettings.providers).toEqual([]);
for (const [path, init] of [
[`/api/v1/ai/transcription-providers/${providerId}`, jsonRequest("PUT", transcriptionSettings)],
[`/api/v1/ai/transcription-providers/${providerId}`, { method: "DELETE" }],
[`/api/v1/ai/transcription-providers/${providerId}/models`, jsonRequest("POST", { modelId: "x" })],
[`/api/v1/ai/transcription-providers/${providerId}/models/${model.id}`, { method: "DELETE" }],
[`/api/v1/ai/transcription-providers/${providerId}/direct-credential`, { method: "POST" }],
]) {
const response = await otherApp.request(path, init, databaseEnvironment);
expect(response.status, `${init.method} ${path}`).toBe(404);
}
const wrongProvider = await app.request(
`/api/v1/ai/transcription-providers/atp_other/models/${model.id}`,
{ method: "DELETE" },
databaseEnvironment,
);
expect(wrongProvider.status).toBe(404);
expect(await wrongProvider.json()).toMatchObject({ error: { message: "Speech model not found." } });
const removeModel = await app.request(
`/api/v1/ai/transcription-providers/${providerId}/models/${model.id}`,
{ method: "DELETE" },
databaseEnvironment,
);
expect(removeModel.status).toBe(200);
expect((await removeModel.json()).providers[0].models.map((entry) => entry.modelId)).toEqual(["whisper-large"]);
const removeProvider = await app.request(
`/api/v1/ai/transcription-providers/${providerId}`,
{ method: "DELETE" },
databaseEnvironment,
);
expect(removeProvider.status).toBe(200);
expect((await removeProvider.json()).providers).toEqual([]);
expect(auditActionsOf(sqlite)).toEqual([
"workspace.ai_transcription_provider.create",
"workspace.ai_transcription_model.create",
"workspace.ai_transcription_model.create",
"workspace.ai_transcription_default.update",
"workspace.ai_transcription_default.update",
"workspace.ai_transcription_model.delete",
"workspace.ai_transcription_provider.delete",
]);
sqlite.close();
});
test("updates a speech provider and keeps the stored key unless a new one is sent", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const created = await createTranscriptionProvider(app, databaseEnvironment, { initialModelId: "whisper-1" });
const providerId = created.providers[0].id;
const credentialPath = `/api/v1/ai/transcription-providers/${providerId}/direct-credential`;
const renamed = await app.request(
`/api/v1/ai/transcription-providers/${providerId}`,
jsonRequest("PUT", { ...transcriptionSettings, apiKey: undefined, displayName: "Renamed", isEnabled: false }),
databaseEnvironment,
);
expect(renamed.status).toBe(200);
expect((await renamed.json()).providers[0]).toMatchObject({ displayName: "Renamed", isEnabled: false });
expect(await (await app.request(credentialPath, { method: "POST" }, databaseEnvironment)).json())
.toEqual({ apiKey: "speech-secret" });
// A model of a disabled service cannot become the default.
const disabledDefault = await app.request(
"/api/v1/ai/transcription-default-model",
jsonRequest("PUT", { modelConfigId: created.providers[0].models[0].id }),
databaseEnvironment,
);
expect(disabledDefault.status).toBe(400);
const rekeyed = await app.request(
`/api/v1/ai/transcription-providers/${providerId}`,
jsonRequest("PUT", { ...transcriptionSettings, apiKey: "rotated-secret" }),
databaseEnvironment,
);
expect(rekeyed.status).toBe(200);
expect(await (await app.request(credentialPath, { method: "POST" }, databaseEnvironment)).json())
.toEqual({ apiKey: "rotated-secret" });
const stored = sqlite.query("SELECT api_key_encrypted FROM ai_transcription_providers WHERE id = ?").get(providerId);
expect(stored.api_key_encrypted).not.toContain("rotated-secret");
const metadata = sqlite.query(
"SELECT metadata_json FROM audit_events WHERE action = 'workspace.ai_transcription_provider.update' ORDER BY rowid",
).all().map((row) => JSON.parse(row.metadata_json).apiKeyUpdated);
expect(metadata).toEqual([false, true]);
const missing = await app.request(
"/api/v1/ai/transcription-providers/atp_missing",
jsonRequest("PUT", transcriptionSettings),
databaseEnvironment,
);
expect(missing.status).toBe(404);
sqlite.close();
});
test("blocks speech setting changes in demo mode and for API tokens", async () => {
for (const app of [createApp({ demoMode: true }), createApp({ currentAuth: agentAuth })]) {
for (const [path, init] of [
["/api/v1/ai/transcription-providers", jsonRequest("POST", transcriptionSettings)],
["/api/v1/ai/transcription-providers/atp_x", jsonRequest("PUT", transcriptionSettings)],
["/api/v1/ai/transcription-providers/atp_x", { method: "DELETE" }],
["/api/v1/ai/transcription-providers/atp_x/models", jsonRequest("POST", { modelId: "m" })],
["/api/v1/ai/transcription-providers/atp_x/models/atm_x", { method: "DELETE" }],
["/api/v1/ai/transcription-default-model", jsonRequest("PUT", { modelConfigId: null })],
]) {
const response = await app.request(path, init, environment);
expect(response.status, `${init.method} ${path}`).toBe(403);
}
}
});
});
describe("AI model provider settings routes", () => {
test("blocks provider changes in demo mode and for API tokens", async () => {
for (const app of [createApp({ demoMode: true }), createApp({ currentAuth: agentAuth })]) {
for (const [path, init] of [
["/api/v1/ai/providers/aip_x", jsonRequest("PUT", validSettings)],
["/api/v1/ai/providers/aip_x", { method: "DELETE" }],
["/api/v1/ai/providers/aip_x/models", jsonRequest("POST", { modelId: "m" })],
["/api/v1/ai/providers/aip_x/models/aim_x", { method: "DELETE" }],
["/api/v1/ai/default-model", jsonRequest("PUT", { modelConfigId: null })],
]) {
const response = await app.request(path, init, environment);
expect(response.status, `${init.method} ${path}`).toBe(403);
}
}
});
test("keeps the saved API key on update unless a new one is provided", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const created = await createProvider(app, databaseEnvironment);
const providerId = created.providers[0].id;
const credentialPath = `/api/v1/ai/providers/${providerId}/direct-credential`;
const { apiKey: _apiKey, initialModelId: _model, ...fields } = validSettings;
const renamed = await app.request(
`/api/v1/ai/providers/${providerId}`,
jsonRequest("PUT", { ...fields, displayName: "Renamed" }),
databaseEnvironment,
);
expect(renamed.status).toBe(200);
expect((await renamed.json()).providers[0].displayName).toBe("Renamed");
const kept = await app.request(credentialPath, jsonRequest("POST", {}), databaseEnvironment);
expect(await kept.json()).toEqual({
provider: "openai-compatible",
baseUrl: "https://models.example.com/v1",
apiKey: "secret",
modelId: "",
});
await app.request(
`/api/v1/ai/providers/${providerId}`,
jsonRequest("PUT", { ...fields, apiKey: "rotated" }),
databaseEnvironment,
);
expect((await (await app.request(credentialPath, jsonRequest("POST", {}), databaseEnvironment)).json()).apiKey)
.toBe("rotated");
const missing = await app.request(
"/api/v1/ai/providers/aip_missing",
jsonRequest("PUT", fields),
databaseEnvironment,
);
expect(missing.status).toBe(404);
expect(await missing.json()).toMatchObject({ error: { message: "AI provider not found." } });
sqlite.close();
});
test("rejects provider creation without an encryption key", async () => {
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const { EDGE_EVER_AUTH_PASSWORD: _password, ...withoutKey } = databaseEnvironment;
const response = await createApp().request("/api/v1/ai/providers", jsonRequest("POST", validSettings), withoutKey);
expect(response.status).toBe(400);
expect(await response.json()).toMatchObject({ error: { code: "ai_encryption_key_missing" } });
sqlite.close();
});
test("isolates providers, models and the default model per workspace", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
sqlite.query("INSERT INTO workspaces (id, name, is_personal) VALUES (?, ?, 1)").run("ws_other", "Other");
const created = await createProvider(app, databaseEnvironment);
const provider = created.providers[0];
const model = provider.models[0];
const otherApp = createApp({ currentAuth: otherWorkspaceAuth });
for (const [path, init] of [
[`/api/v1/ai/providers/${provider.id}`, jsonRequest("PUT", validSettings)],
[`/api/v1/ai/providers/${provider.id}`, { method: "DELETE" }],
[`/api/v1/ai/providers/${provider.id}/models`, jsonRequest("POST", { modelId: "x" })],
[`/api/v1/ai/providers/${provider.id}/models/${model.id}`, { method: "DELETE" }],
[`/api/v1/ai/providers/${provider.id}/direct-credential`, jsonRequest("POST", {})],
]) {
const response = await otherApp.request(path, init, databaseEnvironment);
expect(response.status, `${init.method} ${path}`).toBe(404);
}
const foreignDefault = await otherApp.request(
"/api/v1/ai/default-model",
jsonRequest("PUT", { modelConfigId: model.id }),
databaseEnvironment,
);
expect(foreignDefault.status).toBe(400);
expect(await foreignDefault.json()).toMatchObject({ error: { code: "ai_default_model_unavailable" } });
const ownSettings = await (await app.request("/api/v1/ai/settings", {}, databaseEnvironment)).json();
expect(ownSettings.providers[0].displayName).toBe(validSettings.displayName);
expect(ownSettings.defaultModelId).toBe(model.id);
sqlite.close();
});
test("adds, selects and removes models and deletes the provider", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const created = await createProvider(app, databaseEnvironment, { initialModelId: undefined });
const providerId = created.providers[0].id;
expect(created.defaultModelId).toBeNull();
const added = await app.request(
`/api/v1/ai/providers/${providerId}/models`,
jsonRequest("POST", { modelId: "model-b" }),
databaseEnvironment,
);
expect(added.status).toBe(201);
const withModel = await added.json();
const model = withModel.providers[0].models[0];
expect(model).toMatchObject({ modelId: "model-b", displayName: "model-b" });
expect(withModel.defaultModelId).toBe(model.id);
const cleared = await app.request("/api/v1/ai/default-model", jsonRequest("PUT", { modelConfigId: null }), databaseEnvironment);
expect(cleared.status).toBe(200);
expect((await cleared.json()).defaultModelId).toBeNull();
const selected = await app.request("/api/v1/ai/default-model", jsonRequest("PUT", { modelConfigId: model.id }), databaseEnvironment);
expect(selected.status).toBe(200);
expect((await selected.json()).defaultModelId).toBe(model.id);
const unknown = await app.request("/api/v1/ai/default-model", jsonRequest("PUT", { modelConfigId: "aim_missing" }), databaseEnvironment);
expect(unknown.status).toBe(400);
const wrongProvider = await app.request(
`/api/v1/ai/providers/aip_other/models/${model.id}`,
{ method: "DELETE" },
databaseEnvironment,
);
expect(wrongProvider.status).toBe(404);
expect(await wrongProvider.json()).toMatchObject({ error: { message: "AI model not found." } });
const removedModel = await app.request(
`/api/v1/ai/providers/${providerId}/models/${model.id}`,
{ method: "DELETE" },
databaseEnvironment,
);
expect(removedModel.status).toBe(200);
expect((await removedModel.json()).providers[0].models).toEqual([]);
const missingProvider = await app.request(
"/api/v1/ai/providers/aip_missing/models",
jsonRequest("POST", { modelId: "x" }),
databaseEnvironment,
);
expect(missingProvider.status).toBe(404);
const removedProvider = await app.request(`/api/v1/ai/providers/${providerId}`, { method: "DELETE" }, databaseEnvironment);
expect(removedProvider.status).toBe(200);
expect((await removedProvider.json()).providers).toEqual([]);
expect((await app.request(`/api/v1/ai/providers/${providerId}`, { method: "DELETE" }, databaseEnvironment)).status).toBe(404);
expect(auditActionsOf(sqlite)).toEqual([
"workspace.ai_provider.create",
"workspace.ai_model.create",
"workspace.ai_default_model.update",
"workspace.ai_default_model.update",
"workspace.ai_model.delete",
"workspace.ai_provider.delete",
]);
sqlite.close();
});
test("does not auto-select a default model for a disabled provider", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const created = await createProvider(app, databaseEnvironment, { initialModelId: undefined, isEnabled: false });
const providerId = created.providers[0].id;
const added = await app.request(
`/api/v1/ai/providers/${providerId}/models`,
jsonRequest("POST", { modelId: "model-c", displayName: "Model C" }),
databaseEnvironment,
);
const body = await added.json();
expect(body.providers[0].models[0].displayName).toBe("Model C");
expect(body.defaultModelId).toBeNull();
const selected = await app.request(
"/api/v1/ai/default-model",
jsonRequest("PUT", { modelConfigId: body.providers[0].models[0].id }),
databaseEnvironment,
);
expect(selected.status).toBe(400);
sqlite.close();
});
test("reports provider errors for malformed direct credential requests", async () => {
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const response = await createApp().request(
"/api/v1/ai/providers/aip_x/direct-credential",
{ method: "POST", headers: { "content-type": "application/json" }, body: "{not json" },
databaseEnvironment,
);
expect(response.status).toBe(400);
const body = await response.json();
expect(body.error.code).toBe("ai_credential_failed");
expect(typeof body.error.message).toBe("string");
const tokenResponse = await createApp({ currentAuth: agentAuth }).request(
"/api/v1/ai/providers/aip_x/direct-credential",
jsonRequest("POST", {}),
databaseEnvironment,
);
expect(tokenResponse.status).toBe(403);
sqlite.close();
});
});
describe("AI preparation routes without a configured model", () => {
const prepareRequests = [
["/api/v1/ai/direct-target", {}],
["/api/v1/ai/tag-suggestions/prepare", jsonRequest("POST", { title: "T", contentMarkdown: "Body", currentTags: [] })],
[
"/api/v1/ai/infographic-agent/prepare",
jsonRequest("POST", { prompt: "List", currentContent: "", candidates: ["list-grid-simple"], history: [] }),
],
["/api/v1/ai/generate/prepare", jsonRequest("POST", { action: "summarize", title: "T", contentMarkdown: "Body" })],
];
test("report that AI is not configured", async () => {
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
for (const [path, init] of prepareRequests) {
const response = await createApp().request(path, init, databaseEnvironment);
expect(response.status, path).toBe(409);
expect(await response.json()).toMatchObject({ error: { code: "ai_not_configured" } });
}
sqlite.close();
});
test("require an interactive user session", async () => {
for (const [path, init] of prepareRequests) {
const response = await createApp({ currentAuth: agentAuth }).request(path, init, environment);
expect(response.status, path).toBe(403);
}
});
});
describe("AI generation preparation", () => {
test("includes only the parameters the action needs", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
await createProvider(app, databaseEnvironment);
const translate = await app.request(
"/api/v1/ai/generate/prepare",
jsonRequest("POST", { action: "translate", title: "Note", contentMarkdown: "Hallo", targetLanguage: "en", tone: "friendly" }),
databaseEnvironment,
);
expect(translate.status).toBe(200);
const tone = await app.request(
"/api/v1/ai/generate/prepare",
jsonRequest("POST", { action: "change-tone", title: "Note", contentMarkdown: "Body" }),
databaseEnvironment,
);
expect(tone.status).toBe(400);
expect(await tone.json()).toMatchObject({ error: { code: "ai_request_invalid" } });
const custom = await app.request(
"/api/v1/ai/generate/prepare",
jsonRequest("POST", { action: "custom", title: "Note", contentMarkdown: "Body", instruction: " Keep every date unique-marker. " }),
databaseEnvironment,
);
expect(custom.status).toBe(200);
expect(JSON.stringify(await custom.json())).toContain("Keep every date unique-marker.");
sqlite.close();
});
test("uses a saved workspace prompt's instruction", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
await createProvider(app, databaseEnvironment);
const now = "2026-08-12T01:00:00.000Z";
sqlite.query(
`INSERT INTO ai_prompt_templates (
id, workspace_id, seed_key, action, parameter_kind, result_mode,
name, description, instruction,
name_customized, description_customized, instruction_customized,
created_at, updated_at
) VALUES (?, ?, NULL, 'custom', 'none', 'replace', ?, NULL, ?, 1, 1, 1, ?, ?)`,
).run("aiprompt_saved", auth.workspaceId, "Saved", "Saved-prompt-marker instruction.", now, now);
const response = await app.request(
"/api/v1/ai/generate/prepare",
jsonRequest("POST", { action: "translate", promptId: "aiprompt_saved", title: "Note", contentMarkdown: "Body" }),
databaseEnvironment,
);
expect(response.status).toBe(200);
expect(JSON.stringify(await response.json())).toContain("Saved-prompt-marker instruction.");
sqlite.query(
`INSERT INTO ai_prompt_templates (
id, workspace_id, seed_key, action, parameter_kind, result_mode,
name, description, instruction,
name_customized, description_customized, instruction_customized,
created_at, updated_at
) VALUES (?, ?, NULL, 'custom', 'target-language', 'replace', ?, NULL, ?, 1, 1, 1, ?, ?)`,
).run("aiprompt_language", auth.workspaceId, "Language", "Translate it.", now, now);
const missingLanguage = await app.request(
"/api/v1/ai/generate/prepare",
jsonRequest("POST", { action: "custom", promptId: "aiprompt_language", title: "Note", contentMarkdown: "Body" }),
databaseEnvironment,
);
expect(missingLanguage.status).toBe(400);
expect(await missingLanguage.json()).toMatchObject({ error: { code: "ai_target_language_required" } });
const withLanguage = await app.request(
"/api/v1/ai/generate/prepare",
jsonRequest("POST", {
action: "custom",
promptId: "aiprompt_language",
title: "Note",
contentMarkdown: "Body",
targetLanguage: "en",
}),
databaseEnvironment,
);
expect(withLanguage.status).toBe(200);
sqlite.close();
});
test("maps existing tag spellings onto the canonical workspace tags", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
await createProvider(app, databaseEnvironment);
const response = await app.request(
"/api/v1/ai/tag-suggestions/prepare",
jsonRequest("POST", { title: "Note", contentMarkdown: "Body", currentTags: ["draft"], locale: "en-US" }),
databaseEnvironment,
);
expect(response.status).toBe(200);
const body = await response.json();
expect(body.currentTags).toEqual(["draft"]);
expect(body.canonicalTags).toEqual({});
sqlite.close();
});
});
describe("video outline preparation", () => {
test("requires the ai:generate scope for API tokens", async () => {
const response = await createApp({ currentAuth: { ...agentAuth, scopes: ["read:memos"] } }).request(
"/api/v1/ai/video-outline/prepare",
jsonRequest("POST", videoOutlineBody()),
environment,
);
expect(response.status).toBe(403);
});
test("returns model credentials with the outline prompt for a configured workspace", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
await createProvider(app, databaseEnvironment);
const response = await createApp({ currentAuth: agentAuth }).request(
"/api/v1/ai/video-outline/prepare",
jsonRequest("POST", videoOutlineBody()),
databaseEnvironment,
);
expect(response.status).toBe(200);
const body = await response.json();
expect(body).toMatchObject({ apiKey: "secret", modelId: "model-a", maxOutputTokens: 1200 });
expect(body.prompt).toContain("Hello world");
expect(typeof body.system).toBe("string");
sqlite.close();
});
});
describe("AI settings storage failures", () => {
test("rejects duplicate model ids without changing the stored models", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const provider = (await createProvider(app, databaseEnvironment)).providers[0];
const duplicate = await app.request(
`/api/v1/ai/providers/${provider.id}/models`,
jsonRequest("POST", { modelId: "model-a" }),
databaseEnvironment,
);
expect(duplicate.status).toBe(400);
expect(await duplicate.json()).toMatchObject({ error: { code: "ai_model_create_failed" } });
const speech = (await createTranscriptionProvider(app, databaseEnvironment, { initialModelId: "whisper-1" })).providers[0];
const duplicateSpeech = await app.request(
`/api/v1/ai/transcription-providers/${speech.id}/models`,
jsonRequest("POST", { modelId: "whisper-1" }),
databaseEnvironment,
);
expect(duplicateSpeech.status).toBe(400);
expect(await duplicateSpeech.json()).toMatchObject({ error: { code: "ai_transcription_model_create_failed" } });
expect(sqlite.query("SELECT COUNT(*) AS count FROM ai_models").get().count).toBe(1);
expect(sqlite.query("SELECT COUNT(*) AS count FROM ai_transcription_models").get().count).toBe(1);
expect(auditActionsOf(sqlite).filter((action) => action.endsWith("model.create"))).toEqual([]);
sqlite.close();
});
test("refuses to rotate keys when the encryption key is no longer configured", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const provider = (await createProvider(app, databaseEnvironment)).providers[0];
const speech = (await createTranscriptionProvider(app, databaseEnvironment)).providers[0];
const { EDGE_EVER_AUTH_PASSWORD: _password, ...withoutKey } = databaseEnvironment;
const { initialModelId: _model, ...providerFields } = validSettings;
const providerUpdate = await app.request(
`/api/v1/ai/providers/${provider.id}`,
jsonRequest("PUT", { ...providerFields, apiKey: "rotated" }),
withoutKey,
);
expect(providerUpdate.status).toBe(400);
expect(await providerUpdate.json()).toMatchObject({ error: { code: "ai_encryption_key_missing" } });
const speechUpdate = await app.request(
`/api/v1/ai/transcription-providers/${speech.id}`,
jsonRequest("PUT", { ...transcriptionSettings, apiKey: "rotated" }),
withoutKey,
);
expect(speechUpdate.status).toBe(400);
expect(await speechUpdate.json()).toMatchObject({ error: { code: "ai_encryption_key_missing" } });
sqlite.close();
});
test("reports an undecryptable speech credential instead of returning it", async () => {
const app = createApp();
const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
const speech = (await createTranscriptionProvider(app, databaseEnvironment)).providers[0];
sqlite.query("UPDATE ai_transcription_providers SET api_key_encrypted = ? WHERE id = ?").run("corrupted", speech.id);
const response = await app.request(
`/api/v1/ai/transcription-providers/${speech.id}/direct-credential`,
{ method: "POST" },
databaseEnvironment,
);
expect(response.status).toBe(503);
expect(await response.json()).toMatchObject({ error: { code: "ai_credentials_unavailable" } });
sqlite.close();
});
});