@finalai/agent-protocol 0.1.0

package/dist/modules/agent-platform/sessions.mjs

@@ -0,0 +1,242 @@
+import * as z from "zod";
+import { jsonObjectSchema, jsonValueSchema } from "../json.mjs";
+import { tolerantStringEnum } from "../tolerance.mjs";
+import { acpWireMessageSchema, contentInputSchema, nullableNumber, nullableString } from "./common.mjs";
+import {
+  AcpFrameDirection,
+  AcpPreviewKind,
+  AgentSessionState,
+  AgentTurnPolicy,
+  PendingEventState,
+  PendingRequestKind
+} from "./enums.mjs";
+const sessionConfigOptionSchema = z.looseObject({
+  id: z.string().optional(),
+  configId: z.string().optional(),
+  name: z.string().optional(),
+  category: z.string().nullable().optional(),
+  currentValue: jsonValueSchema.optional()
+});
+const sessionSchema = z.object({
+  id: z.string(),
+  organizationId: z.string(),
+  agentId: z.string(),
+  revisionId: nullableString(),
+  ownerUserId: nullableString(),
+  conversationId: nullableString(),
+  participantId: nullableString(),
+  state: tolerantStringEnum(AgentSessionState),
+  turnPolicy: tolerantStringEnum(AgentTurnPolicy),
+  title: nullableString(),
+  /** Seq of the newest logged frame; 0 before the first frame. */
+  headSeq: z.number().default(0),
+  configOptions: z.array(sessionConfigOptionSchema).default([]),
+  lastPromptAt: nullableString(),
+  closedAt: nullableString(),
+  createdAt: z.string(),
+  updatedAt: nullableString()
+});
+const sessionManifestSchema = z.object({
+  sessionId: z.string(),
+  revisionId: nullableString(),
+  resolvedAt: nullableString(),
+  manifest: jsonObjectSchema.nullable().default(null),
+  report: jsonObjectSchema.nullable().default(null)
+});
+const turnSchema = z.object({
+  id: z.string(),
+  sessionId: z.string(),
+  promptMessageId: nullableString(),
+  startedAt: z.string(),
+  endedAt: nullableString(),
+  stopReason: nullableString(),
+  fromSeq: nullableNumber(),
+  toSeq: nullableNumber(),
+  inputTokens: nullableNumber(),
+  outputTokens: nullableNumber()
+});
+const promptAcceptedSchema = z.object({
+  messageId: z.string(),
+  turnId: z.string(),
+  /** Seq of the logged `session/prompt` frame; a turn-scoped stream starts here. */
+  fromSeq: nullableNumber()
+});
+const acpFrameEventSchema = z.object({
+  seq: z.number(),
+  frame: acpWireMessageSchema,
+  direction: tolerantStringEnum(AcpFrameDirection),
+  at: nullableString(),
+  /**
+   * The open pending request an agent request frame (`session/request_permission`,
+   * `elicitation/create`) raised: answer it with `respond({ pendingId })`. Replay
+   * pages set it; live frames precede their pending request, so the SDK joins
+   * them with the session's `acp.pending` events.
+   */
+  pendingId: nullableString()
+});
+const acpLiveFrameEventSchema = acpFrameEventSchema.extend({ streamId: z.string() });
+const acpLiveResetEventSchema = z.object({
+  streamId: nullableString(),
+  throughSeq: nullableNumber(),
+  reason: nullableString()
+});
+const acpPreviewEventSchema = z.object({
+  seq: z.number(),
+  text: z.string(),
+  // Not `kind`: realtime events are flattened under the envelope's kind.
+  previewKind: tolerantStringEnum(AcpPreviewKind).nullable().default(null),
+  messageId: nullableString(),
+  turnId: nullableString()
+});
+const permissionOptionSchema = z.object({
+  optionId: z.string(),
+  name: z.string(),
+  // ACP `PermissionOptionKind` (allow_once, allow_always, reject_once, ...); open.
+  kind: nullableString()
+});
+const pendingRequestDetailSchema = z.object({
+  title: nullableString(),
+  body: nullableString(),
+  options: z.array(permissionOptionSchema).default([]),
+  /** Elicitation `requestedSchema` (form mode). */
+  schema: jsonValueSchema.nullable().default(null),
+  /** Elicitation mode (`form`, `url`); open. */
+  mode: nullableString(),
+  url: nullableString(),
+  toolCall: jsonValueSchema.nullable().default(null)
+});
+const pendingRequestSchema = z.object({
+  id: z.string(),
+  sessionId: z.string(),
+  turnId: nullableString(),
+  conversationId: nullableString(),
+  kind: tolerantStringEnum(PendingRequestKind),
+  request: pendingRequestDetailSchema,
+  audienceParticipantIds: z.array(z.string()).default([]),
+  audienceUserIds: z.array(z.string()).default([]),
+  logSeq: nullableNumber(),
+  createdAt: nullableString(),
+  expiresAt: nullableString(),
+  resolvedAt: nullableString(),
+  resolvedByUserId: nullableString(),
+  outcome: jsonValueSchema.nullable().default(null)
+});
+const acpPendingEventSchema = z.object({
+  pending: pendingRequestSchema,
+  state: tolerantStringEnum(PendingEventState)
+});
+const sessionStateEventSchema = z.object({
+  state: tolerantStringEnum(AgentSessionState),
+  turnId: nullableString(),
+  stopReason: nullableString()
+});
+const createSessionResponseSchema = z.object({
+  session: sessionSchema,
+  turn: promptAcceptedSchema.nullable().default(null)
+});
+const FIRST_ACP_FRAME_SEQ = 1;
+const sessionFramesPageSchema = z.object({
+  frames: z.array(acpFrameEventSchema),
+  headSeq: z.number().default(0),
+  hasMore: z.boolean().default(false)
+});
+const pendingRequestListSchema = z.object({
+  pending: z.array(pendingRequestSchema),
+  /** Pass as `cursor` for the next (older) page; null on the last page. */
+  nextCursor: nullableString()
+});
+const respondPendingResponseSchema = z.object({ resolved: z.boolean() });
+const createSessionRequestSchema = z.strictObject({
+  /** Agent slug or id. */
+  agent: z.string().min(1),
+  /** An immutable revision for author test sessions; requires agents:write. */
+  revisionId: z.string().min(1).optional(),
+  message: contentInputSchema.optional(),
+  turnPolicy: z.enum(AgentTurnPolicy).optional(),
+  idempotencyKey: z.string().min(1).max(200).optional(),
+  title: z.string().max(200).optional(),
+  meta: jsonObjectSchema.optional(),
+  /** The client's clock when the person submitted `message` (prompt-to-inference trace). */
+  clientSubmittedAtMs: z.number().int().nonnegative().optional()
+});
+const forkSessionRequestSchema = z.strictObject({
+  idempotencyKey: z.string().min(1).max(200),
+  title: z.string().max(200).optional()
+});
+const promptSessionRequestSchema = z.strictObject({
+  content: contentInputSchema,
+  turnPolicy: z.enum(AgentTurnPolicy).optional(),
+  idempotencyKey: z.string().min(1).max(200),
+  meta: jsonObjectSchema.optional(),
+  /** The client's clock when the person submitted (prompt-to-inference trace). */
+  clientSubmittedAtMs: z.number().int().nonnegative().optional()
+});
+const observeSessionRequestSchema = z.strictObject({
+  content: contentInputSchema,
+  idempotencyKey: z.string().min(1).max(200).optional(),
+  /** The observe's `_meta` (e.g. `"final.ai".author`), as on prompt. */
+  meta: jsonObjectSchema.optional()
+});
+const cancelRequestSchema = z.strictObject({
+  reason: z.string().max(500).optional()
+});
+const cancelConversationRequestSchema = cancelRequestSchema.extend({
+  /** Retry the same Stop without interrupting messages posted after this sequence. */
+  throughMessageSeq: z.number().int().nonnegative().optional()
+});
+const pendingOutcomeInputSchema = z.union([
+  z.strictObject({ outcome: z.literal("selected"), optionId: z.string().min(1) }),
+  z.strictObject({ outcome: z.literal("cancelled") }),
+  z.strictObject({ action: z.literal("accept"), content: jsonObjectSchema.optional() }),
+  z.strictObject({ action: z.literal("decline") }),
+  z.strictObject({ action: z.literal("cancel") })
+]);
+const respondPendingRequestSchema = z.strictObject({
+  pendingId: z.string().min(1),
+  outcome: pendingOutcomeInputSchema
+});
+const setConfigOptionRequestSchema = z.strictObject({
+  configId: z.string().min(1),
+  value: jsonValueSchema
+});
+const listPendingQuerySchema = z.strictObject({
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().positive().max(200).optional()
+});
+const sessionFramesQuerySchema = z.strictObject({
+  fromSeq: z.coerce.number().int().nonnegative().default(0),
+  limit: z.coerce.number().int().positive().max(1e3).optional()
+});
+export {
+  FIRST_ACP_FRAME_SEQ,
+  acpFrameEventSchema,
+  acpLiveFrameEventSchema,
+  acpLiveResetEventSchema,
+  acpPendingEventSchema,
+  acpPreviewEventSchema,
+  cancelConversationRequestSchema,
+  cancelRequestSchema,
+  createSessionRequestSchema,
+  createSessionResponseSchema,
+  forkSessionRequestSchema,
+  listPendingQuerySchema,
+  observeSessionRequestSchema,
+  pendingOutcomeInputSchema,
+  pendingRequestDetailSchema,
+  pendingRequestListSchema,
+  pendingRequestSchema,
+  permissionOptionSchema,
+  promptAcceptedSchema,
+  promptSessionRequestSchema,
+  respondPendingRequestSchema,
+  respondPendingResponseSchema,
+  sessionConfigOptionSchema,
+  sessionFramesPageSchema,
+  sessionFramesQuerySchema,
+  sessionManifestSchema,
+  sessionSchema,
+  sessionStateEventSchema,
+  setConfigOptionRequestSchema,
+  turnSchema
+};
+//# sourceMappingURL=sessions.mjs.map

