@7n/tauri-components 0.13.10 → 0.13.11

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [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.13.11",
   "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/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;