diff --git a/README.md b/README.md index 9a4b15c..a2ad740 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ Fix punctuation and grammar of selected text with a single command or right-clic - **Prompt injection resistant** โ€” the built-in system prompt explicitly guards against prompt injection attacks in the text being proofread - **Smart quote replacement** โ€” straight quotes โ†’ curly quotes (except in code blocks) +- **Timing and token report** โ€” a live timer runs while the model works; when done, a notice shows elapsed time, model, upstream host (OpenRouter), and prompt/output/reasoning token counts (also logged to the console) - Works with any OpenAI-compatible provider (OpenRouter, OpenAI, etc.) ### ๐Ÿท๏ธ Title Generation @@ -71,7 +72,7 @@ Then copy the `main.js`, `manifest.json`, and `styles.css` to your vault's plugi ## Getting Started ### 1. Configure API Keys -Open **Settings** โ†’ **NibbleAI** and add at least one API key: +Open **Settings** โ†’ **NibbleAI** and, for at least one provider, pick the secret holding its key from Obsidian's keychain (**Settings** โ†’ **Keychain**): | Key | Used For | |-----|----------| @@ -144,7 +145,7 @@ Wherever you need to select an AI model (post-processing, proofreading, title ge ## Settings Reference ### API Keys -Securely stored in your system keychain via Obsidian's SecretStorage. Never written to `data.json`. +Keys live in Obsidian's keychain (SecretStorage). NibbleAI stores only the name of the secret you picked for each provider in `data.json`, and reads the key at the moment it calls the API, so a key rotated in the keychain applies immediately. Upgrading from โ‰ค 1.2.1 links the previously used `groq-api-key`, `openai-api-key`, `anthropic-api-key`, `openrouter-api-key` and `custom-api-key` secrets automatically. ### Transcription | Setting | Default | Description | @@ -187,6 +188,8 @@ Securely stored in your system keychain via Obsidian's SecretStorage. Never writ | Model | `openai/gpt-4o-mini` | Model for proofreading | | Temperature | `0.2` | Lower = more consistent | | Max tokens | `2000` | Maximum response length | +| Reasoning | Off | OpenRouter only. Let the model think before answering; slower and uses more tokens | +| Effort | Low | OpenRouter only. Output effort (`verbosity`); with reasoning on, also reasoning depth | | System prompt | *(built-in)* | Editable with prompt injection protections | ### Title Generation diff --git a/src/AIService.ts b/src/AIService.ts index c809a2e..827bc7c 100644 --- a/src/AIService.ts +++ b/src/AIService.ts @@ -1,5 +1,5 @@ import axios from "axios"; -import { PostProcessingProvider } from "./SettingsManager"; +import { PostProcessingProvider, ReasoningEffort } from "./SettingsManager"; export interface ChatCompletionOptions { apiKey: string; @@ -8,8 +8,36 @@ export interface ChatCompletionOptions { provider?: "anthropic" | "openai" | "openrouter" | "groq" | "custom"; temperature?: number; maxTokens?: number; + /** + * OpenRouter only: reasoning on/off plus effort. Effort maps to + * `verbosity` (Anthropic's output effort) and, when reasoning is on, to + * `reasoning.effort`. `reasoning.effort` alone would turn reasoning on. + */ + reasoning?: { enabled: boolean; effort: ReasoningEffort }; } +export interface ChatCompletionResult { + text: string; + /** Upstream host that served the request (OpenRouter only, e.g. "CoreWeave"). */ + upstream?: string; + /** Token counts as reported by the API; absent when the API omits usage. */ + usage?: { + promptTokens: number; + completionTokens: number; + /** Part of `completionTokens` spent thinking, when the API reports it. */ + reasoningTokens?: number; + }; +} + +/** + * Shown when the response stops at max_tokens. A cut-off answer is never + * usable (proofreading would replace the selection with a truncated copy), + * and reasoning models spend this budget on thinking too, which can leave + * no tokens for the answer at all. + */ +const TRUNCATED_HINT = + "Try less text, a higher Max tokens (Proofreading settings), or a non-reasoning model."; + /** * Unified AI service for all NibbleAI modules. * Supports OpenAI-compatible chat completions and Anthropic native API. @@ -20,13 +48,13 @@ export class AIService { * @param userMessage - The user's input text * @param systemPrompt - System-level instructions * @param options - API configuration - * @returns The model's response text + * @returns The model's response text, plus token usage and upstream host */ static async callChatCompletion( userMessage: string, systemPrompt: string, options: ChatCompletionOptions - ): Promise { + ): Promise { const provider = options.provider || "openai"; const endpoint = options.endpoint || "https://openrouter.ai/api/v1/chat/completions"; @@ -45,7 +73,8 @@ export class AIService { userMessage: string, systemPrompt: string, options: ChatCompletionOptions - ): Promise { + ): Promise { + const maxTokens = options.maxTokens ?? 2000; const response = await axios.post( options.endpoint || "https://openrouter.ai/api/v1/chat/completions", @@ -56,7 +85,15 @@ export class AIService { { role: "user", content: userMessage }, ], temperature: options.temperature ?? 0.3, - max_tokens: options.maxTokens ?? 2000, + max_tokens: maxTokens, + ...(options.reasoning && options.provider === "openrouter" + ? { + reasoning: options.reasoning.enabled + ? { effort: options.reasoning.effort } + : { enabled: false }, + verbosity: options.reasoning.effort, + } + : {}), }, { headers: { @@ -71,19 +108,39 @@ export class AIService { }, } ); - return response.data.choices[0].message.content.trim(); + const choice = response.data.choices[0]; + if (choice.finish_reason === "length") { + throw new Error( + `${options.model} hit its ${maxTokens}-token limit before finishing. ${TRUNCATED_HINT}` + ); + } + const content: string | null = choice.message.content; + if (!content) { + throw new Error(`Model returned no text (finish reason: ${choice.finish_reason}).`); + } + const usage = response.data.usage; + return { + text: content.trim(), + upstream: response.data.provider, + usage: usage && { + promptTokens: usage.prompt_tokens, + completionTokens: usage.completion_tokens, + reasoningTokens: usage.completion_tokens_details?.reasoning_tokens, + }, + }; } private static async callAnthropic( userMessage: string, systemPrompt: string, options: ChatCompletionOptions - ): Promise { + ): Promise { + const maxTokens = options.maxTokens ?? 8192; const response = await axios.post( options.endpoint || "https://api.anthropic.com/v1/messages", { model: options.model, - max_tokens: options.maxTokens ?? 8192, + max_tokens: maxTokens, system: systemPrompt, messages: [{ role: "user", content: userMessage }], }, @@ -96,6 +153,18 @@ export class AIService { }, } ); - return response.data.content[0].text; + if (response.data.stop_reason === "max_tokens") { + throw new Error( + `${options.model} hit its ${maxTokens}-token limit before finishing. ${TRUNCATED_HINT}` + ); + } + const usage = response.data.usage; + return { + text: response.data.content[0].text, + usage: usage && { + promptTokens: usage.input_tokens, + completionTokens: usage.output_tokens, + }, + }; } } \ No newline at end of file diff --git a/src/NibbleAISettingsTab.ts b/src/NibbleAISettingsTab.ts index 47f7a4e..b893c6e 100644 --- a/src/NibbleAISettingsTab.ts +++ b/src/NibbleAISettingsTab.ts @@ -1,11 +1,13 @@ import NibbleAI from "main"; -import { App, PluginSettingTab, Setting, setIcon } from "obsidian"; +import { App, PluginSettingTab, SecretComponent, Setting, setIcon } from "obsidian"; import { SettingsManager, PostProcessingProvider, TranscriptionProvider, CHAT_PROVIDERS, PROVIDER_DEFAULT_MODELS, + ReasoningEffort, + getApiKey, } from "./SettingsManager"; import { ModelSuggestModal } from "./ModelBrowser"; @@ -102,7 +104,7 @@ export class NibbleAISettingsTab extends PluginSettingTab { private renderApiKeysTab(containerEl: HTMLElement): void { containerEl.createEl("h2", { text: "API Keys" }); containerEl.createEl("p", { - text: "API keys are stored securely in your system keychain.", + text: "Pick a secret from Obsidian's keychain (Settings โ†’ Keychain) for each provider. NibbleAI stores only the secret's name; the key itself stays in the keychain.", cls: "setting-item-description", }); containerEl.createEl("p", { @@ -113,50 +115,45 @@ export class NibbleAISettingsTab extends PluginSettingTab { this.createApiKeySetting(containerEl, "Groq API Key", "For Whisper transcription and Groq chat models (groq.com)", - "gsk_...", - this.plugin.settings.groqApiKey, + this.plugin.settings.groqSecret, async (value) => { - this.plugin.settings.groqApiKey = value; + this.plugin.settings.groqSecret = value; await this.save(); } ); this.createApiKeySetting(containerEl, "OpenAI API Key", "For GPT / OpenAI-compatible models", - "sk-...xxxx", - this.plugin.settings.openAiApiKey, + this.plugin.settings.openAiSecret, async (value) => { - this.plugin.settings.openAiApiKey = value; + this.plugin.settings.openAiSecret = value; await this.save(); } ); this.createApiKeySetting(containerEl, "Anthropic API Key", "For Claude models (sk-ant-...)", - "sk-ant-...xxxx", - this.plugin.settings.anthropicApiKey, + this.plugin.settings.anthropicSecret, async (value) => { - this.plugin.settings.anthropicApiKey = value; + this.plugin.settings.anthropicSecret = value; await this.save(); } ); this.createApiKeySetting(containerEl, "OpenRouter API Key", "For OpenRouter models โ€” get one at openrouter.ai/keys.", - "sk-or-v1-...", - this.plugin.settings.openRouterApiKey, + this.plugin.settings.openRouterSecret, async (value) => { - this.plugin.settings.openRouterApiKey = value; + this.plugin.settings.openRouterSecret = value; await this.save(); } ); this.createApiKeySetting(containerEl, "Custom API Key", "For a self-hosted or OpenAI-compatible endpoint not listed above", - "sk-...xxxx", - this.plugin.settings.customApiKey, + this.plugin.settings.customSecret, async (value) => { - this.plugin.settings.customApiKey = value; + this.plugin.settings.customSecret = value; await this.save(); } ); @@ -498,6 +495,36 @@ export class NibbleAISettingsTab extends PluginSettingTab { } ); + if (this.plugin.settings.proofreadingProvider === "openrouter") { + new Setting(containerEl) + .setName("Reasoning") + .setDesc( + "Let the model think before answering. Slower and uses more tokens; rarely needed for punctuation and grammar." + ) + .addToggle((toggle) => + toggle + .setValue(this.plugin.settings.proofreadingReasoning) + .onChange(async (value) => { + this.plugin.settings.proofreadingReasoning = value; + await this.save(); + }) + ); + new Setting(containerEl) + .setName("Effort") + .setDesc( + "How much the model writes (OpenRouter verbosity, Anthropic output effort). With reasoning on, also sets how deeply it thinks. Models without support ignore it." + ) + .addDropdown((dropdown) => + dropdown + .addOptions({ low: "Low", medium: "Medium", high: "High" }) + .setValue(this.plugin.settings.proofreadingEffort) + .onChange(async (value) => { + this.plugin.settings.proofreadingEffort = value as ReasoningEffort; + await this.save(); + }) + ); + } + this.createPromptSetting(containerEl, "System prompt", "Instructions for the AI on how to proofread. Guarded against prompt injection.", @@ -722,19 +749,17 @@ export class NibbleAISettingsTab extends PluginSettingTab { containerEl: HTMLElement, name: string, desc: string, - placeholder: string, - value: string, - onChange: (value: string) => Promise + secretName: string, + onChange: (secretName: string) => Promise ): void { new Setting(containerEl) .setName(name) .setDesc(desc) - .addText((text) => { - text.setPlaceholder(placeholder) - .setValue(value) - .onChange(async (value) => await onChange(value)); - text.inputEl.type = "password"; - }); + .addComponent((el) => + new SecretComponent(this.app, el) + .setValue(secretName) + .onChange(async (value) => await onChange(value)) + ); } /** @@ -801,9 +826,9 @@ export class NibbleAISettingsTab extends PluginSettingTab { onChange: (provider: PostProcessingProvider) => Promise ): void { const configured = new Set( - CHAT_PROVIDERS.filter((p) => !!this.plugin.settings[p.apiKeyField]).map( - (p) => p.id - ) + CHAT_PROVIDERS.filter( + (p) => !!getApiKey(this.app, this.plugin.settings[p.secretField]) + ).map((p) => p.id) ); new Setting(containerEl) @@ -944,11 +969,10 @@ export class NibbleAISettingsTab extends PluginSettingTab { ); this.createApiKeySetting(containerEl, "Custom API Key", - "API key for the custom endpoint", - "sk-...xxxx", - this.plugin.settings.customApiKey, + "Keychain secret holding the key for the custom endpoint", + this.plugin.settings.customSecret, async (value) => { - this.plugin.settings.customApiKey = value; + this.plugin.settings.customSecret = value; await this.save(); } ); diff --git a/src/PostProcessor.ts b/src/PostProcessor.ts index 6ae84f8..67743e4 100644 --- a/src/PostProcessor.ts +++ b/src/PostProcessor.ts @@ -20,12 +20,13 @@ export class PostProcessor { } async process(text: string, prompt: string): Promise { - return AIService.callChatCompletion(text, prompt, { + const result = await AIService.callChatCompletion(text, prompt, { apiKey: this.config.apiKey, model: this.config.model, endpoint: this.config.url, provider: this.config.provider, maxTokens: 8192, }); + return result.text; } } \ No newline at end of file diff --git a/src/ProviderResolver.ts b/src/ProviderResolver.ts index 418d783..b068c38 100644 --- a/src/ProviderResolver.ts +++ b/src/ProviderResolver.ts @@ -1,4 +1,11 @@ -import { CHAT_PROVIDERS, PROVIDER_URLS, PluginSettings, PostProcessingProvider } from "./SettingsManager"; +import { App } from "obsidian"; +import { + CHAT_PROVIDERS, + PROVIDER_URLS, + PluginSettings, + PostProcessingProvider, + getApiKey, +} from "./SettingsManager"; export interface ResolvedChatProvider { apiKey: string; @@ -13,13 +20,14 @@ export interface ResolvedChatProvider { * providers โ€” including "no key configured" โ€” identically. */ export function resolveChatProvider( + app: App, settings: PluginSettings, provider: PostProcessingProvider ): ResolvedChatProvider | null { const info = CHAT_PROVIDERS.find((p) => p.id === provider); if (!info) return null; - const apiKey = settings[info.apiKeyField]; + const apiKey = getApiKey(app, settings[info.secretField]); const endpoint = provider === "custom" ? settings.customApiUrl : PROVIDER_URLS[provider]; if (!apiKey || !endpoint) return null; diff --git a/src/SettingsManager.ts b/src/SettingsManager.ts index 20c909f..48fdfa7 100644 --- a/src/SettingsManager.ts +++ b/src/SettingsManager.ts @@ -1,11 +1,15 @@ -import { Plugin } from "obsidian"; +import { App, Plugin } from "obsidian"; -const SECRET_IDS: Partial> = { - groqApiKey: "groq-api-key", - openAiApiKey: "openai-api-key", - anthropicApiKey: "anthropic-api-key", - customApiKey: "custom-api-key", - openRouterApiKey: "openrouter-api-key", +/** + * Fixed keychain names NibbleAI โ‰ค 1.2.1 wrote keys under, and the plain-text + * data.json fields older versions used. Only read by the one-time migration. + */ +const LEGACY_KEYS: Record = { + groqSecret: { field: "groqApiKey", secretId: "groq-api-key" }, + openAiSecret: { field: "openAiApiKey", secretId: "openai-api-key" }, + anthropicSecret: { field: "anthropicApiKey", secretId: "anthropic-api-key" }, + customSecret: { field: "customApiKey", secretId: "custom-api-key" }, + openRouterSecret: { field: "openRouterApiKey", secretId: "openrouter-api-key" }, }; export type PostProcessingProvider = "anthropic" | "openai" | "openrouter" | "groq" | "custom"; @@ -31,7 +35,7 @@ export const PROVIDER_DEFAULT_MODELS: Record = { export interface ChatProviderInfo { id: PostProcessingProvider; label: string; - apiKeyField: keyof ApiKeysSettings; + secretField: ApiKeySecretField; } /** @@ -41,11 +45,11 @@ export interface ChatProviderInfo { * Generation, Property Filler) offers the exact same providers. */ export const CHAT_PROVIDERS: ChatProviderInfo[] = [ - { id: "anthropic", label: "Anthropic", apiKeyField: "anthropicApiKey" }, - { id: "openai", label: "OpenAI", apiKeyField: "openAiApiKey" }, - { id: "groq", label: "Groq", apiKeyField: "groqApiKey" }, - { id: "openrouter", label: "OpenRouter", apiKeyField: "openRouterApiKey" }, - { id: "custom", label: "Custom", apiKeyField: "customApiKey" }, + { id: "anthropic", label: "Anthropic", secretField: "anthropicSecret" }, + { id: "openai", label: "OpenAI", secretField: "openAiSecret" }, + { id: "groq", label: "Groq", secretField: "groqSecret" }, + { id: "openrouter", label: "OpenRouter", secretField: "openRouterSecret" }, + { id: "custom", label: "Custom", secretField: "customSecret" }, ]; export type TranscriptionProvider = "groq" | "openai" | "azure" | "custom"; @@ -59,13 +63,25 @@ export const TRANSCRIPTION_PROVIDER_URLS: Record export type TitleGenMode = "rename-file" | "frontmatter-property"; +/** + * The `*Secret` fields hold the *name* of a secret in Obsidian's keychain + * (Settings โ†’ Keychain), never the key itself. Resolve with `getApiKey`. + */ export interface ApiKeysSettings { - groqApiKey: string; - openAiApiKey: string; - anthropicApiKey: string; - customApiKey: string; + groqSecret: string; + openAiSecret: string; + anthropicSecret: string; + customSecret: string; customApiUrl: string; - openRouterApiKey: string; + openRouterSecret: string; +} + +export type ApiKeySecretField = Exclude; + +/** Reads the key from the keychain at call time, so rotated keys apply immediately. */ +export function getApiKey(app: App, secretName: string): string { + if (!secretName) return ""; + return app.secretStorage.getSecret(secretName) ?? ""; } export interface TranscriptionSettings { @@ -104,11 +120,17 @@ export interface PostProcessingSettings { keepOriginalTranscription: boolean; } +export type ReasoningEffort = "low" | "medium" | "high"; + export interface ProofreadingSettings { proofreadingProvider: AIProvider; proofreadingModel: string; proofreadingTemperature: number; proofreadingMaxTokens: number; + /** OpenRouter only: let the model think before answering. */ + proofreadingReasoning: boolean; + /** OpenRouter only: output effort (`verbosity`), and reasoning depth when reasoning is on. */ + proofreadingEffort: ReasoningEffort; proofreadingSystemPrompt: string; proofreadingContextMenu: boolean; } @@ -146,12 +168,12 @@ export type PluginSettings = ApiKeysSettings & // โ”€โ”€ Defaults โ”€โ”€ export const DEFAULT_API_KEYS: ApiKeysSettings = { - groqApiKey: "", - openAiApiKey: "", - anthropicApiKey: "", - customApiKey: "", + groqSecret: "", + openAiSecret: "", + anthropicSecret: "", + customSecret: "", customApiUrl: "", - openRouterApiKey: "", + openRouterSecret: "", }; export const DEFAULT_TRANSCRIPTION: TranscriptionSettings = { @@ -214,6 +236,8 @@ export const DEFAULT_PROOFREADING: ProofreadingSettings = { proofreadingModel: "openai/gpt-4o-mini", proofreadingTemperature: 0.2, proofreadingMaxTokens: 2000, + proofreadingReasoning: false, + proofreadingEffort: "low", proofreadingSystemPrompt: DEFAULT_PROOFREADING_SYSTEM_PROMPT, proofreadingContextMenu: true, }; @@ -265,35 +289,32 @@ export class SettingsManager { return this.plugin.app.secretStorage; } - private migrateKeysFromDataJson(settings: PluginSettings): boolean { - // One-time migration: move plain-text keys out of data.json into SecretStorage. + /** + * One-time migration to user-selected keychain secrets. Older versions + * either kept keys in plain text in data.json or wrote them to the keychain + * under fixed names. Point each `*Secret` field at the fixed name when it + * holds a key, then drop the legacy field. Runs only while a legacy field + * is still present in data.json, so clearing a selection later sticks. + */ + private migrateKeysToSecretNames(settings: PluginSettings): boolean { + const legacy = settings as PluginSettings & Record; let migrated = false; - for (const [field, secretId] of Object.entries(SECRET_IDS)) { - const key = field as keyof ApiKeysSettings; - if (settings[key]) { - this.secrets.setSecret(secretId, settings[key]); - settings[key] = ""; - migrated = true; + for (const [secretField, { field, secretId }] of Object.entries(LEGACY_KEYS)) { + if (!(field in legacy)) continue; + const plainKey = legacy[field]; + const name = secretField as ApiKeySecretField; + if (typeof plainKey === "string" && plainKey) { + this.secrets.setSecret(secretId, plainKey); } + if (!settings[name] && this.secrets.getSecret(secretId)) { + settings[name] = secretId; + } + delete legacy[field]; + migrated = true; } return migrated; } - private syncKeysToSecretStorage(settings: PluginSettings): void { - for (const [field, secretId] of Object.entries(SECRET_IDS)) { - const key = field as keyof ApiKeysSettings; - this.secrets.setSecret(secretId, settings[key]); - settings[key] = ""; - } - } - - private loadKeysFromSecretStorage(settings: PluginSettings): void { - for (const [field, secretId] of Object.entries(SECRET_IDS)) { - const key = field as keyof ApiKeysSettings; - settings[key] = this.secrets.getSecret(secretId) ?? ""; - } - } - private migratePostProcessingProvider(settings: PluginSettings): boolean { if (settings.postProcessingProvider) return false; const legacyUrl = (settings as PluginSettings & { postProcessingUrl?: string }) @@ -338,17 +359,14 @@ export class SettingsManager { await this.plugin.saveData(settings); } - if (this.migrateKeysFromDataJson(settings)) { + if (this.migrateKeysToSecretNames(settings)) { await this.plugin.saveData(settings); } - this.loadKeysFromSecretStorage(settings); return settings; } async saveSettings(settings: PluginSettings): Promise { - this.syncKeysToSecretStorage(settings); await this.plugin.saveData(settings); - this.loadKeysFromSecretStorage(settings); } } \ No newline at end of file diff --git a/src/proofreading/Proofreader.ts b/src/proofreading/Proofreader.ts index b958a5b..7e32b89 100644 --- a/src/proofreading/Proofreader.ts +++ b/src/proofreading/Proofreader.ts @@ -18,6 +18,7 @@ export class Proofreader { } const config = resolveChatProvider( + this.plugin.app, this.plugin.settings, this.plugin.settings.proofreadingProvider || "openrouter" ); @@ -28,23 +29,34 @@ export class Proofreader { return; } - new Notice("๐Ÿค– Fixing punctuation and grammar..."); + const model = this.plugin.settings.proofreadingModel; + const startedAt = performance.now(); + const elapsed = () => `${((performance.now() - startedAt) / 1000).toFixed(1)} s`; + const progress = new Notice(`๐Ÿค– Proofreading with ${model}โ€ฆ 0.0 s`, 0); + const ticker = window.setInterval( + () => progress.setMessage(`๐Ÿค– Proofreading with ${model}โ€ฆ ${elapsed()}`), + 100 + ); try { const systemPrompt = this.plugin.settings.proofreadingSystemPrompt || "You are a text proofreading tool. Fix punctuation and grammar in the text below. Return only the corrected text, nothing else."; - const corrected = await AIService.callChatCompletion( + const { text: corrected, upstream, usage } = await AIService.callChatCompletion( selection, systemPrompt, { apiKey: config.apiKey, - model: this.plugin.settings.proofreadingModel, + model, endpoint: config.endpoint, provider: config.provider, temperature: this.plugin.settings.proofreadingTemperature, maxTokens: this.plugin.settings.proofreadingMaxTokens, + reasoning: { + enabled: this.plugin.settings.proofreadingReasoning, + effort: this.plugin.settings.proofreadingEffort, + }, } ); @@ -54,12 +66,27 @@ export class Proofreader { } editor.replaceSelection(corrected); - new Notice("โœ… Punctuation and grammar fixed."); + // Prompt tokens = system prompt + selection. Reasoning tokens are part + // of the output count and are usually what makes a short fix slow. + const tokens = usage + ? `Prompt ${usage.promptTokens} tok ยท output ${usage.completionTokens} tok` + + (usage.reasoningTokens ? ` (${usage.reasoningTokens} reasoning)` : "") + : "Token usage not reported"; + const knobs = + config.provider === "openrouter" + ? ` ยท reasoning ${this.plugin.settings.proofreadingReasoning ? "on" : "off"} ยท effort ${this.plugin.settings.proofreadingEffort}` + : ""; + const summary = `โœ… Fixed in ${elapsed()}\n${model}${upstream ? ` via ${upstream}` : ""}${knobs}\n${tokens}`; + console.info(`NibbleAI proofread: ${summary.replace(/\n/g, " | ")}`); + new Notice(summary, 10000); } catch (error) { console.error("Proofreading error:", error); new Notice( - `โŒ Fix failed: ${error instanceof Error ? error.message : String(error)}` + `โŒ Fix failed after ${elapsed()} (${model}): ${error instanceof Error ? error.message : String(error)}` ); + } finally { + window.clearInterval(ticker); + progress.hide(); } } } \ No newline at end of file diff --git a/src/property/PropertyFiller.ts b/src/property/PropertyFiller.ts index 925e46f..3bc68e2 100644 --- a/src/property/PropertyFiller.ts +++ b/src/property/PropertyFiller.ts @@ -115,6 +115,7 @@ export class PropertyFiller { } const config = resolveChatProvider( + this.plugin.app, this.plugin.settings, this.plugin.settings.propertyGenProvider || "openrouter" ); @@ -146,7 +147,7 @@ export class PropertyFiller { "Based on the following note content, generate a value for the property '{property}'. Return only the value, nothing else."; const prompt = promptTemplate.replace(/\{property\}/g, propertyName); - const generated = await AIService.callChatCompletion( + const { text: generated } = await AIService.callChatCompletion( content, prompt, { diff --git a/src/title/TitleGenerator.ts b/src/title/TitleGenerator.ts index 11f33a0..741ad3a 100644 --- a/src/title/TitleGenerator.ts +++ b/src/title/TitleGenerator.ts @@ -31,6 +31,7 @@ export class TitleGenerator { } const config = resolveChatProvider( + this.plugin.app, this.plugin.settings, this.plugin.settings.titleGenProvider || "openrouter" ); @@ -48,7 +49,7 @@ export class TitleGenerator { this.plugin.settings.titleGenPrompt || "Generate a short, descriptive title (1-8 words) for the following note content. Return only the title, nothing else."; - const generated = await AIService.callChatCompletion( + const { text: generated } = await AIService.callChatCompletion( content, prompt, { diff --git a/src/transcription/AudioHandler.ts b/src/transcription/AudioHandler.ts index 4bcd70b..a8c3884 100644 --- a/src/transcription/AudioHandler.ts +++ b/src/transcription/AudioHandler.ts @@ -9,6 +9,7 @@ import { } from "./utils"; import { PostProcessor } from "../PostProcessor"; import { resolveChatProvider } from "../ProviderResolver"; +import { getApiKey } from "../SettingsManager"; export class AudioHandler { private plugin: NibbleAI; @@ -31,14 +32,15 @@ export class AudioHandler { } getTranscriptionApiKey(): string { - switch (this.plugin.settings.transcriptionProvider) { + const { app, settings } = this.plugin; + switch (settings.transcriptionProvider) { case "groq": - return this.plugin.settings.groqApiKey; + return getApiKey(app, settings.groqSecret); case "openai": case "azure": - return this.plugin.settings.openAiApiKey; + return getApiKey(app, settings.openAiSecret); case "custom": - return this.plugin.settings.groqApiKey || this.plugin.settings.openAiApiKey; + return getApiKey(app, settings.groqSecret) || getApiKey(app, settings.openAiSecret); } } @@ -162,6 +164,7 @@ export class AudioHandler { // Post-process with LLM if enabled if (this.plugin.settings.postProcessing) { const resolved = resolveChatProvider( + this.plugin.app, this.plugin.settings, this.plugin.settings.postProcessingProvider ); @@ -201,6 +204,7 @@ export class AudioHandler { this.plugin.settings.createNoteFile ) { const resolved = resolveChatProvider( + this.plugin.app, this.plugin.settings, this.plugin.settings.postProcessingProvider );