package/dist/modules/agent-platform/sessions.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/agent-platform/sessions.ts"],
+  "sourcesContent": ["import * as z from 'zod';\n\nimport { jsonObjectSchema, jsonValueSchema } from \"../json.mjs\";\n\nimport { tolerantStringEnum } from \"../tolerance.mjs\";\n\nimport { acpWireMessageSchema, contentInputSchema, nullableNumber, nullableString } from \"./common.mjs\";\n\nimport {\n  AcpFrameDirection,\n  AcpPreviewKind,\n  AgentSessionState,\n  AgentTurnPolicy,\n  PendingEventState,\n  PendingRequestKind,\n} from \"./enums.mjs\";\n\n// Sessions: direct ACP use of an agent (`/api/v1/sessions`) and the session\n// realtime topic `agent.session:<sessionId>`.\n\n/**\n * One ACP session config option (model, thought level, mode, ...). ACP v2 keys\n * options by `configId`; `id` is the older spelling. Every other field (type,\n * category, options) is kept loosely for clients to read.\n */\nexport const sessionConfigOptionSchema = z.looseObject({\n  id: z.string().optional(),\n  configId: z.string().optional(),\n  name: z.string().optional(),\n  category: z.string().nullable().optional(),\n  currentValue: jsonValueSchema.optional(),\n});\n\nexport const sessionSchema = z.object({\n  id: z.string(),\n  organizationId: z.string(),\n  agentId: z.string(),\n  revisionId: nullableString(),\n  ownerUserId: nullableString(),\n  conversationId: nullableString(),\n  participantId: nullableString(),\n  state: tolerantStringEnum(AgentSessionState),\n  turnPolicy: tolerantStringEnum(AgentTurnPolicy),\n  title: nullableString(),\n  /** Seq of the newest logged frame; 0 before the first frame. */\n  headSeq: z.number().default(0),\n  configOptions: z.array(sessionConfigOptionSchema).default([]),\n  lastPromptAt: nullableString(),\n  closedAt: nullableString(),\n  createdAt: z.string(),\n  updatedAt: nullableString(),\n});\n\nexport type AgentSessionIface = z.infer<typeof sessionSchema>;\n\n/**\n * `GET /v1/sessions/:id/manifest`: what the session was given: the\n * revision's manifest with its dynamic slots resolved, and the resolver\n * report (each slot's resolved value, compatibility notes). Null fields\n * before the session's first open resolved them.\n */\nexport const sessionManifestSchema = z.object({\n  sessionId: z.string(),\n  revisionId: nullableString(),\n  resolvedAt: nullableString(),\n  manifest: jsonObjectSchema.nullable().default(null),\n  report: jsonObjectSchema.nullable().default(null),\n});\n\nexport type SessionManifestIface = z.infer<typeof sessionManifestSchema>;\n\nexport const turnSchema = z.object({\n  id: z.string(),\n  sessionId: z.string(),\n  promptMessageId: nullableString(),\n  startedAt: z.string(),\n  endedAt: nullableString(),\n  stopReason: nullableString(),\n  fromSeq: nullableNumber(),\n  toSeq: nullableNumber(),\n  inputTokens: nullableNumber(),\n  outputTokens: nullableNumber(),\n});\n\nexport type AgentTurnIface = z.infer<typeof turnSchema>;\n\n/** A prompt the session accepted (ACP insertion semantics: not the end of the turn). */\nexport const promptAcceptedSchema = z.object({\n  messageId: z.string(),\n  turnId: z.string(),\n  /** Seq of the logged `session/prompt` frame; a turn-scoped stream starts here. */\n  fromSeq: nullableNumber(),\n});\n\nexport type PromptAcceptedIface = z.infer<typeof promptAcceptedSchema>;\n\n/** One logged ACP frame: the `acp.frame` realtime payload and a replay row. */\nexport const acpFrameEventSchema = z.object({\n  seq: z.number(),\n  frame: acpWireMessageSchema,\n  direction: tolerantStringEnum(AcpFrameDirection),\n  at: nullableString(),\n  /**\n   * The open pending request an agent request frame (`session/request_permission`,\n   * `elicitation/create`) raised: answer it with `respond({ pendingId })`. Replay\n   * pages set it; live frames precede their pending request, so the SDK joins\n   * them with the session's `acp.pending` events.\n   */\n  pendingId: nullableString(),\n});\n\nexport type AcpFrameEventIface = z.infer<typeof acpFrameEventSchema>;\n\n/** Provisional full frame; `streamId` scopes its seq until the durable stream confirms it. */\nexport const acpLiveFrameEventSchema = acpFrameEventSchema.extend({ streamId: z.string() });\n\nexport type AcpLiveFrameEventIface = z.infer<typeof acpLiveFrameEventSchema>;\n\n/** Discard provisional state after a lost writer/stream; null means the durable head is unknown. */\nexport const acpLiveResetEventSchema = z.object({\n  streamId: nullableString(),\n  throughSeq: nullableNumber(),\n  reason: nullableString(),\n});\n\nexport type AcpLiveResetEventIface = z.infer<typeof acpLiveResetEventSchema>;\n\n/** `acp.preview`: low-latency text ahead of the durable frames (voice, typing previews). */\nexport const acpPreviewEventSchema = z.object({\n  seq: z.number(),\n  text: z.string(),\n  // Not `kind`: realtime events are flattened under the envelope's kind.\n  previewKind: tolerantStringEnum(AcpPreviewKind).nullable().default(null),\n  messageId: nullableString(),\n  turnId: nullableString(),\n});\n\nexport type AcpPreviewEventIface = z.infer<typeof acpPreviewEventSchema>;\n\nexport const permissionOptionSchema = z.object({\n  optionId: z.string(),\n  name: z.string(),\n  // ACP `PermissionOptionKind` (allow_once, allow_always, reject_once, ...); open.\n  kind: nullableString(),\n});\n\nexport type PermissionOptionIface = z.infer<typeof permissionOptionSchema>;\n\nexport const pendingRequestDetailSchema = z.object({\n  title: nullableString(),\n  body: nullableString(),\n  options: z.array(permissionOptionSchema).default([]),\n  /** Elicitation `requestedSchema` (form mode). */\n  schema: jsonValueSchema.nullable().default(null),\n  /** Elicitation mode (`form`, `url`); open. */\n  mode: nullableString(),\n  url: nullableString(),\n  toolCall: jsonValueSchema.nullable().default(null),\n});\n\nexport const pendingRequestSchema = z.object({\n  id: z.string(),\n  sessionId: z.string(),\n  turnId: nullableString(),\n  conversationId: nullableString(),\n  kind: tolerantStringEnum(PendingRequestKind),\n  request: pendingRequestDetailSchema,\n  audienceParticipantIds: z.array(z.string()).default([]),\n  audienceUserIds: z.array(z.string()).default([]),\n  logSeq: nullableNumber(),\n  createdAt: nullableString(),\n  expiresAt: nullableString(),\n  resolvedAt: nullableString(),\n  resolvedByUserId: nullableString(),\n  outcome: jsonValueSchema.nullable().default(null),\n});\n\nexport type PendingRequestIface = z.infer<typeof pendingRequestSchema>;\n\nexport const acpPendingEventSchema = z.object({\n  pending: pendingRequestSchema,\n  state: tolerantStringEnum(PendingEventState),\n});\n\nexport type AcpPendingEventIface = z.infer<typeof acpPendingEventSchema>;\n\nexport const sessionStateEventSchema = z.object({\n  state: tolerantStringEnum(AgentSessionState),\n  turnId: nullableString(),\n  stopReason: nullableString(),\n});\n\nexport type SessionStateEventIface = z.infer<typeof sessionStateEventSchema>;\n\nexport const createSessionResponseSchema = z.object({\n  session: sessionSchema,\n  turn: promptAcceptedSchema.nullable().default(null),\n});\n\nexport type CreateSessionResponseIface = z.infer<typeof createSessionResponseSchema>;\n\n/** Seq of a session's first logged frame; the log is dense from here. */\nexport const FIRST_ACP_FRAME_SEQ = 1;\n\n/**\n * `GET /sessions/:id/frames?fromSeq&limit`: `fromSeq` is inclusive and clamped\n * to `FIRST_ACP_FRAME_SEQ`; `hasMore` is set while the page is full and ends\n * before `headSeq`.\n */\nexport const sessionFramesPageSchema = z.object({\n  frames: z.array(acpFrameEventSchema),\n  headSeq: z.number().default(0),\n  hasMore: z.boolean().default(false),\n});\n\nexport type SessionFramesPageIface = z.infer<typeof sessionFramesPageSchema>;\n\nexport const pendingRequestListSchema = z.object({\n  pending: z.array(pendingRequestSchema),\n  /** Pass as `cursor` for the next (older) page; null on the last page. */\n  nextCursor: nullableString(),\n});\n\nexport type PendingRequestListIface = z.infer<typeof pendingRequestListSchema>;\n\nexport const respondPendingResponseSchema = z.object({ resolved: z.boolean() });\n\nexport type RespondPendingResponseIface = z.infer<typeof respondPendingResponseSchema>;\n\n// Client-to-server requests.\n\nexport const createSessionRequestSchema = z.strictObject({\n  /** Agent slug or id. */\n  agent: z.string().min(1),\n  /** An immutable revision for author test sessions; requires agents:write. */\n  revisionId: z.string().min(1).optional(),\n  message: contentInputSchema.optional(),\n  turnPolicy: z.enum(AgentTurnPolicy).optional(),\n  idempotencyKey: z.string().min(1).max(200).optional(),\n  title: z.string().max(200).optional(),\n  meta: jsonObjectSchema.optional(),\n  /** The client's clock when the person submitted `message` (prompt-to-inference trace). */\n  clientSubmittedAtMs: z.number().int().nonnegative().optional(),\n});\n\nexport type CreateSessionRequestIface = z.infer<typeof createSessionRequestSchema>;\n\nexport const forkSessionRequestSchema = z.strictObject({\n  idempotencyKey: z.string().min(1).max(200),\n  title: z.string().max(200).optional(),\n});\n\nexport type ForkSessionRequestIface = z.infer<typeof forkSessionRequestSchema>;\n\nexport const promptSessionRequestSchema = z.strictObject({\n  content: contentInputSchema,\n  turnPolicy: z.enum(AgentTurnPolicy).optional(),\n  idempotencyKey: z.string().min(1).max(200),\n  meta: jsonObjectSchema.optional(),\n  /** The client's clock when the person submitted (prompt-to-inference trace). */\n  clientSubmittedAtMs: z.number().int().nonnegative().optional(),\n});\n\nexport type PromptSessionRequestIface = z.infer<typeof promptSessionRequestSchema>;\n\nexport const observeSessionRequestSchema = z.strictObject({\n  content: contentInputSchema,\n  idempotencyKey: z.string().min(1).max(200).optional(),\n  /** The observe's `_meta` (e.g. `\"final.ai\".author`), as on prompt. */\n  meta: jsonObjectSchema.optional(),\n});\n\nexport const cancelRequestSchema = z.strictObject({\n  reason: z.string().max(500).optional(),\n});\n\nexport const cancelConversationRequestSchema = cancelRequestSchema.extend({\n  /** Retry the same Stop without interrupting messages posted after this sequence. */\n  throughMessageSeq: z.number().int().nonnegative().optional(),\n});\n\n/** ACP outcomes: `session/request_permission` and `elicitation/create` responses. */\nexport const pendingOutcomeInputSchema = z.union([\n  z.strictObject({ outcome: z.literal('selected'), optionId: z.string().min(1) }),\n  z.strictObject({ outcome: z.literal('cancelled') }),\n  z.strictObject({ action: z.literal('accept'), content: jsonObjectSchema.optional() }),\n  z.strictObject({ action: z.literal('decline') }),\n  z.strictObject({ action: z.literal('cancel') }),\n]);\n\nexport type PendingOutcomeInput = z.infer<typeof pendingOutcomeInputSchema>;\n\nexport const respondPendingRequestSchema = z.strictObject({\n  pendingId: z.string().min(1),\n  outcome: pendingOutcomeInputSchema,\n});\n\nexport type RespondPendingRequestIface = z.infer<typeof respondPendingRequestSchema>;\n\nexport const setConfigOptionRequestSchema = z.strictObject({\n  configId: z.string().min(1),\n  value: jsonValueSchema,\n});\n\n/** `GET /pending`: newest first; `cursor` is a previous page's `nextCursor`. */\nexport const listPendingQuerySchema = z.strictObject({\n  cursor: z.string().optional(),\n  limit: z.coerce.number().int().positive().max(200).optional(),\n});\n\nexport const sessionFramesQuerySchema = z.strictObject({\n  fromSeq: z.coerce.number().int().nonnegative().default(0),\n  limit: z.coerce.number().int().positive().max(1000).optional(),\n});\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/base58.d.mts

@@ -0,0 +1,2 @@
+export declare const base58Encode: (bytes: Uint8Array) => string;
+export declare const base58Decode: (str: string) => Uint8Array;

package/dist/modules/base58.mjs

@@ -0,0 +1,46 @@
+const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const BASE = 58n;
+const VALUE_BY_CHAR = Object.fromEntries(
+  Array.from(ALPHABET, (ch, i) => [ch, i])
+);
+const base58Encode = (bytes) => {
+  let num = 0n;
+  for (const b of bytes) {
+    num = num * 256n + BigInt(b);
+  }
+  let out = "";
+  while (num > 0n) {
+    out = ALPHABET[Number(num % BASE)] + out;
+    num /= BASE;
+  }
+  for (const b of bytes) {
+    if (b !== 0) break;
+    out = "1" + out;
+  }
+  return out;
+};
+const base58Decode = (str) => {
+  let num = 0n;
+  for (const ch of str) {
+    const value = VALUE_BY_CHAR[ch];
+    if (value === void 0) {
+      throw new Error(`invalid base58 character: ${ch}`);
+    }
+    num = num * BASE + BigInt(value);
+  }
+  const out = [];
+  while (num > 0n) {
+    out.unshift(Number(num % 256n));
+    num /= 256n;
+  }
+  for (const ch of str) {
+    if (ch !== "1") break;
+    out.unshift(0);
+  }
+  return new Uint8Array(out);
+};
+export {
+  base58Decode,
+  base58Encode
+};
+//# sourceMappingURL=base58.mjs.map

package/dist/modules/base58.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/base58.ts"],
+  "sourcesContent": ["// Bitcoin-style base58: base64 without the ambiguous characters (0 O I l) and\n// without +/. Operates on raw bytes. Used to encode the 16 bytes of a uuid into\n// a short, URL-safe, copy-paste-safe token.\n//\n// We roll our own (rather than depend on a base58 package) because the surface\n// is tiny and fully pinned by the canonical test vectors in base58.test.ts.\n// This is not crypto: no checksum, no secrets, no constant-time requirement.\n\nconst ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\nconst BASE = 58n;\n\n// char -> value, for decode. Index into ALPHABET reversed.\nconst VALUE_BY_CHAR: Record<string, number> = Object.fromEntries(\n  Array.from(ALPHABET, (ch, i) => [ch, i]),\n);\n\nexport const base58Encode = (bytes: Uint8Array): string => {\n  let num = 0n;\n  for (const b of bytes) {\n    num = num * 256n + BigInt(b);\n  }\n  let out = '';\n  while (num > 0n) {\n    out = ALPHABET[Number(num % BASE)] + out;\n    num /= BASE;\n  }\n  // base58 is not pure base conversion: a bignum can't distinguish a leading\n  // 0x00 byte from no byte, so each leading zero byte maps to a leading '1'.\n  for (const b of bytes) {\n    if (b !== 0) break;\n    out = '1' + out;\n  }\n  return out;\n};\n\nexport const base58Decode = (str: string): Uint8Array => {\n  let num = 0n;\n  for (const ch of str) {\n    const value = VALUE_BY_CHAR[ch];\n    if (value === undefined) {\n      throw new Error(`invalid base58 character: ${ch}`);\n    }\n    num = num * BASE + BigInt(value);\n  }\n  const out: number[] = [];\n  while (num > 0n) {\n    out.unshift(Number(num % 256n));\n    num /= 256n;\n  }\n  // Inverse of the encode side: each leading '1' restores a leading 0x00 byte.\n  for (const ch of str) {\n    if (ch !== '1') break;\n    out.unshift(0);\n  }\n  return new Uint8Array(out);\n};\n"],
+  "mappings": "AAQA,MAAM,WAAW;AACjB,MAAM,OAAO;AAGb,MAAM,gBAAwC,OAAO;AAAA,EACnD,MAAM,KAAK,UAAU,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC;AACzC;AAEO,MAAM,eAAe,CAAC,UAA8B;AACzD,MAAI,MAAM;AACV,aAAW,KAAK,OAAO;AACrB,UAAM,MAAM,OAAO,OAAO,CAAC;AAAA,EAC7B;AACA,MAAI,MAAM;AACV,SAAO,MAAM,IAAI;AACf,UAAM,SAAS,OAAO,MAAM,IAAI,CAAC,IAAI;AACrC,WAAO;AAAA,EACT;AAGA,aAAW,KAAK,OAAO;AACrB,QAAI,MAAM,EAAG;AACb,UAAM,MAAM;AAAA,EACd;AACA,SAAO;AACT;AAEO,MAAM,eAAe,CAAC,QAA4B;AACvD,MAAI,MAAM;AACV,aAAW,MAAM,KAAK;AACpB,UAAM,QAAQ,cAAc,EAAE;AAC9B,QAAI,UAAU,QAAW;AACvB,YAAM,IAAI,MAAM,6BAA6B,EAAE,EAAE;AAAA,IACnD;AACA,UAAM,MAAM,OAAO,OAAO,KAAK;AAAA,EACjC;AACA,QAAM,MAAgB,CAAC;AACvB,SAAO,MAAM,IAAI;AACf,QAAI,QAAQ,OAAO,MAAM,IAAI,CAAC;AAC9B,WAAO;AAAA,EACT;AAEA,aAAW,MAAM,KAAK;AACpB,QAAI,OAAO,IAAK;AAChB,QAAI,QAAQ,CAAC;AAAA,EACf;AACA,SAAO,IAAI,WAAW,GAAG;AAC3B;",
+  "names": []
+}

