@7n/tauri-components 0.13.10 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.14.0] - 2026-07-21
+
+### Added
+
+- AgentDialog: інкрементальний стрімінг відповіді (текст/tool-call з'являються по мірі надходження session/update-чанків, а не лише після завершення всього ходу). AuditDialog: коректно показує нативні ACP permission-request поряд з MCP tool-call approval в одному списку.
+
+## [0.13.11] - 2026-07-21
+
+### Changed
+
+- hk.pkl gen-types тепер реально генерує декларації для всього npm/src (раніше npm/npm/src/**/*.js через дублювання dir-префікса в glob ніколи не матчився — типи для components/vue/testing взагалі не генерувались); exports у package.json отримали types-умову для ./vue, ./components, ./testing (раніше лише "." мав types)
+
 ## [0.13.10] - 2026-07-21
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/tauri-components",
-  "version": "0.13.10",
+  "version": "0.14.0",
   "type": "module",
   "description": "Shared LLM agent engine + Vue/Quasar UI for Tauri apps (chat, journal, trust-tier approval).",
   "license": "MIT",
@@ -18,9 +18,18 @@
       "types": "./types/index.d.ts",
       "default": "./src/index.js"
     },
-    "./vue": "./src/vue/index.js",
-    "./components": "./src/components/index.js",
-    "./testing": "./src/testing/index.js"
+    "./vue": {
+      "types": "./types/vue/index.d.ts",
+      "default": "./src/vue/index.js"
+    },
+    "./components": {
+      "types": "./types/components/index.d.ts",
+      "default": "./src/components/index.js"
+    },
+    "./testing": {
+      "types": "./types/testing/index.d.ts",
+      "default": "./src/testing/index.js"
+    }
   },
   "files": [
     "src",

package/src/components/AgentDialog.vue

@@ -142,12 +142,14 @@ async function scrollToEnd() {
 }
 
 /**
- * Append an agent turn, latch the conversation id, refresh the graph on writes.
+ * Fill in the live turn with the final result, latch the conversation id,
+ * refresh the graph on writes.
  * @param {object} outcome structured result from request/respond
+ * @param {object} turn the live turn pushed at the start of send(), updated in place
  */
-function apply(outcome) {
+function apply(outcome, turn) {
   if (outcome.requestId) requestId.value = outcome.requestId
-  turns.value.push({ role: 'agent', result: outcome, agentLabel: activeAgentLabel.value })
+  turn.result = outcome
   if (outcome.actions?.some(action => action.envelope?.ok)) emit('ran')
   scrollToEnd()
 }
@@ -202,17 +204,33 @@ async function send() {
   }
   prompt.value = ''
   turns.value.push({ role: 'user', text })
+  // Only a fresh request() actually spawns with the currently-selected
+  // agent/tier — a respond() keeps talking to whatever the conversation
+  // already started with, so the label must not move mid-conversation.
+  if (!requestId.value) {
+    activeAgentLabel.value = currentAgentLabel()
+    activeSpawnKey.value = currentSpawnKey()
+  }
+  // Pushed before the call resolves and updated in place as session/update
+  // chunks stream in (onChunk below), so the reply grows live instead of
+  // only appearing once the whole turn finishes.
+  const liveTurn = {
+    role: 'agent',
+    agentLabel: activeAgentLabel.value,
+    result: { status: 'running', summary: '', actions: [], question: null, pendingApproval: null }
+  }
+  turns.value.push(liveTurn)
   scrollToEnd()
   running.value = true
   try {
-    // Only a fresh request() actually spawns with the currently-selected
-    // agent/tier — a respond() keeps talking to whatever the conversation
-    // already started with, so the label must not move mid-conversation.
-    if (!requestId.value) {
-      activeAgentLabel.value = currentAgentLabel()
-      activeSpawnKey.value = currentSpawnKey()
+    const onChunk = ({ text: liveText, actions }) => {
+      liveTurn.result = { ...liveTurn.result, summary: liveText, actions }
+      scrollToEnd()
     }
-    apply(await (requestId.value ? respond(requestId.value, payload) : request(payload)))
+    const outcome = await (requestId.value
+      ? respond(requestId.value, payload, { onChunk })
+      : request(payload, { onChunk }))
+    apply(outcome, liveTurn)
   } catch (error) {
     $q.notify({ type: 'negative', message: String(error?.message ?? error) })
   } finally {

package/src/components/AuditDialog.vue

@@ -25,7 +25,11 @@
       <div v-if="expandedId === rec.id" class="audit-body">
         <RequestView @respond="msg => onRespond(rec, msg)" :result="rec" :busy="busyId === rec.id" />
         <div v-if="rec.status === 'needs_approval' && rec.pendingApproval" class="audit-approval">
-          <div class="audit-pending">
+          <div v-if="rec.pendingApproval.kind === 'acp'" class="audit-pending">
+            Permission request:
+            <code>{{ rec.pendingApproval.toolCall?.title ?? rec.pendingApproval.toolCall?.toolCallId }}</code>
+          </div>
+          <div v-else class="audit-pending">
             Approve action: <code>{{ rec.pendingApproval.tool }}({{ JSON.stringify(rec.pendingApproval.input) }})</code>
           </div>
           <div class="row q-gutter-sm">

package/src/components/docs/AgentDialog.md

@@ -3,7 +3,7 @@ type: Vue Component
 title: AgentDialog.vue
 resource: npm/src/components/AgentDialog.vue
 docgen:
-  crc: 9ff2a698
+  crc: 6be89ae5
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
 ---
 

package/src/components/docs/AuditDialog.md

@@ -3,7 +3,7 @@ type: Vue Component
 title: AuditDialog.vue
 resource: npm/src/components/AuditDialog.vue
 docgen:
-  crc: 8c440daf
+  crc: c716181c
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
 ---
 

package/src/core/acp-agent.js

@@ -101,7 +101,7 @@ function applySessionUpdate(state, update) {
  * @param {object} params turn parameters
  * @param {string} params.sessionKey handle from `createAcpSession`
  * @param {string} params.text prompt text for this turn
- * @param {(update: object) => void} [params.onChunk] optional live callback for each raw session/update (UI streaming)
+ * @param {(snapshot: {text: string, actions: {tool: string, input: object, envelope: object|null}[]}) => void} [params.onChunk] optional live callback with the turn's accumulated text/tool-calls so far, fired on every session/update (UI streaming)
  * @returns {Promise<{content: string, steps: number, trace: object[], messages: object[], stopped?: string}>} runAgent()-shaped result
  */
 export async function runAcpTurn({ sessionKey, text, onChunk }) {
@@ -110,7 +110,7 @@ export async function runAcpTurn({ sessionKey, text, onChunk }) {
   const unlisten = await listen('acp://session-update', event => {
     if (event.payload?.sessionKey !== sessionKey) return
     applySessionUpdate(state, event.payload.update)
-    onChunk?.(event.payload.update)
+    onChunk?.({ text: state.text, actions: state.calls.values().toArray() })
   })
 
   try {

package/src/core/acp-kit.js

@@ -175,10 +175,10 @@ export function createAcpAgentKit({
     /**
      * Start a new ACP-backed request: spawns the agent session and runs the
      * first prompt turn.
-     * @param {{intent: string, agent: object}} opts `agent` is passed straight to `createAcpSession` (agentKind/command/args/env/cwd/…)
+     * @param {{intent: string, agent: object, onChunk?: (snapshot: {text: string, actions: object[]}) => void}} opts `agent` is passed straight to `createAcpSession` (agentKind/command/args/env/cwd/…); `onChunk` streams live text/tool-calls as the turn runs
      * @returns {Promise<object>} structured result envelope
      */
-    async request({ intent, agent }) {
+    async request({ intent, agent, onChunk }) {
       await ensureListening()
       const id = await journal.create({ intent, actor: AGENT_ACTOR })
       await journal.update(id, { status: 'running' })
@@ -191,15 +191,15 @@ export function createAcpAgentKit({
       activeSessionKey = session.sessionKey
       activeRequestId = id
       await journal.update(id, { acp: { agentKind: session.agentKind, sessionKey: session.sessionKey } })
-      return runAndJournal(id, [], deps.runAcpTurn({ sessionKey: activeSessionKey, text: intent }))
+      return runAndJournal(id, [], deps.runAcpTurn({ sessionKey: activeSessionKey, text: intent, onChunk }))
     },
 
     /**
      * Continue the active session with a follow-up message.
-     * @param {{requestId: string, message: string}} opts resume parameters
+     * @param {{requestId: string, message: string, onChunk?: (snapshot: {text: string, actions: object[]}) => void}} opts resume parameters; `onChunk` streams live text/tool-calls as the turn runs
      * @returns {Promise<object>} updated result envelope
      */
-    async respond({ requestId, message }) {
+    async respond({ requestId, message, onChunk }) {
       if (!activeSessionKey) {
         return {
           requestId,
@@ -228,7 +228,7 @@ export function createAcpAgentKit({
       return runAndJournal(
         requestId,
         record.actions ?? [],
-        deps.runAcpTurn({ sessionKey: activeSessionKey, text: message })
+        deps.runAcpTurn({ sessionKey: activeSessionKey, text: message, onChunk })
       )
     },
 

package/src/core/docs/acp-agent.md

@@ -3,7 +3,7 @@ type: JS Module
 title: acp-agent.js
 resource: npm/src/core/acp-agent.js
 docgen:
-  crc: a9f48a2c
+  crc: 8fd9fdb8
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
   issues: judge:inaccurate:0.98

package/src/core/docs/acp-kit.md

@@ -3,7 +3,7 @@ type: JS Module
 title: acp-kit.js
 resource: npm/src/core/acp-kit.js
 docgen:
-  crc: e42fda83
+  crc: 0c38d95b
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
   judgeModel: openai-codex/gpt-5.4-mini

package/src/core/scope.js

@@ -22,7 +22,7 @@ export function classify(catalog, actorTiers, actor, toolName) {
   const tiers = actorTiers ?? DEFAULT_ACTOR_TIERS
   const tool = getTool(catalog, toolName)
   if (!tool) return 'deny'
-  const rank = TIER_RANK[tool.tier] ?? Number.POSITIVE_INFINITY
+  const rank = TIER_RANK[tool.tier] ?? Infinity
   const max = tiers[actor?.kind] ?? 0
   if (rank <= max) return 'allow'
   if (tool.tier === 'destructive' && actor?.kind === 'agent') return 'approval'

package/src/vue/docs/use-acp-agent.md

@@ -3,7 +3,7 @@ type: JS Module
 title: use-acp-agent.js
 resource: npm/src/vue/use-acp-agent.js
 docgen:
-  crc: e5d5b271
+  crc: 42706f67
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
   issues: judge:inaccurate:0.97

package/src/vue/use-acp-agent.js

@@ -114,14 +114,20 @@ export function useAcpAgent({
     journal,
     /**
      * @param {string} intent user prompt
-     * @param {{modelTier?: string}} [opts] per-call overrides
+     * @param {{modelTier?: string, onChunk?: (snapshot: {text: string, actions: object[]}) => void}} [opts] per-call overrides; `onChunk` streams live text/tool-calls as the turn runs
      * @returns {Promise<object>} structured result envelope
      */
     request: (intent, opts = {}) => {
       if (opts.modelTier) modelTier.value = opts.modelTier
-      return kit.request({ intent, agent: resolveSpawnArgs() })
+      return kit.request({ intent, agent: resolveSpawnArgs(), onChunk: opts.onChunk })
     },
-    respond: (requestId, message) => kit.respond({ requestId, message }),
+    /**
+     * @param {string} requestId journal record id from a prior request()/respond()
+     * @param {string} message follow-up user message
+     * @param {{onChunk?: (snapshot: {text: string, actions: object[]}) => void}} [opts] `onChunk` streams live text/tool-calls as the turn runs
+     * @returns {Promise<object>} updated result envelope
+     */
+    respond: (requestId, message, opts = {}) => kit.respond({ requestId, message, onChunk: opts.onChunk }),
     approve: (requestId, approve) => kit.approve({ requestId, approve })
   }
 }

package/types/components/index.d.ts

@@ -0,0 +1 @@
+export { STATUS_COLOR, statusColor } from "./status.js";

package/types/components/status.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {string} status request status
+ * @returns {string} accent color (fallback grey for unknown statuses)
+ */
+export function statusColor(status: string): string;
+export namespace STATUS_COLOR {
+    let pending: string;
+    let running: string;
+    let done: string;
+    let partial: string;
+    let needs_clarification: string;
+    let needs_approval: string;
+    let failed: string;
+    let rejected: string;
+}

package/types/core/acp-agent-presets.d.ts

@@ -0,0 +1,28 @@
+export namespace CODEX_ACP_AGENT_PRESET {
+    let command: string;
+    let args: string[];
+    namespace tiers {
+        namespace MIN {
+            let label: string;
+            let env: {
+                CODEX_CONFIG: string;
+            };
+        }
+        namespace AVG {
+            let label_1: string;
+            export { label_1 as label };
+            let env_1: {
+                CODEX_CONFIG: string;
+            };
+            export { env_1 as env };
+        }
+        namespace MAX {
+            let label_2: string;
+            export { label_2 as label };
+            let env_2: {
+                CODEX_CONFIG: string;
+            };
+            export { env_2 as env };
+        }
+    }
+}

package/types/core/acp-agent.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Spawn an ACP agent subprocess and run its `initialize` + `session/new`
+ * handshake. Returns a session handle to pass to `runAcpTurn`/`cancelAcpSession`.
+ * @param {object} params spawn parameters
+ * @param {string} params.agentKind 'codex'|'claude'|'cursor'|'pi' (informational — passed through, not interpreted here)
+ * @param {string} params.command executable to spawn (e.g. 'npx')
+ * @param {string[]} [params.args] command arguments
+ * @param {Record<string,string>} [params.env] extra environment variables for the subprocess
+ * @param {string} params.cwd session working directory (absolute path)
+ * @param {string} [params.mcpBridgeUrl] this app's domain MCP bridge URL (from acpStartMcpBridge), omit for no domain tools
+ * @param {boolean} [params.allowFs] grant fs/read_text_file + fs/write_text_file
+ * @param {boolean} [params.allowTerminal] grant terminal/*
+ * @returns {Promise<{sessionKey: string, agentKind: string}>} session handle
+ */
+export function createAcpSession({ agentKind, command, args, env, cwd, mcpBridgeUrl, allowFs, allowTerminal }: {
+    agentKind: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd: string;
+    mcpBridgeUrl?: string;
+    allowFs?: boolean;
+    allowTerminal?: boolean;
+}): Promise<{
+    sessionKey: string;
+    agentKind: string;
+}>;
+/**
+ * Run one prompt turn on an already-spawned ACP session, streaming
+ * `session/update` chunks into the same shape `runAgent()` returned.
+ * @param {object} params turn parameters
+ * @param {string} params.sessionKey handle from `createAcpSession`
+ * @param {string} params.text prompt text for this turn
+ * @param {(update: object) => void} [params.onChunk] optional live callback for each raw session/update (UI streaming)
+ * @returns {Promise<{content: string, steps: number, trace: object[], messages: object[], stopped?: string}>} runAgent()-shaped result
+ */
+export function runAcpTurn({ sessionKey, text, onChunk }: {
+    sessionKey: string;
+    text: string;
+    onChunk?: (update: object) => void;
+}): Promise<{
+    content: string;
+    steps: number;
+    trace: object[];
+    messages: object[];
+    stopped?: string;
+}>;
+/**
+ * Ask the agent to cancel its in-flight prompt turn.
+ * @param {string} sessionKey handle from `createAcpSession`
+ * @returns {Promise<void>} resolves once the cancel notification is sent
+ */
+export function cancelAcpSession(sessionKey: string): Promise<void>;
+/**
+ * Subscribe to `acp://mcp-tool-call` (a domain-catalog tool call the agent
+ * made through the MCP bridge, waiting on `acp_mcp_tool_result`).
+ * @param {(payload: {requestId: string, tool: string, input: object}) => void} handler callback
+ * @returns {Promise<() => void>} unlisten function
+ */
+export function onAcpToolCall(handler: (payload: {
+    requestId: string;
+    tool: string;
+    input: object;
+}) => void): Promise<() => void>;
+/**
+ * Resolve a pending `acp://mcp-tool-call` with the same envelope shape
+ * `createDispatch` returns.
+ * @param {string} requestId id from the `acp://mcp-tool-call` payload
+ * @param {{ok: boolean, output?: unknown, error?: {code: string, message: string}}} envelope dispatch result
+ * @returns {Promise<void>} resolves once the reply reaches the Rust bridge
+ */
+export function respondAcpToolCall(requestId: string, envelope: {
+    ok: boolean;
+    output?: unknown;
+    error?: {
+        code: string;
+        message: string;
+    };
+}): Promise<void>;
+/**
+ * Subscribe to `acp://permission-request` (a native ACP `session/request_permission`
+ * call, e.g. the agent's own file-edit/bash tools asking before running).
+ * @param {(payload: {sessionKey: string, requestId: string, toolCall: object, options: {optionId: string, name: string}[]}) => void} handler callback
+ * @returns {Promise<() => void>} unlisten function
+ */
+export function onAcpPermissionRequest(handler: (payload: {
+    sessionKey: string;
+    requestId: string;
+    toolCall: object;
+    options: {
+        optionId: string;
+        name: string;
+    }[];
+}) => void): Promise<() => void>;
+/**
+ * Resolve a pending `acp://permission-request` by selecting one of its options.
+ * @param {string} requestId id from the `acp://permission-request` payload
+ * @param {string} optionId one of the payload's `options[].optionId`
+ * @returns {Promise<void>} resolves once the permission response is sent
+ */
+export function respondAcpPermission(requestId: string, optionId: string): Promise<void>;
+/**
+ * Register this app's tool catalog with the domain MCP bridge and start it.
+ * @param {object[]} catalog tool definitions (same shape passed to `createAcpAgentKit`)
+ * @returns {Promise<string>} the bridge's loopback URL, e.g. `http://127.0.0.1:54321/`
+ */
+export function startAcpMcpBridge(catalog: object[]): Promise<string>;
+/**
+ * Read the per-machine default agent kind (`ACP_DEFAULT_AGENT` env var).
+ * @returns {Promise<{defaultAgentKind: string|null}>} config
+ */
+export function acpConfig(): Promise<{
+    defaultAgentKind: string | null;
+}>;

package/types/core/acp-kit.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @param {object} config kit configuration
+ * @param {object[]} config.catalog tool definitions (required)
+ * @param {object} config.journal journal store { create, load, update, list }
+ * @param {(tool: object, input: object) => unknown} [config.transport] backend runner for domain tools; omit for a chat-only kit (no domain MCP tools)
+ * @param {Record<string, number>} [config.actorTiers] max executable tier rank per actor kind
+ * @param {object} [config.deps] injectable `acp-agent.js` functions (tests only — defaults to the real module)
+ * @returns {{request: (opts: {intent: string, agent: object}) => Promise<object>, respond: (opts: {requestId: string, message: string}) => Promise<object>, approve: (opts: {requestId: string, approve: boolean}) => Promise<object>}} bound kit
+ */
+export function createAcpAgentKit({ catalog, journal, transport, actorTiers, deps }?: {
+    catalog: object[];
+    journal: object;
+    transport?: (tool: object, input: object) => unknown;
+    actorTiers?: Record<string, number>;
+    deps?: object;
+}): {
+    request: (opts: {
+        intent: string;
+        agent: object;
+    }) => Promise<object>;
+    respond: (opts: {
+        requestId: string;
+        message: string;
+    }) => Promise<object>;
+    approve: (opts: {
+        requestId: string;
+        approve: boolean;
+    }) => Promise<object>;
+};

package/types/core/dispatch.d.ts

@@ -4,14 +4,11 @@
  * @param {object} [input] candidate input
  * @returns {string|null} error message, or null when valid
  */
-export function validateInput(tool: object, input?: object): string | null
+export function validateInput(tool: object, input?: object): string | null;
 /**
  * Build a dispatch function bound to a catalog and a transport.
  * @param {object[]} catalog tool definitions
  * @param {(tool: object, input: object) => unknown} transport runs the tool's backend call
  * @returns {(name: string, input?: object) => Promise<object>} dispatch returning an envelope
  */
-export function createDispatch(
-  catalog: object[],
-  transport: (tool: object, input: object) => unknown
-): (name: string, input?: object) => Promise<object>
+export function createDispatch(catalog: object[], transport: (tool: object, input: object) => unknown): (name: string, input?: object) => Promise<object>;

package/types/core/manifest.d.ts

@@ -3,29 +3,24 @@
  * @param {Record<string, {type: string, required?: boolean, description?: string}>} input tool input spec
  * @returns {object} JSON Schema for the parameters object
  */
-export function toJsonSchema(
-  input: Record<
-    string,
-    {
-      type: string
-      required?: boolean
-      description?: string
-    }
-  >
-): object
+export function toJsonSchema(input: Record<string, {
+    type: string;
+    required?: boolean;
+    description?: string;
+}>): object;
 /**
  * OpenAI function-calling tool definitions, optionally filtered (e.g. by scope).
  * @param {object[]} catalog tool definitions
  * @param {(tool: object) => boolean} [allow] predicate; default includes all tools
  * @returns {object[]} OpenAI `tools` array
  */
-export function toolManifest(catalog: object[], allow?: (tool: object) => boolean): object[]
+export function toolManifest(catalog: object[], allow?: (tool: object) => boolean): object[];
 /**
  * Compact catalog listing (name + summary).
  * @param {object[]} catalog tool definitions
  * @returns {{name: string, summary: string}[]} tool list
  */
 export function listTools(catalog: object[]): {
-  name: string
-  summary: string
-}[]
+    name: string;
+    summary: string;
+}[];

package/types/core/scope.d.ts

@@ -6,14 +6,9 @@
  * @param {string} toolName tool name
  * @returns {'allow'|'approval'|'deny'} decision
  */
-export function classify(
-  catalog: object[],
-  actorTiers: Record<string, number> | undefined,
-  actor: {
-    kind?: string
-  },
-  toolName: string
-): 'allow' | 'approval' | 'deny'
+export function classify(catalog: object[], actorTiers: Record<string, number> | undefined, actor: {
+    kind?: string;
+}, toolName: string): "allow" | "approval" | "deny";
 /**
  * LLM tool manifest visible to the actor (everything it may run OR request approval for).
  * @param {object[]} catalog tool definitions
@@ -21,13 +16,9 @@ export function classify(
  * @param {{ kind?: string }} actor caller identity
  * @returns {object[]} OpenAI tools array
  */
-export function scopedManifest(
-  catalog: object[],
-  actorTiers: Record<string, number> | undefined,
-  actor: {
-    kind?: string
-  }
-): object[]
+export function scopedManifest(catalog: object[], actorTiers: Record<string, number> | undefined, actor: {
+    kind?: string;
+}): object[];
 /**
  * Tool names visible to the actor.
  * @param {object[]} catalog tool definitions
@@ -35,14 +26,10 @@ export function scopedManifest(
  * @param {{ kind?: string }} actor caller identity
  * @returns {string[]} visible tool names
  */
-export function scopedToolNames(
-  catalog: object[],
-  actorTiers: Record<string, number> | undefined,
-  actor: {
-    kind?: string
-  }
-): string[]
+export function scopedToolNames(catalog: object[], actorTiers: Record<string, number> | undefined, actor: {
+    kind?: string;
+}): string[];
 export namespace DEFAULT_ACTOR_TIERS {
-  let human: number
-  let agent: number
+    let human: number;
+    let agent: number;
 }

package/types/core/tools.d.ts

@@ -4,4 +4,4 @@
  * @param {string} name tool name
  * @returns {object|null} the tool definition, or null if unknown
  */
-export function getTool(catalog: object[], name: string): object | null
+export function getTool(catalog: object[], name: string): object | null;

package/types/index.d.ts

@@ -1,4 +1,7 @@
-export { getTool } from './core/tools.js'
-export { createDispatch, validateInput } from './core/dispatch.js'
-export { listTools, toJsonSchema, toolManifest } from './core/manifest.js'
-export { classify, DEFAULT_ACTOR_TIERS, scopedManifest, scopedToolNames } from './core/scope.js'
+export { CODEX_ACP_AGENT_PRESET } from "./core/acp-agent-presets.js";
+export { createAcpAgentKit } from "./core/acp-kit.js";
+export { getTool } from "./core/tools.js";
+export { acpConfig, cancelAcpSession, createAcpSession, onAcpPermissionRequest, onAcpToolCall, respondAcpPermission, respondAcpToolCall, runAcpTurn, startAcpMcpBridge } from "./core/acp-agent.js";
+export { createDispatch, validateInput } from "./core/dispatch.js";
+export { listTools, toJsonSchema, toolManifest } from "./core/manifest.js";
+export { classify, DEFAULT_ACTOR_TIERS, scopedManifest, scopedToolNames } from "./core/scope.js";

package/types/testing/index.d.ts

@@ -0,0 +1 @@
+export { mountQuasar, mountWithQuasar } from "./quasar.js";

package/types/testing/quasar.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Mount a component with Quasar registered, without any layout wrapper.
+ * @param {object} component Vue component (e.g. one that renders its own QLayout)
+ * @param {object} [options] mount options (forwarded)
+ * @returns {object} test wrapper
+ */
+export function mountQuasar(component: object, options?: object): object;
+/**
+ * Mount a page-level component wrapped in QLayout > QPageContainer.
+ * @param {object} component Vue component
+ * @param {object} [options] mount options (forwarded)
+ * @returns {object} test wrapper
+ */
+export function mountWithQuasar(component: object, options?: object): object;

package/types/vue/index.d.ts

@@ -0,0 +1,4 @@
+export { useAcpAgent } from "./use-acp-agent.js";
+export { useUpdater } from "./use-updater.js";
+export { createTauriJournalStore } from "./journal-store-tauri.js";
+export { tauriTransport } from "./transports.js";

package/types/vue/journal-store-tauri.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @returns {{ create: (r:object)=>Promise<string>, load: (id:string)=>Promise<object>, update: (id:string,patch:object)=>Promise<void>, list: ()=>Promise<object[]> }} journal store
+ */
+export function createTauriJournalStore(): {
+    create: (r: object) => Promise<string>;
+    load: (id: string) => Promise<object>;
+    update: (id: string, patch: object) => Promise<void>;
+    list: () => Promise<object[]>;
+};

package/types/vue/transports.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {object} tool tool definition (uses `tool.tauri`)
+ * @param {object} input tool input, forwarded as command args
+ * @returns {Promise<unknown>} the command result
+ */
+export function tauriTransport(tool: object, input: object): Promise<unknown>;

package/types/vue/use-acp-agent.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @param {object} config gateway config
+ * @param {object[]} config.catalog app tool catalog (required — passed to the domain MCP bridge)
+ * @param {Record<string, {command: string, args?: string[], env?: Record<string,string>, tiers: Record<string, {label: string, args?: string[], env?: Record<string,string>}>}>} config.agents per-agent-kind spawn presets, keyed by 'codex'|'claude'|'cursor'|'pi'
+ * @param {string} [config.defaultTier] fallback modelTier when a request doesn't specify one (default 'AVG')
+ * @param {string} config.cwd session working directory (absolute path)
+ * @param {Record<string, number>} [config.actorTiers] max executable tier rank per actor kind
+ * @param {(tool: object, input: object) => unknown} [config.transport] tool transport (default Tauri invoke)
+ * @returns {object} in-app ACP agent gateway
+ */
+export function useAcpAgent({ catalog, agents, defaultTier, cwd, actorTiers, transport }?: {
+    catalog: object[];
+    agents: Record<string, {
+        command: string;
+        args?: string[];
+        env?: Record<string, string>;
+        tiers: Record<string, {
+            label: string;
+            args?: string[];
+            env?: Record<string, string>;
+        }>;
+    }>;
+    defaultTier?: string;
+    cwd: string;
+    actorTiers?: Record<string, number>;
+    transport?: (tool: object, input: object) => unknown;
+}): object;

package/types/vue/use-updater.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {void}
+ */
+export function useUpdater(): void;