Smart Chat Pro v2.2

The chat lives with the note

Smart Chat Pro now gives each note one universal place for the conversation it depends on. Open a supported provider thread or start a Smart Chat API Extension thread from the same codeblock, then return to the note later and continue from the same place.

That is the release: not another chat destination and not another API wrapper. It is a better way to keep a conversation attached to the project, decision, research trail, or draft that gave it meaning.

Update all installed Smart Plugins together, then restart Obsidian. Smart Chat Pro v2.2 requires Smart Environment v3.

Organize by note, not by provider

The universal codeblock can connect a note to two kinds of conversation without blurring where the data lives.

Supported provider thread: the provider keeps the transcript. The note keeps the durable thread reference, active or done state, and the local presentation choices needed to return to it.
Smart Chat API Extension thread: Smart Chat manages the API conversation history, selected model, and reviewed source set. The note still anchors where that conversation belongs.

You choose how the conversation runs. The note remains the organizing layer.

Leave the note without losing the thread

Each codeblock now has a stable identity, so reopening a note, moving a pane, changing tabs, or restarting Obsidian is less likely to break the association between the block and its conversation.

Active and completed thread menus keep several conversations available without filling the note with open webviews. Grow / contain and Collapse / expand choices persist. Slow or stalled provider views now show a real status and recovery path instead of leaving a blank rectangle to explain itself.

Bring the note into the conversation from the same block

The codeblock can insert the current selection, current note, clipboard content, or custom text into supported provider threads. It can also build Context when the conversation needs a reviewed package rather than an indiscriminate paste.

For Smart Chat API Extension threads, drop supported Obsidian items, Smart Plugin results, or a saved named Context into the visible source set before sending. The sources remain inspectable instead of disappearing into prompt assembly.

The API Extension now feels like part of the same workflow

API conversations use the same note-attached codeblock rather than asking you to maintain a second mental model for where chats belong. Model choice and source state remain explicit, while the note gives the thread durable context in your vault.

Smart Environment v3 strengthens the workflow around it. The suite starts faster, model management is clearer, and source-aware workflows get more built-in local embedding models without destructive switching. Learn more about the release of Smart Environment v3.

Shared drag-and-drop carries reviewed source sets into the block, and Pro can keep supported API keys in Obsidian's native keychain-backed secret storage.

Before / After

Before	With the universal Smart Chat codeblock
A useful conversation could disappear into tabs or provider history.	The note keeps the thread reference and local state needed to return to it.
Provider threads and API conversations felt like separate places to organize.	One note-attached block opens the thread type the work needs.
Pane movement, hidden tabs, or a slow webview could make continuity feel fragile.	Stable identities, lifecycle recovery, visible loading, and static fallbacks make the attachment more dependable.
Bringing note material into chat meant manual copying and re-finding sources.	Insert the note or selection, build Context, or drop a reviewed source set into the thread.
API keys lived in ordinary plugin settings.	Supported Pro credentials can use Obsidian's native keychain-backed secret storage.

Supporting improvements

Safer thread-reference writes, duplicate handling, and rollback behavior.
Better provider-view loading, refresh, hidden-tab recovery, pane movement, cleanup, hotkey forwarding, and click forwarding.
Static thread rendering on Canvas, hover previews, and other surfaces that cannot safely host an interactive provider view.
Collision handling and rollback for new API Extension threads.
One shared drop path for supported Obsidian and Smart Plugin items.

Learn more

Release notes

`v2.2.1`

Fixed: commands should be properly registered to the Pro plugin

Updated: Smart Environment

`v2.2.0`

Add user-agent synchronization for web viewer in chat codeblock

refactor: migrate chat platform handling to CodeblockThreadPlatformAdapter

Introduced CodeblockThreadPlatformAdapter and its subclasses for better structure and extensibility.
Replaced existing platform descriptor functions with static methods in the new adapter classes.
Updated chat platform resolution logic to utilize the new adapter classes.
Enhanced URL normalization and thread URL detection mechanisms.
Refactored tests to align with the new adapter structure and ensure compatibility.
Removed legacy platform handling and streamlined the codebase for improved maintainability.

Improved: Drained child component disposers before thread rerenders to avoid leaked old webview listeners.

