@agentdock/wire 0.0.94 → 0.0.96

package/dist/accountLanguage.d.ts

@@ -1,13 +1,8 @@
 import { z } from 'zod';
-/** Account-wide UI and generated-response language preference. */
+
 export declare const ACCOUNT_LANGUAGES: readonly ["en", "zh-Hans"];
 export declare const DEFAULT_ACCOUNT_LANGUAGE = "en";
-/**
- * Daemon capability flag (RFC-081 rolling-upgrade gate). The server only injects
- * `responseLanguage` into spawn-session/ai-helper RPC params when the target
- * daemon declared this capability at machine-register. Older daemons whose
- * `SpawnSessionParamsSchema` is `.strict()` reject the unknown field outright.
- */
+
 export declare const ACCOUNT_LANGUAGE_CAPABILITY = "account-language";
 export declare const AccountLanguageSchema: z.ZodEnum<["en", "zh-Hans"]>;
 export type AccountLanguage = z.infer<typeof AccountLanguageSchema>;
@@ -29,4 +24,3 @@ export declare const AccountLanguageResponseSchema: z.ZodObject<{
     language: "en" | "zh-Hans";
     initialized: boolean;
 }>;
-//# sourceMappingURL=accountLanguage.d.ts.map

package/dist/activityPreferences.d.ts

@@ -1,5 +1,3 @@
-/** Activity tracking preferences — shared type used by server, web, and daemon. */
 export interface ActivityPreferences {
     enabled: boolean;
 }
-//# sourceMappingURL=activityPreferences.d.ts.map

package/dist/agentCapabilities.d.ts

