@agentrix/shared 1.0.1

package/dist/index.cjs

@@ -0,0 +1,1957 @@
+'use strict';
+
+var zod = require('zod');
+var node_fs = require('node:fs');
+var node_path = require('node:path');
+var tweetnacl = require('tweetnacl');
+var base64js = require('base64-js');
+
+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 base64js__namespace = /*#__PURE__*/_interopNamespaceDefault(base64js);
+
+const ApiErrorSchema = zod.z.object({
+  error: zod.z.string(),
+  message: zod.z.string(),
+  details: zod.z.any().optional()
+});
+const PaginatedResponseSchema = (itemSchema) => zod.z.object({
+  total: zod.z.number(),
+  page: zod.z.number(),
+  limit: zod.z.number(),
+  items: zod.z.array(itemSchema)
+});
+const SimpleSuccessSchema = zod.z.object({
+  success: zod.z.literal(true),
+  message: zod.z.string()
+});
+const DateSchema = zod.z.string().datetime();
+const IdSchema = zod.z.string().min(1);
+const FileStatsSchema = zod.z.object({
+  path: zod.z.string(),
+  insertions: zod.z.number(),
+  deletions: zod.z.number()
+});
+
+const UserBasicInfoSchema = zod.z.object({
+  id: IdSchema,
+  username: zod.z.string(),
+  email: zod.z.string().email().nullable(),
+  avatar: zod.z.string().url().nullable()
+});
+const OAuthAccountInfoSchema = zod.z.object({
+  provider: zod.z.string(),
+  username: zod.z.string(),
+  email: zod.z.string().email().nullable(),
+  avatarUrl: zod.z.string().url()
+});
+const UserWithOAuthAccountsSchema = UserBasicInfoSchema.extend({
+  oauthAccounts: zod.z.array(OAuthAccountInfoSchema).optional()
+});
+
+const SignatureAuthRequestSchema = zod.z.object({
+  publicKey: zod.z.string(),
+  // Base64-encoded Ed25519 public key
+  challenge: zod.z.string(),
+  // Base64-encoded random challenge
+  signature: zod.z.string(),
+  // Base64-encoded Ed25519 signature
+  salt: zod.z.string(),
+  // Salt for PIN code encryption (base64)
+  encryptedSecret: zod.z.string()
+  // Encrypted secret (base64)
+});
+const SignatureAuthResponseSchema = zod.z.object({
+  token: zod.z.string(),
+  user: UserBasicInfoSchema
+});
+const UserProfileResponseSchema = zod.z.object({
+  user: UserBasicInfoSchema.extend({
+    encryptedSecret: zod.z.string(),
+    secretSalt: zod.z.string(),
+    createdAt: DateSchema,
+    oauthAccounts: zod.z.array(OAuthAccountInfoSchema).optional()
+  })
+});
+const LogoutResponseSchema = zod.z.object({
+  success: zod.z.literal(true)
+});
+const ResetSecretRequestSchema = zod.z.object({
+  salt: zod.z.string(),
+  // New salt for PIN code encryption
+  encryptedSecret: zod.z.string()
+  // New encrypted secret
+});
+const ResetSecretResponseSchema = zod.z.object({
+  deleted: zod.z.object({
+    machines: zod.z.number(),
+    ownedMachineUsers: zod.z.number(),
+    memberAccess: zod.z.number()
+  })
+});
+const OAuthLoginQuerySchema = zod.z.object({
+  redirect: zod.z.string().optional(),
+  // Optional redirect URL
+  signature: zod.z.string(),
+  // Base64-encoded Ed25519 public key
+  challenge: zod.z.string(),
+  // Base64-encoded random challenge
+  signatureProof: zod.z.string(),
+  // Base64-encoded Ed25519 signature
+  salt: zod.z.string(),
+  // Salt for PIN code encryption (base64)
+  encryptedSecret: zod.z.string()
+  // Encrypted secret (base64)
+});
+const OAuthCallbackQuerySchema = zod.z.object({
+  code: zod.z.string(),
+  state: zod.z.string().optional()
+});
+const OAuthCallbackResponseSchema = zod.z.object({
+  token: zod.z.string(),
+  user: UserWithOAuthAccountsSchema
+});
+const OAuthBindQuerySchema = zod.z.object({
+  redirect: zod.z.string().optional()
+  // Optional redirect URL
+});
+const OAuthBindResponseSchema = zod.z.object({
+  authUrl: zod.z.string().url()
+});
+const OAuthBindCallbackResponseSchema = OAuthAccountInfoSchema;
+const OAuthUnbindResponseSchema = zod.z.object({
+  success: zod.z.literal(true)
+});
+const MachineAuthRequestSchema = zod.z.object({
+  machineId: zod.z.string()
+  // Unique machine identifier
+});
+const MachineAuthResultQuerySchema = zod.z.object({
+  machineId: zod.z.string()
+});
+const MachineAuthAuthorizedResponseSchema = zod.z.object({
+  id: zod.z.string(),
+  state: zod.z.literal("authorized"),
+  token: zod.z.string(),
+  content: zod.z.string()
+  // Encrypted approval data
+});
+const MachineApprovalStatusQuerySchema = zod.z.object({
+  machineId: zod.z.string()
+});
+const ApprovalStatusResponseSchema = zod.z.object({
+  status: zod.z.enum(["pending", "approved"])
+});
+const MachineApprovalRequestSchema = zod.z.object({
+  machineId: zod.z.string(),
+  content: zod.z.string()
+  // Base64-encoded encrypted approval data
+});
+const CloudJoinRequestSchema = zod.z.object({
+  cloudId: zod.z.string()
+});
+const CloudJoinResultQuerySchema = zod.z.object({
+  cloudId: zod.z.string()
+});
+const CloudJoinStatusQuerySchema = zod.z.object({
+  userId: zod.z.string(),
+  cloudId: zod.z.string()
+});
+const CloudJoinApprovalRequestSchema = zod.z.object({
+  userId: zod.z.string(),
+  cloudId: zod.z.string()
+});
+
+const StartTaskRequestSchema = zod.z.object({
+  chatId: zod.z.string(),
+  message: zod.z.custom(
+    (data) => {
+      return typeof data === "object" && data !== null && "type" in data;
+    },
+    {
+      message: "Invalid SDKMessage format"
+    }
+  ).optional(),
+  encryptedMessage: zod.z.string().optional(),
+  // base64 sealed-box payload for local machines
+  cwd: zod.z.string().optional(),
+  // For local mode: current working directory
+  machineId: zod.z.string().optional(),
+  // For local mode: specific machine
+  cloudId: zod.z.string().optional(),
+  // For cloud mode: cloud ID
+  repositoryId: zod.z.string().optional(),
+  baseBranch: zod.z.string().optional(),
+  // Base branch for the repository
+  dataEncryptionKey: zod.z.string().optional()
+  // base64 sealed-box: app public key encrypted by machine public key
+}).refine((data) => data.machineId || data.cloudId, {
+  message: "Must provide either machineId or cloudId"
+}).refine(
+  (data) => {
+    if (data.machineId) {
+      return !!data.encryptedMessage && !!data.dataEncryptionKey && !data.message;
+    }
+    if (data.cloudId) {
+      return !!data.message && !data.encryptedMessage;
+    }
+    return true;
+  },
+  {
+    message: "For local machine tasks, encryptedMessage is required; for cloud tasks, message is required"
+  }
+);
+const startTaskSchema = StartTaskRequestSchema;
+const StartTaskResponseSchema = zod.z.object({
+  taskId: IdSchema,
+  chatId: IdSchema,
+  agentId: zod.z.string(),
+  userId: zod.z.string(),
+  state: zod.z.string(),
+  machineId: zod.z.string().nullable(),
+  cloudId: zod.z.string().nullable(),
+  repositoryId: zod.z.string().nullable(),
+  baseBranch: zod.z.string().nullable(),
+  title: zod.z.string().nullable(),
+  createdAt: DateSchema,
+  updatedAt: DateSchema
+});
+const TaskItemSchema = zod.z.object({
+  id: IdSchema,
+  chatId: IdSchema,
+  userId: zod.z.string(),
+  state: zod.z.string(),
+  agentId: zod.z.string(),
+  machineId: zod.z.string().nullable(),
+  cloudId: zod.z.string().nullable(),
+  repositoryId: zod.z.string().nullable(),
+  baseBranch: zod.z.string().nullable(),
+  title: zod.z.string().nullable(),
+  // Task title (can be set by worker)
+  agentSessionId: zod.z.string().nullable(),
+  dataEncryptionKey: zod.z.string().nullable(),
+  pullRequestNumber: zod.z.number().nullable(),
+  pullRequestUrl: zod.z.string().nullable(),
+  pullRequestState: zod.z.enum(["open", "closed", "merged"]).nullable(),
+  // PR state
+  pullRequestStateChangedAt: zod.z.string().nullable(),
+  // ISO 8601 string
+  gitStats: zod.z.object({
+    totalInsertions: zod.z.number(),
+    totalDeletions: zod.z.number(),
+    files: zod.z.array(FileStatsSchema)
+  }).nullable(),
+  createdAt: zod.z.string(),
+  // ISO 8601 string
+  updatedAt: zod.z.string()
+  // ISO 8601 string
+});
+const ListTasksResponseSchema = zod.z.object({
+  tasks: zod.z.array(TaskItemSchema)
+});
+const ResumeTaskRequestSchema = zod.z.object({
+  taskId: zod.z.string(),
+  message: zod.z.custom(
+    (data) => {
+      return typeof data === "object" && data !== null && "type" in data;
+    },
+    {
+      message: "Invalid SDKMessage format"
+    }
+  ).optional(),
+  encryptedMessage: zod.z.string().optional(),
+  // base64 sealed-box payload for local tasks
+  dataEncryptionKey: zod.z.string().optional()
+  // base64 sealed-box: app public key encrypted by machine public key
+}).refine(
+  (data) => {
+    return !!data.message !== !!data.encryptedMessage;
+  },
+  {
+    message: "Exactly one of message or encryptedMessage must be provided"
+  }
+);
+const resumeTaskRequestSchema = ResumeTaskRequestSchema;
+const ResumeTaskResponseSchema = zod.z.object({
+  message: zod.z.string(),
+  taskId: IdSchema
+});
+const CancelTaskRequestSchema = zod.z.object({
+  taskId: zod.z.string(),
+  reason: zod.z.string().optional()
+});
+const cancelTaskRequestSchema = CancelTaskRequestSchema;
+const CancelTaskResponseSchema = zod.z.object({
+  message: zod.z.string(),
+  taskId: IdSchema
+});
+const StopTaskRequestSchema = zod.z.object({
+  reason: zod.z.string().optional()
+});
+const stopTaskRequestSchema = StopTaskRequestSchema;
+const StopTaskResponseSchema = zod.z.object({
+  message: zod.z.string(),
+  taskId: IdSchema
+});
+const PermissionResponseRequestSchema = zod.z.object({
+  // Permission response data - structure depends on what the worker requested
+  // For now, we keep it flexible
+  approved: zod.z.boolean().optional(),
+  data: zod.z.any().optional()
+});
+const permissionResponseRequestSchema = PermissionResponseRequestSchema;
+const PermissionResponseResponseSchema = zod.z.object({
+  message: zod.z.string(),
+  taskId: IdSchema
+});
+const ProjectEntrySchema = zod.z.object({
+  name: zod.z.string(),
+  type: zod.z.enum(["file", "directory"]),
+  size: zod.z.number(),
+  // Size in bytes
+  modifiedAt: zod.z.string()
+  // ISO 8601 string
+});
+const ProjectDirectoryResponseSchema = zod.z.object({
+  type: zod.z.literal("directory"),
+  path: zod.z.string(),
+  // Relative path from project root
+  entries: zod.z.array(ProjectEntrySchema),
+  modifiedAt: zod.z.string()
+  // ISO 8601 string
+});
+const QueryEventsRequestSchema = zod.z.object({
+  limit: zod.z.coerce.number().min(1).max(100).optional(),
+  offset: zod.z.coerce.number().min(0).optional(),
+  before: zod.z.string().datetime().optional(),
+  after: zod.z.string().datetime().optional(),
+  eventType: zod.z.enum(["task-message", "task-artifacts-updated"]).optional()
+});
+const CreateMergeRequestSchema = zod.z.object({
+  taskId: zod.z.string(),
+  // taskId
+  title: zod.z.string().optional(),
+  // PR title
+  description: zod.z.string().optional(),
+  // PR description
+  draft: zod.z.boolean().optional(),
+  // Create as draft PR (default: false)
+  autoMerge: zod.z.boolean().optional()
+  // Enable auto-merge (default: false)
+});
+const createMergeRequestSchema = CreateMergeRequestSchema;
+const CreateMergeRequestResponseSchema = zod.z.object({
+  taskId: zod.z.string(),
+  pullRequestNumber: zod.z.number().optional(),
+  // PR number (e.g., #123)
+  pullRequestUrl: zod.z.string().optional(),
+  // Full URL to the PR
+  status: zod.z.enum(["success", "failed"]),
+  // Current status
+  reason: zod.z.string().optional()
+  // failed-reason
+});
+
+const ChatMemberSchema = zod.z.object({
+  id: IdSchema,
+  chatId: IdSchema,
+  memberCode: zod.z.string(),
+  type: zod.z.enum(["human", "agent"]),
+  role: zod.z.string(),
+  createdAt: zod.z.string(),
+  // ISO 8601 string
+  updatedAt: zod.z.string()
+  // ISO 8601 string
+});
+const ChatTypeSchema = zod.z.enum(["direct", "group"]);
+const ChatSchema = zod.z.object({
+  id: IdSchema,
+  owner: IdSchema,
+  // Group: userId of owner; Direct: "memberCode1:memberCode2" (sorted)
+  type: ChatTypeSchema,
+  createdAt: zod.z.string(),
+  // ISO 8601 string
+  updatedAt: zod.z.string()
+  // ISO 8601 string
+});
+const ChatWithMembersSchema = ChatSchema.extend({
+  members: zod.z.array(ChatMemberSchema)
+});
+const ChatMemberInputSchema = zod.z.object({
+  memberCode: zod.z.string().min(1),
+  type: zod.z.enum(["human", "agent"])
+});
+const CreateChatRequestSchema = zod.z.object({
+  type: ChatTypeSchema.default("direct"),
+  // Optional, defaults to 'direct'
+  members: zod.z.array(ChatMemberInputSchema)
+});
+const CreateChatResponseSchema = ChatWithMembersSchema;
+const ListChatsResponseSchema = zod.z.object({
+  chats: zod.z.array(ChatWithMembersSchema)
+});
+const GetChatResponseSchema = ChatWithMembersSchema;
+const ListChatMembersResponseSchema = zod.z.object({
+  members: zod.z.array(ChatMemberSchema)
+});
+const AddChatMemberRequestSchema = zod.z.object({
+  members: zod.z.array(ChatMemberInputSchema).min(1)
+});
+const AddChatMemberResponseSchema = zod.z.object({
+  members: zod.z.array(ChatMemberSchema)
+});
+const RemoveChatMemberRequestSchema = zod.z.object({
+  members: zod.z.array(ChatMemberInputSchema).min(1)
+});
+const ListChatTasksResponseSchema = zod.z.object({
+  tasks: zod.z.array(TaskItemSchema)
+});
+
+const AgentTypeSchema = zod.z.enum(["claude", "codex"]);
+const AgentSchema = zod.z.object({
+  id: IdSchema,
+  name: zod.z.string(),
+  type: AgentTypeSchema,
+  avatar: zod.z.string().nullable(),
+  userId: zod.z.string(),
+  description: zod.z.string().nullable(),
+  signature: zod.z.string().nullable(),
+  guildMsg: zod.z.string(),
+  placeholderMsg: zod.z.string(),
+  developerName: zod.z.string(),
+  developerEmail: zod.z.string().nullable(),
+  gitRepoId: zod.z.string().nullable(),
+  supportLocal: zod.z.boolean(),
+  enable: zod.z.boolean()
+});
+const ListAgentsResponseSchema = zod.z.object({
+  agents: zod.z.array(AgentSchema)
+});
+const GetAgentResponseSchema = AgentSchema;
+const CreateAgentRequestSchema = zod.z.object({
+  name: zod.z.string().min(1, "Name is required"),
+  type: AgentTypeSchema,
+  avatar: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  signature: zod.z.string().optional(),
+  guildMsg: zod.z.string().default("what can I do for you today?"),
+  placeholderMsg: zod.z.string().default("Ask me anything..."),
+  gitRepoId: zod.z.string().optional(),
+  supportLocal: zod.z.boolean().default(false)
+});
+const CreateAgentResponseSchema = AgentSchema;
+const UpdateAgentRequestSchema = zod.z.object({
+  name: zod.z.string().min(1).optional(),
+  type: AgentTypeSchema.optional(),
+  avatar: zod.z.string().nullable().optional(),
+  description: zod.z.string().nullable().optional(),
+  signature: zod.z.string().nullable().optional(),
+  guildMsg: zod.z.string().optional(),
+  placeholderMsg: zod.z.string().optional(),
+  gitRepoId: zod.z.string().nullable().optional(),
+  supportLocal: zod.z.boolean().optional()
+});
+const UpdateAgentResponseSchema = AgentSchema;
+const DeleteAgentResponseSchema = zod.z.object({
+  message: zod.z.string(),
+  agentId: IdSchema
+});
+
+const LocalMachineSchema = zod.z.object({
+  id: IdSchema,
+  owner: IdSchema,
+  status: zod.z.string(),
+  metadata: zod.z.string().nullable(),
+  approval: zod.z.string(),
+  dataEncryptionKey: zod.z.string(),
+  // per-user sealed-box key (base64)
+  createdAt: zod.z.string(),
+  // ISO 8601 string
+  updatedAt: zod.z.string()
+  // ISO 8601 string
+});
+const CloudMachineSchema = zod.z.object({
+  id: IdSchema,
+  cloudId: IdSchema,
+  deviceId: zod.z.string(),
+  status: zod.z.string(),
+  metadata: zod.z.string().nullable(),
+  createdAt: zod.z.string(),
+  // ISO 8601 string
+  updatedAt: zod.z.string()
+  // ISO 8601 string
+});
+const CloudSchema = zod.z.object({
+  id: IdSchema,
+  owner: IdSchema,
+  name: zod.z.string(),
+  type: zod.z.enum(["public", "private"]),
+  createdAt: zod.z.string(),
+  // ISO 8601 string
+  updatedAt: zod.z.string(),
+  // ISO 8601 string
+  machines: zod.z.array(CloudMachineSchema).optional()
+});
+const ListMachinesResponseSchema = zod.z.object({
+  clouds: zod.z.array(CloudSchema),
+  localMachines: zod.z.array(LocalMachineSchema)
+});
+const SyncMachineRequestSchema = zod.z.object({
+  id: zod.z.string(),
+  // Machine ID (local) or deviceId (cloud)
+  metadata: zod.z.string(),
+  // Encrypted metadata (or plaintext JSON for cloud/local-debug modes)
+  dataEncryptionKey: zod.z.string().optional()
+  // Encrypted machine encryption key (required for local machines)
+});
+const SyncLocalMachineResponseSchema = zod.z.object({
+  machine: zod.z.object({
+    id: IdSchema,
+    metadata: zod.z.string().nullable()
+  })
+});
+const SyncCloudMachineResponseSchema = zod.z.object({
+  machine: zod.z.object({
+    id: IdSchema,
+    deviceId: zod.z.string(),
+    metadata: zod.z.string().nullable()
+  })
+});
+
+const FileVisibilitySchema = zod.z.enum(["public", "private"]);
+const GetUploadUrlsRequestSchema = zod.z.object({
+  count: zod.z.number().min(1).max(10)
+  // Number of upload URLs to generate (1-10)
+});
+const UploadUrlResultSchema = zod.z.object({
+  id: IdSchema,
+  url: zod.z.string().url(),
+  expiresAt: zod.z.string()
+  // ISO 8601 string
+});
+const GetUploadUrlsResponseSchema = zod.z.object({
+  files: zod.z.array(UploadUrlResultSchema)
+});
+const FileItemSchema = zod.z.object({
+  fileId: IdSchema,
+  name: zod.z.string(),
+  size: zod.z.number(),
+  contentType: zod.z.string(),
+  createdAt: zod.z.string()
+  // ISO 8601 string
+});
+const ConfirmUploadRequestSchema = zod.z.object({
+  fileId: IdSchema,
+  name: zod.z.string(),
+  size: zod.z.number(),
+  contentType: zod.z.string(),
+  visibility: FileVisibilitySchema.optional().default("private")
+});
+const ConfirmUploadResponseSchema = zod.z.object({
+  file: FileItemSchema
+});
+const ListFilesQuerySchema = zod.z.object({
+  page: zod.z.coerce.number().min(1).optional().default(1),
+  limit: zod.z.coerce.number().min(1).max(100).optional().default(20),
+  fileIds: zod.z.string().optional()
+  // Comma-separated file IDs (e.g., "file-123,file-456")
+});
+const ListFilesResponseSchema = zod.z.object({
+  total: zod.z.number(),
+  page: zod.z.number(),
+  limit: zod.z.number(),
+  files: zod.z.array(FileItemSchema)
+});
+
+const RepositorySchema = zod.z.object({
+  id: IdSchema,
+  owner: zod.z.string(),
+  name: zod.z.string(),
+  fullName: zod.z.string(),
+  defaultBranch: zod.z.string(),
+  isPrivate: zod.z.boolean(),
+  description: zod.z.string().nullable(),
+  url: zod.z.string().url(),
+  createdAt: DateSchema,
+  updatedAt: DateSchema
+});
+const ListRepositoriesResponseSchema = zod.z.object({
+  repositories: zod.z.array(RepositorySchema)
+});
+const GetRepositoryResponseSchema = zod.z.object({
+  repository: RepositorySchema
+});
+const GetGitUrlQuerySchema = zod.z.object({
+  branch: zod.z.string().optional()
+});
+const GetGitUrlResponseSchema = zod.z.object({
+  gitUrl: zod.z.string().url(),
+  branch: zod.z.string(),
+  repository: zod.z.object({
+    owner: zod.z.string(),
+    name: zod.z.string(),
+    fullName: zod.z.string()
+  })
+});
+const BranchSchema = zod.z.object({
+  name: zod.z.string(),
+  commit: zod.z.object({
+    sha: zod.z.string(),
+    url: zod.z.string().url()
+  }),
+  protected: zod.z.boolean()
+});
+const ListBranchesResponseSchema = zod.z.object({
+  branches: zod.z.array(BranchSchema)
+});
+const GetInstallUrlResponseSchema = zod.z.object({
+  installUrl: zod.z.string().url()
+});
+const GitHubIssueListItemSchema = zod.z.object({
+  number: zod.z.number(),
+  title: zod.z.string(),
+  html_url: zod.z.string().url()
+});
+const GitHubIssueSchema = zod.z.object({
+  number: zod.z.number(),
+  title: zod.z.string(),
+  body: zod.z.string().nullable(),
+  html_url: zod.z.string().url()
+});
+const ListIssuesQuerySchema = zod.z.object({
+  q: zod.z.string().optional()
+  // Search query
+});
+const ListIssuesResponseSchema = zod.z.object({
+  issues: zod.z.array(GitHubIssueListItemSchema),
+  total_count: zod.z.number()
+});
+
+const CreateCloudRequestSchema = zod.z.discriminatedUnion("type", [
+  zod.z.object({
+    type: zod.z.literal("public"),
+    name: zod.z.string().min(1, "name is required")
+  }),
+  zod.z.object({
+    type: zod.z.literal("private"),
+    name: zod.z.string().min(1, "name is required"),
+    ownerId: zod.z.string().min(1, "ownerId is required")
+  })
+]);
+const CreateCloudResponseSchema = zod.z.object({
+  id: IdSchema,
+  owner: zod.z.string(),
+  name: zod.z.string(),
+  secret: zod.z.string(),
+  // JWT token for cloud authentication
+  createdAt: DateSchema
+});
+
+const OAuthServerSchema = zod.z.object({
+  id: IdSchema,
+  provider: zod.z.string(),
+  displayName: zod.z.string(),
+  authorizeUrl: zod.z.string().url(),
+  tokenUrl: zod.z.string().url(),
+  userInfoUrl: zod.z.string().url(),
+  clientId: zod.z.string(),
+  clientSecret: zod.z.string(),
+  callbackUrl: zod.z.string().url(),
+  scopes: zod.z.array(zod.z.string()).default([]),
+  userInfoMapping: zod.z.record(zod.z.string(), zod.z.string()),
+  enabled: zod.z.boolean(),
+  createdAt: zod.z.union([DateSchema, zod.z.date().transform((d) => d.toISOString())]),
+  updatedAt: zod.z.union([DateSchema, zod.z.date().transform((d) => d.toISOString())])
+});
+const OAuthServerPublicSchema = OAuthServerSchema.omit({
+  clientSecret: true
+});
+const CreateOAuthServerRequestSchema = zod.z.object({
+  provider: zod.z.string().min(1).regex(/^[a-z0-9-]+$/),
+  displayName: zod.z.string().min(1),
+  authorizeUrl: zod.z.string().url(),
+  tokenUrl: zod.z.string().url(),
+  userInfoUrl: zod.z.string().url(),
+  clientId: zod.z.string().min(1),
+  clientSecret: zod.z.string().min(1),
+  scopes: zod.z.array(zod.z.string()).optional().default([]),
+  userInfoMapping: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  enabled: zod.z.boolean().default(true)
+});
+const CreateOAuthServerResponseSchema = OAuthServerSchema;
+const ListOAuthServersQuerySchema = zod.z.object({
+  enabled: zod.z.string().optional().transform((val) => val === "true" ? true : val === "false" ? false : void 0)
+});
+const ListOAuthServersResponseSchema = zod.z.array(OAuthServerSchema);
+const GetOAuthServerResponseSchema = OAuthServerSchema;
+const UpdateOAuthServerRequestSchema = CreateOAuthServerRequestSchema.partial();
+const UpdateOAuthServerResponseSchema = OAuthServerSchema;
+const DeleteOAuthServerResponseSchema = zod.z.object({
+  success: zod.z.literal(true)
+});
+const ToggleOAuthServerRequestSchema = zod.z.object({
+  enabled: zod.z.boolean()
+});
+const ToggleOAuthServerResponseSchema = OAuthServerSchema;
+
+const RechargeResponseSchema = zod.z.object({
+  success: zod.z.literal(true),
+  packageId: zod.z.string(),
+  newBalance: zod.z.number().nonnegative()
+});
+const UserBalanceResponseSchema = zod.z.object({
+  userId: zod.z.string(),
+  balance: zod.z.number().nonnegative(),
+  currentCreditsPackageId: zod.z.string().nullable(),
+  balanceRefreshAt: DateSchema.nullable(),
+  lastCalculatedAt: DateSchema
+});
+const CreditsPackageSchema = zod.z.object({
+  id: zod.z.string(),
+  userId: zod.z.string(),
+  name: zod.z.string(),
+  credit: zod.z.number().positive(),
+  usage: zod.z.number().nonnegative(),
+  remaining: zod.z.number().nonnegative(),
+  expiredAt: DateSchema,
+  createdAt: DateSchema,
+  updatedAt: DateSchema
+});
+const ListPackagesQuerySchema = zod.z.object({
+  limit: zod.z.string().optional().transform((v) => v ? parseInt(v) : 20),
+  offset: zod.z.string().optional().transform((v) => v ? parseInt(v) : 0),
+  activeOnly: zod.z.string().optional().transform((v) => v === "true")
+});
+const ListPackagesResponseSchema = zod.z.object({
+  packages: zod.z.array(CreditsPackageSchema),
+  total: zod.z.number().int().nonnegative()
+});
+const ChargeTransactionSchema = zod.z.object({
+  id: zod.z.string(),
+  userId: zod.z.string(),
+  creditsPackageId: zod.z.string(),
+  packageName: zod.z.string().optional(),
+  amount: zod.z.number().positive(),
+  balanceBefore: zod.z.number().nonnegative(),
+  balanceAfter: zod.z.number().nonnegative(),
+  type: zod.z.enum(["user_recharge", "system_bonus", "refund"]),
+  paymentMethod: zod.z.string().nullable(),
+  paymentId: zod.z.string().nullable(),
+  metadata: zod.z.any(),
+  createdAt: DateSchema,
+  transactionType: zod.z.literal("charge")
+});
+const ConsumeTransactionSchema = zod.z.object({
+  id: zod.z.string(),
+  userId: zod.z.string(),
+  taskId: zod.z.string(),
+  agentId: zod.z.string(),
+  creditsPackageId: zod.z.string(),
+  packageName: zod.z.string().optional(),
+  amount: zod.z.number().positive(),
+  balanceBefore: zod.z.number().nonnegative(),
+  balanceAfter: zod.z.number().nonnegative(),
+  metadata: zod.z.any(),
+  createdAt: DateSchema,
+  transactionType: zod.z.literal("consume")
+});
+const TransactionSchema = zod.z.union([
+  ChargeTransactionSchema,
+  ConsumeTransactionSchema
+]);
+const ListTransactionsQuerySchema = zod.z.object({
+  limit: zod.z.string().optional().transform((v) => v ? parseInt(v) : 50),
+  offset: zod.z.string().optional().transform((v) => v ? parseInt(v) : 0),
+  type: zod.z.enum(["charge", "consume"]).optional(),
+  startDate: zod.z.string().datetime().optional(),
+  endDate: zod.z.string().datetime().optional()
+});
+const ListTransactionsResponseSchema = zod.z.object({
+  transactions: zod.z.array(TransactionSchema),
+  total: zod.z.number().int().nonnegative()
+});
+const TaskTransactionsResponseSchema = zod.z.object({
+  transactions: zod.z.array(ConsumeTransactionSchema),
+  total: zod.z.number().int().nonnegative()
+});
+const StatsQuerySchema = zod.z.object({
+  startDate: zod.z.string().datetime().optional(),
+  endDate: zod.z.string().datetime().optional()
+});
+const BillingStatsResponseSchema = zod.z.object({
+  totalCharged: zod.z.number().nonnegative(),
+  totalConsumed: zod.z.number().nonnegative(),
+  chargeCount: zod.z.number().int().nonnegative(),
+  consumeCount: zod.z.number().int().nonnegative(),
+  transactionCount: zod.z.number().int().nonnegative()
+});
+
+const EventBaseSchema = zod.z.object({
+  eventId: zod.z.string()
+});
+const createEventId = () => {
+  return `event-${crypto.randomUUID()}`;
+};
+const EventAckSchema = EventBaseSchema.extend({
+  status: zod.z.enum(["success", "failed"]),
+  message: zod.z.string().optional(),
+  opCode: zod.z.string().optional(),
+  data: zod.z.any().optional()
+});
+const AppAliveEventSchema = EventBaseSchema.extend({
+  timestamp: zod.z.string()
+});
+const ApiServerAliveEventSchema = EventBaseSchema.extend({
+  timestamp: zod.z.string()
+});
+const MachineAliveEventSchema = EventBaseSchema.extend({
+  machineId: zod.z.string(),
+  timestamp: zod.z.string()
+});
+const ShutdownMachineSchema = EventBaseSchema.extend({
+  machineId: zod.z.string(),
+  reason: zod.z.string().optional()
+});
+const WorkerInitializingSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  machineId: zod.z.string(),
+  timestamp: zod.z.string()
+});
+const WorkerReadySchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  machineId: zod.z.string(),
+  timestamp: zod.z.string()
+});
+const WorkerAliveEventSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  machineId: zod.z.string(),
+  status: zod.z.string(),
+  // running, ready
+  timestamp: zod.z.string()
+});
+const WorkerExitSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  machineId: zod.z.string(),
+  timestamp: zod.z.string(),
+  reason: zod.z.string().optional()
+});
+const WorkerRunningSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  machineId: zod.z.string(),
+  timestamp: zod.z.string()
+});
+const baseTaskSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  userId: zod.z.string(),
+  chatId: zod.z.string(),
+  agentId: zod.z.string(),
+  agentType: zod.z.string().optional().default("claude"),
+  gitUrl: zod.z.string().optional(),
+  baseBranch: zod.z.string().optional(),
+  cwd: zod.z.string().optional(),
+  // Current working directory for the task, only used under 'local' mode
+  dataEncryptionKey: zod.z.string().optional(),
+  // User's public key for encrypting sensitive data
+  model: zod.z.string().optional(),
+  // AI model to use
+  fallbackModel: zod.z.string().optional(),
+  // Fallback AI model
+  api_base_url: zod.z.string().optional(),
+  // Custom API base URL
+  api_key: zod.z.string().optional(),
+  // Custom API key
+  maxTurns: zod.z.number().optional()
+  // Maximum number of turns for the agent (default: 50)
+});
+const createTaskSchema = baseTaskSchema.extend({
+  message: zod.z.custom(
+    (data) => {
+      return typeof data === "object" && data !== null && "type" in data;
+    },
+    {
+      message: "Invalid SDKMessage format"
+    }
+  ).optional(),
+  encryptedMessage: zod.z.string().optional()
+  // base64 sealed-box payload for local machines
+}).refine(
+  (data) => {
+    return !!data.message !== !!data.encryptedMessage;
+  },
+  {
+    message: "Exactly one of message or encryptedMessage must be provided"
+  }
+);
+const resumeTaskSchema = baseTaskSchema.extend({
+  agentSessionId: zod.z.string(),
+  event: zod.z.string().optional(),
+  eventData: zod.z.any().optional(),
+  message: zod.z.custom(
+    (data) => {
+      return typeof data === "object" && data !== null && "type" in data;
+    },
+    {
+      message: "Invalid SDKMessage format"
+    }
+  ).optional(),
+  encryptedMessage: zod.z.string().optional()
+  // base64 sealed-box for local tasks
+});
+const cancelTaskSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  userId: zod.z.string(),
+  chatId: zod.z.string(),
+  agentId: zod.z.string(),
+  reason: zod.z.string().optional()
+});
+const StopTaskSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  reason: zod.z.string().optional()
+});
+const TaskMessageSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  from: zod.z.enum(["app", "api-server", "machine", "worker"]),
+  message: zod.z.custom(
+    (data) => {
+      return typeof data === "object" && data !== null && "type" in data;
+    },
+    {
+      message: "Invalid SDKMessage format"
+    }
+  ).optional(),
+  encryptedMessage: zod.z.string().optional()
+  // base64 sealed-box payload (local mode)
+}).refine(
+  (data) => {
+    return !!data.message !== !!data.encryptedMessage;
+  },
+  {
+    message: "Exactly one of message or encryptedMessage must be provided"
+  }
+);
+const RequirePermissionSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  toolName: zod.z.string(),
+  toolInput: zod.z.record(zod.z.unknown())
+});
+const RequirePermissionResponseSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  opCode: zod.z.string(),
+  // Echoed back, equals to eventId in RequirePermissionRequest
+  behavior: zod.z.enum(["allow", "deny"]),
+  message: zod.z.string().optional()
+});
+const TaskArtifactsUpdatedEventSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  commitHash: zod.z.string(),
+  timestamp: zod.z.string(),
+  stats: zod.z.object({
+    totalInsertions: zod.z.number(),
+    totalDeletions: zod.z.number(),
+    files: zod.z.array(FileStatsSchema)
+  })
+});
+const ChangeTaskTitleEventSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  title: zod.z.string()
+});
+const CreditExhaustedEventSchema = EventBaseSchema.extend({});
+const WorkspaceFileRequestSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  userId: zod.z.string(),
+  // User ID for workspace path resolution
+  relativePath: zod.z.string(),
+  // Relative path from workspace root (e.g., 'data/patch.diff', 'project/src/index.ts')
+  requestId: zod.z.string(),
+  // UUID for correlating request-response
+  maxFileSizeMB: zod.z.number().optional(),
+  // Maximum file size in MB (set by API, default: 10)
+  ifModifiedSince: zod.z.string().optional(),
+  // ISO timestamp for cache validation
+  dataEncryptionKey: zod.z.string().optional()
+  // Encrypted data encryption key (for local mode)
+});
+const WorkspaceFileResponseSchema = EventBaseSchema.extend({
+  requestId: zod.z.string(),
+  // Corresponds to request's requestId
+  taskId: zod.z.string(),
+  success: zod.z.boolean(),
+  notModified: zod.z.boolean().optional(),
+  // True if file hasn't changed since ifModifiedSince
+  // Success response
+  data: zod.z.object({
+    type: zod.z.enum(["file", "directory"]),
+    content: zod.z.string().optional(),
+    // File content (base64 encoded) - plaintext
+    encryptedContent: zod.z.string().optional(),
+    // File content (encrypted) - for local mode with dataEncryptionKey
+    entries: zod.z.array(zod.z.object({
+      name: zod.z.string(),
+      type: zod.z.enum(["file", "directory"]),
+      size: zod.z.number(),
+      modifiedAt: zod.z.string(),
+      accessDenied: zod.z.boolean().optional()
+      // Exceeds size limit
+    })).optional(),
+    // Directory listing
+    metadata: zod.z.object({
+      size: zod.z.number(),
+      mimeType: zod.z.string().optional(),
+      modifiedAt: zod.z.string(),
+      accessDenied: zod.z.boolean().optional()
+      // Exceeds size limit
+    })
+  }).optional(),
+  // Error response
+  error: zod.z.object({
+    code: zod.z.string(),
+    // 'file_not_found' | 'permission_denied' | 'file_too_large' | 'timeout' | 'machine_offline'
+    message: zod.z.string()
+  }).optional()
+});
+const UpdateTaskAgentSessionIdEventSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  agentSessionId: zod.z.string()
+});
+const MergeRequestEventSchema = EventBaseSchema.extend({
+  taskId: zod.z.string(),
+  summary: zod.z.string(),
+  description: zod.z.string().optional()
+});
+const IdOnlySchema = zod.z.object({
+  id: zod.z.string()
+});
+const PrStateChangedSchema = zod.z.object({
+  taskId: zod.z.string(),
+  pullRequestNumber: zod.z.number(),
+  pullRequestUrl: zod.z.string(),
+  oldState: zod.z.enum(["open", "closed", "merged"]).nullable(),
+  newState: zod.z.enum(["open", "closed", "merged"]),
+  changedAt: zod.z.string()
+  // ISO 8601 string
+});
+const SystemMessageSchema = EventBaseSchema.extend({
+  type: zod.z.enum([
+    "machine-online",
+    "machine-offline",
+    "chat-added",
+    "chat-removed",
+    "chat-member-added",
+    "chat-member-removed",
+    "repo-added",
+    "repo-removed",
+    "pr-state-changed"
+  ]),
+  data: zod.z.union([
+    IdOnlySchema,
+    // machine-online, machine-offline, chat-removed, repo-removed
+    ChatSchema,
+    // chat-added
+    zod.z.array(ChatMemberSchema),
+    // chat-member-added (array)
+    zod.z.array(IdOnlySchema),
+    // chat-member-removed (array)
+    RepositorySchema,
+    // repo-added
+    PrStateChangedSchema
+    // pr-state-changed
+  ]),
+  timestamp: zod.z.string()
+});
+const EventSchemaMap = {
+  // App events
+  "app-alive": AppAliveEventSchema,
+  "api-server-alive": ApiServerAliveEventSchema,
+  // Machine events
+  "machine-alive": MachineAliveEventSchema,
+  // Worker events
+  "worker-initializing": WorkerInitializingSchema,
+  "worker-ready": WorkerReadySchema,
+  "worker-alive": WorkerAliveEventSchema,
+  "worker-exit": WorkerExitSchema,
+  "worker-running": WorkerRunningSchema,
+  // Task events
+  "create-task": createTaskSchema,
+  "resume-task": resumeTaskSchema,
+  "cancel-task": cancelTaskSchema,
+  "stop-task": StopTaskSchema,
+  "task-message": TaskMessageSchema,
+  "change-task-title": ChangeTaskTitleEventSchema,
+  "update-task-agent-session-id": UpdateTaskAgentSessionIdEventSchema,
+  // Artifacts events
+  "task-artifacts-updated": TaskArtifactsUpdatedEventSchema,
+  // Permission events
+  "require-permission": RequirePermissionSchema,
+  "require-permission-response": RequirePermissionResponseSchema,
+  // Git operation events
+  // Merge request events
+  "merge-request": MergeRequestEventSchema,
+  // System message events
+  "system-message": SystemMessageSchema,
+  // Billing events
+  "credit-exhausted": CreditExhaustedEventSchema,
+  // Workspace file events
+  "workspace-file-request": WorkspaceFileRequestSchema,
+  "workspace-file-response": WorkspaceFileResponseSchema,
+  // Ack events
+  "event-ack": EventAckSchema
+};
+const workerTaskEvents = [
+  "worker-initializing",
+  "worker-ready",
+  "worker-running",
+  "worker-exit",
+  "change-task-title",
+  "update-task-agent-session-id",
+  "task-artifacts-updated",
+  "require-permission",
+  "merge-request"
+];
+
+function userAuth(token) {
+  return {
+    token,
+    clientType: "user"
+  };
+}
+function machineAuth(token, machineId) {
+  return {
+    token,
+    clientType: "machine",
+    machineId
+  };
+}
+function workerAuth(token, machineId, taskId) {
+  return {
+    token,
+    clientType: "worker",
+    machineId,
+    taskId
+  };
+}
+
+let agentContext = null;
+function setAgentContext(context) {
+  agentContext = context;
+}
+function getAgentContext() {
+  if (!agentContext) {
+    throw new Error("Agent context not initialized. Call setAgentContext() first.");
+  }
+  return agentContext;
+}
+
+const FRAMEWORK_TYPES = ["claude", "codex"];
+
+const AgentMetadataSchema = zod.z.object({
+  name: zod.z.string(),
+  version: zod.z.string(),
+  description: zod.z.string().optional()
+});
+const MCPServerConfigSchema = zod.z.object({
+  name: zod.z.string(),
+  command: zod.z.string().optional(),
+  args: zod.z.array(zod.z.string()).optional(),
+  env: zod.z.record(zod.z.string()).optional(),
+  url: zod.z.string().url().optional(),
+  transport: zod.z.enum(["stdio", "http"]).optional()
+});
+const SkillConfigSchema = zod.z.object({
+  name: zod.z.string(),
+  description: zod.z.string().optional(),
+  enabled: zod.z.boolean(),
+  implementation: zod.z.string().optional()
+});
+const ClaudeConfigSchema = zod.z.object({
+  // SDK native model configuration
+  model: zod.z.string().optional(),
+  fallbackModel: zod.z.string().optional(),
+  maxTurns: zod.z.number().int().positive().optional(),
+  // SDK native extra arguments
+  extraArgs: zod.z.record(zod.z.string().nullable()).optional(),
+  systemPrompt: zod.z.object({
+    path: zod.z.string(),
+    mode: zod.z.enum(["append", "replace"]).optional().default("append")
+  }).optional(),
+  settings: zod.z.object({
+    permissionMode: zod.z.enum(["default", "acceptEdits", "bypassPermissions", "plan"]).optional(),
+    allowedTools: zod.z.array(zod.z.string()).optional()
+  }).optional(),
+  mcpServers: zod.z.object({
+    enabled: zod.z.array(zod.z.string()),
+    directory: zod.z.string()
+  }).optional(),
+  skills: zod.z.object({
+    enabled: zod.z.array(zod.z.string()),
+    directory: zod.z.string()
+  }).optional()
+});
+
+class AgentError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentError";
+  }
+}
+class AgentNotFoundError extends AgentError {
+  constructor(agentId) {
+    super(`Agent not found: ${agentId}`);
+    this.name = "AgentNotFoundError";
+  }
+}
+class AgentConfigValidationError extends AgentError {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "AgentConfigValidationError";
+  }
+}
+class FrameworkNotSupportedError extends AgentError {
+  constructor(agentId, framework) {
+    super(`Agent "${agentId}" does not support framework: ${framework}`);
+    this.name = "FrameworkNotSupportedError";
+  }
+}
+class AgentLoadError extends AgentError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "AgentLoadError";
+  }
+}
+class MissingAgentFileError extends AgentError {
+  constructor(filePath) {
+    super(`Required agent file missing: ${filePath}`);
+    this.name = "MissingAgentFileError";
+  }
+}
+
+function validateAgentDirectory(agentDir) {
+  const errors = [];
+  const warnings = [];
+  if (!node_fs.existsSync(agentDir)) {
+    errors.push(`Agent directory does not exist: ${agentDir}`);
+    return { valid: false, errors, warnings };
+  }
+  if (!node_fs.statSync(agentDir).isDirectory()) {
+    errors.push(`Path is not a directory: ${agentDir}`);
+    return { valid: false, errors, warnings };
+  }
+  const agentJsonPath = node_path.join(agentDir, "agent.json");
+  if (!node_fs.existsSync(agentJsonPath)) {
+    errors.push("Missing required file: agent.json");
+  }
+  const readmePath = node_path.join(agentDir, "README.md");
+  if (!node_fs.existsSync(readmePath)) {
+    warnings.push("Missing README.md (recommended)");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateFrameworkDirectory(frameworkDir, framework) {
+  const errors = [];
+  const warnings = [];
+  if (!node_fs.existsSync(frameworkDir)) {
+    errors.push(`Framework directory does not exist: ${frameworkDir}`);
+    return { valid: false, errors, warnings };
+  }
+  const configPath = node_path.join(frameworkDir, "config.json");
+  if (!node_fs.existsSync(configPath)) {
+    errors.push(`Missing required file: ${framework}/config.json`);
+  }
+  if (framework === "claude") {
+    const mcpServersDir = node_path.join(frameworkDir, "mcp-servers");
+    if (!node_fs.existsSync(mcpServersDir)) {
+      warnings.push("Missing mcp-servers directory (optional)");
+    }
+    const skillsDir = node_path.join(frameworkDir, "skills");
+    if (!node_fs.existsSync(skillsDir)) {
+      warnings.push("Missing skills directory (optional)");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function assertFileExists(filePath, description) {
+  if (!node_fs.existsSync(filePath)) {
+    throw new MissingAgentFileError(description || filePath);
+  }
+}
+function assertAgentExists(agentDir, agentId) {
+  if (!node_fs.existsSync(agentDir)) {
+    throw new AgentNotFoundError(agentId);
+  }
+}
+
+async function loadMcpServers(mcpServersDir, enabledServers) {
+  const loaded = {};
+  if (!node_fs.existsSync(mcpServersDir)) {
+    return loaded;
+  }
+  const serverDirs = node_fs.readdirSync(mcpServersDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  for (const serverName of enabledServers) {
+    if (!serverDirs.includes(serverName)) {
+      throw new AgentLoadError(
+        `MCP server "${serverName}" is enabled but directory not found`
+      );
+    }
+    const serverDir = node_path.join(mcpServersDir, serverName);
+    try {
+      const config = await loadMcpServerConfig(serverDir, serverName);
+      const instance = await createMcpServerInstance(config);
+      loaded[serverName] = {
+        name: serverName,
+        config,
+        instance
+      };
+    } catch (error) {
+      throw new AgentLoadError(
+        `Failed to load MCP server "${serverName}": ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  return loaded;
+}
+async function loadMcpServerConfig(serverDir, serverName) {
+  const configPath = node_path.join(serverDir, "config.json");
+  if (!node_fs.existsSync(configPath)) {
+    throw new AgentLoadError(`MCP server "${serverName}" missing config.json`);
+  }
+  try {
+    const content = node_fs.readFileSync(configPath, "utf-8");
+    const rawConfig = JSON.parse(content);
+    const validatedConfig = MCPServerConfigSchema.parse(rawConfig);
+    return validatedConfig;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new AgentConfigValidationError(
+        `Invalid JSON in MCP server config: ${serverName}`
+      );
+    }
+    throw new AgentConfigValidationError(
+      `Invalid MCP server configuration for "${serverName}": ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function createMcpServerInstance(config) {
+  if (config.transport === "stdio" && config.command) {
+    throw new AgentLoadError(
+      "stdio transport for MCP servers not yet implemented. Use inline MCP servers for now."
+    );
+  }
+  if (config.transport === "http" && config.url) {
+    throw new AgentLoadError(
+      "HTTP transport for MCP servers not yet implemented"
+    );
+  }
+  throw new AgentLoadError(
+    `Cannot create MCP server instance: unsupported configuration for "${config.name}"`
+  );
+}
+
+async function loadAgentConfig(options) {
+  const { agentId, framework, validateOnly = false } = options;
+  const agentContext = getAgentContext();
+  const agentDir = agentContext.resolveAgentDir(agentId);
+  assertAgentExists(agentDir, agentId);
+  const validation = validateAgentDirectory(agentDir);
+  if (!validation.valid) {
+    throw new AgentConfigValidationError(
+      `Agent directory validation failed for "${agentId}"`,
+      validation.errors
+    );
+  }
+  if (validation.warnings.length > 0) {
+    console.warn(`[AGENT] Warnings for agent "${agentId}":`, validation.warnings);
+  }
+  const metadata = await loadAgentMetadata(agentDir);
+  const frameworkDir = node_path.join(agentDir, `.${framework}`);
+  if (!node_fs.existsSync(frameworkDir)) {
+    throw new FrameworkNotSupportedError(agentId, framework);
+  }
+  if (validateOnly) {
+    return {
+      metadata,
+      framework
+    };
+  }
+  if (framework === "claude") {
+    const claudeConfig = await loadClaudeConfiguration(agentDir);
+    return {
+      metadata,
+      framework,
+      claude: claudeConfig
+    };
+  }
+  throw new AgentLoadError(`Framework "${framework}" loader not implemented`);
+}
+async function loadAgentMetadata(agentDir) {
+  const agentJsonPath = node_path.join(agentDir, "agent.json");
+  assertFileExists(agentJsonPath, "agent.json");
+  try {
+    const content = node_fs.readFileSync(agentJsonPath, "utf-8");
+    const rawData = JSON.parse(content);
+    const metadata = AgentMetadataSchema.parse(rawData);
+    return metadata;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new AgentConfigValidationError("Invalid JSON in agent.json");
+    }
+    throw new AgentConfigValidationError(
+      `Invalid agent metadata: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function loadClaudeConfiguration(agentDir, metadata) {
+  const claudeDir = node_path.join(agentDir, ".claude");
+  const validation = validateFrameworkDirectory(claudeDir, "claude");
+  if (!validation.valid) {
+    throw new AgentConfigValidationError(
+      "Claude framework directory validation failed",
+      validation.errors
+    );
+  }
+  const config = await loadClaudeConfig(claudeDir);
+  let systemPrompt;
+  if (config.systemPrompt) {
+    systemPrompt = await loadSystemPrompt(claudeDir, config.systemPrompt.path);
+  }
+  const mcpServers = config.mcpServers ? await loadMcpServers(
+    node_path.join(claudeDir, config.mcpServers.directory),
+    config.mcpServers.enabled
+  ) : {};
+  const skills = config.skills ? await loadSkills(
+    node_path.join(claudeDir, config.skills.directory),
+    config.skills.enabled
+  ) : [];
+  return {
+    config,
+    systemPrompt,
+    mcpServers,
+    skills
+  };
+}
+async function loadClaudeConfig(claudeDir) {
+  const configPath = node_path.join(claudeDir, "config.json");
+  assertFileExists(configPath, ".claude/config.json");
+  try {
+    const content = node_fs.readFileSync(configPath, "utf-8");
+    const rawConfig = JSON.parse(content);
+    const config = ClaudeConfigSchema.parse(rawConfig);
+    return config;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new AgentConfigValidationError(
+        "Invalid JSON in .claude/config.json"
+      );
+    }
+    throw new AgentConfigValidationError(
+      `Invalid Claude configuration: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function loadSystemPrompt(claudeDir, promptFile) {
+  const promptPath = node_path.join(claudeDir, promptFile);
+  if (!node_fs.existsSync(promptPath)) {
+    throw new MissingAgentFileError(`.claude/${promptFile}`);
+  }
+  try {
+    return node_fs.readFileSync(promptPath, "utf-8");
+  } catch (error) {
+    throw new AgentLoadError(
+      `Failed to read system prompt: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function loadSkills(skillsDir, enabledSkills) {
+  const skills = [];
+  if (!node_fs.existsSync(skillsDir)) {
+    return skills;
+  }
+  const skillDirs = node_fs.readdirSync(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  for (const skillName of enabledSkills) {
+    if (!skillDirs.includes(skillName)) {
+      throw new AgentLoadError(
+        `Skill "${skillName}" is enabled but directory not found`
+      );
+    }
+    const skillDir = node_path.join(skillsDir, skillName);
+    const skillConfigPath = node_path.join(skillDir, "skill.json");
+    if (!node_fs.existsSync(skillConfigPath)) {
+      throw new MissingAgentFileError(
+        `skills/${skillName}/skill.json`
+      );
+    }
+    try {
+      const content = node_fs.readFileSync(skillConfigPath, "utf-8");
+      const rawSkill = JSON.parse(content);
+      const skill = SkillConfigSchema.parse(rawSkill);
+      skills.push(skill);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new AgentConfigValidationError(
+          `Invalid JSON in skills/${skillName}/skill.json`
+        );
+      }
+      throw new AgentConfigValidationError(
+        `Invalid skill configuration for "${skillName}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return skills;
+}
+
+const cryptoModule = typeof globalThis.crypto !== "undefined" ? globalThis.crypto : (async () => {
+  try {
+    const nodeCrypto = await import('node:crypto');
+    return nodeCrypto.webcrypto;
+  } catch {
+    throw new Error("Web Crypto API not available");
+  }
+})();
+async function getCrypto() {
+  if (typeof cryptoModule === "object" && cryptoModule !== null && "subtle" in cryptoModule) {
+    return cryptoModule;
+  }
+  return await cryptoModule;
+}
+async function hmac_sha512(key, data) {
+  const crypto = await getCrypto();
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    key,
+    { name: "HMAC", hash: "SHA-512" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", cryptoKey, data);
+  return new Uint8Array(signature);
+}
+
+async function deriveSecretKeyTreeRoot(seed, usage) {
+  const I = await hmac_sha512(new TextEncoder().encode(usage + " Master Seed"), seed);
+  return {
+    key: I.slice(0, 32),
+    chainCode: I.slice(32)
+  };
+}
+async function deriveSecretKeyTreeChild(chainCode, index) {
+  const data = new Uint8Array([0, ...new TextEncoder().encode(index)]);
+  const I = await hmac_sha512(chainCode, data);
+  return {
+    key: I.subarray(0, 32),
+    chainCode: I.subarray(32)
+  };
+}
+async function deriveKey(master, usage, path) {
+  let state = await deriveSecretKeyTreeRoot(master, usage);
+  let remaining = [...path];
+  while (remaining.length > 0) {
+    let index = remaining[0];
+    remaining = remaining.slice(1);
+    state = await deriveSecretKeyTreeChild(state.chainCode, index);
+  }
+  return state.key;
+}
+
+function encodeBase64(buffer, variant = "base64") {
+  if (variant === "base64url") {
+    return encodeBase64Url(buffer);
+  }
+  return base64js__namespace.fromByteArray(buffer);
+}
+function encodeBase64Url(buffer) {
+  return base64js__namespace.fromByteArray(buffer).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function decodeBase64(base64, variant = "base64") {
+  if (!base64) {
+    throw new Error("Invalid base64 input: must be a non-empty string");
+  }
+  const cleaned = base64.replace(/\s/g, "");
+  if (!cleaned) {
+    throw new Error("Invalid base64 input: empty after removing whitespace");
+  }
+  try {
+    if (variant === "base64url") {
+      let base64Standard = cleaned.replace(/-/g, "+").replace(/_/g, "/");
+      const padding = (4 - base64Standard.length % 4) % 4;
+      if (padding > 0) {
+        base64Standard += "=".repeat(padding);
+      }
+      return base64js__namespace.toByteArray(base64Standard);
+    }
+    return base64js__namespace.toByteArray(cleaned);
+  } catch (error) {
+    throw new Error(`Failed to decode base64 (variant: ${variant}): ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function getRandomBytes(size) {
+  return tweetnacl.randomBytes(size);
+}
+function generateAESKey() {
+  return getRandomBytes(tweetnacl.secretbox.keyLength);
+}
+function generateAESKeyBase64(variant = "base64") {
+  const key = generateAESKey();
+  return encodeBase64(key, variant);
+}
+function encryptAES(data, dataKey) {
+  if (dataKey.length !== tweetnacl.secretbox.keyLength) {
+    throw new Error(`Invalid key length: expected ${tweetnacl.secretbox.keyLength}, got ${dataKey.length}`);
+  }
+  const nonce = getRandomBytes(tweetnacl.secretbox.nonceLength);
+  const plaintext = new TextEncoder().encode(JSON.stringify(data));
+  const encrypted = tweetnacl.secretbox(plaintext, nonce, dataKey);
+  const bundle = new Uint8Array(1 + nonce.length + encrypted.length);
+  bundle.set([0], 0);
+  bundle.set(nonce, 1);
+  bundle.set(encrypted, 1 + nonce.length);
+  return bundle;
+}
+function decryptAES(bundle, dataKey) {
+  if (dataKey.length !== tweetnacl.secretbox.keyLength) {
+    return null;
+  }
+  if (bundle.length < 1) {
+    return null;
+  }
+  if (bundle[0] !== 0) {
+    return null;
+  }
+  const minLength = 1 + tweetnacl.secretbox.nonceLength + tweetnacl.secretbox.overheadLength;
+  if (bundle.length < minLength) {
+    return null;
+  }
+  const nonce = bundle.slice(1, 1 + tweetnacl.secretbox.nonceLength);
+  const ciphertext = bundle.slice(1 + tweetnacl.secretbox.nonceLength);
+  try {
+    const decrypted = tweetnacl.secretbox.open(ciphertext, nonce, dataKey);
+    if (!decrypted) {
+      return null;
+    }
+    return JSON.parse(new TextDecoder().decode(decrypted));
+  } catch (error) {
+    return null;
+  }
+}
+async function createKeyPairWithUit8Array(masterSecret) {
+  const contentDataKey = await deriveKey(masterSecret, "Agentrix EnCoder", ["content"]);
+  return tweetnacl.box.keyPair.fromSecretKey(contentDataKey);
+}
+async function createKeyPair(masterSecret, variant = "base64") {
+  return await createKeyPairWithUit8Array(decodeBase64(masterSecret, variant));
+}
+function decryptWithEphemeralKey(encryptedBundle, secretKey) {
+  const ephemeralPublicKey = encryptedBundle.slice(0, 32);
+  const nonce = encryptedBundle.slice(32, 32 + tweetnacl.box.nonceLength);
+  const encrypted = encryptedBundle.slice(32 + tweetnacl.box.nonceLength);
+  const decrypted = tweetnacl.box.open(encrypted, nonce, ephemeralPublicKey, secretKey);
+  if (!decrypted) {
+    return null;
+  }
+  return decrypted;
+}
+function encryptWithEphemeralKey(data, publicKey) {
+  const ephemeralKeyPair = tweetnacl.box.keyPair();
+  const nonce = getRandomBytes(tweetnacl.box.nonceLength);
+  const encrypted = tweetnacl.box(data, nonce, publicKey, ephemeralKeyPair.secretKey);
+  const result = new Uint8Array(ephemeralKeyPair.publicKey.length + nonce.length + encrypted.length);
+  result.set(ephemeralKeyPair.publicKey, 0);
+  result.set(nonce, ephemeralKeyPair.publicKey.length);
+  result.set(encrypted, ephemeralKeyPair.publicKey.length + nonce.length);
+  return result;
+}
+function encryptSdkMessage(message, dataKey) {
+  const encryptedWithVersion = encryptAES(message, dataKey);
+  const encryptedWithoutVersion = encryptedWithVersion.slice(1);
+  return encodeBase64(encryptedWithoutVersion);
+}
+function decryptSdkMessage(encryptedMessage, dataKey) {
+  try {
+    const encryptedWithoutVersion = decodeBase64(encryptedMessage);
+    const encryptedWithVersion = new Uint8Array(1 + encryptedWithoutVersion.length);
+    encryptedWithVersion.set([0], 0);
+    encryptedWithVersion.set(encryptedWithoutVersion, 1);
+    return decryptAES(encryptedWithVersion, dataKey);
+  } catch (error) {
+    return null;
+  }
+}
+function encryptMachineEncryptionKey(machinePublicKey, aesKey, userPublicKey) {
+  if (machinePublicKey.length !== 32) {
+    throw new Error(`Invalid machine public key length: expected 32, got ${machinePublicKey.length}`);
+  }
+  if (aesKey.length !== tweetnacl.secretbox.keyLength) {
+    throw new Error(`Invalid AES key length: expected ${tweetnacl.secretbox.keyLength}, got ${aesKey.length}`);
+  }
+  if (userPublicKey.length !== 32) {
+    throw new Error(`Invalid user public key length: expected 32, got ${userPublicKey.length}`);
+  }
+  const combined = new Uint8Array(machinePublicKey.length + aesKey.length);
+  combined.set(machinePublicKey, 0);
+  combined.set(aesKey, machinePublicKey.length);
+  const encrypted = encryptWithEphemeralKey(combined, userPublicKey);
+  return encodeBase64(encrypted);
+}
+function decryptMachineEncryptionKey(encryptedData, userPrivateKey) {
+  if (userPrivateKey.length !== 32) {
+    return null;
+  }
+  try {
+    const encryptedBundle = decodeBase64(encryptedData);
+    const decrypted = decryptWithEphemeralKey(encryptedBundle, userPrivateKey);
+    if (!decrypted) {
+      return null;
+    }
+    const expectedLength = 32 + tweetnacl.secretbox.keyLength;
+    if (decrypted.length !== expectedLength) {
+      return null;
+    }
+    const machinePublicKey = decrypted.slice(0, 32);
+    const aesKey = decrypted.slice(32);
+    return { machinePublicKey, aesKey };
+  } catch (error) {
+    return null;
+  }
+}
+function encryptFileContent(fileContentBase64, dataKey) {
+  const encryptedWithVersion = encryptAES(fileContentBase64, dataKey);
+  const encryptedWithoutVersion = encryptedWithVersion.slice(1);
+  return encodeBase64(encryptedWithoutVersion);
+}
+function decryptFileContent(encryptedContent, dataKey) {
+  try {
+    const encryptedWithoutVersion = decodeBase64(encryptedContent);
+    const encryptedWithVersion = new Uint8Array(1 + encryptedWithoutVersion.length);
+    encryptedWithVersion.set([0], 0);
+    encryptedWithVersion.set(encryptedWithoutVersion, 1);
+    return decryptAES(encryptedWithVersion, dataKey);
+  } catch (error) {
+    return null;
+  }
+}
+
+exports.AddChatMemberRequestSchema = AddChatMemberRequestSchema;
+exports.AddChatMemberResponseSchema = AddChatMemberResponseSchema;
+exports.AgentConfigValidationError = AgentConfigValidationError;
+exports.AgentError = AgentError;
+exports.AgentLoadError = AgentLoadError;
+exports.AgentMetadataSchema = AgentMetadataSchema;
+exports.AgentNotFoundError = AgentNotFoundError;
+exports.AgentSchema = AgentSchema;
+exports.AgentTypeSchema = AgentTypeSchema;
+exports.ApiErrorSchema = ApiErrorSchema;
+exports.ApiServerAliveEventSchema = ApiServerAliveEventSchema;
+exports.AppAliveEventSchema = AppAliveEventSchema;
+exports.ApprovalStatusResponseSchema = ApprovalStatusResponseSchema;
+exports.BillingStatsResponseSchema = BillingStatsResponseSchema;
+exports.BranchSchema = BranchSchema;
+exports.CancelTaskRequestSchema = CancelTaskRequestSchema;
+exports.CancelTaskResponseSchema = CancelTaskResponseSchema;
+exports.ChangeTaskTitleEventSchema = ChangeTaskTitleEventSchema;
+exports.ChargeTransactionSchema = ChargeTransactionSchema;
+exports.ChatMemberInputSchema = ChatMemberInputSchema;
+exports.ChatMemberSchema = ChatMemberSchema;
+exports.ChatSchema = ChatSchema;
+exports.ChatTypeSchema = ChatTypeSchema;
+exports.ChatWithMembersSchema = ChatWithMembersSchema;
+exports.ClaudeConfigSchema = ClaudeConfigSchema;
+exports.CloudJoinApprovalRequestSchema = CloudJoinApprovalRequestSchema;
+exports.CloudJoinRequestSchema = CloudJoinRequestSchema;
+exports.CloudJoinResultQuerySchema = CloudJoinResultQuerySchema;
+exports.CloudJoinStatusQuerySchema = CloudJoinStatusQuerySchema;
+exports.CloudMachineSchema = CloudMachineSchema;
+exports.CloudSchema = CloudSchema;
+exports.ConfirmUploadRequestSchema = ConfirmUploadRequestSchema;
+exports.ConfirmUploadResponseSchema = ConfirmUploadResponseSchema;
+exports.ConsumeTransactionSchema = ConsumeTransactionSchema;
+exports.CreateAgentRequestSchema = CreateAgentRequestSchema;
+exports.CreateAgentResponseSchema = CreateAgentResponseSchema;
+exports.CreateChatRequestSchema = CreateChatRequestSchema;
+exports.CreateChatResponseSchema = CreateChatResponseSchema;
+exports.CreateCloudRequestSchema = CreateCloudRequestSchema;
+exports.CreateCloudResponseSchema = CreateCloudResponseSchema;
+exports.CreateMergeRequestResponseSchema = CreateMergeRequestResponseSchema;
+exports.CreateMergeRequestSchema = CreateMergeRequestSchema;
+exports.CreateOAuthServerRequestSchema = CreateOAuthServerRequestSchema;
+exports.CreateOAuthServerResponseSchema = CreateOAuthServerResponseSchema;
+exports.CreditExhaustedEventSchema = CreditExhaustedEventSchema;
+exports.CreditsPackageSchema = CreditsPackageSchema;
+exports.DateSchema = DateSchema;
+exports.DeleteAgentResponseSchema = DeleteAgentResponseSchema;
+exports.DeleteOAuthServerResponseSchema = DeleteOAuthServerResponseSchema;
+exports.EventAckSchema = EventAckSchema;
+exports.EventSchemaMap = EventSchemaMap;
+exports.FRAMEWORK_TYPES = FRAMEWORK_TYPES;
+exports.FileItemSchema = FileItemSchema;
+exports.FileStatsSchema = FileStatsSchema;
+exports.FileVisibilitySchema = FileVisibilitySchema;
+exports.FrameworkNotSupportedError = FrameworkNotSupportedError;
+exports.GetAgentResponseSchema = GetAgentResponseSchema;
+exports.GetChatResponseSchema = GetChatResponseSchema;
+exports.GetGitUrlQuerySchema = GetGitUrlQuerySchema;
+exports.GetGitUrlResponseSchema = GetGitUrlResponseSchema;
+exports.GetInstallUrlResponseSchema = GetInstallUrlResponseSchema;
+exports.GetOAuthServerResponseSchema = GetOAuthServerResponseSchema;
+exports.GetRepositoryResponseSchema = GetRepositoryResponseSchema;
+exports.GetUploadUrlsRequestSchema = GetUploadUrlsRequestSchema;
+exports.GetUploadUrlsResponseSchema = GetUploadUrlsResponseSchema;
+exports.GitHubIssueListItemSchema = GitHubIssueListItemSchema;
+exports.GitHubIssueSchema = GitHubIssueSchema;
+exports.IdSchema = IdSchema;
+exports.ListAgentsResponseSchema = ListAgentsResponseSchema;
+exports.ListBranchesResponseSchema = ListBranchesResponseSchema;
+exports.ListChatMembersResponseSchema = ListChatMembersResponseSchema;
+exports.ListChatTasksResponseSchema = ListChatTasksResponseSchema;
+exports.ListChatsResponseSchema = ListChatsResponseSchema;
+exports.ListFilesQuerySchema = ListFilesQuerySchema;
+exports.ListFilesResponseSchema = ListFilesResponseSchema;
+exports.ListIssuesQuerySchema = ListIssuesQuerySchema;
+exports.ListIssuesResponseSchema = ListIssuesResponseSchema;
+exports.ListMachinesResponseSchema = ListMachinesResponseSchema;
+exports.ListOAuthServersQuerySchema = ListOAuthServersQuerySchema;
+exports.ListOAuthServersResponseSchema = ListOAuthServersResponseSchema;
+exports.ListPackagesQuerySchema = ListPackagesQuerySchema;
+exports.ListPackagesResponseSchema = ListPackagesResponseSchema;
+exports.ListRepositoriesResponseSchema = ListRepositoriesResponseSchema;
+exports.ListTasksResponseSchema = ListTasksResponseSchema;
+exports.ListTransactionsQuerySchema = ListTransactionsQuerySchema;
+exports.ListTransactionsResponseSchema = ListTransactionsResponseSchema;
+exports.LocalMachineSchema = LocalMachineSchema;
+exports.LogoutResponseSchema = LogoutResponseSchema;
+exports.MCPServerConfigSchema = MCPServerConfigSchema;
+exports.MachineAliveEventSchema = MachineAliveEventSchema;
+exports.MachineApprovalRequestSchema = MachineApprovalRequestSchema;
+exports.MachineApprovalStatusQuerySchema = MachineApprovalStatusQuerySchema;
+exports.MachineAuthAuthorizedResponseSchema = MachineAuthAuthorizedResponseSchema;
+exports.MachineAuthRequestSchema = MachineAuthRequestSchema;
+exports.MachineAuthResultQuerySchema = MachineAuthResultQuerySchema;
+exports.MergeRequestEventSchema = MergeRequestEventSchema;
+exports.MissingAgentFileError = MissingAgentFileError;
+exports.OAuthAccountInfoSchema = OAuthAccountInfoSchema;
+exports.OAuthBindCallbackResponseSchema = OAuthBindCallbackResponseSchema;
+exports.OAuthBindQuerySchema = OAuthBindQuerySchema;
+exports.OAuthBindResponseSchema = OAuthBindResponseSchema;
+exports.OAuthCallbackQuerySchema = OAuthCallbackQuerySchema;
+exports.OAuthCallbackResponseSchema = OAuthCallbackResponseSchema;
+exports.OAuthLoginQuerySchema = OAuthLoginQuerySchema;
+exports.OAuthServerPublicSchema = OAuthServerPublicSchema;
+exports.OAuthServerSchema = OAuthServerSchema;
+exports.OAuthUnbindResponseSchema = OAuthUnbindResponseSchema;
+exports.PaginatedResponseSchema = PaginatedResponseSchema;
+exports.PermissionResponseRequestSchema = PermissionResponseRequestSchema;
+exports.PermissionResponseResponseSchema = PermissionResponseResponseSchema;
+exports.ProjectDirectoryResponseSchema = ProjectDirectoryResponseSchema;
+exports.ProjectEntrySchema = ProjectEntrySchema;
+exports.QueryEventsRequestSchema = QueryEventsRequestSchema;
+exports.RechargeResponseSchema = RechargeResponseSchema;
+exports.RemoveChatMemberRequestSchema = RemoveChatMemberRequestSchema;
+exports.RepositorySchema = RepositorySchema;
+exports.RequirePermissionResponseSchema = RequirePermissionResponseSchema;
+exports.RequirePermissionSchema = RequirePermissionSchema;
+exports.ResetSecretRequestSchema = ResetSecretRequestSchema;
+exports.ResetSecretResponseSchema = ResetSecretResponseSchema;
+exports.ResumeTaskRequestSchema = ResumeTaskRequestSchema;
+exports.ResumeTaskResponseSchema = ResumeTaskResponseSchema;
+exports.ShutdownMachineSchema = ShutdownMachineSchema;
+exports.SignatureAuthRequestSchema = SignatureAuthRequestSchema;
+exports.SignatureAuthResponseSchema = SignatureAuthResponseSchema;
+exports.SimpleSuccessSchema = SimpleSuccessSchema;
+exports.SkillConfigSchema = SkillConfigSchema;
+exports.StartTaskRequestSchema = StartTaskRequestSchema;
+exports.StartTaskResponseSchema = StartTaskResponseSchema;
+exports.StatsQuerySchema = StatsQuerySchema;
+exports.StopTaskRequestSchema = StopTaskRequestSchema;
+exports.StopTaskResponseSchema = StopTaskResponseSchema;
+exports.StopTaskSchema = StopTaskSchema;
+exports.SyncCloudMachineResponseSchema = SyncCloudMachineResponseSchema;
+exports.SyncLocalMachineResponseSchema = SyncLocalMachineResponseSchema;
+exports.SyncMachineRequestSchema = SyncMachineRequestSchema;
+exports.SystemMessageSchema = SystemMessageSchema;
+exports.TaskArtifactsUpdatedEventSchema = TaskArtifactsUpdatedEventSchema;
+exports.TaskItemSchema = TaskItemSchema;
+exports.TaskMessageSchema = TaskMessageSchema;
+exports.TaskTransactionsResponseSchema = TaskTransactionsResponseSchema;
+exports.ToggleOAuthServerRequestSchema = ToggleOAuthServerRequestSchema;
+exports.ToggleOAuthServerResponseSchema = ToggleOAuthServerResponseSchema;
+exports.TransactionSchema = TransactionSchema;
+exports.UpdateAgentRequestSchema = UpdateAgentRequestSchema;
+exports.UpdateAgentResponseSchema = UpdateAgentResponseSchema;
+exports.UpdateOAuthServerRequestSchema = UpdateOAuthServerRequestSchema;
+exports.UpdateOAuthServerResponseSchema = UpdateOAuthServerResponseSchema;
+exports.UpdateTaskAgentSessionIdEventSchema = UpdateTaskAgentSessionIdEventSchema;
+exports.UploadUrlResultSchema = UploadUrlResultSchema;
+exports.UserBalanceResponseSchema = UserBalanceResponseSchema;
+exports.UserBasicInfoSchema = UserBasicInfoSchema;
+exports.UserProfileResponseSchema = UserProfileResponseSchema;
+exports.UserWithOAuthAccountsSchema = UserWithOAuthAccountsSchema;
+exports.WorkerAliveEventSchema = WorkerAliveEventSchema;
+exports.WorkerExitSchema = WorkerExitSchema;
+exports.WorkerInitializingSchema = WorkerInitializingSchema;
+exports.WorkerReadySchema = WorkerReadySchema;
+exports.WorkerRunningSchema = WorkerRunningSchema;
+exports.WorkspaceFileRequestSchema = WorkspaceFileRequestSchema;
+exports.WorkspaceFileResponseSchema = WorkspaceFileResponseSchema;
+exports.assertAgentExists = assertAgentExists;
+exports.assertFileExists = assertFileExists;
+exports.baseTaskSchema = baseTaskSchema;
+exports.cancelTaskRequestSchema = cancelTaskRequestSchema;
+exports.cancelTaskSchema = cancelTaskSchema;
+exports.createEventId = createEventId;
+exports.createKeyPair = createKeyPair;
+exports.createKeyPairWithUit8Array = createKeyPairWithUit8Array;
+exports.createMergeRequestSchema = createMergeRequestSchema;
+exports.createTaskSchema = createTaskSchema;
+exports.decodeBase64 = decodeBase64;
+exports.decryptAES = decryptAES;
+exports.decryptFileContent = decryptFileContent;
+exports.decryptMachineEncryptionKey = decryptMachineEncryptionKey;
+exports.decryptSdkMessage = decryptSdkMessage;
+exports.decryptWithEphemeralKey = decryptWithEphemeralKey;
+exports.encodeBase64 = encodeBase64;
+exports.encodeBase64Url = encodeBase64Url;
+exports.encryptAES = encryptAES;
+exports.encryptFileContent = encryptFileContent;
+exports.encryptMachineEncryptionKey = encryptMachineEncryptionKey;
+exports.encryptSdkMessage = encryptSdkMessage;
+exports.encryptWithEphemeralKey = encryptWithEphemeralKey;
+exports.generateAESKey = generateAESKey;
+exports.generateAESKeyBase64 = generateAESKeyBase64;
+exports.getAgentContext = getAgentContext;
+exports.getRandomBytes = getRandomBytes;
+exports.loadAgentConfig = loadAgentConfig;
+exports.loadMcpServers = loadMcpServers;
+exports.machineAuth = machineAuth;
+exports.permissionResponseRequestSchema = permissionResponseRequestSchema;
+exports.resumeTaskRequestSchema = resumeTaskRequestSchema;
+exports.resumeTaskSchema = resumeTaskSchema;
+exports.setAgentContext = setAgentContext;
+exports.startTaskSchema = startTaskSchema;
+exports.stopTaskRequestSchema = stopTaskRequestSchema;
+exports.userAuth = userAuth;
+exports.validateAgentDirectory = validateAgentDirectory;
+exports.validateFrameworkDirectory = validateFrameworkDirectory;
+exports.workerAuth = workerAuth;
+exports.workerTaskEvents = workerTaskEvents;