package/dist/modules/index.d.mts

@@ -0,0 +1,4 @@
+export * from "./json.mjs";
+export * from "./json-rpc.mjs";
+export * from "./process-inspection.mjs";
+export * from "./tolerance.mjs";

package/dist/modules/index.mjs

@@ -0,0 +1,5 @@
+export * from "./json.mjs";
+export * from "./json-rpc.mjs";
+export * from "./process-inspection.mjs";
+export * from "./tolerance.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/modules/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/index.ts"],
+  "sourcesContent": ["export * from \"./json.mjs\";\nexport * from \"./json-rpc.mjs\";\nexport * from \"./process-inspection.mjs\";\nexport * from \"./tolerance.mjs\";\n"],
+  "mappings": "AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;",
+  "names": []
+}

package/dist/modules/json-rpc.d.mts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+export declare const jsonRpcIdSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+export declare const jsonRpcMessageSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    method: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodType<import("./json.mjs").JsonValue, unknown, z.core.$ZodTypeInternals<import("./json.mjs").JsonValue, unknown>>>;
+    result: z.ZodOptional<z.ZodType<import("./json.mjs").JsonValue, unknown, z.core.$ZodTypeInternals<import("./json.mjs").JsonValue, unknown>>>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodType<import("./json.mjs").JsonValue, unknown, z.core.$ZodTypeInternals<import("./json.mjs").JsonValue, unknown>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type JsonRpcMessage = z.infer<typeof jsonRpcMessageSchema>;

