@digimuza/system-core 0.2.0-rc.2 → 0.3.0-rc.1

package/INTEGRATION.md

@@ -21,10 +21,16 @@ Pin the version per tenant app (`"@digimuza/system-core": "0.1.0"`, or `~0.1.0`)
 | `@digimuza/system-core/next` | Next.js server | `createSystemServerClient()` (session token, tracing, typed errors), `createAgentClient()`. |
 | `@digimuza/system-core/react` | Client components | `<SystemProvider>`, `useCan`, `useVisibleModules`, `useCurrentUser`, `useFeatureFlag`, `useRoleView`, `<Can>`. |
 | `@digimuza/system-core/finance` | Convex | The finance business module: `finance` manifest, `financeTables`, `defineFinance(system)` functions, `FinancePermissions`, `InvoiceView`. |
-| `@digimuza/system-core` | Any | `SystemError`, redaction, logger, tracer, shared types. |
+| `@digimuza/system-core/ai` | Convex + browser (types) | The AI assistant module: `ai` manifest, `aiTables`, `defineAi(system, options)` functions, `defineAiTool`, `defineAiAgent`, `executeAiTool`, views (`ThreadView`, `MessageView`, `AgentView`, …). No Mastra / AI SDK imports. Finance tools: `financeTools` from `./finance`. |
+| `@digimuza/system-core/ai/card` | Browser (no dependencies) | `cardDocument`, `AI_CARD_CSP`, `AI_CARD_THEME_VARS`, `AI_CARD_RESIZE_MESSAGE`: renders `ai.show_card` HTML in a sandboxed iframe. |
+| `@digimuza/system-core/ai/runner` | Convex Node runtime only (`"use node"`) | `defineAiRunner(options)` → `{ runAgent }`, the Mastra runner (OpenAI or any OpenAI-compatible Chat Completions API, e.g. 9Router). Needs the optional peers `@mastra/core`, `@ai-sdk/openai`, `ai`. |
+| `@digimuza/system-core/search` | Convex | Global search: `defineSearchProvider`, `defineSearch(system, { providers })` → `{ search }`, `SearchHit`, `SearchResult`. Finance provider: `financeSearch` from `./finance`. |
+| `@digimuza/system-core/notifications` | Convex + browser (types) | `notificationTables`, `notificationsHook()`, `defineNotifications(system, options)`, `notify`, `defineNotificationType`, views (`NotificationView`, `NotificationPreferenceView`). |
+| `@digimuza/system-core/audit` | Browser (no dependencies) | `auditToCsv`, `csvCell`, `AUDIT_CSV_COLUMNS`, `auditModuleOf`, audit types. |
+| `@digimuza/system-core` | Any | `SystemError`, redaction, logger, tracer, shared types, `auditToCsv`. |
 | `@digimuza/system-core/testing` | Tests | `MemoryStore` (same semantics as Convex, serializable transactions). |
 
-These seven subpaths, listed in `package.json#exports`, are the whole public surface. Deep imports
+These thirteen subpaths, listed in `package.json#exports`, are the whole public surface. Deep imports
 (`@digimuza/system-core/dist/...`) are not supported. Server and browser entries stay separate:
 `.`, `./modules` and `./react` never import `./config`, `./convex` or `./next`, and never read
 `process.env`. `npm run check:pack` enforces this in CI. Removing or renaming an entry or export,