@@ -1,9 +1,3 @@
-/**
- * Agent capability matrix — static mapping of which features each CLI agent supports.
- *
- * Web UI uses this to conditionally show/hide spawn parameters
- * (model, systemPrompt, tools, permissions, etc.) based on the selected agent.
- */
 import type { ControlLevelType } from './controlLevel.js';
 export interface AgentPermissionMode {
     readonly value: string;
@@ -13,7 +7,7 @@ export interface AgentModelOption {
     readonly value: string;
     readonly label: string;
 }
-/** 模型来源标签 */
+
 export type ModelSource = 'builtin' | 'acp' | 'env' | 'custom';
 export interface AgentCapability {
     readonly controlLevel: ControlLevelType;
@@ -21,67 +15,43 @@ export interface AgentCapability {
     readonly supportsSystemPrompt: boolean;
     readonly supportsToolConfig: boolean;
     readonly supportsMcpConfig: boolean;
-    /** Whether the agent can receive a daemon-injected MCP server (session MCP
-     * injection, e.g. the handoff tool). Distinct from `supportsMcpConfig`, which is
-     * about the user filling a `--mcp-config` CLI flag. */
+    
     readonly supportsMcpInjection: boolean;
     readonly supportsPermissionMode: boolean;
     readonly supportsResume: boolean;
     readonly supportsMaxTurns: boolean;
     readonly supportsSlashClear: boolean;
     readonly supportsSlashCompact: boolean;
-    /** Whether the agent supports switching model mid-session (without restart). */
+    
     readonly supportsInSessionModelSwitch: boolean;
-    /** Whether the agent supports switching permission mode mid-session (without restart). */
+    
     readonly supportsInSessionModeSwitch: boolean;
-    /**
-     * Whether dynamically-discovered agent-native ACP modes (e.g. hermes
-     * accept_edits, opencode build/plan, copilot URL IDs) can be forwarded to
-     * the agent's own mode mechanism (session/set_config_option / session/set_mode).
-     * Agents with this=false never expose runtime native modes in the permission
-     * pill (their reported "modes" are not permission modes, e.g. openclaw
-     * thinking levels). Codex routes its modes via its own policy instead.
-     */
+    
     readonly supportsNativeModeForward: boolean;
-    /** Whether the agent supports real-time context window usage queries (getContextUsage). */
+    
     readonly supportsContextUsageQuery: boolean;
-    /** ACP agent — model/mode lists come from daemon cache, not static config. */
+    
     readonly usesAcpConfig: boolean;
-    /** Static model options for non-ACP agents (Claude, Codex). Empty = use server catalog or ACP. */
+    
     readonly staticModels: readonly AgentModelOption[];
-    /** Permission modes available for this agent. Empty = no selector. */
+    
     readonly permissionModes: readonly AgentPermissionMode[];
-    /** Default permission mode value for this agent. */
+    
     readonly defaultPermissionMode: string;
 }
-/**
- * Semantic mapping of known agent-native mode IDs to AgentDock policy values.
- * Only for native modes that ARE approval strategies (hermes). Unmapped/unknown
- * native modes fall through to the open native channel (forwarded) — no schema
- * or capability change needed for future agent modes.
- */
+
 export declare const NATIVE_MODE_TO_POLICY: Readonly<Record<string, Readonly<Record<string, string>>>>;
-/**
- * Resolve a permission-mode value to the AgentDock policy value the daemon
- * should enforce, or null when the value is an agent-native mode to forward.
- * Agent-aware: codex's native approval policies count as policy for codex.
- */
+
 export declare function resolvePolicyMode(agentType: string, mode: string): string | null;
 export declare const AGENT_CAPABILITIES: Readonly<Record<string, AgentCapability>>;
-/** Update dynamic modes for an ACP agent (called by daemon when session reports modes). */
+
 export declare function updateDynamicModes(agentType: string, modes: readonly {
     id: string;
     label: string;
 }[]): void;
-/** Get dynamic modes for an agent, or null if none reported. */
+
 export declare function getDynamicModes(agentType: string): readonly AgentPermissionMode[] | null;
-/** Get capability for an agent, falling back to minimal (Level 0) for unknown agents. */
+
 export declare function getAgentCapability(agentType: string): AgentCapability;
-/**
- * Normalize a Claude model ID so that dot-separated versions (e.g. `claude-opus-4.6`)
- * match the hyphen-separated form returned by the API (e.g. `claude-opus-4-6`).
- *
- * Safe to call on any string — non-Claude IDs pass through unchanged.
- */
+
 export declare function normalizeModelId(id: string): string;
-//# sourceMappingURL=agentCapabilities.d.ts.map

package/dist/agentCommonEnv.d.ts

@@ -1,15 +1,6 @@
-/**
- * Common environment variables for each agent.
- *
- * Only agents that use a single-provider API key are listed here.
- * Multi-provider agents (opencode, hermes, openclaw) configure keys
- * through their own config files, so they are intentionally omitted.
- * Copilot authenticates via OAuth (`gh auth login`), not env vars.
- */
 import type { AgentType } from './messageMeta.js';
 export interface AgentEnvVarHint {
     readonly key: string;
     readonly placeholder: string;
 }
 export declare const AGENT_COMMON_ENV_VARS: Partial<Record<AgentType, readonly AgentEnvVarHint[]>>;
-//# sourceMappingURL=agentCommonEnv.d.ts.map

package/dist/agentInstallGuide.d.ts

@@ -1,9 +1,3 @@
-/**
- * Per-agent install instructions for the web UI.
- *
- * Display-only data — the actual gating logic lives in daemon's registry.
- * Wire only has the strings so the web can render install/upgrade instructions.
- */
 import type { AgentType } from './messageMeta.js';
 import type { Platform } from './machine.js';
 export interface AgentInstallInfo {
@@ -12,4 +6,3 @@ export interface AgentInstallInfo {
     readonly upgradeUrl: string;
 }
 export declare const AGENT_INSTALL_GUIDE: Readonly<Record<AgentType, AgentInstallInfo>>;
-//# sourceMappingURL=agentInstallGuide.d.ts.map

package/dist/agentRuntimeSettings.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const RuntimeAgentSchema: z.ZodEnum<["claude", "codex", "opencode"]>;
 export type RuntimeAgent = z.infer<typeof RuntimeAgentSchema>;
-/** Versioned, credential-free settings delivered to an enterprise container. */
+
 export declare const AgentRuntimeSettingsSchema: z.ZodObject<{
     agent: z.ZodEnum<["claude", "codex", "opencode"]>;
     routeId: z.ZodString;
@@ -137,4 +137,3 @@ export declare const AgentRuntimeSettingsListSchema: z.ZodArray<z.ZodObject<{
     forced: Record<string, unknown>;
     userOverrides: Record<string, unknown>;
 }>, "many">;
-//# sourceMappingURL=agentRuntimeSettings.d.ts.map

package/dist/bgTask.d.ts

@@ -1,27 +1,26 @@
-/** Common prefix for every bg-task service envelope. */
 export declare const BG_TASK_PREFIX = "bg-task:";
-/** All bg-task lifecycle actions. */
+
 export type BgTaskAction = 'started' | 'progress' | 'completed' | 'failed' | 'stopped';
-/** Parsed bg-task line. `taskId` is already URI-decoded. */
+
 export interface ParsedBgTask {
     readonly action: BgTaskAction;
-    /** URI-decoded Claude taskId (falls back to the raw encoded value if decode fails). */
+    
     readonly taskId: string;
-    /** started: task description. */
+    
     readonly desc?: string;
-    /** progress / failed: latest summary text. */
+    
     readonly summary?: string;
-    /** completed / failed / stopped: background task total token usage (0 when absent). */
+    
     readonly totalTokens?: number;
-    /** completed / failed / stopped: wall-clock duration in ms (0 when absent). */
+    
     readonly durationMs?: number;
-    /** completed / failed / stopped: number of tool calls made by the task (0 when absent). */
+    
     readonly toolUses?: number;
 }
-/** Fields accepted by {@link encodeBgTask}. */
+
 export interface EncodeBgTaskInput {
     readonly action: BgTaskAction;
-    /** Raw (un-encoded) Claude taskId. */
+    
     readonly taskId: string;
     readonly desc?: string;
     readonly summary?: string;
@@ -29,19 +28,9 @@ export interface EncodeBgTaskInput {
     readonly durationMs?: number;
     readonly toolUses?: number;
 }
-/**
- * Encode a bg-task lifecycle event into its service-envelope text form.
- * taskId is URI-encoded so its (rare) colons never break the fixed-segment parser.
- */
+
 export declare function encodeBgTask(input: EncodeBgTaskInput): string;
-/**
- * Parse a bg-task service-envelope text back into structured fields.
- * Returns null when `text` is not a recognized bg-task line.
- *
- * Pure decoding only — business rules (e.g. "empty progress summary must not
- * overwrite the started desc") stay in the caller.
- */
+
 export declare function parseBgTask(text: string): ParsedBgTask | null;
-/** True when `text` is a started or progress line (internal lifecycle, hidden from the flow). */
+
 export declare function isBgTaskLifecycleLine(text: string): boolean;
-//# sourceMappingURL=bgTask.d.ts.map

package/dist/checkpointSchemas.d.ts

@@ -166,7 +166,7 @@ export declare const CheckpointRollbackParamsSchema: z.ZodObject<{
     timestamp: z.ZodOptional<z.ZodString>;
     mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["code", "conversation", "both"]>>>;
     force: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** Sent by web PWA to identify the specific tool call for rollback. */
+    
     toolCallId: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     mode: "code" | "conversation" | "both";
@@ -216,4 +216,3 @@ export type FileDiffEntry = z.infer<typeof FileDiffEntrySchema>;
 export type CheckpointDiffResult = z.infer<typeof CheckpointDiffResultSchema>;
 export type CheckpointRollbackParams = z.infer<typeof CheckpointRollbackParamsSchema>;
 export type CheckpointRollbackResult = z.infer<typeof CheckpointRollbackResultSchema>;
-//# sourceMappingURL=checkpointSchemas.d.ts.map

package/dist/controlLevel.d.ts

@@ -1,12 +1,4 @@
 import { z } from 'zod';
-/**
- * Control depth level for CLI tools.
- *
- * Level 3: Full control — bidirectional ACP, per-tool permissions, resume (Claude Code, OpenCode)
- * Level 2: High control — JSONL + resume + pre-configured permissions (Codex CLI)
- * Level 1: Read-only monitoring — JSONL + no resume + binary permissions (Gemini, Qwen)
- * Level 0: Minimal — plain text + no multi-turn (Aider, not recommended)
- */
+
 export declare const ControlLevel: z.ZodUnion<[z.ZodLiteral<3>, z.ZodLiteral<2>, z.ZodLiteral<1>, z.ZodLiteral<0>]>;
 export type ControlLevelType = z.infer<typeof ControlLevel>;
-//# sourceMappingURL=controlLevel.d.ts.map

package/dist/edition.d.ts

@@ -2,4 +2,3 @@ export declare const EDITIONS: readonly ["personal", "enterprise"];
 export type Edition = (typeof EDITIONS)[number];
 export declare function getEdition(): Edition;
 export declare function isEnterprise(): boolean;
-//# sourceMappingURL=edition.d.ts.map

package/dist/enterpriseCurrency.d.ts

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+
+export declare const ENTERPRISE_CURRENCIES: readonly ["USD", "CNY"];
+export type EnterpriseCurrencyCode = (typeof ENTERPRISE_CURRENCIES)[number];
+export declare const EnterpriseCurrencyCodeSchema: z.ZodEnum<["USD", "CNY"]>;
+export declare const DisplayCurrencyConfigSchema: z.ZodObject<{
+    
+    code: z.ZodString;
+    symbol: z.ZodString;
+    
+    rate: z.ZodNumber;
+    
+    fxRates: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    symbol: string;
+    code: string;
+    rate: number;
+    fxRates: Record<string, number>;
+}, {
+    symbol: string;
+    code: string;
+    rate: number;
+    fxRates: Record<string, number>;
+}>;
+export type DisplayCurrencyConfig = z.infer<typeof DisplayCurrencyConfigSchema>;
+
+export declare const DisplayCurrencySettingsResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    currency: z.ZodObject<{
+        
+        code: z.ZodString;
+        symbol: z.ZodString;
+        
+        rate: z.ZodNumber;
+        
+        fxRates: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        symbol: string;
+        code: string;
+        rate: number;
+        fxRates: Record<string, number>;
+    }, {
+        symbol: string;
+        code: string;
+        rate: number;
+        fxRates: Record<string, number>;
+    }>;
+    
+    missing: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    ok: true;
+    currency: {
+        symbol: string;
+        code: string;
+        rate: number;
+        fxRates: Record<string, number>;
+    };
+    missing: string[];
+}, {
+    ok: true;
+    currency: {
+        symbol: string;
+        code: string;
+        rate: number;
+        fxRates: Record<string, number>;
+    };
+    missing: string[];
+}>;
+export type DisplayCurrencySettings = z.infer<typeof DisplayCurrencySettingsResponseSchema>;
+
+export declare const DisplayCurrencyConfigResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    currency: z.ZodObject<{
+        
+        code: z.ZodString;
+        symbol: z.ZodString;
+        
+        rate: z.ZodNumber;
+        
+        fxRates: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        symbol: string;
+        code: string;
+        rate: number;
+        fxRates: Record<string, number>;
+    }, {
+        symbol: string;
+        code: string;
+        rate: number;
+        fxRates: Record<string, number>;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    ok: true;
+    currency: {
+        symbol: string;
+        code: string;
+        rate: number;
+        fxRates: Record<string, number>;
+    };
+}, {
+    ok: true;
+    currency: {
+        symbol: string;
+        code: string;
+        rate: number;
+        fxRates: Record<string, number>;
+    };
+}>;
+
+export declare const UpdateDisplayCurrencyBodySchema: z.ZodObject<{
+    code: z.ZodEnum<["USD", "CNY"]>;
+    fxRates: z.ZodRecord<z.ZodEnum<["USD", "CNY"]>, z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    code: "USD" | "CNY";
+    fxRates: Partial<Record<"USD" | "CNY", number>>;
+}, {
+    code: "USD" | "CNY";
+    fxRates: Partial<Record<"USD" | "CNY", number>>;
+}>;
+export type UpdateDisplayCurrencyBody = z.infer<typeof UpdateDisplayCurrencyBodySchema>;

package/dist/enterpriseCurrency.js

@@ -0,0 +1 @@
+"use strict";import{z as e}from"zod";export const ENTERPRISE_CURRENCIES=["USD","CNY"],EnterpriseCurrencyCodeSchema=e.enum(ENTERPRISE_CURRENCIES),DisplayCurrencyConfigSchema=e.object({code:e.string().regex(/^[A-Z]{3}$/),symbol:e.string(),rate:e.number().positive().finite(),fxRates:e.record(e.string().regex(/^[A-Z]{3}$/),e.number().positive().finite())}).strict(),DisplayCurrencySettingsResponseSchema=e.object({ok:e.literal(!0),currency:DisplayCurrencyConfigSchema,missing:e.array(e.string().regex(/^[A-Z]{3}$/))}).strict(),DisplayCurrencyConfigResponseSchema=e.object({ok:e.literal(!0),currency:DisplayCurrencyConfigSchema}).strict(),UpdateDisplayCurrencyBodySchema=e.object({code:EnterpriseCurrencyCodeSchema,fxRates:e.record(EnterpriseCurrencyCodeSchema,e.number().positive().finite())}).strict();