package/dist/modules/json-rpc.mjs

@@ -0,0 +1,20 @@
+import * as z from "zod";
+import { jsonValueSchema } from "./json.mjs";
+const jsonRpcIdSchema = z.union([z.string(), z.number(), z.null()]);
+const jsonRpcMessageSchema = z.object({
+  jsonrpc: z.literal("2.0"),
+  id: jsonRpcIdSchema.optional(),
+  method: z.string().min(1).optional(),
+  params: jsonValueSchema.optional(),
+  result: jsonValueSchema.optional(),
+  error: z.object({
+    code: z.number().int(),
+    message: z.string(),
+    data: jsonValueSchema.optional()
+  }).optional()
+});
+export {
+  jsonRpcIdSchema,
+  jsonRpcMessageSchema
+};
+//# sourceMappingURL=json-rpc.mjs.map

package/dist/modules/json-rpc.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/json-rpc.ts"],
+  "sourcesContent": ["import * as z from 'zod';\n\nimport { jsonValueSchema } from \"./json.mjs\";\n\nexport const jsonRpcIdSchema = z.union([z.string(), z.number(), z.null()]);\n\nexport const jsonRpcMessageSchema = z.object({\n  jsonrpc: z.literal('2.0'),\n  id: jsonRpcIdSchema.optional(),\n  method: z.string().min(1).optional(),\n  params: jsonValueSchema.optional(),\n  result: jsonValueSchema.optional(),\n  error: z\n    .object({\n      code: z.number().int(),\n      message: z.string(),\n      data: jsonValueSchema.optional(),\n    })\n    .optional(),\n});\n\nexport type JsonRpcMessage = z.infer<typeof jsonRpcMessageSchema>;\n"],
+  "mappings": "AAAA,YAAY,OAAO;AAEnB,SAAS,uBAAuB;AAEzB,MAAM,kBAAkB,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,EAAE,OAAO,GAAG,EAAE,KAAK,CAAC,CAAC;AAElE,MAAM,uBAAuB,EAAE,OAAO;AAAA,EAC3C,SAAS,EAAE,QAAQ,KAAK;AAAA,EACxB,IAAI,gBAAgB,SAAS;AAAA,EAC7B,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,EACnC,QAAQ,gBAAgB,SAAS;AAAA,EACjC,QAAQ,gBAAgB,SAAS;AAAA,EACjC,OAAO,EACJ,OAAO;AAAA,IACN,MAAM,EAAE,OAAO,EAAE,IAAI;AAAA,IACrB,SAAS,EAAE,OAAO;AAAA,IAClB,MAAM,gBAAgB,SAAS;AAAA,EACjC,CAAC,EACA,SAAS;AACd,CAAC;",
+  "names": []
+}