refactor: update thread ID usage across tests and implementations for consistency

feat: implement chat codeblock ID generation and management for improved thread handling

feat(chat-codeblock): implement grow/contain toggle functionality with persistence

Added is_chat_codeblock_grow_enabled function to check grow setting.
Updated chat_codeblock_toggle_grow to toggle grow state and persist setting.
Enhanced chat codeblock item rendering to reflect grow state.
Introduced webview status handling in chat codeblock threads.
Implemented tests for grow/contain functionality and webview manager behavior.
Modified thread collection key generation to include chat-id for better identification.
Added tests for thread collection key persistence and new codeblock behavior.

feat(chat-codeblock): enhance new chat item creation with title prefix and submenu handling
feat(chat-codeblock): add tests for done threads submenu functionality based on threshold
style: adjust z-index for Obsidian tabs to ensure proper layering above smart-chat webviews

feat(webview-manager): enhance handling of zero-size anchors with prior bounds (resolves flicker when changing between tabs)

feat: add webview IPC for chat codeblocks and register action methods

Implemented create_webview_ipc for managing communication between host and guest in webviews.
Added tests for webview IPC functionality to ensure proper method registration and event handling.
Enhanced ChatCodeblockWebviewManager to support IPC and method registration for different chat providers.
Introduced get_provider_action_webview_methods and register_action_webview_methods to streamline action method management based on provider keys.
Updated post_process_webview in the base adapter to automatically register action methods for the active provider.

feat(webview-manager): enhance detach functionality to support immediate parking

feat(hotkey): implement webview hotkey forwarding and associated tests

feat(commands): refactor smart chat codeblock insertion command for improved structure
feat(chat-codeblock): update documentation for unsaved thread selection logic
feat(codeblock-processor): enhance static fallback rendering for unsupported webviews

Refactor chat platform adapter tests and remove deprecated code

Updated tests in chat_platforms.test.js to utilize new adapter resolution methods and improved structure for provider adapters.
Introduced a new scope creation function to streamline test setup.
Enhanced test cases to ensure proper fallback to generic adapters and validate configured adapters.
Removed the codeblock_thread.js file, consolidating functionality into the new adapter structure.
Adjusted tests in chat_platforms_webview_methods.test.js to reflect changes in adapter configuration and method resolution.
Updated codeblock_threads.test.js to align with the new adapter architecture and ensure proper functionality of ephemeral collections.

refactor(webview): simplify settings retrieval and enhance test coverage

refactor(menu_helpers): simplify open_scope_menu parameters and improve readability

refactor(dom_helpers): streamline helper functions and improve code clarity
refactor(chat-codeblock): enhance build_html and post_process functions for better readability

feat(tests): enhance ChatCodeblockWebviewManager tests with new functionality and edge cases

Added tests for default auto-refresh hidden threshold in ChatCodeblockWebviewManager.
Improved FakeDocument and FakeElement classes to better simulate webview behavior.
Introduced tests for managing webview visibility and state during loading and unloading.
Updated test cases to ensure proper handling of thread identity and context.
Enhanced webview manager to handle stale content and refresh logic based on visibility.
Added tests for workspace layout synchronization and transient tab detachment.
Implemented checks for codeblock thread state management and persistence in related tests.

feat: enhance webview management with lifecycle refresh and loading states

Refactored codeblock_thread_refresh_webview to utilize the webview manager lifecycle for refreshing webviews.
Added loading state indicators in CSS for better user feedback during webview loading.
Improved thread management to maintain access to codeblock and adapter after collection removal.
Implemented auto-refresh functionality for hidden webviews based on user-defined settings.
Added tests to ensure proper functionality of webview refresh and loading states.

feat: enhance codeblock functionality with improved error handling and new tests

feat: implement duplicate thread URL handling and repair for chat codeblocks

feat: enhance chat codeblock UI with improved status handling and new toggle functionality

feat: implement chat codeblock collapse functionality with persistent state and UI updates

feat: add collapse/expand functionality for chat codeblock with UI updates

feat: add handling for webview load stall with status reporting and recovery actions

repleaced append clipboard handling so that clipboard is accessed inside the webview to prevent passing large context across bridge

