feat!: Remove openassistant dependency - #423

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@examples/ai-agent/src/agents/WeatherAgent.ts`:
- Around line 13-16: The nested agent started inside the execute function isn't
receiving the caller's tool-call abortSignal, so parent cancellations don't stop
the inner stream; update the call that starts the inner Agent/session (the
nested Agent invocation used with processAgentStream) to pass
options?.abortSignal through (or combine it with the session-level controller
via AbortSignal.any([...]) if both signals must be honored) so the nested agent
and processAgentStream are aborted when the tool-call is cancelled.

In `@examples/ai-nextjs/src/app/lib/tools.ts`:
- Around line 7-35: Update the repo lint/rule that enforces tool authorship to
match the new tool shape used by tool({ inputSchema, ... }) with separate
renderers instead of the old parameters/component contract: change the rule that
currently requires tools to be "composable functions with name, parameters (Zod
schema), execute, and optional component" to accept the new signature used by
the tool factory (referenced by the tool helper and examples like webSearchTool
and weatherTool) so it validates a Zod schema provided as inputSchema (or
similar property name used by the tool factory), ensures an execute async
function exists, and allows separate renderer components to be defined elsewhere
rather than requiring a component property.

In `@packages/ai-config/src/migration/AnalysisSession-v0.26.0.ts`:
- Around line 65-71: The current presence check uses Array.isArray(d.uiMessages)
which treats explicit null/{} as missing; change it to a key-presence check so
explicit values are considered present: replace the hasUiMessages assignment
(currently referencing d.uiMessages) with a check like "'uiMessages' in d" and
keep hasToolState as-is (it already uses 'toolEditState'/'toolAdditionalData' in
d) so the return condition uses key-presence semantics for both.
- Around line 79-82: The migration is copying legacy toolAdditionalData into
toolEditState but leaves toolAdditionalData on the returned payload, causing
duplication; update the migration so after computing const toolEditState =
(session.toolEditState as UnknownRecord) ?? (session.toolAdditionalData as
UnknownRecord) ?? {} you remove/drop the deprecated toolAdditionalData key from
the object you return (e.g., build the new session by spreading ...session but
explicitly omit toolAdditionalData and set toolEditState), and apply the same
change for the second occurrence referenced around the 165–169 block so the
migrated object no longer contains toolAdditionalData.

In `@packages/ai-core/README.md`:
- Around line 17-21: Add a direct link to the 0.29.0 migration guide in the
README section describing createAiSlice so users can find the breaking-change
checklist; update the paragraph that lists createAiSlice requirements to include
a parenthetical or sentence pointing to the 0.29.0 migration guide and
explicitly mention the key renames/migrations (parameters -> inputSchema,
component -> toolRenderers, toolAdditionalData -> toolEditState) and the need to
adjust ToolSet/toolRenderers usage accordingly (referencing createAiSlice,
toolRenderers, toolAdditionalData, and toolEditState to make it easy to locate
relevant code).

In `@packages/ai-core/src/components/PromptSuggestions.tsx`:
- Around line 188-214: The Button inside TooltipTrigger in PromptSuggestions.tsx
currently uses the title prop which causes duplicate browser tooltips; remove
the title prop and add an aria-label instead that mirrors the tooltip text (use
the same conditional string based on isVisible: 'Hide prompt suggestions' or
'Show prompt suggestions') so the accessible label matches the Tooltip; update
the Button JSX (the element using toggleVisibility, variant="ghost",
size="icon", className={cn(...)} and rendering {icon ?? <Lightbulb ... />}) to
use aria-label rather than title.

In `@packages/ai-core/src/index.ts`:
- Line 8: The upgrade guide is missing a 0.29.0 migration section for
`@sqlrooms/ai-core` breaking changes; add a new "0.29.0 - `@sqlrooms/ai-core`"
subsection in upgrade-guide.md that lists concrete migration steps for clients:
describe switching to the new tool() API, the changed shape of inputSchema (and
how to map previous schemas to the new shape), the flattened tool results format
and how to transform prior nested results, updates to toolRenderers (what
props/signatures changed) and the rename of toolEditState (old name → new name),
and mention exported types AiSliceState and AiSliceOptions are part of the
public surface so consumers should check for API usage; keep each step terse
with example mappings and the old→new identifier references so consumers can
update code.

In `@packages/ai/package.json`:
- Line 30: Update the toModelOutput handler in
packages/ai/src/tools/query/queryTool.ts to accept a destructured parameter ({
output }) instead of (output), then adjust all internal uses to reference the
inner output via that name; additionally, make any calls to
convertToModelMessages() await its result (convertToModelMessages(...) -> await
convertToModelMessages(...)) since it is now async—apply these two changes (wrap
toModelOutput parameter and add await where convertToModelMessages is invoked)
across the file/related call sites so they comply with the ai v6 breaking
changes.

In `@packages/ai/src/tools/query/queryTool.ts`:
- Around line 45-47: The re-export "export {QueryToolResult as
queryToolRenderer}" in queryTool.ts creates a circular dependency with
QueryToolResult.tsx (which imports QueryToolOutput/QueryToolParameters from this
file); fix it by removing that re-export from queryTool.ts and placing it into a
separate module (e.g., create a new renderers file that exports QueryToolResult
as queryToolRenderer) or by adding the export to the package index instead,
ensuring QueryToolResult, queryToolRenderer, QueryToolOutput and
QueryToolParameters remain imported from their original modules without cyclic
imports.

In `@packages/ai/src/tools/query/QueryToolResult.tsx`:
- Around line 1-8: QueryToolResult.tsx currently imports QueryToolParameters and
QueryToolOutput from queryTool.ts which creates a circular dependency because
queryTool.ts imports renderer-side exports; extract the shared types into a new
module (e.g., queryToolTypes.ts) and update both QueryToolResult.tsx and
queryTool.ts to import QueryToolParameters and QueryToolOutput from that new
file, or alternatively move the renderer alias export out of queryTool.ts into
the renderer package so queryTool.ts no longer imports renderer code; ensure you
update all import sites (references to QueryToolParameters, QueryToolOutput, and
any renderer alias export) to the new shared module to break the cycle.
- Around line 66-71: The current code passes sqlQuery into DataTableModal
(props: title, query, tableModal, formatValue), which causes the modal to
re-execute the SQL; instead, change QueryToolResult to pass the persisted result
snapshot (serialized in Apache Arrow format) to DataTableModal (e.g., a prop
named resultArrow or rows) and remove the query prop so the modal renders the
original output without reissuing the statement; update DataTableModal to accept
and deserialize the Arrow payload from the browser <-> DuckDB connector and
render that snapshot (using Arrow utilities) rather than executing sqlQuery,
ensuring all browser/connector serialization uses Apache Arrow format.

---

Outside diff comments:
In `@examples/ai-core/package.json`:
- Around line 19-33: Update the devDependency for eslint-plugin-react-hooks in
package.json to a version compatible with ESLint 9 and React 19 (bump
"eslint-plugin-react-hooks" from "5.2.0" to "6.1.0" or newer); locate the
dependency entry `"eslint-plugin-react-hooks": "5.2.0"` and change its version
string to "^6.1.0" (or the latest 6.x patch) so the project uses a release that
supports ESLint 9 and avoids the deprecated 6.0.0 release.

In `@packages/ai-core/src/chatTransport.ts`:
- Around line 277-300: The code currently returns silently when a tool has no
renderer, leaving the tool call mapping and assistant tail open; update the
branch after computing hasToolRenderer to detect the absence of both a renderer
and an execute implementation (lookup the tool by toolName via your AI tool
registry accessor), then immediately clear the mapping with
state.ai.setToolCallSession(toolCallId, undefined), call addToolResult({ tool:
toolName, toolCallId, state: 'output-error', errorText: 'Tool has no execute()
or renderer' }) if addToolResult exists, and then throw a descriptive Error (or
otherwise reject) so the caller fails fast instead of returning no-op. Ensure
this logic sits where hasToolRenderer is checked (near state.ai.findToolRenderer
/ state.ai.waitForToolResult) so the toolCallId -> sessionId mapping is always
cleared.

---

Nitpick comments:
In `@examples/ai-nextjs/src/app/lib/tools.ts`:
- Around line 3-4: This module mixes server-only tools, client executors, and
React renderers causing cross-bundle leakage: split into three modules — a
server tools module exporting getServerAiSDKTools (containing server-only tool
logic like webSearch), a client tools/executors module exporting getClientTools
(containing browser-safe executors only), and a renderers module exporting UI
components/ToolRendererRegistry entries (e.g., WebSearchToolResult). Move
WebSearchToolResult and any UI/renderer registrations into the renderers module
and remove UI imports from the server module; update getClientTools and
getServerAiSDKTools to import only from their respective new modules so server
code never imports UI and browser bundles never import server-only code.

In `@examples/ai-rag/src/components/EchoToolResult.tsx`:
- Around line 4-9: EchoToolResult defines a local EchoToolOutput type that
duplicates the output shape returned by the echo tool's execute in the tool
definition; export the output type from the canonical tool module (the echo tool
in store.ts) and remove the local EchoToolOutput here, then import and use that
exported type in the EchoToolResult component signature
(FC<ToolRendererProps<...>>), ensuring both the tool's execute return type and
the renderer reference the same exported type.

In `@examples/app-builder/src/store/store.ts`:
- Around line 79-83: The code duplicates keys between the tools map and
toolRenderers (toolRenderers: { listFiles, getFileContent, updateFileContent }),
which can drift; instead create a single registry (e.g., an object or array)
that pairs each tool identifier with its implementation and renderer (reference
the existing symbols tools, toolRenderers, listFilesToolRenderer,
getFileContentToolRenderer, updateFileContentToolRenderer), then derive both the
tools map and the toolRenderers map from that registry so
adding/renaming/removing a tool only requires one change.

In `@packages/ai-core/src/agents/AgentUtils.ts`:
- Around line 43-66: Rename the AgentToolCallAdditionalData type and any
references to "additional data" to match the new toolEditState terminology and
make the stored payload names consistent with setToolEditState; specifically
rename the type AgentToolCallAdditionalData (and its doc comment) to something
like ToolEditState (or ToolEditStatePayload), update the JSDoc above
updateAgentToolCallData to reference toolEditState, and ensure
updateAgentToolCallData still calls state.ai.setToolEditState with the renamed
type and matching field names (agentToolCalls, finalOutput, timestamp) so the
API and types align.

In `@packages/ai-rag/src/createRagTool.tsx`:
- Around line 89-99: In RagToolResult, the destructured variables query and
database from output are unused; update the destructuring to only pull the
needed property (e.g., const {results} = output) or reference output.results
directly to remove the unused variables (modify the destructuring in the
RagToolResult component to eliminate query and database).
- Around line 164-173: The global store access via (globalThis as
any).__ROOM_STORE__ inside the execute function (signature: execute(params:
RagToolParameters): Promise<RagToolOutput>) is an intentional pattern required
by the AI SDK; please add a concise explanatory comment immediately above the
store lookup referencing __ROOM_STORE__, stating that AI tools are invoked by
the framework (not via DI), linking to the README/RAG_TOOL.md design, and
preserving the existing structured error return when the store is
missing—alternatively, if you prefer, replace the direct cast with a single
small helper (e.g., getRoomStore()) that wraps the globalThis access to
centralize the unsafe cast and document the rationale there.

In `@packages/vega/src/index.ts`:
- Line 22: Add a re-export for the renderer alias so consumers can import
vegaChartToolRenderer from the package barrel; update packages/vega/src/index.ts
to export the renderer symbol (vegaChartToolRenderer) from './VegaChartTool'
alongside the existing type exports (VegaChartToolOptions, VegaChartToolOutput)
so the package follows the new tool/renderer API convention.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@CLAUDE.md`:
- Around line 213-231: Update the retrieved learning to reflect the AI SDK
migration: replace the old description that says "AI tools must be composable
functions with `name`, `parameters` (Zod schema), `execute`, and optional
`component` properties" with the new SDK conventions—tools are created via the
`tool()` factory (not inline objects), use `inputSchema` (not `parameters`),
return a flat output shape from `execute` (no `llmResult`/`additionalData`
nesting), and register renderers separately via `toolRenderers` in
`createAiSlice` (instead of attaching a `component` to the tool); reference
examples like `tool()`, `inputSchema`, `execute`, `createAiSlice`, and
`createQueryTool` when updating the text.
- Line 226: The tools registration is incorrectly spreading the complete tool
object (myTool) into the tools object; instead register the tool itself — stop
using the spread operator with myTool in the tools initializer and add myTool as
a value (either as a keyed entry like myTool: myTool or by including myTool in
the tools collection/array), keeping createQueryTool(store) as the query entry;
update the object that currently reads tools: { query: createQueryTool(store),
...myTool } to register myTool directly so the tool() object (myTool) is treated
as one tool rather than its internal properties being spread.

