@ai-matrx/desktop-protocol 0.16.1 → 0.17.1

package/dist/client.d.cts

@@ -1,8 +1,8 @@
 import { BackoffOptions } from '@ai-matrx/realtime';
 export { RECONNECT_ALARM_ATTEMPTS } from '@ai-matrx/realtime';
 import { z } from 'zod';
-import { W as Welcome, D as DesktopProtocolError, C as CloseOutcome, O as OpName, a as OpParams, b as OpResult, c as OPS, S as StreamMeta, E as EndReason, d as EVENTS, e as ClientType, M as ModelsTranscribeResult, T as TranscriptionModelId, f as MlProgress } from './models-CCOaAWaM.cjs';
-export { i as isDesktopProtocolError } from './models-CCOaAWaM.cjs';
+import { W as Welcome, D as DesktopProtocolError, C as CloseOutcome, O as OpName, a as OpParams, b as OpResult, c as OPS, S as StreamMeta, E as EndReason, d as EVENTS, e as ClientType, M as ModelsTranscribeResult, T as TranscriptionModelId, f as MlProgress } from './models-Dj_B9wHj.cjs';
+export { i as isDesktopProtocolError } from './models-Dj_B9wHj.cjs';
 import { FrameHeader } from './frame.cjs';
 
 /** The subset of the WHATWG WebSocket the client uses — browser, React Native, `ws` and Workers all fit. */

package/dist/client.d.ts

@@ -1,8 +1,8 @@
 import { BackoffOptions } from '@ai-matrx/realtime';
 export { RECONNECT_ALARM_ATTEMPTS } from '@ai-matrx/realtime';
 import { z } from 'zod';
-import { W as Welcome, D as DesktopProtocolError, C as CloseOutcome, O as OpName, a as OpParams, b as OpResult, c as OPS, S as StreamMeta, E as EndReason, d as EVENTS, e as ClientType, M as ModelsTranscribeResult, T as TranscriptionModelId, f as MlProgress } from './models-CCOaAWaM.js';
-export { i as isDesktopProtocolError } from './models-CCOaAWaM.js';
+import { W as Welcome, D as DesktopProtocolError, C as CloseOutcome, O as OpName, a as OpParams, b as OpResult, c as OPS, S as StreamMeta, E as EndReason, d as EVENTS, e as ClientType, M as ModelsTranscribeResult, T as TranscriptionModelId, f as MlProgress } from './models-Dj_B9wHj.js';
+export { i as isDesktopProtocolError } from './models-Dj_B9wHj.js';
 import { FrameHeader } from './frame.js';
 
 /** The subset of the WHATWG WebSocket the client uses — browser, React Native, `ws` and Workers all fit. */

package/dist/client.js

@@ -94,7 +94,7 @@ import { z as z2 } from "zod";
 // src/schema/primitives.ts
 import { z } from "zod";
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 5;
+var PROTOCOL_MINOR = 6;
 var PROTOCOL_VERSION = `${PROTOCOL_MAJOR}.${PROTOCOL_MINOR}`;
 var ProtocolVersion = z.string().regex(/^[1-9][0-9]{0,2}\.[0-9]{1,3}$/);
 var RequestId = z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
@@ -1077,117 +1077,147 @@ var PowerPreventSleepResult = z17.strictObject({
   awake_until_ms: epochMs.nullable()
 });
 
-// src/schema/resources.ts
+// src/schema/audio.ts
 import { z as z18 } from "zod";
