@motrix/mdxp 0.1.0

package/src/connection.ts

@@ -0,0 +1,162 @@
+import type {
+  CancellationToken,
+  MessageConnection,
+  MessageReader,
+  MessageWriter,
+} from 'vscode-jsonrpc'
+import { createMessageConnection } from 'vscode-jsonrpc'
+import type {
+  CancelRequestParams,
+  DownloadAddParams,
+  DownloadAddResult,
+  DownloadCancelParams,
+  DownloadCancelResult,
+  DownloadSubmitParams,
+  DownloadSubmitResult,
+  EngineStatusParams,
+  EngineStatusResult,
+  InitializeParams,
+  InitializeResult,
+  PairRevokedParams,
+  StatsGetParams,
+  StatsResult,
+  StatsUpdateParams,
+  SystemPingParams,
+  SystemPingResult,
+  TaskCompletedParams,
+  TaskErrorParams,
+  TaskGetParams,
+  TaskGetResult,
+  TaskListParams,
+  TaskListResult,
+  TaskPauseParams,
+  TaskPauseResult,
+  TaskProgressParams,
+  TaskRemoveParams,
+  TaskRemoveResult,
+  TaskResumeParams,
+  TaskResumeResult,
+  UrlProbeParams,
+  UrlProbeResult,
+  UrlResolveParams,
+  UrlResolveResult,
+} from './types.js'
+
+// Maps method name → [params type, result type]
+export interface MdxpRequestMap {
+  'motrix/initialize': [InitializeParams, InitializeResult]
+  'download/submit': [DownloadSubmitParams, DownloadSubmitResult]
+  'download/cancel': [DownloadCancelParams, DownloadCancelResult]
+  'url/probe': [UrlProbeParams, UrlProbeResult]
+  'url/resolve': [UrlResolveParams, UrlResolveResult]
+  'system/ping': [SystemPingParams, SystemPingResult]
+  // v1 control-plane (Spec 2)
+  'download/add': [DownloadAddParams, DownloadAddResult]
+  'task/list': [TaskListParams, TaskListResult]
+  'task/get': [TaskGetParams, TaskGetResult]
+  'task/pause': [TaskPauseParams, TaskPauseResult]
+  'task/resume': [TaskResumeParams, TaskResumeResult]
+  'task/remove': [TaskRemoveParams, TaskRemoveResult]
+  'stats/get': [StatsGetParams, StatsResult]
+  'engine/status': [EngineStatusParams, EngineStatusResult]
+}
+
+// Maps notification name → params type
+export interface MdxpNotificationMap {
+  'motrix/initialized': undefined
+  '$/task/progress': TaskProgressParams
+  '$/task/completed': TaskCompletedParams
+  '$/task/error': TaskErrorParams
+  '$/pair/revoked': PairRevokedParams
+  '$/cancelRequest': CancelRequestParams
+  '$/stats': StatsUpdateParams
+}
+
+export interface MdxpConnection {
+  /** Begin processing incoming messages. Call AFTER attaching handlers. */
+  listen(): void
+
+  /**
+   * Send a request. Optionally pass a `CancellationToken` so the caller can
+   * abort an in-flight request — vscode-jsonrpc emits `$/cancelRequest`
+   * automatically per spec §9.
+   */
+  sendRequest<M extends keyof MdxpRequestMap>(
+    method: M,
+    params: MdxpRequestMap[M][0],
+    token?: CancellationToken
+  ): Promise<MdxpRequestMap[M][1]>
+
+  /**
+   * Handler can accept an optional `CancellationToken`. vscode-jsonrpc wires
+   * it to the underlying `$/cancelRequest` notification — the handler MUST
+   * observe `token.isCancellationRequested` for cooperative cancellation.
+   */
+  onRequest<M extends keyof MdxpRequestMap>(
+    method: M,
+    handler: (
+      params: MdxpRequestMap[M][0],
+      token: CancellationToken
+    ) => MdxpRequestMap[M][1] | Promise<MdxpRequestMap[M][1]>
+  ): void
+
+  sendNotification<N extends keyof MdxpNotificationMap>(
+    name: N,
+    params: MdxpNotificationMap[N]
+  ): void
+
+  onNotification<N extends keyof MdxpNotificationMap>(
+    name: N,
+    handler: (params: MdxpNotificationMap[N]) => void
+  ): void
+
+  dispose(): void
+
+  /** Escape hatch: access the underlying vscode-jsonrpc connection. */
+  readonly raw: MessageConnection
+}
+
+export function createMdxpConnection(
+  reader: MessageReader,
+  writer: MessageWriter
+): MdxpConnection {
+  const raw = createMessageConnection(reader, writer)
+
+  return {
+    listen: () => raw.listen(),
+    // Promise<never> is assignable to all Promise<X>, satisfying the generic
+    // constraint for all M simultaneously at the implementation site.
+    sendRequest: (method, params, token) =>
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (token === undefined
+        ? raw.sendRequest(method as string, params)
+        : raw.sendRequest(method as string, params, token)) as Promise<never>,
+    onRequest: (method, handler) => {
+      // vscode-jsonrpc v9 tightened GenericRequestHandler/HandlerResult, so a
+      // generically-typed handler is no longer directly assignable. The runtime
+      // function is correct for every M; cast the whole handler via `never`
+      // (matching the `as never` escape hatches used elsewhere in this file).
+      raw.onRequest(
+        method as string,
+        ((params: unknown, token: CancellationToken) =>
+          handler(params as never, token)) as never
+      )
+    },
+    sendNotification: (name, params) => {
+      if (params === undefined) {
+        raw.sendNotification(name as string)
+      } else {
+        raw.sendNotification(name as string, params)
+      }
+    },
+    onNotification: (name, handler) => {
+      raw.onNotification(name as string, (params: unknown) =>
+        // Cast via `never`: handler accepts the concrete notification params
+        // type for N, but raw.onNotification gives us `unknown`.
+        handler(params as never)
+      )
+    },
+    dispose: () => raw.dispose(),
+    raw,
+  }
+}