package/dist/modules/json.d.mts

@@ -0,0 +1,7 @@
+import * as z from 'zod';
+export type JsonValue = boolean | number | string | null | JsonObjectIface | JsonValue[];
+export interface JsonObjectIface {
+    [key: string]: JsonValue | undefined;
+}
+export declare const jsonValueSchema: z.ZodType<JsonValue>;
+export declare const jsonObjectSchema: z.ZodType<JsonObjectIface>;

package/dist/modules/json.mjs

@@ -0,0 +1,11 @@
+import * as z from "zod";
+const jsonValueSchema = z.json();
+const jsonObjectSchema = z.record(
+  z.string(),
+  jsonValueSchema.optional()
+);
+export {
+  jsonObjectSchema,
+  jsonValueSchema
+};
+//# sourceMappingURL=json.mjs.map

package/dist/modules/json.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/json.ts"],
+  "sourcesContent": ["import * as z from 'zod';\n\nexport type JsonValue = boolean | number | string | null | JsonObjectIface | JsonValue[];\n\nexport interface JsonObjectIface {\n  [key: string]: JsonValue | undefined;\n}\n\nexport const jsonValueSchema: z.ZodType<JsonValue> = z.json();\n\nexport const jsonObjectSchema: z.ZodType<JsonObjectIface> = z.record(\n  z.string(),\n  jsonValueSchema.optional(),\n);\n"],
+  "mappings": "AAAA,YAAY,OAAO;AAQZ,MAAM,kBAAwC,EAAE,KAAK;AAErD,MAAM,mBAA+C,EAAE;AAAA,EAC5D,EAAE,OAAO;AAAA,EACT,gBAAgB,SAAS;AAC3B;",
+  "names": []
+}