In `@docs/upgrade-guide.md`:
- Around line 261-299: The docs currently tell server-side removals for
`data-tool-additional-output` but omit client-side cleanup; update the upgrade
guide to instruct removing any client `onChatData` handlers (e.g., in
chatTransport.ts) that await/branch on parts with type
`'data-tool-additional-output'` and calls like `setToolEditState`, since those
branches are now dead, and note that tool edit state is populated from
`ToolRendererProps.output` instead.

In `@examples/ai-agent/src/agents/WeatherAgent.ts`:
- Around line 29-38: The code is fetching a redundant session-based abort signal
(sessionAbortSignal via currentSession/getAbortController) which binds the Agent
to the currently focused session; remove the sessionAbortSignal logic and any
use of getAbortController/currentSession and instead pass only
options?.abortSignal (or undefined) into the Agent constructor's abortSignal;
update the Agent instantiation (symbol: Agent) to set abortSignal:
options?.abortSignal and remove the conditional combining logic so cancellation
is driven solely by the abort signal provided by tool.execute.

In `@packages/ai-config/src/migration/AnalysisSession-v0.26.0.ts`:
- Around line 68-71: The current check treats the deprecated key
toolAdditionalData as if the new structure exists, so update the detection logic
in AnalysisSession-v0.26.0 by making hasToolState only true when 'toolEditState'
is present (i.e., remove 'toolAdditionalData' from the hasToolState check) so
sessions that still only have toolAdditionalData will not skip the migration;
reference the symbols hasUiMessages, hasToolState, uiMessages,
toolAdditionalData and toolEditState when making this change.
- Around line 76-84: Destructuring removed toolAdditionalData from session but
the fallback for toolEditState still reads session.toolAdditionalData (now
undefined), losing legacy payload; update the toolEditState assignment to fall
back to the captured _legacyToolAdditionalData (i.e., use (session.toolEditState
as UnknownRecord) ?? (_legacyToolAdditionalData as UnknownRecord) ?? {}), or
merge both sources if needed, so legacy toolAdditionalData is preserved when
computing toolEditState.

