Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

feat: provision managed Bedrock and Azure access

Gabriel Steindf52041b7e40
diff --git a/preload.js b/preload.js
index 4e4125228..bff15162a 100644
--- a/preload.js
+++ b/preload.js
@@ -540,6 +540,14 @@ contextBridge.exposeInMainWorld("electronAPI", {
(callback) => (_event, payload) => callback(payload)
),
listBedrockModels: (config) => ipcRenderer.invoke("bedrock-list-models", config),
+ getManagedEnterpriseConfig: (accountId, workspaceId, expectedAuthGeneration) =>
+ ipcRenderer.invoke(
+ "get-managed-enterprise-config",
+ accountId,
+ workspaceId,
+ expectedAuthGeneration
+ ),
+ clearManagedEnterpriseIdentity: () => ipcRenderer.invoke("clear-managed-enterprise-identity"),
// llama.cpp
llamaCppCheck: () => ipcRenderer.invoke("llama-cpp-check"),
diff --git a/src/components/AuthenticationStep.tsx b/src/components/AuthenticationStep.tsx
index e26f0a5b3..35da2cc6d 100644
--- a/src/components/AuthenticationStep.tsx
+++ b/src/components/AuthenticationStep.tsx
@@ -25,6 +25,11 @@ interface AuthenticationStepProps {
}
type AuthMode = "sign-in" | "sign-up" | null;
+type SsoDiscovery = {
+ required: boolean;
+ domain: string;
+ exists: boolean;
+};
const GoogleIcon = ({ className }: { className?: string }) => (
<svg className={className} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
@@ -82,6 +87,7 @@ export default function AuthenticationStep({
const [isCheckingEmail, setIsCheckingEmail] = useState(false);
const [isSocialLoading, setIsSocialLoading] = useState<SocialProvider | null>(null);
const [isSSOLoading, setIsSSOLoading] = useState(false);
+ const [ssoDiscovery, setSsoDiscovery] = useState<SsoDiscovery | null>(null);
const [error, setError] = useState<string | null>(null);
const [forgotPasswordOpen, setForgotPasswordOpen] = useState(false);
const [oauthProtocolRegistered, setOauthProtocolRegistered] = useState(true);
@@ -141,21 +147,32 @@ export default function AuthenticationStep({
[t]
);
+ const startSSOSignIn = useCallback(
+ async (value: string) => {
+ if (!value.trim()) {
+ setError(t("auth.sso.emailRequired"));
+ return;
+ }
+ setIsSSOLoading(true);
+ setError(null);
+
+ const result = await signInWithSSO(value.trim());
+
+ if (result.error) {
+ setError(result.error.message || t("auth.sso.failed"));
+ setIsSSOLoading(false);
+ }
+ },
+ [t]
+ );
+
const handleSSOSignIn = useCallback(async () => {
if (!email.trim()) {
setError(t("auth.sso.emailRequired"));
return;
}
- setIsSSOLoading(true);
- setError(null);
-
- const result = await signInWithSSO(email.trim());
-
- if (result.error) {
- setError(result.error.message || t("auth.sso.failed"));
- setIsSSOLoading(false);
- }
- }, [email, t]);
+ await startSSOSignIn(email);
+ }, [email, startSSOSignIn, t]);
const handleEmailContinue = useCallback(async () => {
if (!email.trim() || !authClient) return;
@@ -185,7 +202,20 @@ export default function AuthenticationStep({
throw new Error(t("auth.errors.failedUserCheck"));
}
- const data = await response.json().catch(() => ({}));
+ const data = (await response.json().catch(() => ({}))) as {
+ exists?: boolean;
+ sso?: { available?: boolean; required?: boolean; domain?: string };
+ };
+ if (data.sso?.available) {
+ const discovery = {
+ required: data.sso.required === true,
+ domain: data.sso.domain || email.trim().split("@")[1] || "your organization",
+ exists: data.exists === true,
+ };
+ setSsoDiscovery(discovery);
+ if (discovery.required) await startSSOSignIn(email);
+ return;
+ }
setAuthMode(data.exists ? "sign-in" : "sign-up");
} catch (err) {
logger.error("Error checking user existence", err, "auth");
@@ -193,7 +223,7 @@ export default function AuthenticationStep({
} finally {
setIsCheckingEmail(false);
}
- }, [email, t]);
+ }, [email, startSSOSignIn, t]);
const errorMessageIncludes = (message: string | undefined, keywords: string[]): boolean => {
if (!message) return false;
@@ -270,6 +300,7 @@ export default function AuthenticationStep({
const handleBack = useCallback(() => {
setAuthMode(null);
+ setSsoDiscovery(null);
setPassword("");
setFullName("");
setError(null);
@@ -360,6 +391,78 @@ export default function AuthenticationStep({
return <ForgotPasswordView email={email} onBack={handleBackFromForgotPassword} />;
}
+ if (ssoDiscovery && authMode === null) {
+ return (
+ <div className="space-y-3">
+ <button
+ type="button"
+ onClick={handleBack}
+ className="flex items-center gap-0.5 text-xs text-muted-foreground transition-colors hover:text-foreground"
+ >
+ <ChevronLeft className="h-3 w-3" />
+ {t("auth.common.back")}
+ </button>
+
+ <div className="pb-1 text-center">
+ <p className="mb-2 text-sm leading-tight text-muted-foreground/70">{email}</p>
+ <p className="text-lg font-semibold leading-tight tracking-tight text-foreground">
+ {t("auth.sso.companySignInTitle", { defaultValue: "Use your company sign-in" })}
+ </p>
+ <p className="mt-1 text-xs leading-snug text-muted-foreground">
+ {ssoDiscovery.required
+ ? t("auth.sso.requiredDescription", {
+ defaultValue: "{{domain}} requires SSO for OpenWhispr.",
+ domain: ssoDiscovery.domain,
+ })
+ : t("auth.sso.availableDescription", {
+ defaultValue: "Your {{domain}} account is ready for company SSO.",
+ domain: ssoDiscovery.domain,
+ })}
+ </p>
+ </div>
+
+ <Button
+ type="button"
+ onClick={handleSSOSignIn}
+ disabled={isSSOLoading || !oauthProtocolRegistered}
+ className="h-9 w-full"
+ >
+ {isSSOLoading ? (
+ <>
+ <Loader2 className="h-3.5 w-3.5 animate-spin" />
+ <span className="text-sm font-medium">{t("auth.social.completeInBrowser")}</span>
+ </>
+ ) : (
+ <span className="text-sm font-medium">{t("auth.sso.continueWithSSO")}</span>
+ )}
+ </Button>
+
+ {!ssoDiscovery.required && (
+ <Button
+ type="button"
+ variant="ghost"
+ size="sm"
+ className="w-full font-normal text-muted-foreground"
+ disabled={isSSOLoading}
+ onClick={() => {
+ setSsoDiscovery(null);
+ setAuthMode(ssoDiscovery.exists ? "sign-in" : "sign-up");
+ }}
+ >
+ {t("auth.sso.useEmailInstead", { defaultValue: "Use email and password instead" })}
+ </Button>
+ )}
+
+ {error && (
+ <div className="flex items-center gap-1.5 rounded border border-destructive/20 bg-destructive/5 px-2.5 py-1.5">
+ <AlertCircle className="h-3 w-3 shrink-0 text-destructive" />
+ <p className="text-xs leading-snug text-destructive">{error}</p>
+ </div>
+ )}
+ </div>
+ );
+ }
+
// Password form (after email is entered)
if (authMode !== null) {
return (
diff --git a/src/components/EnterpriseSection.tsx b/src/components/EnterpriseSection.tsx
index 7d7ddbf9d..0c7ab5565 100644
--- a/src/components/EnterpriseSection.tsx
+++ b/src/components/EnterpriseSection.tsx
@@ -9,7 +9,7 @@ import { usePolicySnapshot } from "../hooks/usePolicy";
const ENTERPRISE_PROVIDER_TABS = [
{ id: "bedrock", name: "AWS Bedrock" },
- { id: "azure", name: "Azure OpenAI", disabled: true, disabledLabel: "Soon" },
+ { id: "azure", name: "Azure OpenAI" },
{ id: "vertex", name: "Vertex AI", disabled: true, disabledLabel: "Soon" },
];
diff --git a/src/components/TestConnectionButton.tsx b/src/components/TestConnectionButton.tsx
index 7f262ef5e..87e953076 100644
--- a/src/components/TestConnectionButton.tsx
+++ b/src/components/TestConnectionButton.tsx
@@ -5,7 +5,7 @@ import { CheckCircle, XCircle, Loader2, Copy } from "lucide-react";
interface TestConnectionButtonProps {
provider: string;
- getConfig: () => Record<string, string>;
+ getConfig: () => Record<string, unknown>;
}
export default function TestConnectionButton({ provider, getConfig }: TestConnectionButtonProps) {
diff --git a/src/components/chat/useChatStreaming.ts b/src/components/chat/useChatStreaming.ts
index ee8277d0f..fc936e314 100644
--- a/src/components/chat/useChatStreaming.ts
+++ b/src/components/chat/useChatStreaming.ts
@@ -2,7 +2,7 @@ import { useState, useRef, useEffect, useCallback } from "react";
import { useTranslation } from "react-i18next";
import ReasoningService, { type AgentStreamChunk } from "../../services/ReasoningService";
import { isEnterpriseProvider } from "../../models/ModelRegistry";
-import { getSettings } from "../../stores/settingsStore";
+import { getSettings, selectResolvedLLMConfig } from "../../stores/settingsStore";
import {
isAgentAllowed,
isLlmSelectionAllowed,
@@ -110,14 +110,15 @@ export function useChatStreaming({
const sendToAI = useCallback(
async (userText: string, allMessages: Message[]) => {
const settings = getSettings();
- const chatAgentMode = settings.chatAgentMode || "openwhispr";
+ const chatConfig = selectResolvedLLMConfig(settings, "chatIntelligence");
+ const chatAgentMode = chatConfig.mode || "openwhispr";
const policyState = usePolicyStore.getState();
const policyProvider =
chatAgentMode === "openwhispr"
? "openwhispr"
: chatAgentMode === "local"
? "local"
- : settings.chatAgentProvider;
+ : chatConfig.provider;
if (
!isAgentAllowed(policyState) ||
!isLlmSelectionAllowed(policyState, { mode: chatAgentMode, provider: policyProvider })
@@ -135,11 +136,10 @@ export function useChatStreaming({
setAgentState("thinking");
const isCloudAgent = chatAgentMode === "openwhispr" && settings.isSignedIn;
- const isLanAgent = chatAgentMode === "self-hosted" && !!settings.chatAgentRemoteUrl;
- const isCustomAgent =
- chatAgentMode === "providers" && settings.chatAgentProvider === "custom";
+ const isLanAgent = chatAgentMode === "self-hosted" && !!chatConfig.remoteUrl;
+ const isCustomAgent = chatAgentMode === "providers" && chatConfig.provider === "custom";
const isLocalProvider =
- !isEnterpriseProvider(settings.chatAgentProvider) &&
+ !isEnterpriseProvider(chatConfig.provider) &&
![
"openai",
"groq",
@@ -149,9 +149,9 @@ export function useChatStreaming({
"tinfoil",
"openrouter",
"corti",
- ].includes(settings.chatAgentProvider);
+ ].includes(chatConfig.provider);
const localModelCanUseTool =
- isLocalProvider && estimateModelSizeB(settings.chatAgentModel) >= LOCAL_TOOL_MIN_PARAMS_B;
+ isLocalProvider && estimateModelSizeB(chatConfig.model) >= LOCAL_TOOL_MIN_PARAMS_B;
const supportsTools = isCloudAgent || !isLocalProvider || localModelCanUseTool;
const scope = searchScopeRef.current;
@@ -242,17 +242,16 @@ export function useChatStreaming({
const aiTools = registry?.toAISDKFormat();
stream = ReasoningService.processTextStreamingAI(
llmMessages,
- settings.chatAgentModel,
- settings.chatAgentProvider,
+ chatConfig.model,
+ chatConfig.provider,
{
systemPrompt,
- lanUrl: isLanAgent ? settings.chatAgentRemoteUrl : undefined,
- baseUrl: isCustomAgent ? settings.chatAgentCloudBaseUrl || undefined : undefined,
+ inferenceScope: "chatIntelligence",
+ lanUrl: isLanAgent ? chatConfig.remoteUrl : undefined,
+ baseUrl: isCustomAgent ? chatConfig.cloudBaseUrl || undefined : undefined,
customApiKey:
- isCustomAgent || isLanAgent
- ? settings.chatAgentCustomApiKey || undefined
- : undefined,
- disableThinking: settings.chatAgentDisableThinking,
+ isCustomAgent || isLanAgent ? chatConfig.customApiKey || undefined : undefined,
+ disableThinking: chatConfig.disableThinking,
},
aiTools
);
diff --git a/src/components/settings/InferenceConfigEditor.tsx b/src/components/settings/InferenceConfigEditor.tsx
index 4539d095d..f78719bea 100644
--- a/src/components/settings/InferenceConfigEditor.tsx
+++ b/src/components/settings/InferenceConfigEditor.tsx
@@ -1,7 +1,7 @@
import { useCallback } from "react";
import { useShallow } from "zustand/react/shallow";
import { useTranslation } from "react-i18next";
-import { Cloud, Key, Cpu, Network, Building2 } from "lucide-react";
+import { Cloud, Key, Cpu, Network, Building2, ShieldCheck, AlertTriangle } from "lucide-react";
import {
useSettingsStore,
selectResolvedLLMConfig,
@@ -17,6 +17,13 @@ import { Toggle } from "../ui/toggle";
import type { InferenceMode } from "../../types/electron";
import type { InferenceScope } from "../../config/inferenceScopes";
import { isProviderValidForMode, getCloudModel, getLocalModel } from "../../models/ModelRegistry";
+import {
+ useEnterpriseIdentityStore,
+ getManagedScopeResolution,
+} from "../../stores/enterpriseIdentityStore";
+import TestConnectionButton from "../TestConnectionButton";
+import { getEnterpriseCallSettings } from "../../services/ai/enterpriseSettings";
+import { Button } from "../ui/button";
const MODE_LABEL_PREFIX: Record<InferenceScope, string> = {
dictationCleanup: "settingsPage.aiModels.modes",
@@ -42,6 +49,11 @@ export default function InferenceConfigEditor({ scope, onModeChange }: Inference
const { t } = useTranslation();
const config = useSettingsStore(useShallow((s) => selectResolvedLLMConfig(s, scope)));
const isSignedIn = useSettingsStore((s) => s.isSignedIn);
+ const enterpriseSetupMode = useSettingsStore((s) => s.enterpriseSetupMode);
+ const setEnterpriseSetupMode = useSettingsStore((s) => s.setEnterpriseSetupMode);
+ useEnterpriseIdentityStore(useShallow((s) => [s.status, s.config, s.error]));
+ const managed = getManagedScopeResolution(scope, enterpriseSetupMode);
+ const managedAvailable = getManagedScopeResolution(scope, "managed");
const prefix = MODE_LABEL_PREFIX[scope];
const { modes, isModeAllowed } = usePolicyModeOptions<InferenceModeOption>(
@@ -145,8 +157,84 @@ export default function InferenceConfigEditor({ scope, onModeChange }: Inference
!!getCloudModel(config.model)?.supportsThinking)) ||
(config.mode === "local" && !!getLocalModel(config.model)?.supportsThinking);
+ if (managed.kind === "error") {
+ return (
+ <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-3" role="alert">
+ <div className="flex items-start gap-2">
+ <AlertTriangle className="mt-0.5 h-4 w-4 shrink-0 text-destructive" />
+ <div>
+ <p className="text-sm font-medium">Managed enterprise AI needs attention</p>
+ <p className="mt-0.5 text-xs text-muted-foreground">{managed.message}</p>
+ </div>
+ </div>
+ </div>
+ );
+ }
+
+ if (managed.kind === "managed") {
+ const providerName = managed.provider === "bedrock" ? "Amazon Bedrock" : "Azure OpenAI";
+ return (
+ <div className="space-y-3 rounded-lg border border-primary/20 bg-primary/[0.03] p-3">
+ <div className="flex items-start gap-2.5">
+ <div className="rounded-md bg-primary/10 p-1.5 text-primary">
+ <ShieldCheck className="h-4 w-4" />
+ </div>
+ <div className="min-w-0 flex-1">
+ <p className="text-sm font-medium">Managed by your organization</p>
+ <p className="mt-0.5 text-xs text-muted-foreground">
+ {providerName} · <span className="font-mono">{managed.model}</span>
+ </p>
+ <p className="mt-1 text-xs text-muted-foreground">
+ Sign-in supplies short-lived access automatically. No cloud keys or CLI setup are
+ required.
+ </p>
+ </div>
+ </div>
+ <div className="flex flex-wrap items-center gap-2 border-t border-border/60 pt-3">
+ <TestConnectionButton
+ provider={managed.provider}
+ getConfig={() => ({
+ ...getEnterpriseCallSettings(managed.provider, scope),
+ model: managed.model,
+ })}
+ />
+ {managed.mode !== "managed_required" && managed.allowManualSetup && (
+ <Button
+ type="button"
+ variant="ghost"
+ size="sm"
+ onClick={() => setEnterpriseSetupMode("manual")}
+ >
+ Use personal setup
+ </Button>
+ )}
+ </div>
+ </div>
+ );
+ }
+
return (
<div className="space-y-3">
+ {enterpriseSetupMode === "manual" && managedAvailable.kind === "managed" && (
+ <div className="flex items-center justify-between gap-3 rounded-lg border bg-muted/30 p-3">
+ <div className="min-w-0">
+ <p className="text-sm font-medium">Organization setup available</p>
+ <p className="text-xs text-muted-foreground">
+ Use {managedAvailable.provider === "bedrock" ? "Amazon Bedrock" : "Azure OpenAI"}
+ without managing credentials.
+ </p>
+ </div>
+ <Button
+ type="button"
+ variant="outline"
+ size="sm"
+ className="shrink-0"
+ onClick={() => setEnterpriseSetupMode("managed")}
+ >
+ Use managed
+ </Button>
+ </div>
+ )}
<InferenceModeSelector modes={modes} activeMode={config.mode} onSelect={handleModeSelect} />
{config.mode === "providers" && renderModelSelector("cloud")}
diff --git a/src/components/ui/PromptStudio.tsx b/src/components/ui/PromptStudio.tsx
index db4d477ef..9aad41c9e 100644
--- a/src/components/ui/PromptStudio.tsx
+++ b/src/components/ui/PromptStudio.tsx
@@ -160,6 +160,7 @@ export default function PromptStudio({ className = "", kind = "cleanup" }: Promp
setCustomPrompt(kind, editedPrompt);
try {
const result = await ReasoningService.processText(testText, modelToUse, agentName, {
+ inferenceScope: "dictationTranslation",
provider,
lanUrl: isSelfHosted ? translationRemoteUrl : undefined,
baseUrl: isCustom ? translationCloudBaseUrl || undefined : undefined,
@@ -204,6 +205,7 @@ export default function PromptStudio({ className = "", kind = "cleanup" }: Promp
try {
const result = await ReasoningService.processText(testText, agent.model, agentName, {
...agent.config,
+ inferenceScope: "dictationAgent",
requiresAgent: true,
systemPrompt: resolvePrompt("dictationAgent", {
agentName,
@@ -275,6 +277,7 @@ export default function PromptStudio({ className = "", kind = "cleanup" }: Promp
setCustomPrompt(kind, editedPrompt);
try {
const result = await ReasoningService.processText(testText, modelToUse, agentName, {
+ inferenceScope: "dictationCleanup",
disableThinking: useSettingsStore.getState().cleanupDisableThinking,
});
setTestResult(result);
diff --git a/src/helpers/audioManager.js b/src/helpers/audioManager.js
index de95efde4..077ef14f4 100644
--- a/src/helpers/audioManager.js
+++ b/src/helpers/audioManager.js
@@ -40,6 +40,7 @@ import {
isCloudCleanupMode,
isCloudDictationAgentMode,
isCloudTranslationMode,
+ selectResolvedLLMConfig,
} from "../stores/settingsStore";
import {
effectiveAudioRetentionDays,
@@ -109,12 +110,13 @@ function dictationAgentReachable(settings) {
}
function translationChainReachable(settings) {
+ const translation = selectResolvedLLMConfig(settings, "dictationTranslation");
const isSelfHostedTranslation =
- settings.translationMode === "self-hosted" && !!settings.translationRemoteUrl?.trim();
+ translation.mode === "self-hosted" && !!translation.remoteUrl?.trim();
return resolveDictationTranslationReachability({
useDictationTranslation: settings.useDictationTranslation,
translationTargetLanguage: settings.translationTargetLanguage,
- translationModel: settings.translationModel,
+ translationModel: translation.model,
isCloudTranslation: isCloudTranslationMode(),
isSelfHostedTranslation,
});
@@ -127,19 +129,21 @@ function resolveReasoningRoute(
voiceAgentRequested,
translationRequested
) {
+ const cleanup = selectResolvedLLMConfig(settings, "dictationCleanup");
+ const translation = selectResolvedLLMConfig(settings, "dictationTranslation");
const cleanupReachable =
- !!settings.useCleanupModel && (!!settings.cleanupModel?.trim() || isCloudCleanupMode());
+ !!settings.useCleanupModel && (!!cleanup.model?.trim() || isCloudCleanupMode());
const agent = resolveDictationAgentInference(settings, {
isCloudAgent: isCloudDictationAgentMode(),
});
const isCloudTranslation = isCloudTranslationMode();
const isSelfHostedTranslation =
- settings.translationMode === "self-hosted" && !!settings.translationRemoteUrl?.trim();
+ translation.mode === "self-hosted" && !!translation.remoteUrl?.trim();
const translationReachable = resolveDictationTranslationReachability({
useDictationTranslation: settings.useDictationTranslation,
translationTargetLanguage: settings.translationTargetLanguage,
- translationModel: settings.translationModel,
+ translationModel: translation.model,
isCloudTranslation,
isSelfHostedTranslation,
});
@@ -164,20 +168,22 @@ function resolveReasoningRoute(
);
}
if (kind === "translation") {
- const provider = isCloudTranslation
- ? "openwhispr"
- : settings.translationProvider?.trim() || undefined;
- const isCustomTranslation = settings.translationMode === "providers" && provider === "custom";
+ const provider = isCloudTranslation ? "openwhispr" : translation.provider?.trim() || undefined;
+ const isCustomTranslation = translation.mode === "providers" && provider === "custom";
return {
kind: "translation",
- model: settings.translationModel?.trim() || "",
+ model: translation.model?.trim() || "",
cleanupReachable,
- cleanupConfig: { disableThinking: settings.cleanupDisableThinking },
+ cleanupConfig: {
+ inferenceScope: /** @type {const} */ ("dictationCleanup"),
+ disableThinking: settings.cleanupDisableThinking,
+ },
config: {
+ inferenceScope: /** @type {const} */ ("dictationTranslation"),
provider,
language: settings.translationTargetLanguage,
- lanUrl: isSelfHostedTranslation ? settings.translationRemoteUrl : undefined,
- baseUrl: isCustomTranslation ? settings.translationCloudBaseUrl || undefined : undefined,
+ lanUrl: isSelfHostedTranslation ? translation.remoteUrl : undefined,
+ baseUrl: isCustomTranslation ? translation.cloudBaseUrl || undefined : undefined,
customApiKey:
isCustomTranslation || isSelfHostedTranslation
? settings.translationCustomApiKey || undefined
@@ -210,7 +216,10 @@ function resolveReasoningRoute(
if (kind === "cleanup") {
return {
kind: "cleanup",
- config: { disableThinking: settings.cleanupDisableThinking },
+ config: {
+ inferenceScope: /** @type {const} */ ("dictationCleanup"),
+ disableThinking: settings.cleanupDisableThinking,
+ },
};
}
return { kind: "skip" };
diff --git a/src/helpers/dictationAgentInference.js b/src/helpers/dictationAgentInference.js
index 95956e39f..30a959c1a 100644
--- a/src/helpers/dictationAgentInference.js
+++ b/src/helpers/dictationAgentInference.js
@@ -2,6 +2,7 @@ import {
resolveDictationAgentProvider,
resolveDictationAgentReachability,
} from "./dictationRouting.js";
+import { getManagedScopeResolution } from "../stores/enterpriseIdentityStore";
// The dictation agent's inference scope, shared by the dictation route in
// audioManager and the Prompt Studio test tab so a prompt test hits the same
@@ -11,6 +12,18 @@ import {
// missing one as its cleanup path, which echoes the input back instead of
// running the instruction.
export function resolveDictationAgentInference(settings, { isCloudAgent = false } = {}) {
+ const managed = getManagedScopeResolution("dictationAgent", settings.enterpriseSetupMode);
+ if (managed.kind === "managed") {
+ return {
+ reachable: settings.useDictationAgent,
+ model: managed.model,
+ config: {
+ inferenceScope: /** @type {const} */ ("dictationAgent"),
+ provider: managed.provider,
+ disableThinking: settings.dictationAgentDisableThinking,
+ },
+ };
+ }
const model = settings.dictationAgentModel?.trim() || "";
const isSelfHosted =
settings.dictationAgentMode === "self-hosted" && !!settings.dictationAgentRemoteUrl?.trim();
@@ -30,6 +43,7 @@ export function resolveDictationAgentInference(settings, { isCloudAgent = false
}),
model,
config: {
+ inferenceScope: /** @type {const} */ ("dictationAgent"),
provider,
lanUrl: isSelfHosted ? settings.dictationAgentRemoteUrl : undefined,
baseUrl: isCustom ? settings.dictationAgentCloudBaseUrl || undefined : undefined,
diff --git a/src/helpers/enterpriseAiProviders.js b/src/helpers/enterpriseAiProviders.js
index fe8145185..9c36203b6 100644
--- a/src/helpers/enterpriseAiProviders.js
+++ b/src/helpers/enterpriseAiProviders.js
@@ -25,6 +25,13 @@ function createBedrockModel(model, enterprise) {
const { createAmazonBedrock } = require("@ai-sdk/amazon-bedrock");
const region = enterprise?.bedrockRegion || "us-east-1";
+ if (enterprise?.managedCredentialProvider) {
+ return createAmazonBedrock({
+ region,
+ credentialProvider: enterprise.managedCredentialProvider,
+ })(model);
+ }
+
if (enterprise?.bedrockProfile) {
const { fromNodeProviderChain } = require("@aws-sdk/credential-providers");
return createAmazonBedrock({
@@ -48,7 +55,9 @@ function createBedrockModel(model, enterprise) {
function createAzureModel(model, apiKey, enterprise) {
const { createAzure } = require("@ai-sdk/azure");
return createAzure({
- apiKey,
+ ...(enterprise?.managedTokenProvider
+ ? { tokenProvider: enterprise.managedTokenProvider }
+ : { apiKey }),
baseURL: enterprise?.azureEndpoint,
apiVersion: enterprise?.azureApiVersion || "2024-10-21",
})(model);
diff --git a/src/helpers/enterpriseIdentityManager.js b/src/helpers/enterpriseIdentityManager.js
new file mode 100644
index 000000000..bbf12ef34
--- /dev/null
+++ b/src/helpers/enterpriseIdentityManager.js
@@ -0,0 +1,412 @@
+const crypto = require("crypto");
+const fs = require("fs");
+const {
+ resolveManagedEnterpriseScope,
+ validateManagedEnterpriseEnvelope,
+} = require("./enterpriseManagedConfig.mjs");
+const { AuthContextError } = require("./cloudApiRequest");
+
+const CONFIG_CACHE_VERSION = 1;
+const CONFIG_REFRESH_MS = 5 * 60 * 1000;
+const CREDENTIAL_REFRESH_WINDOW_MS = 60 * 1000;
+const AZURE_SCOPE = "https://cognitiveservices.azure.com/.default";
+
+function normalizeId(value) {
+ return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function normalizeAuthHeaders(value, token) {
+ const headers = {};
+ if (value && typeof value === "object") {
+ if (typeof value.Authorization === "string" && value.Authorization) {
+ headers.Authorization = value.Authorization;
+ }
+ if (typeof value.Cookie === "string" && value.Cookie) headers.Cookie = value.Cookie;
+ }
+ if (!headers.Authorization && !headers.Cookie && token) {
+ headers.Authorization = `Bearer ${token}`;
+ }
+ return headers;
+}
+
+function readCache(cachePath) {
+ if (!fs.existsSync(cachePath)) return { version: CONFIG_CACHE_VERSION, entries: [] };
+ try {
+ const parsed = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+ return parsed?.version === CONFIG_CACHE_VERSION && Array.isArray(parsed.entries)
+ ? parsed
+ : { version: CONFIG_CACHE_VERSION, entries: [] };
+ } catch {
+ return { version: CONFIG_CACHE_VERSION, entries: [] };
+ }
+}
+
+function writeCache(cachePath, identity, config) {
+ const envelope = readCache(cachePath);
+ const entries = envelope.entries.filter((entry) => entry?.key !== identity.cacheKey);
+ entries.push({ key: identity.cacheKey, workspaceId: identity.workspaceId, config });
+ fs.writeFileSync(cachePath, JSON.stringify({ version: CONFIG_CACHE_VERSION, entries }), {
+ mode: 0o600,
+ });
+}
+
+function cachedConfig(cachePath, identity) {
+ const entry = readCache(cachePath).entries.find(
+ (candidate) => candidate?.key === identity.cacheKey
+ );
+ return validateManagedEnterpriseEnvelope(entry?.config, identity.workspaceId);
+}
+
+function responseError(code, error, identity = null) {
+ return {
+ success: false,
+ status: "error",
+ accountId: identity?.accountId ?? null,
+ workspaceId: identity?.workspaceId ?? null,
+ authGeneration: identity?.authGeneration ?? null,
+ code,
+ error,
+ };
+}
+
+function createEnterpriseIdentityManager({
+ cachePath,
+ getApiUrl,
+ getAppVersion,
+ proxyFetch,
+ tokenStore,
+ logger,
+ createAwsWebIdentityProvider = (init) =>
+ require("@aws-sdk/credential-providers").fromWebToken(init),
+ now = Date.now,
+ requestTimeoutMs = 10_000,
+}) {
+ const configs = new Map();
+ const configRequests = new Map();
+ const cloudCredentials = new Map();
+ const cloudCredentialRequests = new Map();
+
+ function captureIdentity(request = {}) {
+ const tokenState = tokenStore.getState();
+ if (
+ !Number.isSafeInteger(request.expectedAuthGeneration) ||
+ request.expectedAuthGeneration < 0 ||
+ request.expectedAuthGeneration !== tokenState.generation
+ ) {
+ throw new AuthContextError("Authentication changed before managed enterprise request");
+ }
+ const accountId = normalizeId(request.accountId);
+ const workspaceId = normalizeId(request.workspaceId);
+ if (!accountId || !workspaceId) {
+ throw new AuthContextError(
+ "An active workspace is required for managed enterprise AI",
+ "MANAGED_WORKSPACE_REQUIRED"
+ );
+ }
+ const apiUrl = getApiUrl()?.replace(/\/+$/, "");
+ if (!apiUrl) throw new Error("OpenWhispr API URL not configured");
+ const authHeaders = normalizeAuthHeaders(request.authHeaders, tokenState.token);
+ if (!Object.keys(authHeaders).length) {
+ throw new AuthContextError("Not authenticated", "AUTH_CONTEXT_UNVALIDATED");
+ }
+ const credentialHash = crypto
+ .createHash("sha256")
+ .update(JSON.stringify(Object.entries(authHeaders).sort(([a], [b]) => a.localeCompare(b))))
+ .digest("hex");
+ const apiOrigin = new URL(apiUrl).origin;
+ const cacheKey = `${apiOrigin}\n${credentialHash}\n${accountId}\n${workspaceId}`;
+ return {
+ accountId,
+ workspaceId,
+ apiUrl,
+ apiOrigin,
+ authHeaders,
+ authGeneration: tokenState.generation,
+ token: tokenState.token ?? null,
+ cacheKey,
+ };
+ }
+
+ function assertIdentityCurrent(identity) {
+ const current = tokenStore.getState();
+ if (
+ current.generation !== identity.authGeneration ||
+ (identity.token ? current.token !== identity.token : Boolean(current.token))
+ ) {
+ throw new AuthContextError("Authentication changed during managed enterprise request");
+ }
+ }
+
+ function requestHeaders(identity, json = false) {
+ return {
+ ...identity.authHeaders,
+ "x-openwhispr-version": getAppVersion(),
+ ...(json ? { "Content-Type": "application/json" } : {}),
+ };
+ }
+
+ async function fetchWithTimeout(url, init) {
+ const controller = new AbortController();
+ const timeout = setTimeout(() => controller.abort(), requestTimeoutMs);
+ try {
+ return await proxyFetch(url, { ...init, signal: controller.signal });
+ } finally {
+ clearTimeout(timeout);
+ }
+ }
+
+ async function readError(response, fallback) {
+ try {
+ const body = await response.json();
+ return { message: body?.error || fallback, code: body?.code };
+ } catch {
+ return { message: fallback };
+ }
+ }
+
+ async function fetchConfig(identity) {
+ const url = `${identity.apiUrl}/api/workspaces/${encodeURIComponent(
+ identity.workspaceId
+ )}/enterprise-providers`;
+ const response = await fetchWithTimeout(url, {
+ method: "GET",
+ headers: requestHeaders(identity),
+ });
+ assertIdentityCurrent(identity);
+ if (!response.ok) {
+ const detail = await readError(response, `Managed enterprise API error: ${response.status}`);
+ const error = new Error(detail.message);
+ error.code =
+ detail.code || (response.status === 401 ? "AUTH_EXPIRED" : "MANAGED_CONFIG_FAILED");
+ error.status = response.status;
+ throw error;
+ }
+ const body = await response.json();
+ assertIdentityCurrent(identity);
+ const config = validateManagedEnterpriseEnvelope(body?.data, identity.workspaceId);
+ if (!config) {
+ const error = new Error("Managed enterprise configuration is malformed");
+ error.code = "MANAGED_CONFIG_INVALID";
+ throw error;
+ }
+ configs.set(identity.cacheKey, { config, refreshedAt: now() });
+ try {
+ writeCache(cachePath, identity, config);
+ } catch (error) {
+ logger?.warn?.("Managed enterprise configuration cache write failed", {
+ error: error?.message,
+ });
+ }
+ return { config, status: "network" };
+ }
+
+ async function resolveConfig(identity, forceRefresh = false) {
+ const current = configs.get(identity.cacheKey);
+ if (!forceRefresh && current && now() - current.refreshedAt < CONFIG_REFRESH_MS) {
+ return { config: current.config, status: "current" };
+ }
+ if (!forceRefresh && configRequests.has(identity.cacheKey)) {
+ return configRequests.get(identity.cacheKey);
+ }
+ const pending = fetchConfig(identity)
+ .catch((error) => {
+ const memory = configs.get(identity.cacheKey)?.config;
+ const disk = memory || cachedConfig(cachePath, identity);
+ if (disk) {
+ configs.set(identity.cacheKey, { config: disk, refreshedAt: 0 });
+ return { config: disk, status: "cached" };
+ }
+ throw error;
+ })
+ .finally(() => {
+ if (configRequests.get(identity.cacheKey) === pending) {
+ configRequests.delete(identity.cacheKey);
+ }
+ });
+ configRequests.set(identity.cacheKey, pending);
+ return pending;
+ }
+
+ async function getConfig(request) {
+ let identity;
+ try {
+ identity = captureIdentity(request);
+ const resolved = await resolveConfig(identity);
+ return {
+ success: true,
+ status: resolved.status,
+ accountId: identity.accountId,
+ workspaceId: identity.workspaceId,
+ authGeneration: identity.authGeneration,
+ config: resolved.config,
+ };
+ } catch (error) {
+ return responseError(error.code || "MANAGED_CONFIG_FAILED", error.message, identity);
+ }
+ }
+
+ async function fetchAssertion(identity, provider) {
+ const url = `${identity.apiUrl}/api/workspaces/${encodeURIComponent(
+ identity.workspaceId
+ )}/enterprise-providers/${provider}/assertion`;
+ const response = await fetchWithTimeout(url, {
+ method: "POST",
+ headers: requestHeaders(identity, true),
+ body: "{}",
+ });
+ assertIdentityCurrent(identity);
+ if (!response.ok) {
+ const detail = await readError(response, `Managed identity API error: ${response.status}`);
+ const error = new Error(detail.message);
+ error.code =
+ detail.code || (response.status === 401 ? "AUTH_EXPIRED" : "IDENTITY_EXCHANGE_FAILED");
+ error.status = response.status;
+ throw error;
+ }
+ const body = await response.json();
+ if (typeof body?.data?.assertion !== "string") {
+ throw Object.assign(new Error("Managed identity assertion is malformed"), {
+ code: "IDENTITY_EXCHANGE_FAILED",
+ });
+ }
+ return body.data.assertion;
+ }
+
+ function credentialKey(identity, provider, version) {
+ return `${identity.cacheKey}\n${provider}\n${version}`;
+ }
+
+ function usableCredential(entry) {
+ return entry && entry.expiresAt - now() > CREDENTIAL_REFRESH_WINDOW_MS;
+ }
+
+ async function dedupeCredential(key, create) {
+ const cached = cloudCredentials.get(key);
+ if (usableCredential(cached)) return cached.value;
+ if (cloudCredentialRequests.has(key)) return cloudCredentialRequests.get(key);
+ const pending = create()
+ .then((entry) => {
+ cloudCredentials.set(key, entry);
+ return entry.value;
+ })
+ .finally(() => {
+ if (cloudCredentialRequests.get(key) === pending) cloudCredentialRequests.delete(key);
+ });
+ cloudCredentialRequests.set(key, pending);
+ return pending;
+ }
+
+ function managedProviderFunctions(identity, resolution) {
+ const record = resolution.record;
+ const key = credentialKey(identity, record.provider, record.version);
+ if (record.provider === "bedrock") {
+ return {
+ credentialProvider: () =>
+ dedupeCredential(key, async () => {
+ const assertion = await fetchAssertion(identity, "bedrock");
+ const credentials = await createAwsWebIdentityProvider({
+ roleArn: record.config.roleArn,
+ roleSessionName: `openwhispr-${identity.workspaceId.slice(0, 8)}`,
+ webIdentityToken: assertion,
+ durationSeconds: 900,
+ clientConfig: { region: record.config.region },
+ })();
+ assertIdentityCurrent(identity);
+ if (
+ !credentials?.accessKeyId ||
+ !credentials.secretAccessKey ||
+ !credentials.sessionToken ||
+ !credentials.expiration
+ ) {
+ throw Object.assign(new Error("AWS did not return temporary credentials"), {
+ code: "IDENTITY_EXCHANGE_FAILED",
+ });
+ }
+ return {
+ value: {
+ accessKeyId: credentials.accessKeyId,
+ secretAccessKey: credentials.secretAccessKey,
+ sessionToken: credentials.sessionToken,
+ expiration: credentials.expiration,
+ },
+ expiresAt: credentials.expiration.getTime(),
+ };
+ }),
+ };
+ }
+
+ return {
+ tokenProvider: () =>
+ dedupeCredential(key, async () => {
+ const assertion = await fetchAssertion(identity, "azure");
+ const tokenUrl = `https://login.microsoftonline.com/${encodeURIComponent(
+ record.config.tenantId
+ )}/oauth2/v2.0/token`;
+ const body = new URLSearchParams({
+ client_id: record.config.clientId,
+ grant_type: "client_credentials",
+ scope: AZURE_SCOPE,
+ client_assertion_type: "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
+ client_assertion: assertion,
+ });
+ const response = await fetchWithTimeout(tokenUrl, {
+ method: "POST",
+ headers: { "Content-Type": "application/x-www-form-urlencoded" },
+ body: body.toString(),
+ });
+ if (!response.ok) {
+ const detail = await readError(
+ response,
+ `Microsoft identity error: ${response.status}`
+ );
+ throw Object.assign(new Error(detail.message), { code: "IDENTITY_EXCHANGE_FAILED" });
+ }
+ const token = await response.json();
+ assertIdentityCurrent(identity);
+ if (typeof token?.access_token !== "string" || !Number.isFinite(token?.expires_in)) {
+ throw Object.assign(new Error("Microsoft identity response is malformed"), {
+ code: "IDENTITY_EXCHANGE_FAILED",
+ });
+ }
+ return {
+ value: token.access_token,
+ expiresAt: now() + token.expires_in * 1000,
+ };
+ }),
+ };
+ }
+
+ async function resolveProvider(request) {
+ const identity = captureIdentity(request);
+ const { config } = await resolveConfig(identity);
+ const resolution = resolveManagedEnterpriseScope(
+ config,
+ request.inferenceScope,
+ request.setupMode
+ );
+ if (resolution.kind === "error") {
+ throw Object.assign(new Error(resolution.message), { code: resolution.code });
+ }
+ if (resolution.kind === "manual") return { managed: false, identity, config };
+ return {
+ managed: true,
+ identity,
+ provider: resolution.provider,
+ model: resolution.model,
+ config: resolution.record.config,
+ version: resolution.record.version,
+ ...managedProviderFunctions(identity, resolution),
+ };
+ }
+
+ function clear() {
+ configs.clear();
+ configRequests.clear();
+ cloudCredentials.clear();
+ cloudCredentialRequests.clear();
+ }
+
+ return { getConfig, resolveProvider, clear };
+}
+
+module.exports = { createEnterpriseIdentityManager };
diff --git a/src/helpers/enterpriseManagedConfig.mjs b/src/helpers/enterpriseManagedConfig.mjs
new file mode 100644
index 000000000..be4e4ee62
--- /dev/null
+++ b/src/helpers/enterpriseManagedConfig.mjs
@@ -0,0 +1,153 @@
+const ENTERPRISE_INFERENCE_SCOPES = [
+ "dictationCleanup",
+ "dictationAgent",
+ "noteFormatting",
+ "chatIntelligence",
+ "dictationTranslation",
+];
+
+const ENTERPRISE_PROVIDERS = ["bedrock", "azure"];
+const PROVIDER_MODES = ["disabled", "managed_default", "managed_required"];
+const AWS_ROLE_ARN = /^arn:(aws|aws-us-gov|aws-cn):iam::\d{12}:role\/[A-Za-z0-9+=,.@_/-]{1,512}$/;
+const AWS_REGION = /^[a-z]{2}(?:-gov)?-[a-z]+-\d$/;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const AZURE_API_VERSION = /^\d{4}-\d{2}-\d{2}(?:-preview)?$/;
+const AZURE_ENDPOINT_SUFFIXES = [
+ ".openai.azure.com",
+ ".services.ai.azure.com",
+ ".cognitiveservices.azure.com",
+ ".openai.azure.us",
+ ".cognitiveservices.azure.us",
+ ".openai.azure.cn",
+ ".cognitiveservices.azure.cn",
+];
+
+function isNonEmptyString(value) {
+ return typeof value === "string" && value.trim().length > 0;
+}
+
+function isStringMap(value) {
+ return (
+ value &&
+ typeof value === "object" &&
+ !Array.isArray(value) &&
+ Object.values(value).every(isNonEmptyString)
+ );
+}
+
+function isSafeHttpsUrl(value) {
+ try {
+ const url = new URL(value);
+ return (
+ url.protocol === "https:" &&
+ !url.username &&
+ !url.password &&
+ (!url.port || url.port === "443")
+ );
+ } catch {
+ return false;
+ }
+}
+
+function isAllowedAzureEndpoint(value) {
+ if (!isSafeHttpsUrl(value)) return false;
+ const hostname = new URL(value).hostname.toLowerCase();
+ return AZURE_ENDPOINT_SUFFIXES.some((suffix) => hostname.endsWith(suffix));
+}
+
+function isValidProviderConfig(record) {
+ if (!record || !ENTERPRISE_PROVIDERS.includes(record.provider)) return false;
+ if (!PROVIDER_MODES.includes(record.mode) || typeof record.allowManualSetup !== "boolean") {
+ return false;
+ }
+ if (!Number.isSafeInteger(record.version) || record.version < 1) return false;
+ const config = record.config;
+ if (!config || typeof config !== "object") return false;
+ const allowed = record.provider === "bedrock" ? config.allowedModels : config.allowedDeployments;
+ const defaults = config.scopeDefaults;
+ if (!Array.isArray(allowed) || allowed.length === 0 || !allowed.every(isNonEmptyString)) {
+ return false;
+ }
+ if (!isStringMap(defaults)) return false;
+ if (
+ !ENTERPRISE_INFERENCE_SCOPES.every((scope) => isNonEmptyString(defaults[scope])) ||
+ !Object.keys(defaults).every((scope) => ENTERPRISE_INFERENCE_SCOPES.includes(scope))
+ ) {
+ return false;
+ }
+ if (!Object.values(defaults).every((model) => allowed.includes(model))) return false;
+
+ if (record.provider === "bedrock") {
+ return AWS_ROLE_ARN.test(config.roleArn) && AWS_REGION.test(config.region);
+ }
+ return (
+ UUID.test(config.tenantId) &&
+ UUID.test(config.clientId) &&
+ isAllowedAzureEndpoint(config.endpoint) &&
+ AZURE_API_VERSION.test(config.apiVersion)
+ );
+}
+
+function validateManagedEnterpriseEnvelope(value, expectedWorkspaceId) {
+ if (!value || typeof value !== "object" || value.workspaceId !== expectedWorkspaceId) return null;
+ if (!Number.isSafeInteger(value.version) || value.version < 0) return null;
+ if (!value.identity || typeof value.identity !== "object" || !Array.isArray(value.providers)) {
+ return null;
+ }
+ if (
+ !isSafeHttpsUrl(value.identity.issuer) ||
+ !isSafeHttpsUrl(value.identity.jwksUri) ||
+ value.identity.subject !== `workspace:${expectedWorkspaceId}` ||
+ value.identity.audiences?.bedrock !== "sts.amazonaws.com" ||
+ value.identity.audiences?.azure !== "api://AzureADTokenExchange"
+ ) {
+ return null;
+ }
+ if (!value.providers.every(isValidProviderConfig)) return null;
+ return value;
+}
+
+function resolutionError(code, message) {
+ return { kind: "error", code, message };
+}
+
+function resolveManagedEnterpriseScope(envelope, scope, setupMode = "auto") {
+ if (!ENTERPRISE_INFERENCE_SCOPES.includes(scope)) {
+ return resolutionError("MANAGED_SCOPE_INVALID", "The requested inference scope is invalid.");
+ }
+ if (!envelope?.providers?.length) return { kind: "manual" };
+
+ const configured = envelope.providers.filter(
+ (record) => record.mode !== "disabled" && isNonEmptyString(record.config.scopeDefaults[scope])
+ );
+ if (!configured.length) return { kind: "manual" };
+
+ const enforced = configured.filter(
+ (record) => record.mode === "managed_required" || !record.allowManualSetup
+ );
+ const candidates = enforced.length ? enforced : setupMode === "manual" ? [] : configured;
+ if (!candidates.length) return { kind: "manual" };
+ if (candidates.length > 1) {
+ return resolutionError(
+ "MANAGED_PROVIDER_AMBIGUOUS",
+ "Your organization configured more than one managed provider for this feature. Contact your IT administrator."
+ );
+ }
+
+ const record = candidates[0];
+ return {
+ kind: "managed",
+ provider: record.provider,
+ model: record.config.scopeDefaults[scope],
+ mode: record.mode,
+ allowManualSetup: record.allowManualSetup,
+ record,
+ };
+}
+
+export {
+ ENTERPRISE_INFERENCE_SCOPES,
+ ENTERPRISE_PROVIDERS,
+ validateManagedEnterpriseEnvelope,
+ resolveManagedEnterpriseScope,
+};
diff --git a/src/helpers/enterpriseProviderErrors.js b/src/helpers/enterpriseProviderErrors.js
index 6bd558e78..28ca51f0a 100644
--- a/src/helpers/enterpriseProviderErrors.js
+++ b/src/helpers/enterpriseProviderErrors.js
@@ -6,6 +6,49 @@
const { classifyNetworkError } = require("./networkErrors");
+function mapManagedIdentityError(error, provider) {
+ const code = error?.code;
+ if (!code) return null;
+ if (["AUTH_CONTEXT_CHANGED", "AUTH_CONTEXT_UNVALIDATED", "AUTH_EXPIRED"].includes(code)) {
+ return {
+ message: "Your OpenWhispr session changed or expired.",
+ action: "Sign in again, then retry.",
+ retryable: true,
+ };
+ }
+ if (code === "SSO_REQUIRED") {
+ return {
+ message: "Company SSO is required for managed enterprise AI.",
+ action: "Sign out and sign back in with your company SSO account.",
+ };
+ }
+ if (code === "DIRECTORY_ASSIGNMENT_REQUIRED") {
+ return {
+ message: error.message,
+ action: "Ask your IT administrator to restore your directory assignment.",
+ };
+ }
+ if (
+ [
+ "PROVIDER_NOT_ALLOWED",
+ "PROVIDER_NOT_CONFIGURED",
+ "WORKSPACE_SUBSCRIPTION_REQUIRED",
+ "MANAGED_PROVIDER_AMBIGUOUS",
+ "MANAGED_CONFIG_INVALID",
+ ].includes(code)
+ ) {
+ return { message: error.message, action: "Contact your IT administrator." };
+ }
+ if (code === "IDENTITY_EXCHANGE_FAILED") {
+ return {
+ message: `Could not obtain temporary ${provider === "bedrock" ? "AWS" : "Azure"} access.`,
+ action: "Ask your IT administrator to verify the configured federated identity trust.",
+ retryable: true,
+ };
+ }
+ return null;
+}
+
function mapBedrockError(error, config = {}) {
const msg = error?.message || error?.code || String(error);
const profile = config.bedrockProfile || "default";
@@ -123,6 +166,8 @@ function mapVertexError(error, config = {}) {
* @returns {{ message: string, action?: string, copyCommand?: string, retryable?: boolean }}
*/
function mapEnterpriseError(provider, error, config = {}) {
+ const managed = mapManagedIdentityError(error, provider);
+ if (managed) return managed;
switch (provider) {
case "bedrock":
return mapBedrockError(error, config);
diff --git a/src/helpers/ipcHandlers.js b/src/helpers/ipcHandlers.js
index 05f2b9b51..b0162be64 100644
--- a/src/helpers/ipcHandlers.js
+++ b/src/helpers/ipcHandlers.js
@@ -10,6 +10,7 @@ const tokenStore = require("./tokenStore");
const { createCloudApiRequestHandler } = require("./cloudApiRequest");
const { withPolicyRequestHeaders } = require("./policyRequestHeaders");
const { createWorkspacePolicyManager } = require("./workspacePolicyManager");
+const { createEnterpriseIdentityManager } = require("./enterpriseIdentityManager");
const { createCloudConfigRequestHandler } = require("./cloudConfigRequest");
const {
createPolicyResponseError,
@@ -545,6 +546,7 @@ class IPCHandlers {
this.setupHandlers();
// Lives for the app's lifetime; IPCHandlers has no teardown path.
tokenStore.subscribe(({ generation, token }) => {
+ this.enterpriseIdentityManager?.clear();
broadcastToWindows("auth-token-state-changed", {
generation,
hasToken: Boolean(token),
@@ -3681,20 +3683,25 @@ class IPCHandlers {
ipcMain.handle("test-enterprise-connection", async (event, provider, config) => {
const {
mapEnterpriseError,
- pickEnterpriseConfig,
validateEnterpriseEndpoint,
} = require("./enterpriseProviderErrors");
try {
- validateEnterpriseEndpoint(config.azureEndpoint);
+ const runtime = await resolveEnterpriseRuntime(
+ event,
+ provider,
+ config?.model || "test",
+ config
+ );
+ validateEnterpriseEndpoint(runtime.enterprise.azureEndpoint);
const { generateText } = require("ai");
const { getEnterpriseAIModel } = require("./enterpriseAiProviders");
const model = getEnterpriseAIModel(
- provider,
- config.model || "test",
- config.apiKey || "",
- pickEnterpriseConfig(config)
+ runtime.provider,
+ runtime.model,
+ runtime.apiKey,
+ runtime.enterprise
);
await generateText({
@@ -3722,7 +3729,6 @@ class IPCHandlers {
const {
isEnterpriseProvider,
mapEnterpriseError,
- pickEnterpriseConfig,
validateEnterpriseEndpoint,
} = require("./enterpriseProviderErrors");
const provider = config?.provider;
@@ -3730,20 +3736,18 @@ class IPCHandlers {
if (!isEnterpriseProvider(provider)) {
throw new Error(`Unsupported enterprise provider: ${provider}`);
}
- if (!modelId) {
- throw new Error("No model specified for enterprise reasoning");
- }
-
- validateEnterpriseEndpoint(config?.azureEndpoint);
+ const runtime = await resolveEnterpriseRuntime(event, provider, modelId, config || {});
+ if (!runtime.model) throw new Error("No model specified for enterprise reasoning");
+ validateEnterpriseEndpoint(runtime.enterprise.azureEndpoint);
const { generateText } = require("ai");
const { getEnterpriseAIModel } = require("./enterpriseAiProviders");
const model = getEnterpriseAIModel(
- provider,
- modelId,
- config.apiKey || "",
- pickEnterpriseConfig(config)
+ runtime.provider,
+ runtime.model,
+ runtime.apiKey,
+ runtime.enterprise
);
const timeoutMs = config?.timeoutMs || 60000;
@@ -3782,7 +3786,6 @@ class IPCHandlers {
const {
isEnterpriseProvider,
mapEnterpriseError,
- pickEnterpriseConfig,
validateEnterpriseEndpoint,
} = require("./enterpriseProviderErrors");
const { streamId, provider, modelId, config, options } = payload || {};
@@ -3806,17 +3809,16 @@ class IPCHandlers {
if (!streamId || !isEnterpriseProvider(provider)) {
throw new Error(`Unsupported enterprise provider: ${provider}`);
}
- if (!modelId) {
- throw new Error("No model specified for enterprise streaming");
- }
- validateEnterpriseEndpoint(config?.azureEndpoint);
+ const runtime = await resolveEnterpriseRuntime(event, provider, modelId, config || {});
+ if (!runtime.model) throw new Error("No model specified for enterprise streaming");
+ validateEnterpriseEndpoint(runtime.enterprise.azureEndpoint);
const { getEnterpriseAIModel } = require("./enterpriseAiProviders");
const model = getEnterpriseAIModel(
- provider,
- modelId,
- config?.apiKey || "",
- pickEnterpriseConfig(config || {})
+ runtime.provider,
+ runtime.model,
+ runtime.apiKey,
+ runtime.enterprise
);
const { stream } = await model.doStream({
@@ -3863,6 +3865,12 @@ class IPCHandlers {
ipcMain.handle("bedrock-list-models", async (event, config) => {
const { mapEnterpriseError } = require("./enterpriseProviderErrors");
try {
+ const runtime = await resolveEnterpriseRuntime(
+ event,
+ "bedrock",
+ config?.model || "test",
+ config
+ );
const {
BedrockClient,
ListFoundationModelsCommand,
@@ -3870,16 +3878,21 @@ class IPCHandlers {
} = require("@aws-sdk/client-bedrock");
const { normalizeBedrockCatalog } = require("./bedrockCatalog");
- const region = config?.bedrockRegion || "us-east-1";
+ const region = runtime.enterprise.bedrockRegion || "us-east-1";
let credentials;
- if (config?.bedrockProfile) {
+ if (runtime.enterprise.managedCredentialProvider) {
+ credentials = runtime.enterprise.managedCredentialProvider;
+ } else if (runtime.enterprise.bedrockProfile) {
const { fromNodeProviderChain } = require("@aws-sdk/credential-providers");
- credentials = fromNodeProviderChain({ profile: config.bedrockProfile });
- } else if (config?.bedrockAccessKeyId && config?.bedrockSecretAccessKey) {
+ credentials = fromNodeProviderChain({ profile: runtime.enterprise.bedrockProfile });
+ } else if (
+ runtime.enterprise.bedrockAccessKeyId &&
+ runtime.enterprise.bedrockSecretAccessKey
+ ) {
credentials = {
- accessKeyId: config.bedrockAccessKeyId,
- secretAccessKey: config.bedrockSecretAccessKey,
- sessionToken: config.bedrockSessionToken || undefined,
+ accessKeyId: runtime.enterprise.bedrockAccessKeyId,
+ secretAccessKey: runtime.enterprise.bedrockSecretAccessKey,
+ sessionToken: runtime.enterprise.bedrockSessionToken || undefined,
};
}
const client = new BedrockClient({ region, ...(credentials ? { credentials } : {}) });
@@ -4680,6 +4693,55 @@ class IPCHandlers {
broadcast: (snapshot) => broadcastToWindows("workspace-policy-changed", snapshot),
logger: debugLogger,
});
+ this.enterpriseIdentityManager = createEnterpriseIdentityManager({
+ cachePath: path.join(app.getPath("userData"), "managed-enterprise-config.json"),
+ getApiUrl,
+ getAppVersion: () => app.getVersion(),
+ proxyFetch,
+ tokenStore,
+ logger: debugLogger,
+ });
+ const resolveEnterpriseRuntime = async (event, provider, model, config = {}) => {
+ const manual = {
+ provider,
+ model,
+ apiKey: config.apiKey || "",
+ enterprise: require("./enterpriseProviderErrors").pickEnterpriseConfig(config),
+ };
+ const context = config.managedContext;
+ if (!context) return manual;
+ const authHeaders = await getAuthHeader(event);
+ const resolved = await this.enterpriseIdentityManager.resolveProvider({
+ accountId: context.accountId,
+ workspaceId: context.workspaceId,
+ expectedAuthGeneration: context.authGeneration,
+ inferenceScope: context.inferenceScope,
+ setupMode: context.setupMode,
+ authHeaders,
+ });
+ if (!resolved.managed) return manual;
+ if (resolved.provider === "bedrock") {
+ return {
+ provider: resolved.provider,
+ model: resolved.model,
+ apiKey: "",
+ enterprise: {
+ bedrockRegion: resolved.config.region,
+ managedCredentialProvider: resolved.credentialProvider,
+ },
+ };
+ }
+ return {
+ provider: resolved.provider,
+ model: resolved.model,
+ apiKey: "",
+ enterprise: {
+ azureEndpoint: resolved.config.endpoint,
+ azureApiVersion: resolved.config.apiVersion,
+ managedTokenProvider: resolved.tokenProvider,
+ },
+ };
+ };
const handleSttConfigRequest = createCloudConfigRequestHandler({
getApiUrl,
getAuthHeader,
@@ -7699,6 +7761,22 @@ class IPCHandlers {
return workspacePolicyManager.getPolicy({ accountId, expectedAuthGeneration, authHeaders });
});
+ ipcMain.handle(
+ "get-managed-enterprise-config",
+ async (event, accountId, workspaceId, expectedAuthGeneration) => {
+ const authHeaders = await getAuthHeader(event);
+ return this.enterpriseIdentityManager.getConfig({
+ accountId,
+ workspaceId,
+ expectedAuthGeneration,
+ authHeaders,
+ });
+ }
+ );
+ ipcMain.handle("clear-managed-enterprise-identity", async () => {
+ this.enterpriseIdentityManager.clear();
+ });
+
ipcMain.handle("get-note-recording-config", handleNoteRecordingConfigRequest);
ipcMain.handle("transcribe-audio-file-cloud", async (event, filePath, opts = {}) => {
diff --git a/src/helpers/noteFormattingOverrides.js b/src/helpers/noteFormattingOverrides.js
index 431ccdb58..c1dfccd3c 100644
--- a/src/helpers/noteFormattingOverrides.js
+++ b/src/helpers/noteFormattingOverrides.js
@@ -4,6 +4,7 @@
export function buildNoteFormattingOverrides(noteFormatting, isCloudMode) {
if (isCloudMode) {
return {
+ inferenceScope: /** @type {const} */ ("noteFormatting"),
provider: "openwhispr",
baseUrl: undefined,
customApiKey: undefined,
@@ -15,6 +16,7 @@ export function buildNoteFormattingOverrides(noteFormatting, isCloudMode) {
if (mode === "self-hosted") {
return {
+ inferenceScope: /** @type {const} */ ("noteFormatting"),
provider: undefined,
baseUrl: undefined,
customApiKey: noteFormatting?.customApiKey || undefined,
@@ -33,6 +35,7 @@ export function buildNoteFormattingOverrides(noteFormatting, isCloudMode) {
: undefined;
const isCustom = provider === "custom";
return {
+ inferenceScope: /** @type {const} */ ("noteFormatting"),
provider,
baseUrl: isCustom ? noteFormatting?.cloudBaseUrl || undefined : undefined,
customApiKey: isCustom ? noteFormatting?.customApiKey || undefined : undefined,
diff --git a/src/hooks/useAuth.ts b/src/hooks/useAuth.ts
index 7088eb370..6ef0e9f2f 100644
--- a/src/hooks/useAuth.ts
+++ b/src/hooks/useAuth.ts
@@ -28,6 +28,7 @@ import {
import logger from "../utils/logger";
import { useSettingsStore } from "../stores/settingsStore";
import { usePolicyStore } from "../stores/policyStore";
+import { useEnterpriseIdentityStore } from "../stores/enterpriseIdentityStore";
const useStaticSession = () => ({
data: null,
@@ -57,6 +58,16 @@ async function loadAccountDependencies() {
return { syncService, resetRendererCaches };
}
+async function refreshManagedEnterpriseIdentity(accountId: string, authGeneration: number) {
+ const { useWorkspaceStore } = await import("../stores/workspaceStore");
+ const workspaceId = useWorkspaceStore.getState().activeWorkspaceId;
+ if (!workspaceId) {
+ useEnterpriseIdentityStore.getState().clear();
+ return;
+ }
+ await useEnterpriseIdentityStore.getState().refresh(accountId, workspaceId, authGeneration);
+}
+
export function useAuth() {
const useSession = authClient?.useSession ?? useStaticSession;
const { data: ambientSession, isPending, error: sessionError, refetch } = useSession();
@@ -129,6 +140,7 @@ export function useAuth() {
useEffect(() => {
if (!sessionResolutionFailed || !resolvedUserId || boundGeneration == null) return;
void usePolicyStore.getState().fetchPolicy(resolvedUserId, boundGeneration);
+ void refreshManagedEnterpriseIdentity(resolvedUserId, boundGeneration);
}, [boundGeneration, resolvedUserId, sessionResolutionFailed]);
useEffect(() => {
@@ -199,12 +211,14 @@ export function useAuth() {
logger.debug("Auth state sync", { isSignedIn: true, userId: resolvedUserId }, "auth");
useSettingsStore.getState().setIsSignedIn(true);
void usePolicyStore.getState().fetchPolicy(resolvedUserId, boundGeneration);
+ void refreshManagedEnterpriseIdentity(resolvedUserId, boundGeneration);
}
} else {
invalidateValidatedAuthContext();
if (!cancelled) {
useSettingsStore.getState().setIsSignedIn(false);
usePolicyStore.getState().clearPolicy();
+ useEnterpriseIdentityStore.getState().clear();
}
}
resetAccountScopeRetry();
diff --git a/src/services/BaseReasoningService.ts b/src/services/BaseReasoningService.ts
index 19f4ec022..c15f903eb 100644
--- a/src/services/BaseReasoningService.ts
+++ b/src/services/BaseReasoningService.ts
@@ -2,6 +2,7 @@ import { getCleanupSystemPrompt } from "../config/prompts";
import { getSettings } from "../stores/settingsStore";
import { resolveCleanupLanguage } from "../utils/chineseScript";
import { getDictionaryHintWords } from "../utils/snippets";
+import type { InferenceScope } from "../config/inferenceScopes";
export interface ReasoningConfig {
maxTokens?: number;
@@ -16,6 +17,7 @@ export interface ReasoningConfig {
language?: string;
requireCompleteOutput?: boolean;
requiresAgent?: boolean;
+ inferenceScope?: InferenceScope;
}
export abstract class BaseReasoningService {
diff --git a/src/services/EnterpriseIdentityService.ts b/src/services/EnterpriseIdentityService.ts
new file mode 100644
index 000000000..33b198bd4
--- /dev/null
+++ b/src/services/EnterpriseIdentityService.ts
@@ -0,0 +1,33 @@
+import type { ManagedEnterpriseConfig } from "../types/enterpriseIdentity";
+
+export interface ManagedEnterpriseConfigResult {
+ success: boolean;
+ status?: "network" | "current" | "cached" | "error";
+ accountId?: string | null;
+ workspaceId?: string | null;
+ authGeneration?: number | null;
+ config?: ManagedEnterpriseConfig;
+ code?: string;
+ error?: string;
+}
+
+export async function getManagedEnterpriseConfig(
+ accountId: string,
+ workspaceId: string,
+ authGeneration: number
+): Promise<ManagedEnterpriseConfigResult> {
+ const request = window.electronAPI?.getManagedEnterpriseConfig;
+ if (!request) {
+ return {
+ success: false,
+ status: "error",
+ code: "MANAGED_ENTERPRISE_UNSUPPORTED",
+ error: "Managed enterprise AI requires a newer version of OpenWhispr.",
+ };
+ }
+ return request(accountId, workspaceId, authGeneration);
+}
+
+export function clearManagedEnterpriseIdentity(): void {
+ void window.electronAPI?.clearManagedEnterpriseIdentity?.();
+}
diff --git a/src/services/ReasoningService.ts b/src/services/ReasoningService.ts
index 8f1124516..3d09876c2 100644
--- a/src/services/ReasoningService.ts
+++ b/src/services/ReasoningService.ts
@@ -17,6 +17,7 @@ import { stripThinkingTags } from "../helpers/stripThinking.js";
import { streamText, stepCountIs } from "ai";
import { getAIModel } from "./ai/providers";
import { createEnterpriseChatModel } from "./ai/enterpriseChatModel";
+import { getManagedScopeResolution } from "../stores/enterpriseIdentityStore";
import { PROVIDER_REGISTRY, type ProviderContext } from "./ai/inferenceProviders";
import { getConfiguredOpenAIBase } from "./ai/openaiBase";
import { applyThinkingSuppression } from "./ai/thinkingSuppression";
@@ -363,6 +364,13 @@ class ReasoningService extends BaseReasoningService {
agentName: string | null = null,
config: ReasoningConfig = {}
): Promise<string> {
+ const inferenceScope = config.inferenceScope || "dictationCleanup";
+ const managed = getManagedScopeResolution(inferenceScope, getSettings().enterpriseSetupMode);
+ if (managed.kind === "error") throw new Error(managed.message);
+ if (managed.kind === "managed") {
+ model = managed.model;
+ config = { ...config, provider: managed.provider, inferenceScope };
+ }
const trimmedModel = model?.trim?.() || "";
const isLanCleanup = !!config.lanUrl || this.isLanCleanupMode();
const providerId = isLanCleanup
@@ -633,6 +641,14 @@ class ReasoningService extends BaseReasoningService {
config: ReasoningConfig & { systemPrompt: string },
tools?: Record<string, import("ai").Tool>
): AsyncGenerator<AgentStreamChunk, void, unknown> {
+ const inferenceScope = config.inferenceScope || "chatIntelligence";
+ const managed = getManagedScopeResolution(inferenceScope, getSettings().enterpriseSetupMode);
+ if (managed.kind === "error") throw new Error(managed.message);
+ if (managed.kind === "managed") {
+ provider = managed.provider;
+ model = managed.model;
+ config = { ...config, inferenceScope };
+ }
const route = resolveChatRoute({
provider,
lanUrl: config.lanUrl,
@@ -694,7 +710,7 @@ class ReasoningService extends BaseReasoningService {
const openrouterDisableThinking = provider === "openrouter" && config.disableThinking === true;
// Resolving a Tinfoil model refreshes the registry, so read model config after it.
const aiModel = isEnterprise
- ? createEnterpriseChatModel(provider as EnterpriseProvider, model)
+ ? createEnterpriseChatModel(provider as EnterpriseProvider, model, inferenceScope)
: await getAIModel(aiProvider, model, apiKey, baseURL, {
disableThinking: openrouterDisableThinking,
});
@@ -963,6 +979,11 @@ class ReasoningService extends BaseReasoningService {
}
const settings = getSettings();
+ const managedCleanup = getManagedScopeResolution(
+ "dictationCleanup",
+ settings.enterpriseSetupMode
+ );
+ if (managedCleanup.kind === "managed") return true;
if (settings.cleanupProvider === "custom" && settings.cleanupCloudBaseUrl?.trim()) {
logger.logReasoning("API_KEY_CHECK", {
customProvider: true,
diff --git a/src/services/ai/enterpriseChatModel.ts b/src/services/ai/enterpriseChatModel.ts
index 842adf387..2fb98707e 100644
--- a/src/services/ai/enterpriseChatModel.ts
+++ b/src/services/ai/enterpriseChatModel.ts
@@ -5,6 +5,7 @@ import type {
} from "@ai-sdk/provider";
import type { EnterpriseProvider } from "../../models/ModelRegistry";
import { getEnterpriseCallSettings } from "./enterpriseSettings";
+import type { InferenceScope } from "../../config/inferenceScopes";
// Enterprise SDKs (Bedrock/Azure/Vertex) must run in the main process — SigV4
// signing and CORS rule out renderer fetches. This LanguageModelV3 shim keeps
@@ -40,7 +41,8 @@ function pickSerializableOptions(options: LanguageModelV3CallOptions) {
export function createEnterpriseChatModel(
provider: EnterpriseProvider,
- modelId: string
+ modelId: string,
+ inferenceScope: InferenceScope = "chatIntelligence"
): LanguageModelV3 {
return {
specificationVersion: "v3",
@@ -59,7 +61,7 @@ export function createEnterpriseChatModel(
}
const streamId = crypto.randomUUID();
- const config = getEnterpriseCallSettings(provider);
+ const config = getEnterpriseCallSettings(provider, inferenceScope);
let unsubscribe: (() => void) | undefined;
const stopListening = () => {
unsubscribe?.();
diff --git a/src/services/ai/enterpriseSettings.ts b/src/services/ai/enterpriseSettings.ts
index 2acad31ee..887b87b68 100644
--- a/src/services/ai/enterpriseSettings.ts
+++ b/src/services/ai/enterpriseSettings.ts
@@ -1,5 +1,8 @@
import { getSettings } from "../../stores/settingsStore";
import type { EnterpriseProvider } from "../../models/ModelRegistry";
+import type { InferenceScope } from "../../config/inferenceScopes";
+import type { ManagedEnterpriseRequestContext } from "../../types/enterpriseIdentity";
+import { useEnterpriseIdentityStore } from "../../stores/enterpriseIdentityStore";
export type EnterpriseCallSettings = {
apiKey: string;
@@ -12,10 +15,28 @@ export type EnterpriseCallSettings = {
azureApiVersion: string;
vertexProject: string;
vertexLocation: string;
+ managedContext?: ManagedEnterpriseRequestContext;
};
-export function getEnterpriseCallSettings(provider: EnterpriseProvider): EnterpriseCallSettings {
+export function getEnterpriseCallSettings(
+ provider: EnterpriseProvider,
+ inferenceScope: InferenceScope
+): EnterpriseCallSettings {
const s = getSettings();
+ const managedState = useEnterpriseIdentityStore.getState();
+ const managedContext =
+ managedState.config &&
+ managedState.accountId &&
+ managedState.workspaceId &&
+ managedState.authGeneration != null
+ ? {
+ accountId: managedState.accountId,
+ workspaceId: managedState.workspaceId,
+ authGeneration: managedState.authGeneration,
+ setupMode: s.enterpriseSetupMode,
+ inferenceScope,
+ }
+ : undefined;
return {
apiKey: provider === "azure" ? s.azureApiKey : provider === "vertex" ? s.vertexApiKey : "",
bedrockRegion: s.bedrockRegion,
@@ -27,5 +48,6 @@ export function getEnterpriseCallSettings(provider: EnterpriseProvider): Enterpr
azureApiVersion: s.azureApiVersion,
vertexProject: s.vertexProject,
vertexLocation: s.vertexLocation,
+ managedContext,
};
}
diff --git a/src/services/ai/inferenceProviders/enterprise.ts b/src/services/ai/inferenceProviders/enterprise.ts
index 4eb98f047..48fd46039 100644
--- a/src/services/ai/inferenceProviders/enterprise.ts
+++ b/src/services/ai/inferenceProviders/enterprise.ts
@@ -38,7 +38,7 @@ export const enterpriseProvider: InferenceProvider = {
systemPrompt,
provider: enterpriseId,
supportsTemperature,
- ...getEnterpriseCallSettings(enterpriseId),
+ ...getEnterpriseCallSettings(enterpriseId, config.inferenceScope || "dictationCleanup"),
}
);
diff --git a/src/stores/enterpriseIdentityStore.ts b/src/stores/enterpriseIdentityStore.ts
new file mode 100644
index 000000000..b90b1a4d5
--- /dev/null
+++ b/src/stores/enterpriseIdentityStore.ts
@@ -0,0 +1,115 @@
+import { create } from "zustand";
+import {
+ clearManagedEnterpriseIdentity,
+ getManagedEnterpriseConfig,
+} from "../services/EnterpriseIdentityService";
+import type {
+ EnterpriseSetupMode,
+ ManagedEnterpriseConfig,
+ ManagedEnterpriseScopeResolution,
+} from "../types/enterpriseIdentity";
+import type { InferenceScope } from "../config/inferenceScopes";
+import logger from "../utils/logger";
+import { resolveManagedEnterpriseScope } from "../helpers/enterpriseManagedConfig.mjs";
+
+interface EnterpriseIdentityState {
+ accountId: string | null;
+ workspaceId: string | null;
+ authGeneration: number | null;
+ status: "idle" | "loading" | "ready" | "error";
+ config: ManagedEnterpriseConfig | null;
+ error: string | null;
+ refresh: (accountId: string, workspaceId: string, authGeneration: number) => Promise<void>;
+ clear: () => void;
+}
+
+let requestSequence = 0;
+let inFlightKey: string | null = null;
+let inFlightPromise: Promise<void> | null = null;
+
+export const useEnterpriseIdentityStore = create<EnterpriseIdentityState>((set, get) => ({
+ accountId: null,
+ workspaceId: null,
+ authGeneration: null,
+ status: "idle",
+ config: null,
+ error: null,
+
+ refresh: (accountId, workspaceId, authGeneration) => {
+ const key = `${accountId}:${workspaceId}:${authGeneration}`;
+ if (inFlightKey === key && inFlightPromise) return inFlightPromise;
+ const sequence = ++requestSequence;
+ const current = get();
+ const sameIdentity =
+ current.accountId === accountId &&
+ current.workspaceId === workspaceId &&
+ current.authGeneration === authGeneration;
+ set({
+ accountId,
+ workspaceId,
+ authGeneration,
+ status: sameIdentity && current.config ? "ready" : "loading",
+ config: sameIdentity ? current.config : null,
+ error: null,
+ });
+
+ const promise = (async () => {
+ try {
+ const result = await getManagedEnterpriseConfig(accountId, workspaceId, authGeneration);
+ if (sequence !== requestSequence) return;
+ if (
+ !result.success ||
+ result.accountId !== accountId ||
+ result.workspaceId !== workspaceId ||
+ result.authGeneration !== authGeneration
+ ) {
+ throw new Error(result.error || "Managed enterprise AI configuration is unavailable.");
+ }
+ set({ status: "ready", config: result.config ?? null, error: null });
+ } catch (error) {
+ if (sequence !== requestSequence) return;
+ const message = error instanceof Error ? error.message : String(error);
+ logger.warn("Managed enterprise AI configuration unavailable", { error: message }, "auth");
+ set((state) => ({
+ status: "error",
+ config: state.config,
+ error: message,
+ }));
+ } finally {
+ if (inFlightKey === key) {
+ inFlightKey = null;
+ inFlightPromise = null;
+ }
+ }
+ })();
+ inFlightKey = key;
+ inFlightPromise = promise;
+ return promise;
+ },
+
+ clear: () => {
+ requestSequence += 1;
+ inFlightKey = null;
+ inFlightPromise = null;
+ clearManagedEnterpriseIdentity();
+ set({
+ accountId: null,
+ workspaceId: null,
+ authGeneration: null,
+ status: "idle",
+ config: null,
+ error: null,
+ });
+ },
+}));
+
+export function getManagedScopeResolution(
+ scope: InferenceScope,
+ setupMode: EnterpriseSetupMode
+): ManagedEnterpriseScopeResolution {
+ return resolveManagedEnterpriseScope(
+ useEnterpriseIdentityStore.getState().config,
+ scope,
+ setupMode
+ ) as ManagedEnterpriseScopeResolution;
+}
diff --git a/src/stores/settingsStore.ts b/src/stores/settingsStore.ts
index 59e00ca43..aa990e7aa 100644
--- a/src/stores/settingsStore.ts
+++ b/src/stores/settingsStore.ts
@@ -39,6 +39,8 @@ import type {
ChatAgentSettings,
} from "../hooks/useSettings";
import type { Snippet } from "../utils/snippets";
+import type { EnterpriseSetupMode } from "../types/enterpriseIdentity";
+import { getManagedScopeResolution } from "./enterpriseIdentityStore";
let _ReasoningService: typeof import("../services/ReasoningService").default | null = null;
@@ -646,6 +648,7 @@ export interface SettingsState
setCortiTenant: (value: string) => void;
// Enterprise providers
+ enterpriseSetupMode: EnterpriseSetupMode;
bedrockAuthMode: string;
bedrockRegion: string;
bedrockProfile: string;
@@ -661,6 +664,7 @@ export interface SettingsState
vertexLocation: string;
vertexApiKey: string;
setBedrockAuthMode: (value: string) => void;
+ setEnterpriseSetupMode: (value: EnterpriseSetupMode) => void;
setBedrockRegion: (value: string) => void;
setBedrockProfile: (value: string) => void;
setBedrockAccessKeyId: (key: string) => void;
@@ -1010,6 +1014,11 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
cleanupCustomApiKey: "",
// Enterprise providers
+ enterpriseSetupMode: (["auto", "managed", "manual"].includes(
+ readString("enterpriseSetupMode", "auto")
+ )
+ ? readString("enterpriseSetupMode", "auto")
+ : "auto") as EnterpriseSetupMode,
bedrockAuthMode: readString("bedrockAuthMode", "sso"),
bedrockRegion: readString("bedrockRegion", "us-east-1"),
bedrockProfile: readString("bedrockProfile", ""),
@@ -1523,6 +1532,9 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
},
// Enterprise provider setters
+ setEnterpriseSetupMode: createStringSetter("enterpriseSetupMode") as (
+ value: EnterpriseSetupMode
+ ) => void,
setBedrockAuthMode: (value: string) => {
if (isBrowser) localStorage.setItem("bedrockAuthMode", value);
set({ bedrockAuthMode: value });
@@ -2141,7 +2153,7 @@ export const selectResolvedLLMConfig = (
const disableThinkingKey = def.storeKeys.disableThinking;
const disableThinking = disableThinkingKey ? (state[disableThinkingKey] as boolean) : true;
- return {
+ const localConfig: ResolvedLLMConfig = {
scope,
mode: state[def.storeKeys.mode] as InferenceMode,
provider: read("provider") || fallback?.provider || "",
@@ -2155,6 +2167,14 @@ export const selectResolvedLLMConfig = (
customApiKey: read("customApiKey"),
disableThinking,
};
+ const managed = getManagedScopeResolution(scope, state.enterpriseSetupMode);
+ if (managed.kind !== "managed") return localConfig;
+ return {
+ ...localConfig,
+ mode: "enterprise",
+ provider: managed.provider,
+ model: managed.model,
+ };
};
export function setResolvedLLMConfig(
@@ -2226,7 +2246,7 @@ export function getEffectiveCleanupModel() {
if (selectIsCloudCleanupMode(state)) {
return "";
}
- return state.cleanupModel;
+ return selectResolvedLLMConfig(state, "dictationCleanup").model;
}
export function isCloudCleanupMode() {
@@ -2316,6 +2336,19 @@ export async function initializeSettings(): Promise<void> {
vertexApiKey: vertexApiKey || "",
});
+ if (!localStorage.getItem("enterpriseSetupMode")) {
+ const hasLegacyEnterpriseSetup = Boolean(
+ useSettingsStore.getState().bedrockProfile.trim() ||
+ (bedrockAccessKeyId && bedrockSecretAccessKey) ||
+ azureApiKey
+ );
+ const enterpriseSetupMode: EnterpriseSetupMode = hasLegacyEnterpriseSetup
+ ? "manual"
+ : "auto";
+ localStorage.setItem("enterpriseSetupMode", enterpriseSetupMode);
+ useSettingsStore.setState({ enterpriseSetupMode });
+ }
+
for (const key of STALE_SECRET_LOCALSTORAGE_KEYS) {
localStorage.removeItem(key);
}
diff --git a/src/stores/workspaceStore.ts b/src/stores/workspaceStore.ts
index ad344e3ac..be1294a4f 100644
--- a/src/stores/workspaceStore.ts
+++ b/src/stores/workspaceStore.ts
@@ -2,6 +2,8 @@ import { create } from "zustand";
import type { Workspace, WorkspaceMember } from "../types/electron";
import { WorkspacesService } from "../services/WorkspacesService";
import logger from "../utils/logger";
+import { usePolicyStore } from "./policyStore";
+import { useEnterpriseIdentityStore } from "./enterpriseIdentityStore";
interface WorkspaceState {
workspaces: Workspace[];
@@ -35,6 +37,23 @@ let refreshPromise: Promise<void> | null = null;
let membersRequestSeq = 0;
let accountGeneration = 0;
+function refreshManagedEnterpriseIdentity(workspaceId: string | null): void {
+ const enterprise = useEnterpriseIdentityStore.getState();
+ const policy = usePolicyStore.getState();
+ if (!workspaceId || !policy.accountId || policy.authGeneration == null) {
+ enterprise.clear();
+ return;
+ }
+ if (
+ enterprise.workspaceId !== workspaceId ||
+ enterprise.accountId !== policy.accountId ||
+ enterprise.authGeneration !== policy.authGeneration
+ ) {
+ enterprise.clear();
+ }
+ void enterprise.refresh(policy.accountId, workspaceId, policy.authGeneration);
+}
+
export const useWorkspaceStore = create<WorkspaceState>((set, get) => ({
workspaces: [],
loaded: false,
@@ -49,6 +68,7 @@ export const useWorkspaceStore = create<WorkspaceState>((set, get) => ({
// land under the new one.
membersRequestSeq++;
set({ activeWorkspaceId: id, members: [] });
+ refreshManagedEnterpriseIdentity(id);
},
resetForAccountChange: () => {
@@ -58,6 +78,7 @@ export const useWorkspaceStore = create<WorkspaceState>((set, get) => ({
// old request prevents its result/finally block from touching new state.
refreshPromise = null;
writeActiveWorkspaceId(null);
+ useEnterpriseIdentityStore.getState().clear();
set({
workspaces: [],
loaded: false,
@@ -79,14 +100,20 @@ export const useWorkspaceStore = create<WorkspaceState>((set, get) => ({
if (generation !== accountGeneration) return;
const activeId = get().activeWorkspaceId;
const stillValid = activeId && workspaces.some((w) => w.id === activeId);
+ const resolvedActiveId = stillValid
+ ? activeId
+ : workspaces.length === 1
+ ? workspaces[0].id
+ : null;
set({
workspaces,
loaded: true,
loading: false,
error: false,
- activeWorkspaceId: stillValid ? activeId : null,
+ activeWorkspaceId: resolvedActiveId,
});
- if (!stillValid && activeId) writeActiveWorkspaceId(null);
+ if (resolvedActiveId !== activeId) writeActiveWorkspaceId(resolvedActiveId);
+ refreshManagedEnterpriseIdentity(resolvedActiveId);
} catch (error) {
if (generation !== accountGeneration) return;
logger.error(
diff --git a/src/types/electron.ts b/src/types/electron.ts
index 5b230c404..bd52b628f 100644
--- a/src/types/electron.ts
+++ b/src/types/electron.ts
@@ -2,6 +2,7 @@ import type { ModelDefinition } from "../models/ModelRegistry";
import type { TinfoilCatalogModel } from "../models/tinfoilModels";
import type { UsageResponse } from "../lib/usageStore";
import type { OrgPolicy } from "./policy";
+import type { ManagedEnterpriseConfig } from "./enterpriseIdentity";
export type LocalTranscriptionProvider = "whisper" | "nvidia";
@@ -1336,7 +1337,7 @@ declare global {
streamId: string;
provider: string;
modelId: string;
- config: Record<string, string>;
+ config: Record<string, unknown>;
options: Record<string, unknown>;
}) => Promise<{ success: boolean; error?: string }>;
enterpriseStreamCancel?: (streamId: string) => Promise<void>;
@@ -1348,7 +1349,7 @@ declare global {
error?: string;
}) => void
) => () => void;
- listBedrockModels?: (config: Record<string, string>) => Promise<{
+ listBedrockModels?: (config: Record<string, unknown>) => Promise<{
success: boolean;
models?: Array<{ value: string; label: string; vendor: string }>;
error?: string;
@@ -1555,8 +1556,23 @@ declare global {
saveVertexApiKey?: (key: string) => Promise<void>;
testEnterpriseConnection?: (
provider: string,
- config: Record<string, string>
+ config: Record<string, unknown>
) => Promise<{ success: boolean; error?: string; action?: string; copyCommand?: string }>;
+ getManagedEnterpriseConfig?: (
+ accountId: string,
+ workspaceId: string,
+ expectedAuthGeneration: number
+ ) => Promise<{
+ success: boolean;
+ status?: "network" | "current" | "cached" | "error";
+ accountId?: string | null;
+ workspaceId?: string | null;
+ authGeneration?: number | null;
+ config?: ManagedEnterpriseConfig;
+ code?: string;
+ error?: string;
+ }>;
+ clearManagedEnterpriseIdentity?: () => Promise<void>;
// Dictation key persistence (file-based for reliable startup)
getDictationKey?: () => Promise<string | null>;
diff --git a/src/types/enterpriseIdentity.ts b/src/types/enterpriseIdentity.ts
new file mode 100644
index 000000000..af5d505d8
--- /dev/null
+++ b/src/types/enterpriseIdentity.ts
@@ -0,0 +1,56 @@
+import type { InferenceScope } from "../config/inferenceScopes";
+
+export type ManagedEnterpriseProvider = "bedrock" | "azure";
+export type ManagedEnterpriseProviderMode = "disabled" | "managed_default" | "managed_required";
+export type EnterpriseSetupMode = "auto" | "managed" | "manual";
+
+export interface ManagedEnterpriseProviderRecord {
+ provider: ManagedEnterpriseProvider;
+ mode: ManagedEnterpriseProviderMode;
+ allowManualSetup: boolean;
+ config: {
+ scopeDefaults: Partial<Record<InferenceScope, string>>;
+ roleArn?: string;
+ region?: string;
+ allowedModels?: string[];
+ tenantId?: string;
+ clientId?: string;
+ endpoint?: string;
+ apiVersion?: string;
+ allowedDeployments?: string[];
+ };
+ version: number;
+ updatedAt: string;
+}
+
+export interface ManagedEnterpriseConfig {
+ workspaceId: string;
+ version: number;
+ identity: {
+ issuer: string;
+ jwksUri: string;
+ subject: string;
+ audiences: Record<ManagedEnterpriseProvider, string>;
+ };
+ providers: ManagedEnterpriseProviderRecord[];
+}
+
+export type ManagedEnterpriseScopeResolution =
+ | { kind: "manual" }
+ | {
+ kind: "managed";
+ provider: ManagedEnterpriseProvider;
+ model: string;
+ mode: ManagedEnterpriseProviderMode;
+ allowManualSetup: boolean;
+ record: ManagedEnterpriseProviderRecord;
+ }
+ | { kind: "error"; code: string; message: string };
+
+export interface ManagedEnterpriseRequestContext {
+ accountId: string;
+ workspaceId: string;
+ authGeneration: number;
+ setupMode: EnterpriseSetupMode;
+ inferenceScope: InferenceScope;
+}
diff --git a/src/utils/generateTitle.ts b/src/utils/generateTitle.ts
index f697e7a46..4dafebb5e 100644
--- a/src/utils/generateTitle.ts
+++ b/src/utils/generateTitle.ts
@@ -13,6 +13,7 @@ export async function generateNoteTitle(
try {
const raw = await reasoningService.processText(text.slice(0, 2000), modelId, null, {
systemPrompt: TITLE_SYSTEM_PROMPT,
+ inferenceScope: "noteFormatting",
temperature: 0.3,
disableThinking: getSettings().noteFormattingDisableThinking,
...config,
diff --git a/test/helpers/enterpriseIdentityManager.test.js b/test/helpers/enterpriseIdentityManager.test.js
new file mode 100644
index 000000000..ec98f6ee3
--- /dev/null
+++ b/test/helpers/enterpriseIdentityManager.test.js
@@ -0,0 +1,196 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const {
+ createEnterpriseIdentityManager,
+} = require("../../src/helpers/enterpriseIdentityManager.js");
+
+const workspaceId = "11111111-1111-4111-8111-111111111111";
+const accountId = "account-a";
+
+function managedConfig() {
+ const defaults = {
+ dictationCleanup: "deployment-a",
+ dictationAgent: "deployment-a",
+ noteFormatting: "deployment-a",
+ chatIntelligence: "deployment-a",
+ dictationTranslation: "deployment-a",
+ };
+ return {
+ workspaceId,
+ version: 1,
+ identity: {
+ issuer: "https://api.example.com/enterprise-identity",
+ jwksUri: "https://api.example.com/enterprise-identity/jwks.json",
+ subject: `workspace:${workspaceId}`,
+ audiences: { bedrock: "sts.amazonaws.com", azure: "api://AzureADTokenExchange" },
+ },
+ providers: [
+ {
+ provider: "azure",
+ mode: "managed_default",
+ allowManualSetup: true,
+ config: {
+ tenantId: "22222222-2222-4222-8222-222222222222",
+ clientId: "33333333-3333-4333-8333-333333333333",
+ endpoint: "https://example.openai.azure.com",
+ apiVersion: "2024-10-21",
+ allowedDeployments: ["deployment-a"],
+ scopeDefaults: defaults,
+ },
+ version: 1,
+ updatedAt: "2026-08-10T00:00:00.000Z",
+ },
+ ],
+ };
+}
+
+function jsonResponse(data, status = 200) {
+ return new Response(JSON.stringify(data), {
+ status,
+ headers: { "Content-Type": "application/json" },
+ });
+}
+
+function request(overrides = {}) {
+ return {
+ accountId,
+ workspaceId,
+ expectedAuthGeneration: 4,
+ authHeaders: { Authorization: "Bearer openwhispr-session" },
+ inferenceScope: "dictationCleanup",
+ setupMode: "auto",
+ ...overrides,
+ };
+}
+
+test("deduplicates config and Azure token refreshes while keeping cloud tokens out of config", async (t) => {
+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "openwhispr-enterprise-"));
+ t.after(() => fs.rmSync(tempDir, { recursive: true, force: true }));
+ const calls = { config: 0, assertion: 0, azure: 0 };
+ const proxyFetch = async (url) => {
+ if (url.includes("/enterprise-providers/azure/assertion")) {
+ calls.assertion += 1;
+ return jsonResponse({ data: { assertion: "signed-openwhispr-assertion" } });
+ }
+ if (url.startsWith("https://login.microsoftonline.com/")) {
+ calls.azure += 1;
+ return jsonResponse({ access_token: "azure-bearer-token", expires_in: 3600 });
+ }
+ calls.config += 1;
+ return jsonResponse({ data: managedConfig() });
+ };
+ const tokenState = { token: "openwhispr-session", generation: 4 };
+ const manager = createEnterpriseIdentityManager({
+ cachePath: path.join(tempDir, "config.json"),
+ getApiUrl: () => "https://api.example.com",
+ getAppVersion: () => "1.8.1",
+ proxyFetch,
+ tokenStore: { getState: () => tokenState },
+ });
+
+ const [left, right] = await Promise.all([
+ manager.getConfig(request()),
+ manager.getConfig(request()),
+ ]);
+ assert.equal(left.success, true);
+ assert.equal(right.success, true);
+ assert.equal(calls.config, 1);
+ assert.equal(JSON.stringify(left).includes("azure-bearer-token"), false);
+ assert.equal(JSON.stringify(left).includes("signed-openwhispr-assertion"), false);
+
+ const runtime = await manager.resolveProvider(request());
+ assert.equal(runtime.managed, true);
+ assert.equal(runtime.provider, "azure");
+ assert.equal(runtime.model, "deployment-a");
+ assert.equal(await runtime.tokenProvider(), "azure-bearer-token");
+ assert.equal(await runtime.tokenProvider(), "azure-bearer-token");
+ assert.deepEqual(calls, { config: 1, assertion: 1, azure: 1 });
+});
+
+test("rejects stale auth generations before making a request", async (t) => {
+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "openwhispr-enterprise-"));
+ t.after(() => fs.rmSync(tempDir, { recursive: true, force: true }));
+ let called = false;
+ const manager = createEnterpriseIdentityManager({
+ cachePath: path.join(tempDir, "config.json"),
+ getApiUrl: () => "https://api.example.com",
+ getAppVersion: () => "1.8.1",
+ proxyFetch: async () => {
+ called = true;
+ return jsonResponse({ data: managedConfig() });
+ },
+ tokenStore: { getState: () => ({ token: "session", generation: 5 }) },
+ });
+
+ const result = await manager.getConfig(request());
+ assert.equal(result.success, false);
+ assert.equal(result.code, "AUTH_CONTEXT_CHANGED");
+ assert.equal(called, false);
+});
+
+test("Bedrock exchanges the workspace assertion for short-lived web identity credentials", async (t) => {
+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "openwhispr-enterprise-"));
+ t.after(() => fs.rmSync(tempDir, { recursive: true, force: true }));
+ const config = managedConfig();
+ config.providers = [
+ {
+ provider: "bedrock",
+ mode: "managed_required",
+ allowManualSetup: false,
+ config: {
+ roleArn: "arn:aws:iam::123456789012:role/OpenWhispr",
+ region: "us-west-2",
+ allowedModels: ["model-a"],
+ scopeDefaults: Object.fromEntries(
+ Object.keys(config.providers[0].config.scopeDefaults).map((scope) => [scope, "model-a"])
+ ),
+ },
+ version: 2,
+ updatedAt: "2026-08-10T00:00:00.000Z",
+ },
+ ];
+ let providerInit;
+ let providerCalls = 0;
+ const manager = createEnterpriseIdentityManager({
+ cachePath: path.join(tempDir, "config.json"),
+ getApiUrl: () => "https://api.example.com",
+ getAppVersion: () => "1.8.1",
+ proxyFetch: async (url) =>
+ url.includes("/assertion")
+ ? jsonResponse({ data: { assertion: "workspace-assertion" } })
+ : jsonResponse({ data: config }),
+ tokenStore: {
+ getState: () => ({ token: "openwhispr-session", generation: 4 }),
+ },
+ createAwsWebIdentityProvider: (init) => {
+ providerInit = init;
+ return async () => {
+ providerCalls += 1;
+ return {
+ accessKeyId: "temporary-access-key",
+ secretAccessKey: "temporary-secret",
+ sessionToken: "temporary-session",
+ expiration: new Date(Date.now() + 15 * 60 * 1000),
+ };
+ };
+ },
+ });
+
+ const runtime = await manager.resolveProvider(request({ setupMode: "manual" }));
+ const first = await runtime.credentialProvider();
+ const second = await runtime.credentialProvider();
+ assert.equal(first.accessKeyId, "temporary-access-key");
+ assert.equal(second.accessKeyId, "temporary-access-key");
+ assert.equal(providerCalls, 1);
+ assert.deepEqual(providerInit, {
+ roleArn: "arn:aws:iam::123456789012:role/OpenWhispr",
+ roleSessionName: `openwhispr-${workspaceId.slice(0, 8)}`,
+ webIdentityToken: "workspace-assertion",
+ durationSeconds: 900,
+ clientConfig: { region: "us-west-2" },
+ });
+});
diff --git a/test/helpers/enterpriseManagedConfig.test.js b/test/helpers/enterpriseManagedConfig.test.js
new file mode 100644
index 000000000..ce892de80
--- /dev/null
+++ b/test/helpers/enterpriseManagedConfig.test.js
@@ -0,0 +1,145 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const {
+ resolveManagedEnterpriseScope,
+ validateManagedEnterpriseEnvelope,
+} = require("../../src/helpers/enterpriseManagedConfig.mjs");
+
+const scopes = {
+ dictationCleanup: "model-a",
+ dictationAgent: "model-a",
+ noteFormatting: "model-a",
+ chatIntelligence: "model-a",
+ dictationTranslation: "model-a",
+};
+
+function provider(overrides = {}) {
+ return {
+ provider: "bedrock",
+ mode: "managed_default",
+ allowManualSetup: true,
+ config: {
+ roleArn: "arn:aws:iam::123456789012:role/OpenWhispr",
+ region: "us-east-1",
+ allowedModels: ["model-a"],
+ scopeDefaults: scopes,
+ },
+ version: 1,
+ updatedAt: "2026-08-10T00:00:00.000Z",
+ ...overrides,
+ };
+}
+
+function envelope(providers = [provider()]) {
+ return {
+ workspaceId: "workspace-a",
+ version: 1,
+ identity: {
+ issuer: "https://api.example.com/enterprise-identity",
+ jwksUri: "https://api.example.com/enterprise-identity/jwks.json",
+ subject: "workspace:workspace-a",
+ audiences: { bedrock: "sts.amazonaws.com", azure: "api://AzureADTokenExchange" },
+ },
+ providers,
+ };
+}
+
+test("validates safe managed configuration and rejects unknown models", () => {
+ assert.ok(validateManagedEnterpriseEnvelope(envelope(), "workspace-a"));
+ const invalid = envelope([
+ provider({
+ config: {
+ ...provider().config,
+ scopeDefaults: { ...scopes, dictationCleanup: "not-allowed" },
+ },
+ }),
+ ]);
+ assert.equal(validateManagedEnterpriseEnvelope(invalid, "workspace-a"), null);
+ assert.equal(
+ validateManagedEnterpriseEnvelope(
+ envelope([
+ provider({
+ config: {
+ ...provider().config,
+ scopeDefaults: { dictationCleanup: "model-a" },
+ },
+ }),
+ ]),
+ "workspace-a"
+ ),
+ null
+ );
+});
+
+test("rejects unsafe cached cloud destinations and identity metadata", () => {
+ const unsafeAzure = provider({
+ provider: "azure",
+ config: {
+ tenantId: "11111111-1111-4111-8111-111111111111",
+ clientId: "22222222-2222-4222-8222-222222222222",
+ endpoint: "https://openai.azure.com.evil.example",
+ apiVersion: "2025-01-01-preview",
+ allowedDeployments: ["deployment-a"],
+ scopeDefaults: Object.fromEntries(
+ Object.keys(scopes).map((scope) => [scope, "deployment-a"])
+ ),
+ },
+ });
+ assert.equal(validateManagedEnterpriseEnvelope(envelope([unsafeAzure]), "workspace-a"), null);
+ assert.equal(
+ validateManagedEnterpriseEnvelope(
+ { ...envelope(), identity: { ...envelope().identity, subject: "workspace:other" } },
+ "workspace-a"
+ ),
+ null
+ );
+});
+
+test("managed default preserves an explicit legacy manual setup", () => {
+ assert.equal(
+ resolveManagedEnterpriseScope(envelope(), "dictationCleanup", "manual").kind,
+ "manual"
+ );
+ assert.deepEqual(resolveManagedEnterpriseScope(envelope(), "dictationCleanup", "auto"), {
+ kind: "managed",
+ provider: "bedrock",
+ model: "model-a",
+ mode: "managed_default",
+ allowManualSetup: true,
+ record: provider(),
+ });
+});
+
+test("required managed access overrides manual setup", () => {
+ const result = resolveManagedEnterpriseScope(
+ envelope([provider({ mode: "managed_required", allowManualSetup: false })]),
+ "chatIntelligence",
+ "manual"
+ );
+ assert.equal(result.kind, "managed");
+ assert.equal(result.model, "model-a");
+});
+
+test("ambiguous organization defaults fail with an administrator action", () => {
+ const azure = provider({
+ provider: "azure",
+ config: {
+ tenantId: "11111111-1111-4111-8111-111111111111",
+ clientId: "22222222-2222-4222-8222-222222222222",
+ endpoint: "https://example.openai.azure.com",
+ apiVersion: "2024-10-21",
+ allowedDeployments: ["deployment-a"],
+ scopeDefaults: Object.fromEntries(
+ Object.keys(scopes).map((scope) => [scope, "deployment-a"])
+ ),
+ },
+ });
+ const result = resolveManagedEnterpriseScope(
+ envelope([provider(), azure]),
+ "dictationCleanup",
+ "auto"
+ );
+ assert.equal(result.kind, "error");
+ assert.equal(result.code, "MANAGED_PROVIDER_AMBIGUOUS");
+});
diff --git a/test/helpers/noteFormattingOverrides.test.js b/test/helpers/noteFormattingOverrides.test.js
index 5d2789894..bbd21acff 100644
--- a/test/helpers/noteFormattingOverrides.test.js
+++ b/test/helpers/noteFormattingOverrides.test.js
@@ -10,6 +10,7 @@ test("cloud mode routes to openwhispr and ignores self-hosted fields", async ()
true
);
assert.deepEqual(overrides, {
+ inferenceScope: "noteFormatting",
provider: "openwhispr",
baseUrl: undefined,
customApiKey: undefined,
@@ -32,6 +33,7 @@ test("self-hosted forwards remoteUrl as lanUrl and the api key (regression: was
assert.equal(overrides.customApiKey, "sk-local");
assert.equal(overrides.provider, undefined);
assert.equal(overrides.baseUrl, undefined);
+ assert.equal(overrides.inferenceScope, "noteFormatting");
});
test("self-hosted with no key still routes via lanUrl", async () => {
@@ -42,6 +44,7 @@ test("self-hosted with no key still routes via lanUrl", async () => {
);
assert.equal(overrides.lanUrl, "http://host:8080/v1");
assert.equal(overrides.customApiKey, undefined);
+ assert.equal(overrides.inferenceScope, "noteFormatting");
});
test("providers/custom forwards cloudBaseUrl as baseUrl and the key", async () => {
@@ -56,6 +59,7 @@ test("providers/custom forwards cloudBaseUrl as baseUrl and the key", async () =
false
);
assert.deepEqual(overrides, {
+ inferenceScope: "noteFormatting",
provider: "custom",
baseUrl: "https://api.example.com/v1",
customApiKey: "sk-custom",
@@ -70,6 +74,7 @@ test("providers with a first-party cloud provider passes provider only, no key/b
false
);
assert.deepEqual(overrides, {
+ inferenceScope: "noteFormatting",
provider: "anthropic",
baseUrl: undefined,
customApiKey: undefined,
@@ -84,6 +89,7 @@ test("local mode pins the local provider and leaks no key", async () => {
false
);
assert.deepEqual(overrides, {
+ inferenceScope: "noteFormatting",
provider: "local",
baseUrl: undefined,
customApiKey: undefined,
@@ -99,4 +105,5 @@ test("local mode with no model stays local (regression: inherited cloud id hit t
);
assert.equal(overrides.provider, "local");
assert.equal(overrides.customApiKey, undefined);
+ assert.equal(overrides.inferenceScope, "noteFormatting");
});