Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.
JavaScript aianthropiccross-platformgeminigroqlinuxmacosnvidiaopen-sourceopenaiparakeetspeech-to-texttranscribewhisperwindows
feat: provision managed Bedrock and Azure access
Gabriel Steindf52041b7e40
diff --git a/preload.js b/preload.jsindex 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.cppllamaCppCheck: () => ipcRenderer.invoke("llama-cpp-check"),diff --git a/src/components/AuthenticationStep.tsx b/src/components/AuthenticationStep.tsxindex 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.tsxindex 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.tsxindex 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.tsindex 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.tsxindex 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 }: Inferenceconst { 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.tsxindex 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" }: PrompsetCustomPrompt(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" }: Promptry {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" }: PrompsetCustomPrompt(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.jsindex 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.jsindex 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.jsindex 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.jsnew file mode 100644index 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.mjsnew file mode 100644index 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.jsindex 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.jsindex 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.jsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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): EnterprazureApiVersion: s.azureApiVersion,vertexProject: s.vertexProject,vertexLocation: s.vertexLocation,+ managedContext,};}diff --git a/src/services/ai/inferenceProviders/enterprise.ts b/src/services/ai/inferenceProviders/enterprise.tsindex 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.tsnew file mode 100644index 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.tsindex 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 SettingsStatesetCortiTenant: (value: string) => void;// Enterprise providers+ enterpriseSetupMode: EnterpriseSetupMode;bedrockAuthMode: string;bedrockRegion: string;bedrockProfile: string;@@ -661,6 +664,7 @@ export interface SettingsStatevertexLocation: 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.jsnew file mode 100644index 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.jsnew file mode 100644index 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.jsindex 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: wasassert.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/bfalse);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");});