improve webview support checks and enhance static thread rendering logic (prevent from rendering webview in bespoke views like canvas or hover preview)

added: 'Show developer console' action for webview
improved: implement click forwarding (makes menus close when clicking inside the chat UI)

Refactor chat platform adapters to note thread adapters

Renamed and updated the GenericCodeblockThreadPlatformAdapter to GenericNoteThreadAdapter.
Changed method names and references to align with note thread functionality.
Updated import paths for note thread adapters in tests and utility functions.
Introduced new helper functions for extracting smart-chat codeblock ranges and sources.
Ensured compatibility with existing functionality while transitioning from chat codeblock to note thread structure.

refactor: enhance NoteThread save logic and error handling

Improved the save_to_codeblock method in NoteThread to handle pending writes and discard unassociated threads on failure.
Added tests for failed navigation markdown writes to ensure proper rollback behavior for newly created and existing NoteThreads.
Refactored chat codeblock parsing logic into a separate module for better organization and maintainability.
Removed deprecated insert_thread method from ChatCodeblock class.
Updated smart-chat thread reference resolution to prioritize source order.
Enhanced type definitions for NoteThread and related structures to improve clarity and maintainability.

resolved: webview shouldn't remain visible when "jumping" to place in note

refactor: canonicalize thread events and webview ownership

Standardized thread-scoped event identity on scalar thread_key, string thread_ref, scalar codeblock_key, and a plain local codeblock_thread_ref snapshot.
Removed class instances from thread event payloads.
Removed unused event aliases and duplicate success emission paths while preserving onboarding milestone event names.

Refactor chat platform adapters and tests to unify note thread handling

Updated GenericNoteThreadAdapter to extend NoteThreadTypeAdapter and added new properties for visibility and navigation policy.
Introduced normalization and resolution methods for URLs in the GenericNoteThreadAdapter.
Refactored tests to replace references from codeblock to note thread adapters, ensuring consistency in naming and functionality.
Removed obsolete codeblock threads tests and identity tests, consolidating functionality under note thread management.
Simplified menu helper functions to eliminate unnecessary environment fallbacks.
Enhanced URL handling in open_external_url utility to ensure proper normalization and validation of HTTP URLs.

feat: introduce NoteThread action result types and input handling

Added NoteThreadInput type definition for input request structure.
Defined NoteThreadActionStatus for standardized action statuses.
Created NoteThreadActionResult type for consistent return structure of actions.
Updated add_input method signatures in NoteThreadInstance and NoteThreadTypeAdapterInstance to use new types.
Implemented create_note_thread_action_result function for generating action results with validation.
Added tests for action result creation and validation to ensure correctness.
Refactored existing code to utilize new action result types and methods.
Renamed append_input method to insert_input in relevant areas for clarity.
Introduced NoteThreadInsertNoteModal for note selection and insertion functionality.

feat: integrate action_scope into chat codeblock actions and update related imports

feat: implement Cluade and Gemini input method with support for clipboard and text insertion

Updated: Smart Environment v3

Smart Chat Pro v2.2.0

Added one universal Smart Chat codeblock for supported provider and Smart Chat API Extension thread references.
Added stable codeblock and thread identities with improved note associations and thread-reference repair.
Added persistent Grow / contain and Collapse / expand controls.
Improved new-chat, active-thread, and completed-thread selection.
Added safer duplicate handling and rollback when a thread reference cannot be written to its note.
Improved provider-view loading, hidden-tab refresh, stalled-load recovery, pane movement, cleanup, hotkey forwarding, and click forwarding.
Added static thread rendering where interactive provider views are unsupported.
Added current-selection, current-note, clipboard, and custom-text insertion for supported provider workflows.
Updated Smart Chat Pro to Smart Environment Pro v3.2.0.

Smart Chat API Extension v1.6.0

Integrated API Extension threads into the universal note-thread system while preserving API-managed history and model state.
Added a shared drop path for supported Smart Plugin and Obsidian items.
Added drag and drop from the named-context list into API chat Context.
Added collision detection and rollback for new-thread creation.
Removed the retired v1 Context tree and aligned source selection with Smart Environment v3.
Updated Smart Chat API Extension to Smart Environment Pro v3.2.0.

Both thread types require Smart Environment v3.0.0 or newer.