@@ -86,7 +92,7 @@ export const {
   assignRoles, revokeRole, setDelegationScope,
   listInvites, getInvite, revokeInvite, createInvite, resendInvite, _createInvite, _resendInvite, _recordInviteDelivery,
   listMyApiKeys, setApiKeyRoles, revokeApiKey, createApiKey, rotateApiKey, _createApiKey, _rotateApiKey,
-  listFeatureFlags, setFeatureFlag, resetFeatureFlag, listAudit,
+  listFeatureFlags, setFeatureFlag, resetFeatureFlag, listAudit, listAuditFacets, recordAuditExport,
   roleViewStatus, startRoleView, stopRoleView,
 } = system.functions
 ```
@@ -121,6 +127,206 @@ Each function guards itself (permission, module enabled, role view), checks the
 object (existence, state transition), writes, and records an audit event in one
 transaction. The UI stays in the app.
 
+### AI assistant (`@digimuza/system-core/ai`)
+
+A reusable chat with an assistant that can call the app's business functions as
+tools, as the signed-in person and with that person's permissions. Threads,
+messages and runs live in Convex (live queries); a Node action runs the model
+(Mastra, OpenAI-compatible Chat Completions) and writes the answer back in small steps.
+
+Install (five files):
+
+```ts
+// convex/schema.ts
+import { aiTables } from "@digimuza/system-core/ai"
+export default defineSchema({ ...systemTables, ...financeTables, ...aiTables })
+
+// modules/index.ts (or wherever the app lists its modules for defineConvexSystem)
+import { ai } from "@digimuza/system-core/ai"
+export const appModules = [ai, finance /* , … */]
+
+// convex/aiConfig.ts: shared by ai.ts and aiRunner.ts, so NO "use node" here
+import { defineAiAgent, type AiOptions } from "@digimuza/system-core/ai"
+import { financeTools } from "@digimuza/system-core/finance"
+export const aiOptions: AiOptions = {
+  defaultModel: "cc/claude-haiku-4-5-20251001", // must exist on the provider (here 9Router)
+  agents: [defineAiAgent({ id: "assistant", name: "Assistant", description: "…", instructions: "…", tools: [...financeTools] })],
+}
+
+// convex/ai.ts
+import { defineAi } from "@digimuza/system-core/ai"
+import { aiOptions } from "./aiConfig"
+import { system } from "./system"
+export const { listAgents, listThreads, getThread, listMessages, createThread, sendMessage, stopRun, respondToToolCall, renameThread, archiveThread,
+  _startRun, _appendText, _addToolCall, _executeTool, _setToolCallState, _finishRun, _isStopRequested } = defineAi(system, aiOptions).functions
+
+// convex/aiRunner.ts
+"use node"
+import { defineAiRunner } from "@digimuza/system-core/ai/runner"
+import { aiOptions } from "./aiConfig"
+export const { runAgent } = defineAiRunner(aiOptions)
+```
+
+Add the runner's dependencies to the app (`@mastra/core`, `@ai-sdk/openai`, `ai`;
+optional peers of this package). Function names and file names are fixed by
+`AI_PUBLIC_FUNCTIONS`, `AI_INTERNAL_FUNCTIONS` and `AI_RUNNER_FUNCTION`; change
+the files with `functionsModule` / `runnerModule` in the options.
+
+Environment, on the **Convex deployment** (not in Next.js):
+
+| Variable | Required | Meaning |
+| - | - | - |
+| `OPENAI_API_KEY` | No | API key of the provider (OpenAI, or the 9Router key). Without it every answer ends with `UNAVAILABLE` "AI model is not configured". Never logged or returned. |
+| `OPENAI_BASE_URL` | No | Base URL of an OpenAI-compatible API, e.g. the 9Router proxy `https://router.digimuza.ai/v1`. Default: api.openai.com. Or pass `baseURL` to `defineAiRunner`. |
+| `AI_MODEL` | No | Overrides `defaultModel` for agents without their own `model`. Any string the provider accepts (router names like `cc/claude-haiku-4-5-20251001`). Read when a message is sent; the run keeps its model. |
+
+The runner uses the **Chat Completions API** (`POST <baseURL>/chat/completions`,
+streaming, tools), not OpenAI's Responses API, so any OpenAI-compatible proxy works.
+Model ids are plain strings and must exist on that provider. Tool ids are sent as
+function names with dots replaced by underscores (`finance.list_invoices` →
+`finance_list_invoices`). Runner options: `openAiApiKey`, `baseURL`, `fetch`
+(request middleware / tests) and the test hook `model`.
+
+**Permissions.** `ai` is a business module: it registers disabled and a Super
+enables it. `ai:chat:use` (subrole `ai:user`) lets a person chat and see their own
+threads; nobody, Super included, sees someone else's thread (NOT_FOUND). The chat
+is human-only (API keys get FORBIDDEN). What the assistant may *do* is decided per
+tool by the tool's own permission: the model is only offered the tools the actor
+holds right now, `listAgents` shows only those, and every call is re-authorized
+with `authorizeJob` (module enabled, role view, suspended user…) just before it runs.
+
+**Writing a tool.** A module exposes its actions with `defineAiTool`, next to the
+module's own functions (see `src/finance/ai-tools.ts`):
+
+```ts
+export const crmListLeadsTool = defineAiTool({
+  id: "crm.list_leads",                 // module.verb_object
+  description: "Lists leads, newest first.",  // for the model: what and when
+  permission: "crm:lead:read",          // the module's own permission
+  input: z.object({ limit: z.number().int().min(1).max(50).optional() }),
+  handler: async ({ db, sys, actor }, input) => listLeadViews(db, input), // JSON result
+})
+```
+
+Rules:
+
+- `permission` is the owning module's own permission; never `ai:chat:use`.
+- Anything that writes sets `requiresApproval: true`.
+- Reuse the module's shared operations (the same code the module's Convex
+  functions call) so the business rules and audit events are identical.
+- **Validate everything before the first write.** The handler runs inside the
+  `_executeTool` mutation. A failure (thrown `SystemError` or anything else) is
+  returned to the model as `{ ok: false, code }`, not thrown, so the `ai.tool.run`
+  audit event is kept. The consequence: writes the handler made before it failed
+  are committed too. Check existence, state, uniqueness and limits first, then
+  write once (the finance tools do).
+- Throw `SystemError` (`notFound`, `conflict`, …) for expected failures; the code
+  reaches the model and the UI, the details do not.
+
+**Approvals.** A `requiresApproval` call is stored as `awaiting-approval`, the run
+parks (`waiting-approval`) and the UI shows the call with its arguments.
+`respondToToolCall({ messageId, toolCallId, approve })` records the answer
+(audit `ai.tool.approve` / `ai.tool.reject`); a second answer for the same call is
+CONFLICT. When nothing is pending the run is queued again and the runner executes
+approved calls and tells the model about rejected ones. `stopRun` rejects pending
+calls. `_executeTool` refuses an approval-gated call that is not approved.
+
+**Errors.** A failed answer has `MessageView.error = { code, message, operationId }`;
+`operationId` is the run's, show it so support can find the logs.
+
+**Audit actions.** `ai.thread.create`, `ai.message.send`, `ai.tool.run` (success,
+failed or denied, with the tool call id), `ai.tool.approve`, `ai.tool.reject`,
+`ai.run.stop`, plus the business module's own events from the tool handler
+(e.g. `finance.invoice.create`).
+
+Cost: the provider bills per token; every message sends the whole thread history.
+
+#### HTML cards (`ai.show_card`)
+
+`displayTools` adds `ai.show_card` (permission `ai:chat:use`, no approval, no data access): the model sends
+`{ title?, html }` and the chat shows it as a card. Add it to an agent with `tools: [...financeTools, ...displayTools]`.
+
+The HTML is model output, so treat it as untrusted (prompt injection can reach it through tool results). Render it
+**only** as `<iframe sandbox="allow-scripts" srcDoc={cardDocument({ html, id, theme, dark })}>` (import from `@digimuza/system-core/ai/card` in client code), never with
+`allow-same-origin`. `cardDocument` puts `AI_CARD_CSP` first (inline styles/scripts only, `img-src data:`, no
+network, fonts, frames or forms), passes the app's theme variables (`AI_CARD_THEME_VARS`), and posts the content
+height to the parent as `{ type: AI_CARD_RESIZE_MESSAGE, id, height }`; accept it only from that iframe's window and
+clamp it.
+
+### Global search (`@digimuza/system-core/search`)
+
+```ts
+// convex/search.ts
+import { defineSearch } from "@digimuza/system-core/search"
+import { financeSearch } from "@digimuza/system-core/finance"
+import { system } from "./system"
+export const { search } = defineSearch(system, { providers: [financeSearch] }).functions
+```
+
+`search({ query, limit? })` → `{ query, groups: [{ providerId, moduleId, label, hits: SearchHit[] }], total }`,
+`SearchHit = { providerId, id, title, subtitle?, href, kind? }`. Human sessions only (API key: FORBIDDEN). The query is
+trimmed (whitespace collapsed) and must be 2–100 characters (else VALIDATION, `fields: ["query"]`). `limit` is hits per
+provider (default 5, max 20), at most 50 in total. A provider runs only when its module is enabled (or the caller is an
+effective Super) and `decide` allows its permission now, so role view applies. Hits with an href that is not app-relative
+(`/…`, not `//…`) are dropped; a provider that throws is skipped and logged (the query is never logged). Reads are not audited.
+
+A module adds a provider with `defineSearchProvider({ id: "crm.leads", moduleId: "crm", label, permission: "crm:lead:read",
+search: async ({ db, sys, actor }, { query, limit }) => hits })`. `financeSearch` (`finance:invoice:read`) matches invoice
+numbers by prefix (`by_number`) and customers by full text (new search index `search_customer` on `invoices`, schema
+compatible), href `/app/finance?invoice=<number>`.
+
+### Audit filters and CSV export
+
+`listAudit` also takes `moduleId` (`finance` matches `finance.*`; core actions map to their system module, e.g.
+`role.assign` → `roles`, see `auditModuleOf`) and `actionPrefix`. `listAuditFacets()` (same permission
+`audit:event:read`) → `{ actions, moduleIds, scanned, complete }` of the newest 1000 events. For a CSV the UI pages
+through `listAudit`, calls `auditToCsv(items, { bom: true })` (from `@digimuza/system-core/audit`; RFC 4180, CRLF,
+columns `at, action, result, actor, apiKey, target, operationId, details`, cells starting with `= + - @ tab CR` get a
+leading `'`) and then `recordAuditExport({ filter, count })` (audit action `audit.export`). AI events already carry what
+the UI needs: `ai.tool.run` has `targetId` = tool id, `result`, `reason` = error code, `changes.toolCallId`;
+`ai.tool.approve/reject` have `targetId` = tool call id and `changes: { runId, toolName }`.
+
+### Notifications (`@digimuza/system-core/notifications`)
+
+```ts
+// convex/schema.ts
+import { notificationTables } from "@digimuza/system-core/notifications"
+export default defineSchema({ ...systemTables, ...financeTables, ...notificationTables })
+
+// convex/system.ts: the hook makes every mutation's SystemContext able to notify
+import { notificationsHook } from "@digimuza/system-core/notifications"
+export const system = defineConvexSystem({ modules, notifications: notificationsHook() })
+
+// convex/notifications.ts
+import { defineNotifications } from "@digimuza/system-core/notifications"
+export const {
+  listNotifications, unreadNotificationCount, markNotificationRead, markAllNotificationsRead,
+  getNotificationPreferences, setNotificationPreference,
+  _deliverNotificationEmail, _claimNotificationEmail, _recordNotificationEmail,
+} = defineNotifications(system, {
+  renderEmail: (type, params, locale, { href }) => ({ subject: "…", text: `… ${process.env.SITE_URL}${href ?? ""}` }),
+  deliverEmail: async ({ to, subject, text, operationId }) => { /* Resend, SMTP …; throw on failure */ },
+}).functions
+```
+
+`notificationsHook({ functionsModule?: "notifications", email?: true, types?: [], defaultLocale?: "lt" })`. Set
+`email: false` when the app has no email adapter. Without `renderEmail`/`deliverEmail` email rows become `skipped`.
+`SITE_URL` (Convex env) is read by the app's adapter, not by core. Delivery runs in the default Convex runtime (fetch
+works); a failure marks the row `failed` and never throws.
+
+Types are declared on module manifests (`notificationTypes: [defineNotificationType({ id, moduleId, defaultChannels,
+description?, params? })]`), so the system knows them in every Convex file. Built in: `roles.role_assigned`
+(`{ roleNames }`, sent by `assignRoles`) and `finance.invoice_awaiting_approval` (`{ number, customer, amountCents,
+currency }`, href `/app/finance?invoice=<number>`, sent to holders of `finance:invoice:approve` except the creator).
+Both are no-ops when the hook is not installed.
+
+A module notifies from a mutation with `notify(ctx, sys, { to: { userIds } | { permission }, type, params, href?,
+actor?, includeActor? })`; it returns the number of recipients (at most 100). `to.permission` resolves active users who
+hold it now through `decide` and leaves out the acting user (an agent's owner). Each recipient's preference applies:
+both channels off means no row, in-app off gives an email-only row that is never listed. Access is own data, like the
+profile: a human session plus `profile:own:read` / `profile:own:update`, which every active user holds through the
+implicit Profile role.
+
 ### View as role (Super)
 
 A real Super (verified email in `SUPER_USER_EMAILS`) can preview the system as

package/README.md

@@ -19,6 +19,9 @@ Pirmoji versija platinama vienu versijuojamu NPM paketu su atskirais importo kel
 | Convex aplikacija | `@digimuza/system-core/convex` | Sistemos registraciją, užklausų ir mutacijų pagalbines funkcijas, teisių patikrą |
 | Next.js serveris | `@digimuza/system-core/next` | Autentifikuotos sesijos perdavimą ir tipizuotą kreipimąsi į Convex |
 | Next.js kliento komponentai | `@digimuza/system-core/react` | Dabartinio vartotojo, matomų modulių ir leidžiamų veiksmų duomenis kliento kuriamam UI |
+| Paieška | `@digimuza/system-core/search` | Modulių paieškos tiekėjus ir bendrą `search` užklausą |
+| Pranešimai | `@digimuza/system-core/notifications` | Pranešimų lenteles, tipus, `notify` ir vartotojo funkcijas |
+| Audito eksportas | `@digimuza/system-core/audit` | Naršyklei saugų `auditToCsv` |
 
 Šie pavadinimai yra projektuojama v1 sutartis. Paleidimo konfigūracija, Infisical klientas ir paslaptys pasiekiami tik serverio importuose. Kliento komponentų importavimas neturi reikalauti serverio aplinkos kintamųjų.
 
@@ -98,6 +101,26 @@ Tikras `Super` (patvirtintas el. paštas `SUPER_USER_EMAILS` sąraše) gali laik
 
 `@digimuza/system-core/finance` yra pirmasis pakartotinai naudojamas verslo modulis: manifestas, `financeTables`, `defineFinance(system)` funkcijos ir teisės. Aplikacija tik įtraukia lenteles į schemą ir eksportuoja funkcijas; vartotojo sąsaja lieka aplikacijoje.
 
+# AI asistentas
+
+`@digimuza/system-core/ai` yra verslo modulis `ai`: pokalbis su asistentu, kuris gali naudoti aplikacijos funkcijas kaip įrankius. Asistentas veikia prisijungusio žmogaus vardu ir tik su jo teisėmis. Modulis registruojamas išjungtas; jį įjungia `Super`.
+
+1. `ai:chat:use` (subrolė `ai:user`) leidžia kalbėtis su asistentu ir matyti tik savo pokalbius. Kito žmogaus pokalbio nemato niekas, ir `Super` taip pat. API raktai kalbėtis negali.
+2. Ką asistentas gali *daryti*, lemia kiekvieno įrankio teisė (pvz. `finance:invoice:read`). Modeliui siūlomi tik tie įrankiai, kurių teisę veikėjas turi dabar, o prieš kiekvieną kvietimą teisė tikrinama iš naujo. Asistentas neturi savo rolių: atėmus rolę, kitas įrankio kvietimas atmetamas (`FORBIDDEN`), o `Super`, peržiūrintis kaip rolė, asistentu gali tik tai, ką gali ta rolė.
+3. Įrankį apibrėžia modulis su `defineAiTool`: teisė yra paties modulio teisė, rašantys veiksmai reikalauja žmogaus patvirtinimo (`requiresApproval`), o tvarkyklė viską patikrina prieš pirmą įrašymą, nes nepavykusios tvarkyklės ankstesni įrašai lieka.
+4. Kiekvienas įrankio kvietimas, patvirtinimas ir atmetimas įrašomas į auditą. Nepavykęs atsakymas rodo klaidos kodą ir `operationId`.
+5. Modelis kviečiamas Convex Node veiksme (Mastra, OpenAI suderinamas Chat Completions API). `OPENAI_BASE_URL` nurodo tarpinį serverį (pvz. 9Router `https://router.digimuza.ai/v1`), `OPENAI_API_KEY` yra jo raktas, `AI_MODEL` yra jame esantis modelio pavadinimas. Be `OPENAI_API_KEY` asistentas atsako, kad nesukonfigūruotas. Naudojimas apmokamas pagal žetonus.
+
+Įdiegimo žingsniai ir įrankio pavyzdys: `INTEGRATION.md`, skyrius „AI assistant“.
+
+# Paieška, auditas ir pranešimai
+
+`@digimuza/system-core/search`: viena paieška per visus modulius. Kiekvienas modulis pateikia tiekėją su savo teise. Užklausa vykdoma tik tiems tiekėjams, kurių modulis įjungtas ir kurių teisę žmogus turi dabar (`Super`, peržiūrintis kaip rolė, gauna tos rolės rezultatus). Užklausa yra 2–100 simbolių, rezultatų skaičius ribojamas. API raktai paieškos nenaudoja. Skaitymas į auditą neįrašomas.
+
+Auditą galima filtruoti pagal modulį ir veiksmo prefiksą. `listAuditFacets` grąžina esamus veiksmus ir modulius filtrams. CSV eksportą sudaro naršyklėje `auditToCsv` (RFC 4180, apsauga nuo formulių įterpimo), o pats eksportas įrašomas į auditą (`audit.export`).
+
+`@digimuza/system-core/notifications` yra bendras pranešimų pagrindas. Branduolys saugo tipą ir JSON parametrus, o tekstą (LT/EN, UI ir el. laiške) kuria aplikacija. Gavėjai nurodomi vartotojų ID arba teise; teisės turėtojai nustatomi tuo metu galiojančiu prieigos sprendimu, veiksmo autorius praleidžiamas. Kiekvienas vartotojas mato ir tvarko tik savo pranešimus ir nustatymus (kaip profilį). El. laiškus siunčia aplikacijos adapteris; nepavykęs siuntimas pažymimas `failed` ir verslo operacijos nesugadina. Pranešimai siunčiami priskyrus roles ir sukūrus sąskaitą, kurią reikia patvirtinti; be įdiegtų pranešimų šie veiksmai veikia kaip anksčiau.
+
 # Rolės ir modulio registracija
 
 Vienintelė įmonės valdomų suteikimų grandinė yra gavėjas → rolė → subrolė → teisė. Gavėjas yra vartotojas arba agento API raktas. Kiekviename lygyje leidžiama turėti kelias sąsajas. Viena subrolė priklauso vienam moduliui. Rolė gali sujungti kelių modulių subroles. Tiesioginis subrolės ar teisės suteikimas gavėjui yra neleistina operacija.

package/dist/ai/api.d.ts

@@ -0,0 +1,120 @@
+import { type ConvexSystem } from "../convex/functions.js";
+import { type AgentView, type AiMessageId, type AiOptions, type AiRunId, type AiThreadId, type MessageView, type RunContext, type ThreadView, type ToolExecutionResult } from "./contract.js";
+export declare const AI_MESSAGE_MAX = 8000;
+export declare const AI_TITLE_MAX = 120;
+/**
+ * The AI module's Convex functions, bound to the app's system:
+ *   // convex/ai.ts
+ *   export const { listAgents, listThreads, …, _startRun, … } = defineAi(system, aiOptions).functions
+ * Names: AI_PUBLIC_FUNCTIONS + AI_INTERNAL_FUNCTIONS in contract.ts.
+ */
+export declare function defineAi(system: ConvexSystem, options: AiOptions): {
+    functions: {
+        listAgents: import("convex/server").RegisteredQuery<"public", {
+            apiKey?: string | undefined;
+            operationId?: string | undefined;
+        }, Promise<AgentView[]>>;
+        listThreads: import("convex/server").RegisteredQuery<"public", {
+            apiKey?: string | undefined;
+            cursor?: string | null | undefined;
+            limit?: number | undefined;
+            operationId?: string | undefined;
+        }, Promise<{
+            items: ThreadView[];
+            cursor: string | null;
+            done: boolean;
+        }>>;
+        getThread: import("convex/server").RegisteredQuery<"public", {
+            apiKey?: string | undefined;
+            operationId?: string | undefined;
+            threadId: import("convex/values").GenericId<"aiThreads">;
+        }, Promise<ThreadView>>;
+        listMessages: import("convex/server").RegisteredQuery<"public", {
+            apiKey?: string | undefined;
+            operationId?: string | undefined;
+            threadId: import("convex/values").GenericId<"aiThreads">;
+        }, Promise<MessageView[]>>;
+        createThread: import("convex/server").RegisteredMutation<"public", {
+            agentId?: string | undefined;
+            apiKey?: string | undefined;
+            operationId?: string | undefined;
+            title?: string | undefined;
+        }, Promise<{
+            threadId: AiThreadId;
+        }>>;
+        sendMessage: import("convex/server").RegisteredMutation<"public", {
+            apiKey?: string | undefined;
+            operationId?: string | undefined;
+            text: string;
+            threadId: import("convex/values").GenericId<"aiThreads">;
+        }, Promise<{
+            messageId: AiMessageId;
+            runId: AiRunId;
+        }>>;
+        stopRun: import("convex/server").RegisteredMutation<"public", {
+            apiKey?: string | undefined;
+            operationId?: string | undefined;
+            threadId: import("convex/values").GenericId<"aiThreads">;
+        }, Promise<{
+            stopped: boolean;
+        }>>;
+        respondToToolCall: import("convex/server").RegisteredMutation<"public", {
+            apiKey?: string | undefined;
+            approve: boolean;
+            messageId: import("convex/values").GenericId<"aiMessages">;
+            operationId?: string | undefined;
+            toolCallId: string;
+        }, Promise<{
+            runId: AiRunId;
+        }>>;
+        renameThread: import("convex/server").RegisteredMutation<"public", {
+            apiKey?: string | undefined;
+            operationId?: string | undefined;
+            threadId: import("convex/values").GenericId<"aiThreads">;
+            title: string;
+        }, Promise<null>>;
+        archiveThread: import("convex/server").RegisteredMutation<"public", {
+            apiKey?: string | undefined;
+            operationId?: string | undefined;
+            threadId: import("convex/values").GenericId<"aiThreads">;
+        }, Promise<null>>;
+        _startRun: import("convex/server").RegisteredMutation<"internal", {
+            runId: import("convex/values").GenericId<"aiRuns">;
+        }, Promise<RunContext | null>>;
+        _appendText: import("convex/server").RegisteredMutation<"internal", {
+            messageId: import("convex/values").GenericId<"aiMessages">;
+            text: string;
+        }, Promise<null>>;
+        _addToolCall: import("convex/server").RegisteredMutation<"internal", {
+            args: any;
+            messageId: import("convex/values").GenericId<"aiMessages">;
+            state: "approved" | "awaiting-approval" | "done" | "error" | "rejected" | "running";
+            toolCallId: string;
+            toolName: string;
+        }, Promise<null>>;
+        _setToolCallState: import("convex/server").RegisteredMutation<"internal", {
+            error?: string | undefined;
+            messageId: import("convex/values").GenericId<"aiMessages">;
+            result?: any;
+            state: "approved" | "awaiting-approval" | "done" | "error" | "rejected" | "running";
+            toolCallId: string;
+        }, Promise<null>>;
+        _executeTool: import("convex/server").RegisteredMutation<"internal", {
+            runId: import("convex/values").GenericId<"aiRuns">;
+            toolCallId: string;
+        }, Promise<ToolExecutionResult>>;
+        _finishRun: import("convex/server").RegisteredMutation<"internal", {
+            error?: {
+                code: string;
+                message: string;
+            } | undefined;
+            runId: import("convex/values").GenericId<"aiRuns">;
+            status: "done" | "error" | "stopped" | "waiting-approval";
+        }, Promise<null>>;
+        _isStopRequested: import("convex/server").RegisteredQuery<"internal", {
+            runId: import("convex/values").GenericId<"aiRuns">;
+        }, Promise<boolean>>;
+    };
+};
+export type AiSystem = ReturnType<typeof defineAi>;
+//# sourceMappingURL=api.d.ts.map

package/dist/ai/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/ai/api.ts"],"names":[],"mappings":"AAWA,OAAO,EAAiB,KAAK,YAAY,EAAc,MAAM,wBAAwB,CAAA;AACrF,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,OAAO,EACZ,KAAK,UAAU,EAGf,KAAK,WAAW,EAChB,KAAK,UAAU,EAGf,KAAK,UAAU,EAEf,KAAK,mBAAmB,EAEzB,MAAM,eAAe,CAAA;AAItB,eAAO,MAAM,cAAc,OAAO,CAAA;AAClC,eAAO,MAAM,YAAY,MAAM,CAAA;AA8G/B;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,SAAS;;;;;;;;;;;;mBAqFjB,UAAU,EAAE;oBAAU,MAAM,GAAG,IAAI;kBAAQ,OAAO;;;;;;;;;;;;;;;;;;sBAoC/C,UAAU;;;;;;;;uBAeT,WAAW;mBAAS,OAAO;;;;;;;qBAmC7B,OAAO;;;;;;;;;mBAoBT,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8LtD;AAED,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAA"}