package/dist/modules/process-inspection.d.mts

@@ -0,0 +1,177 @@
+import * as z from 'zod';
+export declare enum ProcessInspectionOperation {
+    Available = "available",
+    List = "list",
+    Detail = "detail",
+    Stop = "stop"
+}
+export declare const processInspectionRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<ProcessInspectionOperation.Available>;
+}, z.core.$strict>, z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    operation: z.ZodLiteral<ProcessInspectionOperation.List>;
+}, z.core.$strict>, z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    processId: z.ZodString;
+    bootId: z.ZodString;
+    operation: z.ZodLiteral<ProcessInspectionOperation.Detail>;
+}, z.core.$strict>, z.ZodObject<{
+    processId: z.ZodString;
+    bootId: z.ZodString;
+    operation: z.ZodLiteral<ProcessInspectionOperation.Stop>;
+}, z.core.$strict>], "operation">;
+export type ProcessInspectionRequestIface = z.infer<typeof processInspectionRequestSchema>;
+export declare const inspectedProcessSchema: z.ZodObject<{
+    id: z.ZodString;
+    bootId: z.ZodString;
+    command: z.ZodString;
+    leaderPid: z.ZodNullable<z.ZodNumber>;
+    state: z.ZodString;
+    keepsAwake: z.ZodBoolean;
+    createdAtMs: z.ZodNumber;
+    updatedAtMs: z.ZodNumber;
+    endedAtMs: z.ZodNullable<z.ZodNumber>;
+    cpuUsec: z.ZodNullable<z.ZodNumber>;
+    memoryBytes: z.ZodNullable<z.ZodNumber>;
+    memoryPeakBytes: z.ZodNullable<z.ZodNumber>;
+    ioReadBytes: z.ZodNullable<z.ZodNumber>;
+    ioWriteBytes: z.ZodNullable<z.ZodNumber>;
+    processCount: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type InspectedProcessIface = z.infer<typeof inspectedProcessSchema>;
+export declare const inspectedProcessMemberSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    startTicks: z.ZodNullable<z.ZodNumber>;
+    ppid: z.ZodNumber;
+    executable: z.ZodString;
+    argumentPreview: z.ZodString;
+    state: z.ZodString;
+    startedAtMs: z.ZodNullable<z.ZodNumber>;
+    cpuUsec: z.ZodNullable<z.ZodNumber>;
+    memoryBytes: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const processInspectionPageSchema: z.ZodObject<{
+    status: z.ZodString;
+    processes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        bootId: z.ZodString;
+        command: z.ZodString;
+        leaderPid: z.ZodNullable<z.ZodNumber>;
+        state: z.ZodString;
+        keepsAwake: z.ZodBoolean;
+        createdAtMs: z.ZodNumber;
+        updatedAtMs: z.ZodNumber;
+        endedAtMs: z.ZodNullable<z.ZodNumber>;
+        cpuUsec: z.ZodNullable<z.ZodNumber>;
+        memoryBytes: z.ZodNullable<z.ZodNumber>;
+        memoryPeakBytes: z.ZodNullable<z.ZodNumber>;
+        ioReadBytes: z.ZodNullable<z.ZodNumber>;
+        ioWriteBytes: z.ZodNullable<z.ZodNumber>;
+        processCount: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const processInspectionDetailSchema: z.ZodObject<{
+    process: z.ZodObject<{
+        id: z.ZodString;
+        bootId: z.ZodString;
+        command: z.ZodString;
+        leaderPid: z.ZodNullable<z.ZodNumber>;
+        state: z.ZodString;
+        keepsAwake: z.ZodBoolean;
+        createdAtMs: z.ZodNumber;
+        updatedAtMs: z.ZodNumber;
+        endedAtMs: z.ZodNullable<z.ZodNumber>;
+        cpuUsec: z.ZodNullable<z.ZodNumber>;
+        memoryBytes: z.ZodNullable<z.ZodNumber>;
+        memoryPeakBytes: z.ZodNullable<z.ZodNumber>;
+        ioReadBytes: z.ZodNullable<z.ZodNumber>;
+        ioWriteBytes: z.ZodNullable<z.ZodNumber>;
+        processCount: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    descendants: z.ZodArray<z.ZodObject<{
+        pid: z.ZodNumber;
+        startTicks: z.ZodNullable<z.ZodNumber>;
+        ppid: z.ZodNumber;
+        executable: z.ZodString;
+        argumentPreview: z.ZodString;
+        state: z.ZodString;
+        startedAtMs: z.ZodNullable<z.ZodNumber>;
+        cpuUsec: z.ZodNullable<z.ZodNumber>;
+        memoryBytes: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    logs: z.ZodObject<{
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        stdoutTruncated: z.ZodBoolean;
+        stderrTruncated: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const processInspectionResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    available: z.ZodBoolean;
+    canStop: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodString;
+    processes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        bootId: z.ZodString;
+        command: z.ZodString;
+        leaderPid: z.ZodNullable<z.ZodNumber>;
+        state: z.ZodString;
+        keepsAwake: z.ZodBoolean;
+        createdAtMs: z.ZodNumber;
+        updatedAtMs: z.ZodNumber;
+        endedAtMs: z.ZodNullable<z.ZodNumber>;
+        cpuUsec: z.ZodNullable<z.ZodNumber>;
+        memoryBytes: z.ZodNullable<z.ZodNumber>;
+        memoryPeakBytes: z.ZodNullable<z.ZodNumber>;
+        ioReadBytes: z.ZodNullable<z.ZodNumber>;
+        ioWriteBytes: z.ZodNullable<z.ZodNumber>;
+        processCount: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    process: z.ZodObject<{
+        id: z.ZodString;
+        bootId: z.ZodString;
+        command: z.ZodString;
+        leaderPid: z.ZodNullable<z.ZodNumber>;
+        state: z.ZodString;
+        keepsAwake: z.ZodBoolean;
+        createdAtMs: z.ZodNumber;
+        updatedAtMs: z.ZodNumber;
+        endedAtMs: z.ZodNullable<z.ZodNumber>;
+        cpuUsec: z.ZodNullable<z.ZodNumber>;
+        memoryBytes: z.ZodNullable<z.ZodNumber>;
+        memoryPeakBytes: z.ZodNullable<z.ZodNumber>;
+        ioReadBytes: z.ZodNullable<z.ZodNumber>;
+        ioWriteBytes: z.ZodNullable<z.ZodNumber>;
+        processCount: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    descendants: z.ZodArray<z.ZodObject<{
+        pid: z.ZodNumber;
+        startTicks: z.ZodNullable<z.ZodNumber>;
+        ppid: z.ZodNumber;
+        executable: z.ZodString;
+        argumentPreview: z.ZodString;
+        state: z.ZodString;
+        startedAtMs: z.ZodNullable<z.ZodNumber>;
+        cpuUsec: z.ZodNullable<z.ZodNumber>;
+        memoryBytes: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    logs: z.ZodObject<{
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        stdoutTruncated: z.ZodBoolean;
+        stderrTruncated: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    stopped: z.ZodBoolean;
+}, z.core.$strip>]>;
+export type ProcessInspectionResultIface = z.infer<typeof processInspectionResultSchema>;
+export type ProcessInspectionPageIface = z.infer<typeof processInspectionPageSchema>;
+export type ProcessInspectionDetailIface = z.infer<typeof processInspectionDetailSchema>;