@sokdak/happy-wire 0.1.0-main.5

package/dist/index.cjs

@@ -0,0 +1,473 @@
+'use strict';
+
+var z = require('zod');
+var cuid2 = require('@paralleldrive/cuid2');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
+
+const sessionRoleSchema = z__namespace.enum(["user", "agent"]);
+const sessionTextEventSchema = z__namespace.object({
+  t: z__namespace.literal("text"),
+  text: z__namespace.string(),
+  thinking: z__namespace.boolean().optional()
+});
+const sessionUsageSchema = z__namespace.object({
+  input_tokens: z__namespace.number().int().nonnegative(),
+  cache_creation_input_tokens: z__namespace.number().int().nonnegative().optional(),
+  cache_read_input_tokens: z__namespace.number().int().nonnegative().optional(),
+  output_tokens: z__namespace.number().int().nonnegative(),
+  context_window: z__namespace.number().int().positive().optional(),
+  service_tier: z__namespace.string().optional()
+}).passthrough();
+const sessionServiceMessageEventSchema = z__namespace.object({
+  t: z__namespace.literal("service"),
+  text: z__namespace.string()
+});
+const sessionToolCallStartEventSchema = z__namespace.object({
+  t: z__namespace.literal("tool-call-start"),
+  call: z__namespace.string(),
+  name: z__namespace.string(),
+  title: z__namespace.string(),
+  description: z__namespace.string(),
+  args: z__namespace.record(z__namespace.string(), z__namespace.unknown())
+});
+const sessionToolCallEndEventSchema = z__namespace.object({
+  t: z__namespace.literal("tool-call-end"),
+  call: z__namespace.string()
+});
+const sessionFileEventSchema = z__namespace.object({
+  t: z__namespace.literal("file"),
+  ref: z__namespace.string(),
+  name: z__namespace.string(),
+  size: z__namespace.number(),
+  mimeType: z__namespace.string().optional(),
+  image: z__namespace.object({
+    width: z__namespace.number(),
+    height: z__namespace.number(),
+    thumbhash: z__namespace.string()
+  }).optional()
+});
+const sessionTurnStartEventSchema = z__namespace.object({
+  t: z__namespace.literal("turn-start")
+});
+const sessionStartEventSchema = z__namespace.object({
+  t: z__namespace.literal("start"),
+  title: z__namespace.string().optional()
+});
+const sessionTurnEndStatusSchema = z__namespace.enum(["completed", "failed", "cancelled"]);
+const sessionTurnEndEventSchema = z__namespace.object({
+  t: z__namespace.literal("turn-end"),
+  status: sessionTurnEndStatusSchema
+});
+const sessionStopEventSchema = z__namespace.object({
+  t: z__namespace.literal("stop")
+});
+const sessionEventSchema = z__namespace.discriminatedUnion("t", [
+  sessionTextEventSchema,
+  sessionServiceMessageEventSchema,
+  sessionToolCallStartEventSchema,
+  sessionToolCallEndEventSchema,
+  sessionFileEventSchema,
+  sessionTurnStartEventSchema,
+  sessionStartEventSchema,
+  sessionTurnEndEventSchema,
+  sessionStopEventSchema
+]);
+const sessionEnvelopeSchema = z__namespace.object({
+  id: z__namespace.string(),
+  time: z__namespace.number(),
+  role: sessionRoleSchema,
+  turn: z__namespace.string().optional(),
+  subagent: z__namespace.string().refine((value) => cuid2.isCuid(value), {
+    message: "subagent must be a cuid2 value"
+  }).optional(),
+  // Underlying agent-protocol message id (e.g. Claude's `uuid` in the
+  // session JSONL). Set on text-bearing envelopes so the app can let
+  // users pick a precise rewind point for session fork / duplicate.
+  claudeUuid: z__namespace.string().min(1).optional(),
+  // Codex app-server item id for this envelope. Used as the precise
+  // rollback point for Codex thread duplicate/fork-from-message.
+  codexItemId: z__namespace.string().min(1).optional(),
+  // Optional model usage carried by the source agent message. Consumers use
+  // this to update session context meters without rendering a separate row.
+  usage: sessionUsageSchema.optional(),
+  ev: sessionEventSchema
+}).superRefine((envelope, ctx) => {
+  if (envelope.ev.t === "service" && envelope.role !== "agent") {
+    ctx.addIssue({
+      code: z__namespace.ZodIssueCode.custom,
+      message: 'service events must use role "agent"',
+      path: ["role"]
+    });
+  }
+  if ((envelope.ev.t === "start" || envelope.ev.t === "stop") && envelope.role !== "agent") {
+    ctx.addIssue({
+      code: z__namespace.ZodIssueCode.custom,
+      message: `${envelope.ev.t} events must use role "agent"`,
+      path: ["role"]
+    });
+  }
+});
+function createEnvelope(role, ev, opts = {}) {
+  return sessionEnvelopeSchema.parse({
+    id: opts.id ?? cuid2.createId(),
+    time: opts.time ?? Date.now(),
+    role,
+    ...opts.turn ? { turn: opts.turn } : {},
+    ...opts.subagent ? { subagent: opts.subagent } : {},
+    ...opts.claudeUuid ? { claudeUuid: opts.claudeUuid } : {},
+    ...opts.codexItemId ? { codexItemId: opts.codexItemId } : {},
+    ...opts.usage ? { usage: opts.usage } : {},
+    ev
+  });
+}
+
+const MessageMetaSchema = z__namespace.object({
+  sentFrom: z__namespace.string().optional(),
+  // Native clients may publish their own mode codes (for example Rig's
+  // auto/workspace_write/read_only/full_access), so this stays open-ended.
+  permissionMode: z__namespace.string().optional(),
+  model: z__namespace.string().nullable().optional(),
+  modelProviderId: z__namespace.string().optional(),
+  fallbackModel: z__namespace.string().nullable().optional(),
+  customSystemPrompt: z__namespace.string().nullable().optional(),
+  appendSystemPrompt: z__namespace.string().nullable().optional(),
+  allowedTools: z__namespace.array(z__namespace.string()).nullable().optional(),
+  disallowedTools: z__namespace.array(z__namespace.string()).nullable().optional(),
+  effort: z__namespace.string().nullable().optional(),
+  displayText: z__namespace.string().optional()
+});
+
+const UserMessageSchema = z__namespace.object({
+  role: z__namespace.literal("user"),
+  content: z__namespace.object({
+    type: z__namespace.literal("text"),
+    text: z__namespace.string()
+  }),
+  localKey: z__namespace.string().optional(),
+  meta: MessageMetaSchema.optional()
+});
+const AgentMessageSchema = z__namespace.object({
+  role: z__namespace.literal("agent"),
+  content: z__namespace.object({
+    type: z__namespace.string()
+  }).passthrough(),
+  meta: MessageMetaSchema.optional()
+});
+const LegacyMessageContentSchema = z__namespace.discriminatedUnion("role", [UserMessageSchema, AgentMessageSchema]);
+
+const SessionMessageContentSchema = z__namespace.object({
+  c: z__namespace.string(),
+  t: z__namespace.literal("encrypted")
+});
+const SessionMessageSchema = z__namespace.object({
+  id: z__namespace.string(),
+  seq: z__namespace.number(),
+  localId: z__namespace.string().nullish(),
+  content: SessionMessageContentSchema,
+  createdAt: z__namespace.number(),
+  updatedAt: z__namespace.number()
+});
+const SessionProtocolMessageSchema = z__namespace.object({
+  role: z__namespace.literal("session"),
+  content: sessionEnvelopeSchema,
+  meta: MessageMetaSchema.optional()
+});
+const MessageContentSchema = z__namespace.discriminatedUnion("role", [
+  UserMessageSchema,
+  AgentMessageSchema,
+  SessionProtocolMessageSchema
+]);
+const VersionedEncryptedValueSchema = z__namespace.object({
+  version: z__namespace.number(),
+  value: z__namespace.string()
+});
+const VersionedNullableEncryptedValueSchema = z__namespace.object({
+  version: z__namespace.number(),
+  value: z__namespace.string().nullable()
+});
+const UpdateNewMessageBodySchema = z__namespace.object({
+  t: z__namespace.literal("new-message"),
+  sid: z__namespace.string(),
+  message: SessionMessageSchema
+});
+const UpdateSessionBodySchema = z__namespace.object({
+  t: z__namespace.literal("update-session"),
+  id: z__namespace.string(),
+  metadata: VersionedEncryptedValueSchema.nullish(),
+  agentState: VersionedNullableEncryptedValueSchema.nullish()
+});
+const VersionedMachineEncryptedValueSchema = z__namespace.object({
+  version: z__namespace.number(),
+  value: z__namespace.string()
+});
+const UpdateMachineBodySchema = z__namespace.object({
+  t: z__namespace.literal("update-machine"),
+  machineId: z__namespace.string(),
+  metadata: VersionedMachineEncryptedValueSchema.nullish(),
+  daemonState: VersionedMachineEncryptedValueSchema.nullish(),
+  active: z__namespace.boolean().optional(),
+  activeAt: z__namespace.number().optional()
+});
+const CoreUpdateBodySchema = z__namespace.discriminatedUnion("t", [
+  UpdateNewMessageBodySchema,
+  UpdateSessionBodySchema,
+  UpdateMachineBodySchema
+]);
+const CoreUpdateContainerSchema = z__namespace.object({
+  id: z__namespace.string(),
+  seq: z__namespace.number(),
+  body: CoreUpdateBodySchema,
+  createdAt: z__namespace.number()
+});
+const ApiMessageSchema = SessionMessageSchema;
+const ApiUpdateNewMessageSchema = UpdateNewMessageBodySchema;
+const ApiUpdateSessionStateSchema = UpdateSessionBodySchema;
+const ApiUpdateMachineStateSchema = UpdateMachineBodySchema;
+const UpdateBodySchema = UpdateNewMessageBodySchema;
+const UpdateSchema = CoreUpdateContainerSchema;
+
+const TASK_NOTIFICATION_OPEN = "<task-notification>";
+const TASK_NOTIFICATION_CLOSE = "</task-notification>";
+function leadingTaskNotificationEnd(text) {
+  if (!text.startsWith(TASK_NOTIFICATION_OPEN)) {
+    return null;
+  }
+  let depth = 1;
+  let cursor = TASK_NOTIFICATION_OPEN.length;
+  while (depth > 0) {
+    const nextOpen = text.indexOf(TASK_NOTIFICATION_OPEN, cursor);
+    const nextClose = text.indexOf(TASK_NOTIFICATION_CLOSE, cursor);
+    if (nextClose === -1) {
+      return null;
+    }
+    if (nextOpen !== -1 && nextOpen < nextClose) {
+      depth += 1;
+      cursor = nextOpen + TASK_NOTIFICATION_OPEN.length;
+      continue;
+    }
+    depth -= 1;
+    cursor = nextClose + TASK_NOTIFICATION_CLOSE.length;
+  }
+  return cursor;
+}
+function stripLeadingTaskNotificationWrappers(text) {
+  let remainder = text.trimStart();
+  let stripped = false;
+  while (remainder.startsWith(TASK_NOTIFICATION_OPEN)) {
+    const wrapperEnd = leadingTaskNotificationEnd(remainder);
+    if (wrapperEnd === null) {
+      break;
+    }
+    stripped = true;
+    remainder = remainder.slice(wrapperEnd).trimStart();
+  }
+  return stripped ? remainder : text;
+}
+
+const VoiceConversationGrantedSchema = z__namespace.object({
+  allowed: z__namespace.literal(true),
+  conversationToken: z__namespace.string(),
+  conversationId: z__namespace.string(),
+  agentId: z__namespace.string(),
+  elevenUserId: z__namespace.string(),
+  usedSeconds: z__namespace.number(),
+  limitSeconds: z__namespace.number()
+});
+const VoiceConversationDeniedSchema = z__namespace.object({
+  allowed: z__namespace.literal(false),
+  reason: z__namespace.enum(["voice_hard_limit_reached", "subscription_required", "voice_conversation_limit_reached"]),
+  usedSeconds: z__namespace.number(),
+  limitSeconds: z__namespace.number(),
+  agentId: z__namespace.string()
+});
+const VoiceConversationResponseSchema = z__namespace.discriminatedUnion("allowed", [
+  VoiceConversationGrantedSchema,
+  VoiceConversationDeniedSchema
+]);
+const VoiceUsageResponseSchema = z__namespace.object({
+  usedSeconds: z__namespace.number(),
+  limitSeconds: z__namespace.number(),
+  conversationCount: z__namespace.number(),
+  conversationLimit: z__namespace.number(),
+  elevenUserId: z__namespace.string()
+});
+
+const RigProviderSchema = z__namespace.object({
+  id: z__namespace.string(),
+  kind: z__namespace.string(),
+  name: z__namespace.string()
+}).passthrough();
+const RigModelSchema = z__namespace.object({
+  id: z__namespace.string(),
+  code: z__namespace.string(),
+  name: z__namespace.string(),
+  value: z__namespace.string(),
+  providerId: z__namespace.string(),
+  providerKind: z__namespace.string(),
+  providerName: z__namespace.string(),
+  provider: RigProviderSchema,
+  contextWindow: z__namespace.number().optional(),
+  serviceTiers: z__namespace.array(z__namespace.string()),
+  thinkingLevels: z__namespace.array(z__namespace.string()),
+  defaultThinkingLevel: z__namespace.string()
+}).passthrough();
+const RigOperatingModeKindSchema = z__namespace.string();
+const RigOperatingModeSchema = z__namespace.object({
+  code: z__namespace.string(),
+  value: z__namespace.string(),
+  description: z__namespace.string(),
+  kind: RigOperatingModeKindSchema
+}).passthrough();
+const RigCapabilitiesSchema = z__namespace.object({
+  abort: z__namespace.boolean(),
+  attachments: z__namespace.object({
+    enabled: z__namespace.boolean(),
+    maxBytes: z__namespace.number(),
+    mediaTypes: z__namespace.array(z__namespace.string())
+  }).passthrough(),
+  files: z__namespace.object({
+    browse: z__namespace.boolean(),
+    read: z__namespace.boolean(),
+    search: z__namespace.boolean(),
+    write: z__namespace.boolean()
+  }).passthrough(),
+  modelSelection: z__namespace.boolean(),
+  reasoningSelection: z__namespace.boolean(),
+  permissionModeSelection: z__namespace.boolean(),
+  resume: z__namespace.boolean(),
+  rpcMethods: z__namespace.array(z__namespace.string()),
+  shell: z__namespace.boolean(),
+  steering: z__namespace.boolean()
+}).passthrough();
+const RigActivitySchema = z__namespace.object({
+  subagents: z__namespace.object({
+    running: z__namespace.number(),
+    queued: z__namespace.number(),
+    total: z__namespace.number()
+  }).passthrough(),
+  workflows: z__namespace.object({
+    running: z__namespace.number(),
+    total: z__namespace.number()
+  }).passthrough(),
+  processes: z__namespace.object({
+    running: z__namespace.number()
+  }).passthrough(),
+  tasks: z__namespace.object({
+    pending: z__namespace.number(),
+    inProgress: z__namespace.number(),
+    completed: z__namespace.number(),
+    total: z__namespace.number()
+  }).passthrough()
+}).passthrough();
+const RigMetadataV1Schema = z__namespace.object({
+  // Parse later additive revisions with the v1-compatible fields we know.
+  rigMetadataVersion: z__namespace.number().int().min(1),
+  client: z__namespace.object({
+    id: z__namespace.literal("rig"),
+    name: z__namespace.string(),
+    version: z__namespace.string()
+  }).passthrough(),
+  provider: RigProviderSchema,
+  providers: z__namespace.array(RigProviderSchema),
+  model: z__namespace.object({
+    providerId: z__namespace.string(),
+    id: z__namespace.string()
+  }).passthrough(),
+  models: z__namespace.array(RigModelSchema),
+  currentModelProviderId: z__namespace.string(),
+  currentModelCode: z__namespace.string(),
+  permissionMode: z__namespace.string(),
+  currentOperatingModeCode: z__namespace.string(),
+  operatingModes: z__namespace.array(RigOperatingModeSchema),
+  reasoning: z__namespace.object({
+    current: z__namespace.string().nullable(),
+    levels: z__namespace.array(z__namespace.string())
+  }).passthrough(),
+  currentThoughtLevelCode: z__namespace.string().optional(),
+  thoughtLevels: z__namespace.array(z__namespace.object({
+    code: z__namespace.string(),
+    value: z__namespace.string()
+  }).passthrough()),
+  session: z__namespace.object({
+    status: z__namespace.string(),
+    permissionMode: z__namespace.string(),
+    modelLocked: z__namespace.boolean(),
+    serviceTier: z__namespace.string().optional()
+  }).passthrough(),
+  capabilities: RigCapabilitiesSchema,
+  activity: RigActivitySchema,
+  mcpServers: z__namespace.array(z__namespace.object({
+    name: z__namespace.string(),
+    status: z__namespace.string()
+  }).passthrough()),
+  tools: z__namespace.array(z__namespace.string()),
+  skills: z__namespace.array(z__namespace.string())
+}).passthrough();
+
+exports.AgentMessageSchema = AgentMessageSchema;
+exports.ApiMessageSchema = ApiMessageSchema;
+exports.ApiUpdateMachineStateSchema = ApiUpdateMachineStateSchema;
+exports.ApiUpdateNewMessageSchema = ApiUpdateNewMessageSchema;
+exports.ApiUpdateSessionStateSchema = ApiUpdateSessionStateSchema;
+exports.CoreUpdateBodySchema = CoreUpdateBodySchema;
+exports.CoreUpdateContainerSchema = CoreUpdateContainerSchema;
+exports.LegacyMessageContentSchema = LegacyMessageContentSchema;
+exports.MessageContentSchema = MessageContentSchema;
+exports.MessageMetaSchema = MessageMetaSchema;
+exports.RigActivitySchema = RigActivitySchema;
+exports.RigCapabilitiesSchema = RigCapabilitiesSchema;
+exports.RigMetadataV1Schema = RigMetadataV1Schema;
+exports.RigModelSchema = RigModelSchema;
+exports.RigOperatingModeKindSchema = RigOperatingModeKindSchema;
+exports.RigOperatingModeSchema = RigOperatingModeSchema;
+exports.RigProviderSchema = RigProviderSchema;
+exports.SessionMessageContentSchema = SessionMessageContentSchema;
+exports.SessionMessageSchema = SessionMessageSchema;
+exports.SessionProtocolMessageSchema = SessionProtocolMessageSchema;
+exports.UpdateBodySchema = UpdateBodySchema;
+exports.UpdateMachineBodySchema = UpdateMachineBodySchema;
+exports.UpdateNewMessageBodySchema = UpdateNewMessageBodySchema;
+exports.UpdateSchema = UpdateSchema;
+exports.UpdateSessionBodySchema = UpdateSessionBodySchema;
+exports.UserMessageSchema = UserMessageSchema;
+exports.VersionedEncryptedValueSchema = VersionedEncryptedValueSchema;
+exports.VersionedMachineEncryptedValueSchema = VersionedMachineEncryptedValueSchema;
+exports.VersionedNullableEncryptedValueSchema = VersionedNullableEncryptedValueSchema;
+exports.VoiceConversationDeniedSchema = VoiceConversationDeniedSchema;
+exports.VoiceConversationGrantedSchema = VoiceConversationGrantedSchema;
+exports.VoiceConversationResponseSchema = VoiceConversationResponseSchema;
+exports.VoiceUsageResponseSchema = VoiceUsageResponseSchema;
+exports.createEnvelope = createEnvelope;
+exports.sessionEnvelopeSchema = sessionEnvelopeSchema;
+exports.sessionEventSchema = sessionEventSchema;
+exports.sessionFileEventSchema = sessionFileEventSchema;
+exports.sessionRoleSchema = sessionRoleSchema;
+exports.sessionServiceMessageEventSchema = sessionServiceMessageEventSchema;
+exports.sessionStartEventSchema = sessionStartEventSchema;
+exports.sessionStopEventSchema = sessionStopEventSchema;
+exports.sessionTextEventSchema = sessionTextEventSchema;
+exports.sessionToolCallEndEventSchema = sessionToolCallEndEventSchema;
+exports.sessionToolCallStartEventSchema = sessionToolCallStartEventSchema;
+exports.sessionTurnEndEventSchema = sessionTurnEndEventSchema;
+exports.sessionTurnEndStatusSchema = sessionTurnEndStatusSchema;
+exports.sessionTurnStartEventSchema = sessionTurnStartEventSchema;
+exports.sessionUsageSchema = sessionUsageSchema;
+exports.stripLeadingTaskNotificationWrappers = stripLeadingTaskNotificationWrappers;