@neuralnomads/codenomad-dev 0.18.0-dev-20260712-c8d4a509 → 0.18.0-dev-20260714-f900af1b

package/dist/server/routes/settings.js

@@ -8,12 +8,52 @@ function validateBinaryPath(binaryPath) {
     const result = probeBinaryVersion(binaryPath);
     return { valid: result.valid, version: result.version, error: result.error };
 }
+export function enforceSpeechCredentialPairing(body, currentSpeech) {
+    if (!body || typeof body !== "object")
+        return body;
+    const patch = { ...body };
+    const speech = patch.speech;
+    if (!speech || typeof speech !== "object")
+        return patch;
+    const speechPatch = { ...speech };
+    const cur = (currentSpeech && typeof currentSpeech === "object") ? currentSpeech : {};
+    const curSpeech = (cur.speech && typeof cur.speech === "object") ? cur.speech : cur;
+    if ("baseUrl" in speechPatch && !("apiKey" in speechPatch)) {
+        if ((speechPatch.baseUrl ?? "") !== (curSpeech.baseUrl ?? "")) {
+            speechPatch.apiKey = null;
+        }
+    }
+    for (const dir of ["stt", "tts"]) {
+        if (dir in speechPatch) {
+            const dirPatch = { ...speechPatch[dir] };
+            if ("baseUrl" in dirPatch && !("apiKey" in dirPatch)) {
+                const curDir = (curSpeech[dir] && typeof curSpeech[dir] === "object") ? curSpeech[dir] : {};
+                if ((dirPatch.baseUrl ?? "") !== (curDir.baseUrl ?? "")) {
+                    dirPatch.apiKey = null;
+                }
+                speechPatch[dir] = dirPatch;
+            }
+        }
+    }
+    patch.speech = speechPatch;
+    return patch;
+}
 export function registerSettingsRoutes(app, deps) {
     // Full-document access
     app.get("/api/storage/config", async () => sanitizeConfigDoc(deps.settings.getDoc("config")));
     app.patch("/api/storage/config", async (request, reply) => {
         try {
-            return sanitizeConfigDoc(deps.settings.mergePatchDoc("config", request.body ?? {}));
+            let body = request.body ?? {};
+            if (body && typeof body === "object" && "server" in body) {
+                const bodyObj = { ...body };
+                const serverPatch = bodyObj.server;
+                if (serverPatch && typeof serverPatch === "object") {
+                    const currentServer = deps.settings.getOwner("config", "server");
+                    bodyObj.server = enforceSpeechCredentialPairing(serverPatch, currentServer);
+                }
+                body = bodyObj;
+            }
+            return sanitizeConfigDoc(deps.settings.mergePatchDoc("config", body));
         }
         catch (error) {
             reply.code(400);
@@ -25,7 +65,13 @@ export function registerSettingsRoutes(app, deps) {
     });
     app.patch("/api/storage/config/:owner", async (request, reply) => {
         try {
-            return sanitizeConfigOwner(request.params.owner, deps.settings.mergePatchOwner("config", request.params.owner, request.body ?? {}));
+            const currentOwner = request.params.owner === "server"
+                ? deps.settings.getOwner("config", "server")
+                : undefined;
+            const processed = request.params.owner === "server"
+                ? enforceSpeechCredentialPairing(request.body ?? {}, currentOwner)
+                : request.body ?? {};
+            return sanitizeConfigOwner(request.params.owner, deps.settings.mergePatchOwner("config", request.params.owner, processed));
         }
         catch (error) {
             reply.code(400);

package/dist/server/routes/settings.test.js

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { enforceSpeechCredentialPairing } from "./settings";
+describe("enforceSpeechCredentialPairing", () => {
+    it("clears shared key when baseUrl differs from stored", () => {
+        const result = enforceSpeechCredentialPairing({ speech: { baseUrl: "https://new.com/v1" } }, { speech: { baseUrl: "https://old.com/v1", apiKey: "sk-stored" } });
+        assert.equal(result.speech.apiKey, null);
+    });
+    it("does NOT clear shared key when baseUrl matches stored (old client full patch)", () => {
+        const result = enforceSpeechCredentialPairing({ speech: { baseUrl: "https://api.openai.com/v1", ttsVoice: "alloy", playbackMode: "streaming" } }, { speech: { baseUrl: "https://api.openai.com/v1", apiKey: "sk-stored" } });
+        assert.equal("apiKey" in result.speech, false, "must not clear key when URL unchanged");
+    });
+    it("clears directional key when directional baseUrl differs from stored", () => {
+        const result = enforceSpeechCredentialPairing({ speech: { stt: { baseUrl: "https://new.com/v1" } } }, { speech: { stt: { baseUrl: "https://old.com/v1", apiKey: "sk-stored" } } });
+        assert.equal(result.speech.stt.apiKey, null);
+    });
+    it("does NOT clear directional key when baseUrl matches stored", () => {
+        const result = enforceSpeechCredentialPairing({ speech: { stt: { baseUrl: "https://same.com/v1", model: "whisper-1" } } }, { speech: { stt: { baseUrl: "https://same.com/v1", apiKey: "sk-stored" } } });
+        assert.equal("apiKey" in result.speech.stt, false, "must not clear directional key when URL unchanged");
+    });
+    it("preserves apiKey when both baseUrl and apiKey are in patch", () => {
+        const result = enforceSpeechCredentialPairing({ speech: { baseUrl: "https://new.com/v1", apiKey: "sk-new" } }, { speech: { baseUrl: "https://old.com/v1", apiKey: "sk-old" } });
+        assert.equal(result.speech.apiKey, "sk-new");
+    });
+    it("handles both stt and tts independently against stored values", () => {
+        const result = enforceSpeechCredentialPairing({ speech: { stt: { baseUrl: "https://stt-same.com/v1", apiKey: "sk-stt" }, tts: { baseUrl: "https://tts-new.com/v1" } } }, { speech: { stt: { baseUrl: "https://stt-same.com/v1", apiKey: "sk-stt" }, tts: { baseUrl: "https://tts-old.com/v1", apiKey: "sk-tts" } } });
+        assert.equal(result.speech.stt.apiKey, "sk-stt");
+        assert.equal(result.speech.tts.apiKey, null);
+    });
+    it("passes through non-speech patches unchanged", () => {
+        const body = { logLevel: "INFO" };
+        const result = enforceSpeechCredentialPairing(body, { speech: {} });
+        assert.deepEqual(result, body);
+    });
+    it("passes through null/undefined body", () => {
+        assert.equal(enforceSpeechCredentialPairing(null), null);
+        assert.equal(enforceSpeechCredentialPairing(undefined), undefined);
+    });
+    it("does not mutate the original body", () => {
+        const original = { speech: { baseUrl: "https://new.com/v1" } };
+        const originalCopy = JSON.parse(JSON.stringify(original));
+        enforceSpeechCredentialPairing(original, { speech: { baseUrl: "https://old.com/v1" } });
+        assert.deepEqual(original, originalCopy);
+    });
+    it("doc-level payload: clears key when server.speech.baseUrl changes", () => {
+        const docBody = { server: { speech: { baseUrl: "https://new.com/v1" } } };
+        const currentServer = { speech: { baseUrl: "https://old.com/v1", apiKey: "sk-stored" } };
+        const result = enforceSpeechCredentialPairing(docBody.server, currentServer);
+        assert.equal(result.speech.apiKey, null, "doc-level server.speech must have key cleared on URL change");
+        assert.equal(result.speech.baseUrl, "https://new.com/v1");
+    });
+    it("doc-level payload: preserves key when server.speech.baseUrl unchanged", () => {
+        const docBody = { server: { speech: { baseUrl: "https://same.com/v1", ttsVoice: "alloy" } } };
+        const currentServer = { speech: { baseUrl: "https://same.com/v1", apiKey: "sk-stored" } };
+        const result = enforceSpeechCredentialPairing(docBody.server, currentServer);
+        assert.equal("apiKey" in result.speech, false, "key must not be cleared when URL unchanged in doc-level patch");
+    });
+});

package/dist/server/routes/workspaces.js

@@ -7,6 +7,7 @@ import { resolveWorktreeDirectory } from "../../workspaces/worktree-directory";
 const WorkspaceCreateSchema = z.object({
     path: z.string(),
     name: z.string().optional(),
+    forceNew: z.boolean().optional(),
 });
 const WorkspaceCloneSchema = z.object({
     repositoryUrl: z.string().trim().min(1, "Repository URL is required"),
@@ -51,9 +52,9 @@ export function registerWorkspaceRoutes(app, deps) {
     app.post("/api/workspaces", async (request, reply) => {
         try {
             const body = WorkspaceCreateSchema.parse(request.body ?? {});
-            const workspace = await deps.workspaceManager.create(body.path, body.name);
+            const result = await deps.workspaceManager.create(body.path, body.name, { forceNew: body.forceNew });
             reply.code(201);
-            return workspace;
+            return result.created ? result.workspace : { ...result.workspace, reused: true };
         }
         catch (error) {
             request.log.error({ err: error }, "Failed to create workspace");

package/dist/settings/public-config.js

@@ -15,6 +15,20 @@ function sanitizeServerOwner(value) {
     else if (!("hasApiKey" in speech)) {
         speech.hasApiKey = false;
     }
+    for (const dir of ["stt", "tts"]) {
+        if (isPlainObject(speech[dir])) {
+            const sub = { ...speech[dir] };
+            const dirKey = typeof sub.apiKey === "string" ? sub.apiKey.trim() : "";
+            if (dirKey) {
+                delete sub.apiKey;
+                sub.hasApiKey = true;
+            }
+            else if (!("hasApiKey" in sub)) {
+                sub.hasApiKey = false;
+            }
+            speech[dir] = sub;
+        }
+    }
     next.speech = speech;
     return next;
 }

package/dist/settings/public-config.test.js

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { sanitizeConfigOwner } from "./public-config";
+describe("sanitizeConfigOwner server speech", () => {
+    it("strips shared apiKey and sets hasApiKey", () => {
+        const result = sanitizeConfigOwner("server", {
+            speech: { apiKey: "sk-secret", sttModel: "whisper-1" },
+        });
+        assert.equal(result.speech.apiKey, undefined);
+        assert.equal(result.speech.hasApiKey, true);
+    });
+    it("strips stt.apiKey and sets stt.hasApiKey when separateProviders is true", () => {
+        const result = sanitizeConfigOwner("server", {
+            speech: {
+                separateProviders: true,
+                apiKey: "sk-shared",
+                stt: { apiKey: "sk-stt-secret", baseUrl: "https://groq.com" },
+                tts: { apiKey: "sk-tts-secret", baseUrl: "https://openai.com" },
+            },
+        });
+        assert.equal(result.speech.apiKey, undefined);
+        assert.equal(result.speech.hasApiKey, true);
+        assert.equal(result.speech.stt.apiKey, undefined);
+        assert.equal(result.speech.stt.hasApiKey, true);
+        assert.equal(result.speech.tts.apiKey, undefined);
+        assert.equal(result.speech.tts.hasApiKey, true);
+    });
+    it("sets hasApiKey=false when per-direction apiKey is absent", () => {
+        const result = sanitizeConfigOwner("server", {
+            speech: {
+                separateProviders: true,
+                stt: { baseUrl: "https://groq.com" },
+                tts: { baseUrl: "https://openai.com" },
+            },
+        });
+        assert.equal(result.speech.stt.hasApiKey, false);
+        assert.equal(result.speech.tts.hasApiKey, false);
+    });
+    it("preserves stt/tts sub-objects that have no apiKey", () => {
+        const result = sanitizeConfigOwner("server", {
+            speech: {
+                separateProviders: true,
+                stt: { model: "whisper-large-v3" },
+                tts: { model: "tts-1" },
+            },
+        });
+        assert.equal(result.speech.stt.model, "whisper-large-v3");
+        assert.equal(result.speech.stt.hasApiKey, false);
+        assert.equal(result.speech.tts.model, "tts-1");
+        assert.equal(result.speech.tts.hasApiKey, false);
+    });
+    it("passes through non-server owners unchanged", () => {
+        const result = sanitizeConfigOwner("ui", { foo: "bar" });
+        assert.deepEqual(result, { foo: "bar" });
+    });
+});

package/dist/speech/service.js

@@ -10,6 +10,21 @@ const ServerSpeechSettingsSchema = z.object({
         ttsModel: z.string().optional(),
         ttsVoice: z.string().optional(),
         ttsFormat: z.enum(["mp3", "wav", "opus", "aac"]).optional(),
+        separateProviders: z.boolean().optional(),
+        stt: z
+            .object({
+            apiKey: z.string().nullish(),
+            baseUrl: z.string().nullish(),
+            model: z.string().nullish(),
+        })
+            .optional(),
+        tts: z
+            .object({
+            apiKey: z.string().nullish(),
+            baseUrl: z.string().nullish(),
+            model: z.string().nullish(),
+        })
+            .optional(),
     })
         .optional(),
 });
@@ -24,27 +39,65 @@ export class SpeechService {
         this.logger = logger;
     }
     getCapabilities() {
-        return this.createProvider().getCapabilities();
+        const parsed = this.parseConfig();
+        const speech = parsed.speech ?? {};
+        const separate = speech.separateProviders === true;
+        const sttSettings = this.resolveSttSettingsFrom(speech);
+        const ttsSettings = this.resolveTtsSettingsFrom(speech);
+        const sttConfigured = Boolean(sttSettings.apiKey);
+        const ttsConfigured = Boolean(ttsSettings.apiKey);
+        return {
+            available: true,
+            configured: separate ? (sttConfigured && ttsConfigured) : (sttConfigured || ttsConfigured),
+            provider: sttSettings.provider,
+            supportsStt: true,
+            supportsTts: true,
+            supportsStreamingTts: true,
+            baseUrl: separate ? undefined : (speech.baseUrl?.trim() || process.env.OPENAI_BASE_URL || undefined),
+            sttModel: sttSettings.sttModel,
+            ttsModel: ttsSettings.ttsModel,
+            ttsVoice: ttsSettings.ttsVoice,
+            ttsFormats: ["mp3", "wav", "opus", "aac"],
+            streamingTtsFormats: ["mp3", "wav", "opus", "aac"],
+            separateProviders: separate,
+            sttConfigured,
+            ttsConfigured,
+            ...(separate ? { sttBaseUrl: sttSettings.baseUrl, ttsBaseUrl: ttsSettings.baseUrl } : {}),
+        };
     }
     async transcribe(input) {
-        return this.createProvider().transcribe(input);
+        return this.createSttProvider().transcribe(input);
     }
     async synthesize(input) {
-        return this.createProvider().synthesize(input);
+        return this.createTtsProvider().synthesize(input);
     }
     async synthesizeStream(input) {
-        return this.createProvider().synthesizeStream(input);
+        return this.createTtsProvider().synthesizeStream(input);
+    }
+    parseConfig() {
+        return ServerSpeechSettingsSchema.parse(this.settings.getOwner("config", "server") ?? {});
     }
-    createProvider() {
-        const settings = this.resolveSettings();
+    createSttProvider() {
+        const settings = this.resolveSttSettings();
         return new OpenAICompatibleSpeechProvider({
             settings,
-            logger: this.logger.child({ provider: settings.provider }),
+            logger: this.logger.child({ provider: settings.provider, direction: "stt" }),
         });
     }
-    resolveSettings() {
-        const parsed = ServerSpeechSettingsSchema.parse(this.settings.getOwner("config", "server") ?? {});
-        const speech = parsed.speech ?? {};
+    createTtsProvider() {
+        const settings = this.resolveTtsSettings();
+        return new OpenAICompatibleSpeechProvider({
+            settings,
+            logger: this.logger.child({ provider: settings.provider, direction: "tts" }),
+        });
+    }
+    resolveSttSettings() {
+        return this.resolveSttSettingsFrom(this.parseConfig().speech ?? {});
+    }
+    resolveTtsSettings() {
+        return this.resolveTtsSettingsFrom(this.parseConfig().speech ?? {});
+    }
+    resolveShared(speech) {
         return {
             provider: speech.provider?.trim() || DEFAULT_PROVIDER,
             apiKey: speech.apiKey?.trim() || process.env.OPENAI_API_KEY,
@@ -55,4 +108,62 @@ export class SpeechService {
             ttsFormat: speech.ttsFormat ?? DEFAULT_TTS_FORMAT,
         };
     }
+    resolveSttSettingsFrom(speech) {
+        if (speech.separateProviders !== true) {
+            return this.resolveShared(speech);
+        }
+        const stt = speech.stt ?? {};
+        const sharedBaseUrl = speech.baseUrl?.trim() || undefined;
+        const rawDirBaseUrl = stt.baseUrl?.trim() || undefined;
+        const dirApiKey = stt.apiKey?.trim() || undefined;
+        const dirBaseUrl = dirApiKey
+            ? rawDirBaseUrl
+            : (rawDirBaseUrl && rawDirBaseUrl !== sharedBaseUrl ? rawDirBaseUrl : undefined);
+        const hasCompleteDirectional = Boolean(dirApiKey) && Boolean(dirBaseUrl);
+        const hasNoDirectional = !dirApiKey && !dirBaseUrl;
+        return {
+            provider: speech.provider?.trim() || DEFAULT_PROVIDER,
+            apiKey: hasCompleteDirectional
+                ? dirApiKey
+                : hasNoDirectional
+                    ? speech.apiKey?.trim() || process.env.OPENAI_API_KEY
+                    : undefined,
+            baseUrl: hasCompleteDirectional || hasNoDirectional
+                ? (dirBaseUrl || sharedBaseUrl || process.env.OPENAI_BASE_URL || undefined)
+                : dirBaseUrl || undefined,
+            sttModel: stt.model?.trim() || speech.sttModel?.trim() || DEFAULT_STT_MODEL,
+            ttsModel: speech.ttsModel?.trim() || DEFAULT_TTS_MODEL,
+            ttsVoice: speech.ttsVoice?.trim() || DEFAULT_TTS_VOICE,
+            ttsFormat: speech.ttsFormat ?? DEFAULT_TTS_FORMAT,
+        };
+    }
+    resolveTtsSettingsFrom(speech) {
+        if (speech.separateProviders !== true) {
+            return this.resolveShared(speech);
+        }
+        const tts = speech.tts ?? {};
+        const sharedBaseUrl = speech.baseUrl?.trim() || undefined;
+        const rawDirBaseUrl = tts.baseUrl?.trim() || undefined;
+        const dirApiKey = tts.apiKey?.trim() || undefined;
+        const dirBaseUrl = dirApiKey
+            ? rawDirBaseUrl
+            : (rawDirBaseUrl && rawDirBaseUrl !== sharedBaseUrl ? rawDirBaseUrl : undefined);
+        const hasCompleteDirectional = Boolean(dirApiKey) && Boolean(dirBaseUrl);
+        const hasNoDirectional = !dirApiKey && !dirBaseUrl;
+        return {
+            provider: speech.provider?.trim() || DEFAULT_PROVIDER,
+            apiKey: hasCompleteDirectional
+                ? dirApiKey
+                : hasNoDirectional
+                    ? speech.apiKey?.trim() || process.env.OPENAI_API_KEY
+                    : undefined,
+            baseUrl: hasCompleteDirectional || hasNoDirectional
+                ? (dirBaseUrl || sharedBaseUrl || process.env.OPENAI_BASE_URL || undefined)
+                : dirBaseUrl || undefined,
+            sttModel: speech.sttModel?.trim() || DEFAULT_STT_MODEL,
+            ttsModel: tts.model?.trim() || speech.ttsModel?.trim() || DEFAULT_TTS_MODEL,
+            ttsVoice: speech.ttsVoice?.trim() || DEFAULT_TTS_VOICE,
+            ttsFormat: speech.ttsFormat ?? DEFAULT_TTS_FORMAT,
+        };
+    }
 }

package/dist/speech/service.test.js

@@ -0,0 +1,247 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { SpeechService } from "./service";
+function createMockSettings(serverConfig) {
+    return {
+        getOwner: () => serverConfig,
+    };
+}
+const mockLogger = {
+    child: () => mockLogger,
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    debug: () => { },
+};
+describe("SpeechService direction resolution", () => {
+    describe("separateProviders = false (default)", () => {
+        it("uses shared apiKey for both STT and TTS", () => {
+            const settings = createMockSettings({
+                speech: {
+                    apiKey: "sk-shared",
+                    baseUrl: "https://api.openai.com/v1",
+                    sttModel: "whisper-1",
+                    ttsModel: "tts-1",
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.separateProviders, false);
+            assert.equal(caps.sttConfigured, true);
+            assert.equal(caps.ttsConfigured, true);
+            assert.equal(caps.configured, true);
+        });
+        it("reports unconfigured when no apiKey is set", () => {
+            const settings = createMockSettings({
+                speech: { sttModel: "whisper-1", ttsModel: "tts-1" },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttConfigured, false);
+            assert.equal(caps.ttsConfigured, false);
+            assert.equal(caps.configured, false);
+        });
+        it("transcribe throws not-configured when apiKey absent", async () => {
+            const service = new SpeechService(createMockSettings({ speech: {} }), mockLogger);
+            await assert.rejects(() => service.transcribe({ audioBase64: "", mimeType: "audio/webm" }), /not configured/i);
+        });
+    });
+    describe("separateProviders = true", () => {
+        it("reports per-direction configured status independently", () => {
+            const settings = createMockSettings({
+                speech: {
+                    apiKey: "sk-shared",
+                    separateProviders: true,
+                    stt: { apiKey: "sk-groq", baseUrl: "https://api.groq.com/openai/v1", model: "whisper-large-v3" },
+                    tts: { apiKey: "sk-openai", baseUrl: "https://api.openai.com/v1", model: "gpt-4o-mini-tts" },
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.separateProviders, true);
+            assert.equal(caps.sttConfigured, true);
+            assert.equal(caps.ttsConfigured, true);
+            assert.equal(caps.configured, true);
+            assert.equal(caps.sttBaseUrl, "https://api.groq.com/openai/v1");
+            assert.equal(caps.ttsBaseUrl, "https://api.openai.com/v1");
+        });
+        it("reports partial config when only STT has complete directional pair", () => {
+            const settings = createMockSettings({
+                speech: {
+                    separateProviders: true,
+                    stt: { apiKey: "sk-groq", baseUrl: "https://api.groq.com/openai/v1" },
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttConfigured, true);
+            assert.equal(caps.ttsConfigured, false);
+            assert.equal(caps.configured, false);
+        });
+        it("does NOT combine directional key with shared URL (incomplete pair)", () => {
+            const settings = createMockSettings({
+                speech: {
+                    apiKey: "sk-shared",
+                    baseUrl: "https://api.openai.com/v1",
+                    separateProviders: true,
+                    stt: { apiKey: "sk-groq" },
+                    tts: { apiKey: "sk-deepseek" },
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttConfigured, false, "directional key without directional URL should not be configured");
+            assert.equal(caps.ttsConfigured, false);
+        });
+        it("does NOT combine shared key with foreign directional URL (incomplete pair)", () => {
+            const settings = createMockSettings({
+                speech: {
+                    apiKey: "sk-shared",
+                    baseUrl: "https://api.openai.com/v1",
+                    separateProviders: true,
+                    stt: { baseUrl: "https://api.groq.com/openai/v1" },
+                    tts: { baseUrl: "https://api.deepseek.com/v1" },
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttConfigured, false);
+            assert.equal(caps.ttsConfigured, false);
+        });
+        it("treats directional baseUrl matching shared as inherited (no directional key)", () => {
+            const sharedUrl = "https://api.openai.com/v1";
+            const settings = createMockSettings({
+                speech: {
+                    apiKey: "sk-shared",
+                    baseUrl: sharedUrl,
+                    separateProviders: true,
+                    stt: { baseUrl: sharedUrl },
+                    tts: { baseUrl: sharedUrl },
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttConfigured, true, "directional baseUrl matching shared with no key should inherit shared key");
+            assert.equal(caps.ttsConfigured, true);
+        });
+        it("inherits complete shared pair when neither directional value is set", () => {
+            const settings = createMockSettings({
+                speech: {
+                    apiKey: "sk-shared",
+                    baseUrl: "https://api.openai.com/v1",
+                    separateProviders: true,
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttConfigured, true);
+            assert.equal(caps.ttsConfigured, true);
+        });
+        it("uses complete directional pair when both key and URL are set", () => {
+            const settings = createMockSettings({
+                speech: {
+                    apiKey: "sk-shared",
+                    baseUrl: "https://api.openai.com/v1",
+                    separateProviders: true,
+                    stt: { apiKey: "sk-groq", baseUrl: "https://api.groq.com/openai/v1" },
+                    tts: { apiKey: "sk-openai", baseUrl: "https://api.openai.com/v1" },
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttConfigured, true);
+            assert.equal(caps.ttsConfigured, true);
+            assert.equal(caps.sttBaseUrl, "https://api.groq.com/openai/v1");
+        });
+        it("directional key with matching shared URL forms a complete pair", () => {
+            const sharedUrl = "https://api.openai.com/v1";
+            const settings = createMockSettings({
+                speech: {
+                    apiKey: "sk-shared",
+                    baseUrl: sharedUrl,
+                    separateProviders: true,
+                    stt: { apiKey: "sk-alt-openai", baseUrl: sharedUrl },
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttConfigured, true, "directional key with matching shared URL should be a complete pair");
+        });
+        it("falls back to shared sttModel/ttsModel when per-direction model is absent", () => {
+            const settings = createMockSettings({
+                speech: {
+                    apiKey: "sk-shared",
+                    baseUrl: "https://api.openai.com/v1",
+                    sttModel: "shared-stt-model",
+                    ttsModel: "shared-tts-model",
+                    separateProviders: true,
+                    stt: { apiKey: "sk-stt", baseUrl: "https://api.openai.com/v1" },
+                    tts: { apiKey: "sk-tts", baseUrl: "https://api.openai.com/v1" },
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttModel, "shared-stt-model");
+            assert.equal(caps.ttsModel, "shared-tts-model");
+        });
+        it("uses per-direction model when set", () => {
+            const settings = createMockSettings({
+                speech: {
+                    apiKey: "sk-shared",
+                    baseUrl: "https://api.openai.com/v1",
+                    sttModel: "shared-stt-model",
+                    ttsModel: "shared-tts-model",
+                    separateProviders: true,
+                    stt: { apiKey: "sk-stt", baseUrl: "https://api.openai.com/v1", model: "whisper-large-v3" },
+                    tts: { apiKey: "sk-tts", baseUrl: "https://api.openai.com/v1", model: "gpt-4o-mini-tts" },
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttModel, "whisper-large-v3");
+            assert.equal(caps.ttsModel, "gpt-4o-mini-tts");
+        });
+        it("omits sttBaseUrl/ttsBaseUrl when separateProviders is false", () => {
+            const settings = createMockSettings({
+                speech: { apiKey: "sk-shared", baseUrl: "https://api.openai.com/v1" },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttBaseUrl, undefined);
+            assert.equal(caps.ttsBaseUrl, undefined);
+        });
+        it("transcribe throws not-configured for incomplete pair (key without URL)", async () => {
+            const settings = createMockSettings({
+                speech: {
+                    apiKey: "sk-shared",
+                    baseUrl: "https://api.openai.com/v1",
+                    separateProviders: true,
+                    stt: { apiKey: "sk-groq" },
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            await assert.rejects(() => service.transcribe({ audioBase64: "", mimeType: "audio/webm" }), /not configured/i);
+        });
+        it("configured uses && in separate mode (both required for legacy compat)", () => {
+            const settings = createMockSettings({
+                speech: {
+                    separateProviders: true,
+                    stt: { apiKey: "sk-stt", baseUrl: "https://api.stt.com/v1" },
+                },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.sttConfigured, true);
+            assert.equal(caps.ttsConfigured, false);
+            assert.equal(caps.configured, false, "configured should be false when only one direction is ready");
+        });
+        it("configured uses || in shared mode", () => {
+            const settings = createMockSettings({
+                speech: { apiKey: "sk-shared", baseUrl: "https://api.openai.com/v1" },
+            });
+            const service = new SpeechService(settings, mockLogger);
+            const caps = service.getCapabilities();
+            assert.equal(caps.configured, true);
+        });
+    });
+});