-var ResourcesDisk = z18.strictObject({
+var AudioDevice = z18.strictObject({
+  /** The OS's name for it, as audio.record takes it. */
+  id: z18.string().min(1).max(256),
+  name: z18.string().max(256),
+  default: z18.boolean()
+});
+var AudioDevicesParams = z18.strictObject({});
+var AudioDevicesResult = z18.strictObject({
+  inputs: z18.array(AudioDevice).max(64),
+  outputs: z18.array(AudioDevice).max(64)
+});
+var AudioRecordParams = z18.strictObject({
+  seconds: z18.number().min(0.5).max(600),
+  /** The microphone (from audio.devices); the default input when absent. */
+  device_id: z18.string().min(1).max(256).optional(),
+  /** Where the WAV file goes; a new file in the temp folder when absent. */
+  path: AbsPath.optional()
+});
+var AudioRecordResult = z18.strictObject({
+  path: AbsPath,
+  seconds: z18.number().min(0),
+  bytes: nonNegInt,
+  /** Loudest sample, 0–1: 0 means the device gave silence. */
+  peak: z18.number().min(0).max(1)
+});
+var AudioPlayParams = z18.strictObject({ path: AbsPath });
+var AudioPlayResult = z18.strictObject({ path: AbsPath, seconds: z18.number().min(0) });
+
+// src/schema/resources.ts
+import { z as z19 } from "zod";
+var ResourcesDisk = z19.strictObject({
   /** Where it is mounted ("/", "C:"). */
-  mount: z18.string().max(512),
+  mount: z19.string().max(512),
   /** The file system ("apfs", "NTFS", "ext4"). */
-  fs: z18.string().max(64),
+  fs: z19.string().max(64),
   size_bytes: nonNegInt,
   used_bytes: nonNegInt,
   available_bytes: nonNegInt
 });
-var ResourcesSnapshotParams = z18.strictObject({});
-var ResourcesSnapshotResult = z18.strictObject({
-  cpu: z18.strictObject({
+var ResourcesSnapshotParams = z19.strictObject({});
+var ResourcesSnapshotResult = z19.strictObject({
+  cpu: z19.strictObject({
     /** Busy share of all cores, 0–100, measured now. */
-    percent: z18.number().min(0).max(100),
-    cores: z18.int().min(1),
+    percent: z19.number().min(0).max(100),
+    cores: z19.int().min(1),
     /** 1, 5 and 15 minute load averages; null on Windows. */
-    load: z18.array(z18.number().min(0)).length(3).nullable()
+    load: z19.array(z19.number().min(0)).length(3).nullable()
   }),
-  memory: z18.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
-  swap: z18.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
-  disks: z18.array(ResourcesDisk).max(64),
+  memory: z19.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
+  swap: z19.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
+  disks: z19.array(ResourcesDisk).max(64),
   uptime_seconds: nonNegInt
 });
 
 // src/schema/fs-watch.ts
-import { z as z19 } from "zod";
-var FsWatchId = z19.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
-var FsWatchStartParams = z19.strictObject({
+import { z as z20 } from "zod";
+var FsWatchId = z20.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
+var FsWatchStartParams = z20.strictObject({
   path: AbsPath,
-  recursive: z19.boolean().default(true),
+  recursive: z20.boolean().default(true),
   /** Globs relative to `path` whose changes are not reported (".git/**", "node_modules/**"). */
-  ignore: z19.array(z19.string().max(256)).max(64).default([])
+  ignore: z20.array(z20.string().max(256)).max(64).default([])
 });
-var FsWatchStartResult = z19.strictObject({
+var FsWatchStartResult = z20.strictObject({
   watch_id: FsWatchId,
   path: AbsPath,
   /** The watch ends by itself if nobody reads it for 30 minutes. */
   expires_at_ms: epochMs
 });
-var FsWatchEventsParams = z19.strictObject({
+var FsWatchEventsParams = z20.strictObject({
   watch_id: FsWatchId,
   /** Wait up to this long for a first change when none is waiting (0 answers at once). */
-  wait_ms: z19.int().min(0).max(25e3).default(0)
+  wait_ms: z20.int().min(0).max(25e3).default(0)
 });
-var FsWatchEventsResult = z19.strictObject({
+var FsWatchEventsResult = z20.strictObject({
   /** What changed since the last read, oldest first; re-checked against the disk when read. */
-  changes: z19.array(FsChange).max(1e3),
+  changes: z20.array(FsChange).max(1e3),
   /** Changes were dropped (more than 1000 waited): list the folder again. */
-  overflow: z19.boolean(),
+  overflow: z20.boolean(),
   expires_at_ms: epochMs
 });
-var FsWatchStopParams = z19.strictObject({ watch_id: FsWatchId });
-var FsWatchStopResult = z19.strictObject({ watch_id: FsWatchId });
+var FsWatchStopParams = z20.strictObject({ watch_id: FsWatchId });
+var FsWatchStopResult = z20.strictObject({ watch_id: FsWatchId });
 
 // src/schema/exec-job.ts
-import { z as z20 } from "zod";
-var ExecJobId = z20.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
-var ExecJobStartParams = z20.strictObject({
-  command: z20.string().min(1).max(131072),
+import { z as z21 } from "zod";
+var ExecJobId = z21.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
+var ExecJobStartParams = z21.strictObject({
+  command: z21.string().min(1).max(131072),
   /** The folder it runs in; the home folder when absent. */
   cwd: AbsPath.optional(),
-  env: z20.record(z20.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z20.string().max(32768)).optional()
+  env: z21.record(z21.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z21.string().max(32768)).optional()
 });
-var ExecJobStartResult = z20.strictObject({ job_id: ExecJobId, pid: z20.int().min(1), cwd: AbsPath });
-var ExecJobOutputParams = z20.strictObject({
+var ExecJobStartResult = z21.strictObject({ job_id: ExecJobId, pid: z21.int().min(1), cwd: AbsPath });
+var ExecJobOutputParams = z21.strictObject({
   job_id: ExecJobId,
   /** Byte offset into the job's output to read from (next_offset of the last read; 0 = the start). */
   offset: nonNegInt.default(0),
   /** Wait up to this long for new output or the exit when none is waiting (0 answers at once). */
-  wait_ms: z20.int().min(0).max(25e3).default(0),
-  max_bytes: z20.int().min(1024).max(1048576).default(65536)
+  wait_ms: z21.int().min(0).max(25e3).default(0),
+  max_bytes: z21.int().min(1024).max(1048576).default(65536)
 });
-var ExecJobOutputResult = z20.strictObject({
+var ExecJobOutputResult = z21.strictObject({
   /** stdout and stderr interleaved as they arrived (UTF-8). */
-  output: z20.string(),
+  output: z21.string(),
   next_offset: nonNegInt,
   /** Bytes before `offset` that are gone (the job keeps its last 4 MiB). */
   dropped_bytes: nonNegInt,
-  running: z20.boolean(),
-  exit_code: z20.int().nullable()
+  running: z21.boolean(),
+  exit_code: z21.int().nullable()
 });
-var ExecJobStopParams = z20.strictObject({
+var ExecJobStopParams = z21.strictObject({
   job_id: ExecJobId,
   /** End it at once (SIGKILL; on Windows the whole tree with /F) instead of asking it to quit. */
-  force: z20.boolean().default(false)
+  force: z21.boolean().default(false)
 });
-var ExecJobStopResult = z20.strictObject({ job_id: ExecJobId, exited: z20.boolean(), exit_code: z20.int().nullable() });
-var ExecJobInfo = z20.strictObject({
+var ExecJobStopResult = z21.strictObject({ job_id: ExecJobId, exited: z21.boolean(), exit_code: z21.int().nullable() });
+var ExecJobInfo = z21.strictObject({
   job_id: ExecJobId,
-  command: z20.string().max(1024),
-  pid: z20.int().min(1),
+  command: z21.string().max(1024),
+  pid: z21.int().min(1),
   cwd: AbsPath,
-  running: z20.boolean(),
-  exit_code: z20.int().nullable(),
+  running: z21.boolean(),
+  exit_code: z21.int().nullable(),
   started_at_ms: epochMs,
   output_bytes: nonNegInt
 });
-var ExecJobListParams = z20.strictObject({});
-var ExecJobListResult = z20.strictObject({ jobs: z20.array(ExecJobInfo).max(64) });
+var ExecJobListParams = z21.strictObject({});
+var ExecJobListResult = z21.strictObject({ jobs: z21.array(ExecJobInfo).max(64) });
 
 // src/schema/coding.ts
-import { z as z21 } from "zod";
-var CodingServiceCredentials = z21.strictObject({
-  access_token: z21.string().min(16).max(16384),
-  user_id: z21.string().regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/),
+import { z as z22 } from "zod";
+var CodingServiceCredentials = z22.strictObject({
+  access_token: z22.string().min(16).max(16384),
+  user_id: z22.string().regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/),
   /** The AI Matrx server this app talks to (production, or a local server on the nightly copy). */
-  server_url: z21.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
+  server_url: z22.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
 });
-var CodingHistoryBlocked = z21.enum([
+var CodingHistoryBlocked = z22.enum([
   "signed_out",
   "offline",
   "organization_required",
@@ -1195,11 +1225,11 @@ var CodingHistoryBlocked = z21.enum([
   "cloud_list_unavailable",
   "history_too_large"
 ]);
-var CodingHistoryFailure = z21.strictObject({
-  session_id: z21.string().max(64),
-  reason: z21.string().max(300)
+var CodingHistoryFailure = z22.strictObject({
+  session_id: z22.string().max(64),
+  reason: z22.string().max(300)
 });
-var CodingHistoryRun = z21.strictObject({
+var CodingHistoryRun = z22.strictObject({
   /** Claude Code sessions found on this computer. */
   local_sessions: nonNegInt,
   /** Of those, already complete in AI Matrx. */
@@ -1214,39 +1244,39 @@ var CodingHistoryRun = z21.strictObject({
   /** Changed while being read; a later run takes them. */
   changed: nonNegInt,
   failed: nonNegInt,
-  failures: z21.array(CodingHistoryFailure).max(20),
+  failures: z22.array(CodingHistoryFailure).max(20),
   /** Candidates not reached yet. */
   remaining: nonNegInt,
   /** The one line a person reads, e.g. "Imported 12 of 14 sessions. 140 already in AI Matrx." */
-  summary: z21.string().max(400)
+  summary: z22.string().max(400)
 });
-var CodingHistoryStep = z21.strictObject({
+var CodingHistoryStep = z22.strictObject({
   /** Null when the run could not start (blocked before a plan existed). */
-  plan_id: z21.string().regex(/^[0-9a-f]{32}$/).nullable(),
-  finished: z21.boolean(),
+  plan_id: z22.string().regex(/^[0-9a-f]{32}$/).nullable(),
+  finished: z22.boolean(),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun
 });
-var CodingPlanMissingParams = z21.strictObject({ credentials: CodingServiceCredentials.nullable() });
-var CodingImportNextParams = z21.strictObject({
-  plan_id: z21.string().regex(/^[0-9a-f]{32}$/),
+var CodingPlanMissingParams = z22.strictObject({ credentials: CodingServiceCredentials.nullable() });
+var CodingImportNextParams = z22.strictObject({
+  plan_id: z22.string().regex(/^[0-9a-f]{32}$/),
   credentials: CodingServiceCredentials.nullable()
 });
-var CodingServiceProgress = z21.strictObject({
-  phase: z21.enum(["checking", "importing"]),
+var CodingServiceProgress = z22.strictObject({
+  phase: z22.enum(["checking", "importing"]),
   done: nonNegInt,
   total: nonNegInt
 });
-var CodingHistoryImportMissingParams = z21.strictObject({});
-var CodingHistoryImportMissingResult = z21.strictObject({
-  state: z21.enum(["done", "blocked", "cancelled"]),
+var CodingHistoryImportMissingParams = z22.strictObject({});
+var CodingHistoryImportMissingResult = z22.strictObject({
+  state: z22.enum(["done", "blocked", "cancelled"]),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun,
   elapsed_ms: nonNegInt
 });
-var CodingHistoryProgressEvent = z21.strictObject({
+var CodingHistoryProgressEvent = z22.strictObject({
   request_id: RequestId,
-  phase: z21.enum(["checking", "importing"]),
+  phase: z22.enum(["checking", "importing"]),
   /** Sessions settled so far, of `total` candidates (0 of 0 while checking). */
   done: nonNegInt,
   total: nonNegInt,
@@ -1255,22 +1285,22 @@ var CodingHistoryProgressEvent = z21.strictObject({
 });
 
 // src/schema/apps.ts
-import { z as z22 } from "zod";
-var AppKey = z22.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
-var AppProfileId = z22.string().regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/);
-var AppProfileLocator = z22.string().min(1).max(512).regex(/^[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}(\/[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}){0,7}$/);
-var AppSupport = z22.enum(["supported", "partial", "unsupported"]);
-var AppFeatureStatus = z22.strictObject({
+import { z as z23 } from "zod";
+var AppKey = z23.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
+var AppProfileId = z23.string().regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/);
+var AppProfileLocator = z23.string().min(1).max(512).regex(/^[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}(\/[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}){0,7}$/);
+var AppSupport = z23.enum(["supported", "partial", "unsupported"]);
+var AppFeatureStatus = z23.strictObject({
   status: AppSupport,
   /** One line, set whenever status is not "supported". */
-  reason: z22.string().max(140).nullable()
+  reason: z23.string().max(140).nullable()
 });
-var AppInfo = z22.strictObject({
+var AppInfo = z23.strictObject({
   app_key: AppKey,
-  name: z22.string().max(64),
-  installed: z22.boolean(),
+  name: z23.string().max(64),
+  installed: z23.boolean(),
   /** The app's own version string, or null when it is not installed or does not say. */
-  version: z22.string().max(64).nullable(),
+  version: z23.string().max(64).nullable(),
   /** The install found (an .app bundle, an .exe, a binary), or null. */
   location: AbsPath.nullable(),
   /** Open the app at all on this OS. */
@@ -1280,69 +1310,69 @@ var AppInfo = z22.strictObject({
   /** Plan usage read from the app's own files on this OS. */
   usage: AppFeatureStatus
 });
-var AppUsageReading = z22.strictObject({
-  window: z22.enum(["five_hour", "weekly", "extra"]),
+var AppUsageReading = z23.strictObject({
+  window: z23.enum(["five_hour", "weekly", "extra"]),
   /** 0–100 for five_hour and weekly; extra-usage spend as a percent of its cap (may pass 100). */
-  percent: z22.number().min(0).max(1e4),
+  percent: z23.number().min(0).max(1e4),
   /** When the app recorded it. */
   sampled_at_ms: epochMs,
   /** True when the window has rolled over since the sample, so the figure has reset. */
-  reset_since: z22.boolean()
+  reset_since: z23.boolean()
 });
-var AppProfile = z22.strictObject({
+var AppProfile = z23.strictObject({
   /** The row's id; null for a folder found on disk that no row names yet. */
   id: AppProfileId.nullable(),
   app_key: AppKey,
-  display_name: z22.string().min(1).max(120),
+  display_name: z23.string().min(1).max(120),
   /** The account the person means to be signed in here; null when not stated (never guessed). */
-  account_identity: z22.string().min(3).max(320).nullable(),
+  account_identity: z23.string().min(3).max(320).nullable(),
   profile_locator: AppProfileLocator.nullable(),
   /** The device the row is tied to; null when the row names none. */
   device_id: DeviceId.nullable(),
   /** The folder this profile resolves to on this device; null for a row tied to another device. */
   folder: AbsPath.nullable(),
   /** The folder exists on this device. */
-  on_disk: z22.boolean(),
+  on_disk: z23.boolean(),
   /** An instance with this profile is running; null when it could not be determined. */
-  running: z22.boolean().nullable(),
+  running: z23.boolean().nullable(),
   /** Usage the app recorded for this profile; null when the app exposes none here. */
-  usage: z22.array(AppUsageReading).nullable(),
+  usage: z23.array(AppUsageReading).nullable(),
   last_opened_ms: epochMs.nullable()
 });
-var AppsListParams = z22.strictObject({});
-var AppsListResult = z22.strictObject({ apps: z22.array(AppInfo) });
-var AppsProfilesListParams = z22.strictObject({
+var AppsListParams = z23.strictObject({});
+var AppsListResult = z23.strictObject({ apps: z23.array(AppInfo) });
+var AppsProfilesListParams = z23.strictObject({
   /** Only this app's profiles; every app's when absent. */
   app_key: AppKey.optional()
 });
-var AppsProfilesListResult = z22.strictObject({
-  profiles: z22.array(AppProfile),
+var AppsProfilesListResult = z23.strictObject({
+  profiles: z23.array(AppProfile),
   /**
    * Whether the saved rows could be read: false while signed out or offline, when only folders
    * found on disk are listed.
    */
-  registry: z22.enum(["ok", "signed_out", "unavailable"])
+  registry: z23.enum(["ok", "signed_out", "unavailable"])
 });
-var AppsProfilesSaveParams = z22.strictObject({
+var AppsProfilesSaveParams = z23.strictObject({
   id: AppProfileId.optional(),
   app_key: AppKey,
-  display_name: z22.string().min(1).max(120),
-  account_identity: z22.string().min(3).max(320).nullable(),
+  display_name: z23.string().min(1).max(120),
+  account_identity: z23.string().min(3).max(320).nullable(),
   /** On create: the folder to use (one found on disk), or null for the app's default profile. Ignored on update. */
   profile_locator: AppProfileLocator.nullable(),
   /** On create with profile_locator null: make a new folder named after display_name instead. */
-  new_folder: z22.boolean().default(false)
+  new_folder: z23.boolean().default(false)
 });
 var AppsProfilesSaveResult = AppProfile;
-var AppsProfilesRemoveParams = z22.strictObject({ id: AppProfileId });
-var AppsProfilesRemoveResult = z22.strictObject({ removed: z22.boolean() });
-var AppsOpenParams = z22.strictObject({
+var AppsProfilesRemoveParams = z23.strictObject({ id: AppProfileId });
+var AppsProfilesRemoveResult = z23.strictObject({ removed: z23.boolean() });
+var AppsOpenParams = z23.strictObject({
   app_key: AppKey,
   profile_id: AppProfileId.optional()
 });
-var AppsOpenResult = z22.strictObject({
+var AppsOpenResult = z23.strictObject({
   /** True when an instance with this profile was already running; it is brought forward. */
-  already_running: z22.boolean(),
+  already_running: z23.boolean(),
   folder: AbsPath.nullable()
 });
 
@@ -1411,6 +1441,9 @@ var OPS = {
   "power.status": { params: PowerStatusParams, result: PowerStatusResult, kind: "unary", since: "1.4", errors: ["INTERNAL"] },
   "power.prevent_sleep": { params: PowerPreventSleepParams, result: PowerPreventSleepResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "resources.snapshot": { params: ResourcesSnapshotParams, result: ResourcesSnapshotResult, kind: "unary", since: "1.4", errors: ["INTERNAL"] },
+  "audio.devices": { params: AudioDevicesParams, result: AudioDevicesResult, kind: "unary", since: "1.6", errors: ["PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "audio.record": { params: AudioRecordParams, result: AudioRecordResult, kind: "unary", since: "1.6", errors: ["NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "RESOURCE_BUSY", "INTERNAL"] },
+  "audio.play": { params: AudioPlayParams, result: AudioPlayResult, kind: "unary", since: "1.6", errors: ["NOT_FOUND", "INVALID_PARAMS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   // Claude Code history (SPEC §6 coding): served by the `coding` Python service through SERVICES below.
   "coding.history.import_missing": { params: CodingHistoryImportMissingParams, result: CodingHistoryImportMissingResult, kind: "unary", since: "1.5", errors: ["RESOURCE_BUSY", "RESOURCE_GONE", "CANCELLED", "INTERNAL"] }
 };