In `@packages/ai/src/tools/query/queryTool.ts`:
- Around line 127-134: In execute() currently catching errors and returning a
failure result object, re-throw the caught error instead so callers/renderers
can detect and render error states; locate the catch block in the execute()
function (where it returns { success: false, details: ..., error: ..., title:
'Query Result', sqlQuery: params.sqlQuery }) and replace the return with throw
error (or wrap and throw a new Error with context) so failed or aborted queries
are not treated as successful tool results by QueryToolResult.jsx/tsx.

Verify each finding against the current code and only fix it if needed.

Outside diff comments:
In `@examples/ai-agent/src/agents/WeatherAgent.ts`:
- Around line 13-31: The execute function is using state.ai.getCurrentSession()
to pick provider and model, which causes the nested Agent to use the focused
session instead of the tool-call session; update execute to first resolve the
tool-call session via state.ai.getToolCallSession(options?.toolCallId) (falling
back to state.ai.getCurrentSession() if that returns undefined), and use that
session's modelProvider and model when constructing the
createOpenAICompatible(...) chatModel and new Agent(...) so the nested agent
runs with the tool-call session configuration.

---

Nitpick comments:
In `@examples/ai-agent/src/agents/WeatherAgent.ts`:
- Around line 70-75: The tool currently returns a JSON wrapper (success/details)
which Vercel AI SDK v5 will forward whole to the model; add a toModelOutput
method on the returned object so only the summary text is exposed to the model.
Locate the object returned in WeatherAgent (the block returning { success: true,
details: resultText }) and implement toModelOutput() { return { details:
resultText } } (or return just the summary string) so the model receives only
the summary field instead of the bookkeeping fields.

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@CLAUDE.md`:
- Around line 226-229: The example registers myTool in the tools object but
omits a corresponding entry in toolRenderers, leaving the example incomplete;
add a renderer entry for myTool inside toolRenderers (e.g., myTool:
MyToolRenderer) and ensure the referenced component (MyToolRenderer or
MyToolResult) is declared/imported and typed consistently (ToolRenderer<Output,
Input>) like QueryToolResult; alternatively, if you prefer to show renderers are
optional, add a short clarifying comment next to toolRenderers stating that
tools may omit a renderer if no custom UI is needed.