package/src/errors.ts

@@ -0,0 +1,60 @@
+// MDXP error code model — see docs/01-protocol-mdxp.md §8
+
+export const ErrorCodes = Object.freeze({
+  // JSON-RPC 2.0 reserved (-32768 to -32000)
+  ParseError: -32700,
+  InvalidRequest: -32600,
+  MethodNotFound: -32601,
+  InvalidParams: -32602,
+  InternalError: -32603,
+  RequestCancelled: -32800, // LSP extension
+
+  // Motrix-defined (-32000 to -32099, JSON-RPC server-implementation reserved)
+  AdapterError: -32001,
+  ResourceUnavailable: -32002,
+  PermissionDenied: -32003,
+  RateLimited: -32004,
+  CapabilityNotSupported: -32005,
+  PairRevoked: -32006,
+} as const)
+
+export type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes]
+
+/** True for JSON-RPC 2.0 reserved codes (parse/invalid/method/internal/cancel) */
+export function isProtocolError(code: number): boolean {
+  return (
+    code === ErrorCodes.ParseError ||
+    code === ErrorCodes.InvalidRequest ||
+    code === ErrorCodes.MethodNotFound ||
+    code === ErrorCodes.InvalidParams ||
+    code === ErrorCodes.InternalError ||
+    code === ErrorCodes.RequestCancelled
+  )
+}
+
+/** True for codes in Motrix's -32000..-32099 reserved range */
+export function isMotrixError(code: number): boolean {
+  return code <= -32000 && code >= -32099
+}
+
+export interface MdxpErrorData {
+  appCode?: string
+  localizedMessage?: string
+  retryable?: boolean
+  retryAfterSec?: number
+  context?: Record<string, unknown>
+}
+
+export interface MdxpError {
+  code: number
+  message: string
+  data?: MdxpErrorData
+}
+
+export function makeMdxpError(
+  code: number,
+  message: string,
+  data?: MdxpErrorData
+): MdxpError {
+  return data === undefined ? { code, message } : { code, message, data }
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+// MDXP — Motrix Download eXchange Protocol
+// Public API surface for both Motrix desktop and the browser extension.
+
+export type {
+  MdxpConnection,
+  MdxpNotificationMap,
+  MdxpRequestMap,
+} from './connection.js'
+export { createMdxpConnection } from './connection.js'
+export type { ErrorCode, MdxpError, MdxpErrorData } from './errors.js'
+export {
+  ErrorCodes,
+  isMotrixError,
+  isProtocolError,
+  makeMdxpError,
+} from './errors.js'
+export type { Method, Notification } from './methods.js'
+export { Methods, Notifications } from './methods.js'
+
+// Schemas (for callers that want runtime validation)
+export * from './schemas/index.js'
+export type { AgentTool, MdxpToolDef } from './tools.js'
+
+// Tool registry / AI-agent tool catalog
+export {
+  SERVER_INITIATED_METHODS,
+  Tools,
+  toAgentToolCatalog,
+} from './tools.js'
+// Types (re-exported from schemas via types barrel)
+export type * from './types.js'

package/src/methods.ts

@@ -0,0 +1,36 @@
+// MDXP method names (request/response) — see docs/01-protocol-mdxp.md §6
+export const Methods = Object.freeze({
+  MotrixInitialize: 'motrix/initialize',
+  DownloadSubmit: 'download/submit',
+  DownloadCancel: 'download/cancel',
+  UrlProbe: 'url/probe',
+  UrlResolve: 'url/resolve',
+  SystemPing: 'system/ping',
+  // v1 control-plane (Spec 2)
+  DownloadAdd: 'download/add',
+  TaskList: 'task/list',
+  TaskGet: 'task/get',
+  TaskPause: 'task/pause',
+  TaskResume: 'task/resume',
+  TaskRemove: 'task/remove',
+  StatsGet: 'stats/get',
+  EngineStatus: 'engine/status',
+} as const)
+
+export type Method = (typeof Methods)[keyof typeof Methods]
+
+// MDXP notification names — see docs/01-protocol-mdxp.md §7.
+// `motrix/initialized` follows LSP convention (no $/ prefix because it's
+// a one-way handshake, not a protocol meta-event).
+export const Notifications = Object.freeze({
+  MotrixInitialized: 'motrix/initialized',
+  TaskProgress: '$/task/progress',
+  TaskCompleted: '$/task/completed',
+  TaskError: '$/task/error',
+  PairRevoked: '$/pair/revoked',
+  CancelRequest: '$/cancelRequest',
+  // v1 control-plane (Spec 2): periodic aggregate stats push.
+  StatsUpdate: '$/stats',
+} as const)
+
+export type Notification = (typeof Notifications)[keyof typeof Notifications]

package/src/node.ts

@@ -0,0 +1,15 @@
+// Node platform entry.
+//
+// vscode-jsonrpc v9 split the runtime abstraction layer (RAL) out of the bare
+// `vscode-jsonrpc` entry: creating/listening on a `MessageConnection` now
+// requires a platform RAL to be installed first. Importing this module installs
+// the Node RAL into the SAME `vscode-jsonrpc` instance that this package's
+// `createMdxpConnection` resolves, so it is immune to duplicate-instance issues
+// across linked workspaces.
+//
+// A Node host (e.g. Motrix Turbo's bridge) only needs `import '@motrix/mdxp/node'`
+// once at bootstrap. The full public API is re-exported for convenience, so
+// `import { createMdxpConnection } from '@motrix/mdxp/node'` also works.
+import 'vscode-jsonrpc/node'
+
+export * from './index.js'

package/src/schemas/download-add.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod'
+import { MdxpTaskSchema } from './task.js'
+
+const HttpHeaderSchema = z.object({ name: z.string(), value: z.string() })
+
+/**
+ * Network download schemes allowed on the public, agent-facing `download/add`
+ * surface. Pinned at the contract boundary so an LLM-callable tool can never
+ * be coerced into `file://` (local file read / path traversal), `javascript:`,
+ * `data:`, etc. — independent of whatever the host handler does later.
+ */
+const SAFE_DOWNLOAD_URL = /^(https?|ftps?|sftp):\/\//i
+const safeDownloadUrl = z
+  .string()
+  .url()
+  .refine((u) => SAFE_DOWNLOAD_URL.test(u), {
+    message: 'unsupported URL scheme (allowed: http, https, ftp, ftps, sftp)',
+  })
+
+/**
+ * URL-shaped public "add a download" params — distinct from the browser-page
+ * `download/submit`. Discriminated on `kind`; strict variants so an agent's
+ * typo is loudly rejected rather than silently dropped. The host maps this onto
+ * its native taskCreateRequest in Spec 4.
+ */
+export const DownloadAddParamsSchema = z.discriminatedUnion('kind', [
+  z.strictObject({
+    kind: z.literal('url'),
+    saveDir: z.string().min(1),
+    uris: z.array(safeDownloadUrl).min(1),
+    filename: z.string().optional(),
+    headers: z.array(HttpHeaderSchema).optional(),
+    connections: z.number().int().min(1).max(128).optional(),
+    proxy: z.string().optional(),
+  }),
+  z.strictObject({
+    kind: z.literal('magnet'),
+    saveDir: z.string().min(1),
+    uri: z.string().startsWith('magnet:?'),
+    selectedFiles: z.array(z.number().int().nonnegative()).optional(),
+  }),
+  z.strictObject({
+    kind: z.literal('torrent'),
+    saveDir: z.string().min(1),
+    base64: z.string().min(1),
+    selectedFiles: z.array(z.number().int().nonnegative()).optional(),
+    displayName: z.string().optional(),
+  }),
+])
+
+/** Result is the created task snapshot so callers render without polling. */
+export const DownloadAddResultSchema = MdxpTaskSchema
+
+export type DownloadAddParams = z.infer<typeof DownloadAddParamsSchema>
+export type DownloadAddResult = z.infer<typeof DownloadAddResultSchema>

package/src/schemas/download.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod'
+import { SelectionSchema } from './selection.js'
+
+export const DownloadSubmitParamsSchema = z.object({
+  source: z.object({
+    pageUrl: z.string().url(),
+    pageTitle: z.string().max(500),
+    detectedAt: z.number(),
+    siteHint: z.string().max(64).optional(),
+  }),
+  selection: SelectionSchema,
+  meta: z.object({
+    suggestedFilename: z.string().max(255),
+    qualityLabel: z.string().max(64),
+    estimatedBytes: z.number().nonnegative().optional(),
+    durationSec: z.number().nonnegative().optional(),
+  }),
+  /**
+   * Client-generated key identifying ONE logical submit. Motrix dedups on
+   * (session, key): a retransmit of the same submission — lost response,
+   * reconnect replay — returns the original task instead of creating a
+   * duplicate. Optional for backward compatibility.
+   */
+  idempotencyKey: z.string().min(8).max(128).optional(),
+})
+
+export const DownloadSubmitResultSchema = z.object({
+  taskId: z.string().min(1),
+})
+
+export const DownloadCancelParamsSchema = z.object({
+  taskId: z.string().min(1),
+})
+
+export const DownloadCancelResultSchema = z.object({
+  ok: z.literal(true),
+})
+
+export type DownloadSubmitParams = z.infer<typeof DownloadSubmitParamsSchema>
+export type DownloadSubmitResult = z.infer<typeof DownloadSubmitResultSchema>
+export type DownloadCancelParams = z.infer<typeof DownloadCancelParamsSchema>
+export type DownloadCancelResult = z.infer<typeof DownloadCancelResultSchema>

package/src/schemas/engine.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod'
+
+export const EngineStateSchema = z.enum([
+  'stopped',
+  'starting',
+  'ready',
+  'restarting',
+  'failed',
+])
+
+/** Capability-discovery info; all fields are external-safe. `features` is the
+ *  raw engine feature-string list (e.g. contains 'SQLite3-Persistence'). */
+export const EngineFeatureReportSchema = z.object({
+  version: z.string(),
+  features: z.array(z.string()),
+  hasBtSeedUnverified: z.boolean(),
+  hasBtSaveMetadata: z.boolean(),
+  hasMoveStorage: z.boolean(),
+  hasSqlitePersistence: z.boolean(),
+})
+
+export const EngineStatusParamsSchema = z.strictObject({})
+
+export const EngineStatusResultSchema = z.object({
+  state: EngineStateSchema,
+  featureReport: EngineFeatureReportSchema.nullable(),
+})
+
+export type EngineState = z.infer<typeof EngineStateSchema>
+export type EngineFeatureReport = z.infer<typeof EngineFeatureReportSchema>
+export type EngineStatusParams = z.infer<typeof EngineStatusParamsSchema>
+export type EngineStatusResult = z.infer<typeof EngineStatusResultSchema>

package/src/schemas/events.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod'
+
+export const TaskProgressParamsSchema = z.object({
+  taskId: z.string().min(1),
+  bytesDone: z.number().nonnegative(),
+  bytesTotal: z.number().nonnegative().nullable(),
+  speedBps: z.number().nonnegative(),
+  etaSec: z.number().nonnegative().nullable(),
+  phase: z.enum(['queued', 'downloading', 'muxing', 'finalizing']),
+})
+
+export const TaskCompletedParamsSchema = z.object({
+  taskId: z.string().min(1),
+  filePath: z.string().min(1),
+  durationMs: z.number().nonnegative(),
+})
+
+export const TaskErrorParamsSchema = z.object({
+  taskId: z.string().min(1),
+  code: z.string(),
+  message: z.string(),
+})
+
+export const PairRevokedParamsSchema = z.object({
+  reason: z.string(),
+})
+
+export const CancelRequestParamsSchema = z.object({
+  id: z.string().min(1),
+})
+
+export type TaskProgressParams = z.infer<typeof TaskProgressParamsSchema>
+export type TaskCompletedParams = z.infer<typeof TaskCompletedParamsSchema>
+export type TaskErrorParams = z.infer<typeof TaskErrorParamsSchema>
+export type PairRevokedParams = z.infer<typeof PairRevokedParamsSchema>
+export type CancelRequestParams = z.infer<typeof CancelRequestParamsSchema>

package/src/schemas/index.ts

@@ -0,0 +1,11 @@
+export * from './download.js'
+export * from './download-add.js'
+export * from './engine.js'
+export * from './events.js'
+export * from './initialize.js'
+export * from './resource.js'
+export * from './selection.js'
+export * from './stats.js'
+export * from './system.js'
+export * from './task.js'
+export * from './url.js'

package/src/schemas/initialize.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod'
+
+const PROTOCOL_VERSION = '1.0'
+
+const AdapterDeclSchema = z.object({
+  id: z.string().min(1),
+  version: z.string().min(1),
+  urlPatterns: z.array(z.string()),
+  capabilities: z.array(z.enum(['resolve', 'sniff', 'batch'])),
+})
+
+const ClientCapabilitiesSchema = z.object({
+  submitDownload: z.boolean().optional(),
+  resolveUrl: z.boolean().optional(),
+  probeUrl: z.boolean().optional(),
+  cancellation: z.boolean().optional(),
+  progress: z.boolean().optional(),
+})
+
+const ExtensionClientSchema = z.object({
+  kind: z.literal('extension'),
+  name: z.string().min(1),
+  version: z.string().min(1),
+  extensionId: z.string().min(1),
+  browser: z.enum(['chromium', 'firefox']),
+  browserVersion: z.string().min(1),
+  locale: z.string().min(1),
+})
+
+const CliClientSchema = z.object({
+  kind: z.literal('cli'),
+  name: z.string().min(1),
+  version: z.string().min(1),
+  locale: z.string().min(1).optional(),
+  pid: z.number().int().optional(),
+  host: z.string().optional(),
+})
+
+/**
+ * Client identity, generalized to a `kind` discriminated union so non-extension
+ * clients (CLI/agents) can connect. Compat shim: the shipped extension sends NO
+ * `kind` field, so inject `kind: 'extension'` when absent before discriminating
+ * — keeping `PROTOCOL_VERSION` '1.0' and the existing extension payload valid.
+ */
+const ClientSchema = z.preprocess(
+  (value) =>
+    value &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    (value as { kind?: unknown }).kind === undefined
+      ? { ...(value as Record<string, unknown>), kind: 'extension' }
+      : value,
+  z.discriminatedUnion('kind', [ExtensionClientSchema, CliClientSchema])
+)
+
+export const InitializeParamsSchema = z.object({
+  protocolVersion: z.literal(PROTOCOL_VERSION),
+  client: ClientSchema,
+  capabilities: ClientCapabilitiesSchema,
+  adapters: z.array(AdapterDeclSchema),
+})
+
+const ServerAdapterSchema = z.object({
+  id: z.string().min(1),
+  urlPatterns: z.array(z.string()),
+})
+
+const ServerCapabilitiesSchema = z.object({
+  ffmpegAvailable: z.boolean(),
+  selectionKinds: z.array(z.enum(['direct', 'hls', 'dash', 'mux'])),
+  progress: z.boolean(),
+  cancellation: z.boolean(),
+})
+
+export const InitializeResultSchema = z.object({
+  protocolVersion: z.literal(PROTOCOL_VERSION),
+  server: z.object({
+    name: z.string().min(1),
+    version: z.string().min(1),
+    runtime: z.enum(['electron', 'server']),
+  }),
+  capabilities: ServerCapabilitiesSchema,
+  serverAdapters: z.array(ServerAdapterSchema),
+  pairToken: z.string().optional(),
+})
+
+export type InitializeParams = z.infer<typeof InitializeParamsSchema>
+export type InitializeResult = z.infer<typeof InitializeResultSchema>

package/src/schemas/resource.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod'
+
+const HttpUrl = z.httpUrl({ message: 'URL must be http: or https:' })
+
+export const CookieSchema = z.object({
+  name: z.string(),
+  value: z.string(),
+  domain: z.string(),
+  path: z.string().default('/'),
+  secure: z.boolean().default(false),
+  httpOnly: z.boolean().default(false),
+  sameSite: z
+    .enum(['strict', 'lax', 'none', 'unspecified'])
+    .default('unspecified'),
+  expiresAt: z.number().optional(),
+})
+
+export const ResourceSchema = z.object({
+  url: HttpUrl,
+  headers: z.record(z.string(), z.string()).default({}),
+  cookies: z.array(CookieSchema).default([]),
+  refererPolicy: z.string().default('strict-origin-when-cross-origin'),
+})
+
+export type Resource = z.infer<typeof ResourceSchema>
+export type Cookie = z.infer<typeof CookieSchema>

package/src/schemas/selection.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod'
+import { ResourceSchema } from './resource.js'
+
+export const SelectionSchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('direct'),
+    primary: ResourceSchema,
+    container: z.string().optional(),
+  }),
+  z.object({
+    kind: z.literal('hls'),
+    primary: ResourceSchema,
+    container: z.enum(['mp4', 'mkv', 'ts']).default('mp4'),
+  }),
+  z.object({
+    kind: z.literal('dash'),
+    primary: ResourceSchema,
+    container: z.enum(['mp4', 'mkv']).default('mp4'),
+  }),
+  z.object({
+    kind: z.literal('mux'),
+    video: ResourceSchema,
+    audio: ResourceSchema,
+    container: z.enum(['mp4', 'mkv']).default('mp4'),
+  }),
+  z.object({
+    kind: z.literal('magnet'),
+    uri: z.string().startsWith('magnet:?'),
+  }),
+])
+
+export type Selection = z.infer<typeof SelectionSchema>

package/src/schemas/stats.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+
+/**
+ * Aggregate global stats — mirrors the host's domain `GlobalStats` exactly.
+ * Also the payload of the `$/stats` notification.
+ */
+export const StatsResultSchema = z.object({
+  totalDownloadSpeed: z.number(),
+  totalUploadSpeed: z.number(),
+  activeTasks: z.number(),
+  waitingTasks: z.number(),
+  stoppedTasks: z.number(),
+})
+
+export const StatsGetParamsSchema = z.strictObject({})
+
+export type StatsResult = z.infer<typeof StatsResultSchema>
+export type StatsGetParams = z.infer<typeof StatsGetParamsSchema>
+/** `$/stats` notification carries the same shape as `stats/get`'s result. */
+export type StatsUpdateParams = StatsResult

package/src/schemas/system.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+export const SystemPingParamsSchema = z.object({
+  sentAt: z.number(),
+})
+
+export const SystemPingResultSchema = z.object({
+  sentAt: z.number(),
+  recvAt: z.number(),
+})
+
+export type SystemPingParams = z.infer<typeof SystemPingParamsSchema>
+export type SystemPingResult = z.infer<typeof SystemPingResultSchema>