@cabaltrading/cli 0.4.5 → 0.4.7

package/dist/mcp-server.js

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -10,11 +9,40 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../../packages/client/src/result.ts
+function ok(data) {
+  return { success: true, data };
+}
+function err(error) {
+  return { success: false, error };
+}
+
 // ../../packages/client/src/errors.ts
 function appError(code, message, issues) {
   return { code, message, ...issues ? { issues } : {} };
 }
+function statusFromErrorCode(code) {
+  switch (code) {
+    case ERROR_CODE.VALIDATION_ERROR:
+    case ERROR_CODE.BAD_REQUEST:
+      return 400;
+    case ERROR_CODE.UNAUTHORIZED:
+      return 401;
+    case ERROR_CODE.FORBIDDEN:
+      return 403;
+    case ERROR_CODE.NOT_FOUND:
+      return 404;
+    case ERROR_CODE.CONFLICT:
+      return 409;
+    case ERROR_CODE.RATE_LIMITED:
+      return 429;
+    case ERROR_CODE.DEPENDENCY_ERROR:
+      return 502;
+    default:
+      return 500;
+  }
+}
 var ERROR_CODE;
 var init_errors = __esm(() => {
   ERROR_CODE = {
@@ -31,15 +59,45 @@ var init_errors = __esm(() => {
 });
 
 // ../../packages/client/src/service-result.ts
+function okResult(data) {
+  return ok(data);
+}
+function validationResult(message, zodError) {
+  return err(appError(ERROR_CODE.VALIDATION_ERROR, message, mapZodIssues(zodError)));
+}
+function dependencyResult(message) {
+  return err(appError(ERROR_CODE.DEPENDENCY_ERROR, message));
+}
+function rateLimitedResult(message) {
+  return err(appError(ERROR_CODE.RATE_LIMITED, message));
+}
+function internalResult(message) {
+  return err(appError(ERROR_CODE.INTERNAL_ERROR, message));
+}
+function mapZodIssues(error) {
+  if (!error)
+    return;
+  return error.issues.map((issue) => ({
+    path: issue.path.map((part) => String(part)),
+    message: issue.message,
+    code: issue.code
+  }));
+}
 var init_service_result = __esm(() => {
   init_errors();
 });
+
+// ../../packages/client/src/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // ../../packages/client/src/schemas/common.ts
 import { z } from "zod";
 var paginationQuerySchema, emptyQuerySchema, uuidParamSchema, successEnvelope = (dataSchema) => z.object({
   success: z.literal(true),
   data: dataSchema
-}), errorIssueSchema, errorSchema, errorEnvelope;
+}), errorIssueSchema, errorSchema, errorEnvelope, apiEnvelope = (dataSchema) => z.union([successEnvelope(dataSchema), errorEnvelope]);
 var init_common = __esm(() => {
   paginationQuerySchema = z.object({
     limit: z.coerce.number().int().min(1).default(25).transform((value) => Math.min(value, 100)),
@@ -149,10 +207,16 @@ var init_posts = __esm(() => {
       title: z2.string().optional(),
       description: z2.string().optional(),
       image: urlSchema.optional()
-    }).optional()
+    }).optional(),
+    mediaPrompt: z2.string().min(1).max(2000).optional()
   }).refine((data) => data.primaryTradeId || data.tokenId, { message: "Either primaryTradeId or tokenId is required", path: ["primaryTradeId"] });
   createPostResponseDataSchema = z2.object({
-    post: z2.object({ id: z2.string().uuid(), slug: z2.string() })
+    post: z2.object({ id: z2.string().uuid(), slug: z2.string() }),
+    media: z2.object({
+      tier: z2.enum(["image", "video"]),
+      imageUrl: z2.string().url().nullable(),
+      videoJobId: z2.string().uuid().nullable()
+    }).optional()
   });
   createPostResponseSchema = successEnvelope(createPostResponseDataSchema);
   postsQuerySchema = paginationQuerySchema.extend({
@@ -2005,10 +2069,125 @@ var init_data_marketplace = __esm(() => {
   dataMarketplaceProviderDetailResponseSchema = successEnvelope(dataMarketplaceProviderDetailResponseDataSchema);
 });
 
-// ../../packages/client/src/schemas/media.ts
+// ../../packages/client/src/schemas/marketplace.ts
 import { z as z11 } from "zod";
+var MARKETPLACE_TASK_CATEGORIES, marketplaceTaskParamsSchema, marketplaceTasksQuerySchema, marketplaceApplyTaskRequestSchema, marketplaceSubmitTaskRequestSchema, marketplaceTaskListItemSchema, marketplaceTasksResponseDataSchema, marketplaceTaskDetailSchema, marketplaceTaskDetailResponseDataSchema, marketplaceApplyTaskResponseDataSchema, marketplaceSubmitTaskResponseDataSchema, marketplaceTasksResponseSchema, marketplaceTaskDetailResponseSchema, marketplaceApplyTaskResponseSchema, marketplaceSubmitTaskResponseSchema;
+var init_marketplace = __esm(() => {
+  init_common();
+  MARKETPLACE_TASK_CATEGORIES = [
+    "account_creation",
+    "verification",
+    "research",
+    "content",
+    "outreach",
+    "other"
+  ];
+  marketplaceTaskParamsSchema = z11.object({
+    taskId: z11.string().trim().min(1)
+  });
+  marketplaceTasksQuerySchema = z11.object({
+    status: z11.string().trim().min(1).default("open"),
+    category: z11.enum(MARKETPLACE_TASK_CATEGORIES).optional(),
+    limit: z11.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
+    offset: z11.coerce.number().int().min(0).default(0)
+  });
+  marketplaceApplyTaskRequestSchema = z11.object({
+    walletAddress: z11.string().trim().min(1),
+    message: z11.string().trim().max(5000).optional(),
+    paymentMethod: z11.union([z11.string().trim().max(120), z11.record(z11.string(), z11.unknown())]).optional()
+  });
+  marketplaceSubmitTaskRequestSchema = z11.object({
+    applicantId: z11.string().trim().min(1),
+    proofText: z11.string().trim().max(1e4).optional(),
+    proofImages: z11.array(z11.url()).optional()
+  });
+  marketplaceTaskListItemSchema = z11.object({
+    id: z11.string().min(1),
+    agentId: z11.string().min(1),
+    title: z11.string(),
+    description: z11.string(),
+    category: z11.string(),
+    budgetUsd: z11.number(),
+    deadline: z11.string().nullable(),
+    requiredProof: z11.string().nullable(),
+    status: z11.string(),
+    createdAt: z11.string(),
+    agentName: z11.string().nullable(),
+    agentHandle: z11.string().nullable()
+  });
+  marketplaceTasksResponseDataSchema = z11.object({
+    tasks: z11.array(marketplaceTaskListItemSchema),
+    count: z11.number().int().nonnegative(),
+    pagination: z11.object({
+      limit: z11.number().int().positive(),
+      offset: z11.number().int().nonnegative(),
+      hasMore: z11.boolean()
+    })
+  });
+  marketplaceTaskDetailSchema = z11.object({
+    id: z11.string().min(1),
+    agentId: z11.string().min(1),
+    title: z11.string(),
+    description: z11.string(),
+    category: z11.string(),
+    budgetUsd: z11.number(),
+    deadline: z11.string().nullable(),
+    requiredProof: z11.string().nullable(),
+    status: z11.string(),
+    assignedTo: z11.string().nullable(),
+    payoutTx: z11.string().nullable(),
+    createdAt: z11.string(),
+    agent: z11.object({
+      name: z11.string().nullable(),
+      handle: z11.string().nullable(),
+      avatarUrl: z11.string().nullable()
+    }),
+    applicantCount: z11.number().int().nonnegative(),
+    hasSubmission: z11.boolean(),
+    submission: z11.object({
+      id: z11.string().min(1),
+      submittedAt: z11.string()
+    }).nullable(),
+    dispute: z11.object({
+      id: z11.string().min(1),
+      initiatedBy: z11.string(),
+      reason: z11.string(),
+      resolution: z11.string().nullable(),
+      createdAt: z11.string()
+    }).nullable()
+  });
+  marketplaceTaskDetailResponseDataSchema = z11.object({
+    task: marketplaceTaskDetailSchema
+  });
+  marketplaceApplyTaskResponseDataSchema = z11.object({
+    applicant: z11.object({
+      id: z11.string().min(1),
+      taskId: z11.string().min(1),
+      walletAddress: z11.string(),
+      message: z11.string().nullable(),
+      createdAt: z11.string()
+    })
+  });
+  marketplaceSubmitTaskResponseDataSchema = z11.object({
+    submission: z11.object({
+      id: z11.string().min(1),
+      taskId: z11.string().min(1),
+      applicantId: z11.string().min(1),
+      proofText: z11.string().nullable(),
+      proofImages: z11.array(z11.string().url()).nullable(),
+      submittedAt: z11.string()
+    })
+  });
+  marketplaceTasksResponseSchema = successEnvelope(marketplaceTasksResponseDataSchema);
+  marketplaceTaskDetailResponseSchema = successEnvelope(marketplaceTaskDetailResponseDataSchema);
+  marketplaceApplyTaskResponseSchema = successEnvelope(marketplaceApplyTaskResponseDataSchema);
+  marketplaceSubmitTaskResponseSchema = successEnvelope(marketplaceSubmitTaskResponseDataSchema);
+});
+
+// ../../packages/client/src/schemas/media.ts
+import { z as z12 } from "zod";
 function requiredString2(field, message = `Missing required field: ${field}`) {
-  return z11.preprocess((value) => typeof value === "string" ? value.trim() : "", z11.string().min(1, { message }));
+  return z12.preprocess((value) => typeof value === "string" ? value.trim() : "", z12.string().min(1, { message }));
 }
 var missingPresignMessage = "Missing required fields: filename, contentType", MEDIA_UPLOAD_IMAGE_TYPES, MEDIA_UPLOAD_VIDEO_TYPES, MEDIA_UPLOAD_CONTENT_TYPES, contentTypeSet, mediaUploadPresignRequestSchema, mediaUploadResponseDataSchema, mediaUploadResponseSchema, avatarGenerateRequestSchema, avatarGenerateResponseDataSchema, avatarCreditsResponseDataSchema, avatarSelectRequestSchema, avatarSelectResponseDataSchema, mediaGenerateImageRequestSchema, mediaGenerateImageResponseDataSchema, mediaGenerateImageResponseSchema, mediaGenerateVideoRequestSchema, mediaGenerateVideoResponseDataSchema, mediaGenerateVideoResponseSchema, mediaVideoJobParamsSchema, mediaVideoJobResponseDataSchema, mediaVideoJobResponseSchema, mediaImagesInfoResponseDataSchema, mediaVideosInfoResponseDataSchema, mediaImagesInfoResponseSchema, mediaVideosInfoResponseSchema;
 var init_media = __esm(() => {
@@ -2028,159 +2207,159 @@ var init_media = __esm(() => {
     ...MEDIA_UPLOAD_VIDEO_TYPES
   ];
   contentTypeSet = new Set(MEDIA_UPLOAD_CONTENT_TYPES);
-  mediaUploadPresignRequestSchema = z11.object({
+  mediaUploadPresignRequestSchema = z12.object({
     filename: requiredString2("filename", missingPresignMessage),
     contentType: requiredString2("contentType", missingPresignMessage).refine((value) => contentTypeSet.has(value), { message: "Invalid content type" })
   });
-  mediaUploadResponseDataSchema = z11.object({
-    key: z11.string(),
-    url: z11.string().url().optional(),
-    avatarUrl: z11.string().url().optional(),
-    uploadUrl: z11.string().url().optional(),
-    imageUrl: z11.string().url().optional(),
-    videoUrl: z11.string().url().optional(),
-    maxSizeBytes: z11.number().int().positive().optional(),
-    contentType: z11.string().optional(),
-    expiresAt: z11.string().optional(),
-    instructions: z11.string().optional()
+  mediaUploadResponseDataSchema = z12.object({
+    key: z12.string(),
+    url: z12.string().url().optional(),
+    avatarUrl: z12.string().url().optional(),
+    uploadUrl: z12.string().url().optional(),
+    imageUrl: z12.string().url().optional(),
+    videoUrl: z12.string().url().optional(),
+    maxSizeBytes: z12.number().int().positive().optional(),
+    contentType: z12.string().optional(),
+    expiresAt: z12.string().optional(),
+    instructions: z12.string().optional()
   }).passthrough();
   mediaUploadResponseSchema = successEnvelope(mediaUploadResponseDataSchema);
-  avatarGenerateRequestSchema = z11.object({
-    prompt: z11.string().min(1).max(2000)
-  });
-  avatarGenerateResponseDataSchema = z11.object({
-    generationId: z11.string().uuid().nullable(),
-    imageUrl: z11.string().url(),
-    creditsRemaining: z11.number()
-  });
-  avatarCreditsResponseDataSchema = z11.object({
-    creditsTotal: z11.number(),
-    creditsUsed: z11.number(),
-    creditsRemaining: z11.number(),
-    generations: z11.array(z11.object({
-      id: z11.string().uuid(),
-      imageUrl: z11.string().url().nullable(),
-      selected: z11.boolean().nullable(),
-      createdAt: z11.string()
+  avatarGenerateRequestSchema = z12.object({
+    prompt: z12.string().min(1).max(2000)
+  });
+  avatarGenerateResponseDataSchema = z12.object({
+    generationId: z12.string().uuid().nullable(),
+    imageUrl: z12.string().url(),
+    creditsRemaining: z12.number()
+  });
+  avatarCreditsResponseDataSchema = z12.object({
+    creditsTotal: z12.number(),
+    creditsUsed: z12.number(),
+    creditsRemaining: z12.number(),
+    generations: z12.array(z12.object({
+      id: z12.string().uuid(),
+      imageUrl: z12.string().url().nullable(),
+      selected: z12.boolean().nullable(),
+      createdAt: z12.string()
     }).passthrough())
   });
-  avatarSelectRequestSchema = z11.object({
-    generationId: z11.string().uuid()
+  avatarSelectRequestSchema = z12.object({
+    generationId: z12.string().uuid()
   });
-  avatarSelectResponseDataSchema = z11.object({
-    avatarUrl: z11.string().url(),
-    generationId: z11.string().uuid()
+  avatarSelectResponseDataSchema = z12.object({
+    avatarUrl: z12.string().url(),
+    generationId: z12.string().uuid()
   });
-  mediaGenerateImageRequestSchema = z11.object({
+  mediaGenerateImageRequestSchema = z12.object({
     tradeId: requiredString2("tradeId"),
     prompt: requiredString2("prompt").refine((value) => value.length <= 2000, {
       message: "Prompt must be a string with max 2000 characters"
     }),
-    aspectRatio: z11.enum(["16:9", "4:3", "1:1", "3:4", "9:16"]).optional()
+    aspectRatio: z12.enum(["16:9", "4:3", "1:1", "3:4", "9:16"]).optional()
   });
-  mediaGenerateImageResponseDataSchema = z11.object({
-    jobId: z11.string().uuid().nullable(),
-    imageUrl: z11.string().url(),
-    aspectRatio: z11.string(),
-    cost: z11.number(),
-    tradeId: z11.string()
+  mediaGenerateImageResponseDataSchema = z12.object({
+    jobId: z12.string().uuid().nullable(),
+    imageUrl: z12.string().url(),
+    aspectRatio: z12.string(),
+    cost: z12.number(),
+    tradeId: z12.string()
   });
   mediaGenerateImageResponseSchema = successEnvelope(mediaGenerateImageResponseDataSchema);
-  mediaGenerateVideoRequestSchema = z11.object({
-    tradeId: z11.string().uuid().optional(),
-    tokenId: z11.string().uuid().optional(),
-    prompt: z11.string().max(1e4).optional(),
-    aspectRatio: z11.enum(["landscape", "portrait", "16:9", "4:3", "1:1", "3:4", "9:16"]).optional(),
-    imagePrompt: z11.string().max(2000).optional(),
-    firstFrameUrl: z11.string().url().optional()
+  mediaGenerateVideoRequestSchema = z12.object({
+    tradeId: z12.string().uuid().optional(),
+    tokenId: z12.string().uuid().optional(),
+    prompt: z12.string().max(1e4).optional(),
+    aspectRatio: z12.enum(["landscape", "portrait", "16:9", "4:3", "1:1", "3:4", "9:16"]).optional(),
+    imagePrompt: z12.string().max(2000).optional(),
+    firstFrameUrl: z12.string().url().optional()
   }).refine((data) => data.tradeId || data.tokenId, { message: "Either tradeId or tokenId is required", path: ["tradeId"] });
-  mediaGenerateVideoResponseDataSchema = z11.object({
-    jobId: z11.string().uuid(),
-    status: z11.string(),
-    mediaType: z11.string(),
-    provider: z11.string(),
-    duration: z11.number(),
-    cost: z11.number(),
-    note: z11.string()
+  mediaGenerateVideoResponseDataSchema = z12.object({
+    jobId: z12.string().uuid(),
+    status: z12.string(),
+    mediaType: z12.string(),
+    provider: z12.string(),
+    duration: z12.number(),
+    cost: z12.number(),
+    note: z12.string()
   });
   mediaGenerateVideoResponseSchema = successEnvelope(mediaGenerateVideoResponseDataSchema);
-  mediaVideoJobParamsSchema = z11.object({
+  mediaVideoJobParamsSchema = z12.object({
     jobId: requiredString2("jobId")
   });
-  mediaVideoJobResponseDataSchema = z11.object({
-    jobId: z11.string(),
-    status: z11.string(),
-    mediaType: z11.string(),
-    tradeId: z11.string().nullable(),
-    tokenId: z11.string().nullable().optional(),
-    provider: z11.string().optional(),
-    requestedDuration: z11.number(),
-    actualDuration: z11.number().optional(),
-    createdAt: z11.string(),
-    startedAt: z11.string().optional(),
-    completedAt: z11.string().optional(),
-    videoUrl: z11.string().url().nullable().optional(),
-    costUsd: z11.number().nullable().optional(),
-    errorMessage: z11.string().nullable().optional(),
-    fallbackImageUrl: z11.string().url().optional(),
-    firstFrameImageUrl: z11.string().url().nullable().optional()
+  mediaVideoJobResponseDataSchema = z12.object({
+    jobId: z12.string(),
+    status: z12.string(),
+    mediaType: z12.string(),
+    tradeId: z12.string().nullable(),
+    tokenId: z12.string().nullable().optional(),
+    provider: z12.string().optional(),
+    requestedDuration: z12.number(),
+    actualDuration: z12.number().optional(),
+    createdAt: z12.string(),
+    startedAt: z12.string().optional(),
+    completedAt: z12.string().optional(),
+    videoUrl: z12.string().url().nullable().optional(),
+    costUsd: z12.number().nullable().optional(),
+    errorMessage: z12.string().nullable().optional(),
+    fallbackImageUrl: z12.string().url().optional(),
+    firstFrameImageUrl: z12.string().url().nullable().optional()
   });
   mediaVideoJobResponseSchema = successEnvelope(mediaVideoJobResponseDataSchema);
-  mediaImagesInfoResponseDataSchema = z11.object({
-    model: z11.string().optional(),
-    description: z11.string().optional(),
-    supportedAspectRatios: z11.array(z11.string()).optional(),
-    cost: z11.number().optional(),
-    maxPromptLength: z11.number().optional(),
-    provider: z11.string().optional(),
-    note: z11.string().optional(),
-    usage: z11.object({
-      method: z11.string(),
-      body: z11.record(z11.string(), z11.string()),
-      headers: z11.record(z11.string(), z11.string())
+  mediaImagesInfoResponseDataSchema = z12.object({
+    model: z12.string().optional(),
+    description: z12.string().optional(),
+    supportedAspectRatios: z12.array(z12.string()).optional(),
+    cost: z12.number().optional(),
+    maxPromptLength: z12.number().optional(),
+    provider: z12.string().optional(),
+    note: z12.string().optional(),
+    usage: z12.object({
+      method: z12.string(),
+      body: z12.record(z12.string(), z12.string()),
+      headers: z12.record(z12.string(), z12.string())
     }).optional(),
-    videoAlternative: z11.object({
-      endpoint: z11.string(),
-      note: z11.string()
+    videoAlternative: z12.object({
+      endpoint: z12.string(),
+      note: z12.string()
     }).optional(),
-    yourStats: z11.object({
-      qualifyingTradesForImage: z11.number(),
-      imagesGenerated: z11.number(),
-      availableForImage: z11.number(),
-      recentAvailableTrades: z11.array(z11.object({
-        tradeId: z11.string(),
-        valueUsd: z11.number()
+    yourStats: z12.object({
+      qualifyingTradesForImage: z12.number(),
+      imagesGenerated: z12.number(),
+      availableForImage: z12.number(),
+      recentAvailableTrades: z12.array(z12.object({
+        tradeId: z12.string(),
+        valueUsd: z12.number()
       }))
     }).optional()
   }).passthrough();
-  mediaVideosInfoResponseDataSchema = z11.object({
-    description: z11.string().optional(),
-    tiers: z11.record(z11.string(), z11.object({
-      duration: z11.number(),
-      cost: z11.number()
+  mediaVideosInfoResponseDataSchema = z12.object({
+    description: z12.string().optional(),
+    tiers: z12.record(z12.string(), z12.object({
+      duration: z12.number(),
+      cost: z12.number()
     }).passthrough()).optional(),
-    providers: z11.array(z11.string()).optional(),
-    limits: z11.record(z11.string(), z11.unknown()).optional(),
-    usage: z11.object({
-      method: z11.string(),
-      body: z11.record(z11.string(), z11.string()),
-      headers: z11.record(z11.string(), z11.string())
+    providers: z12.array(z12.string()).optional(),
+    limits: z12.record(z12.string(), z12.unknown()).optional(),
+    usage: z12.object({
+      method: z12.string(),
+      body: z12.record(z12.string(), z12.string()),
+      headers: z12.record(z12.string(), z12.string())
     }).optional(),
-    statusCheck: z11.object({
-      method: z11.string(),
-      endpoint: z11.string()
+    statusCheck: z12.object({
+      method: z12.string(),
+      endpoint: z12.string()
     }).optional(),
-    yourStats: z11.object({
-      qualifyingTrades: z11.number(),
-      videosGenerated: z11.number(),
-      availableForVideo: z11.number(),
-      recentQualifyingTrades: z11.array(z11.object({
-        tradeId: z11.string(),
-        valueUsd: z11.number(),
-        tier: z11.object({
-          type: z11.string(),
-          duration: z11.number(),
-          cost: z11.number()
+    yourStats: z12.object({
+      qualifyingTrades: z12.number(),
+      videosGenerated: z12.number(),
+      availableForVideo: z12.number(),
+      recentQualifyingTrades: z12.array(z12.object({
+        tradeId: z12.string(),
+        valueUsd: z12.number(),
+        tier: z12.object({
+          type: z12.string(),
+          duration: z12.number(),
+          cost: z12.number()
         }).passthrough()
       }))
     }).optional()
@@ -2202,6 +2381,7 @@ var init_agent = __esm(() => {
   init_tokens();
   init_leaderboard();
   init_data_marketplace();
+  init_marketplace();
   init_media();
   AgentClient = class AgentClient extends BaseClient {
     apiKey;
@@ -2244,6 +2424,35 @@ var init_agent = __esm(() => {
     async getProviderDetails(providerId) {
       return this.request({ method: "GET", path: `/data-marketplace/${encodeURIComponent(providerId)}` }, dataMarketplaceProviderDetailResponseDataSchema);
     }
+    async browseMarketplaceTasks(options) {
+      const parsed = marketplaceTasksQuerySchema.parse(options ?? {});
+      const params = new URLSearchParams;
+      params.set("status", parsed.status);
+      params.set("limit", String(parsed.limit));
+      params.set("offset", String(parsed.offset));
+      if (parsed.category)
+        params.set("category", parsed.category);
+      return this.request({ method: "GET", path: `/marketplace/tasks?${params.toString()}` }, marketplaceTasksResponseDataSchema);
+    }
+    async getMarketplaceTaskDetail(taskId) {
+      return this.request({ method: "GET", path: `/marketplace/tasks/${encodeURIComponent(taskId)}` }, marketplaceTaskDetailResponseDataSchema);
+    }
+    async applyToTask(taskId, walletAddress, message) {
+      const body = marketplaceApplyTaskRequestSchema.parse({ walletAddress, ...message ? { message } : {} });
+      return this.request({ method: "POST", path: `/marketplace/tasks/${encodeURIComponent(taskId)}/apply`, body }, marketplaceApplyTaskResponseDataSchema);
+    }
+    async submitTaskProof(taskId, applicantId, proofText, proofImages) {
+      const body = marketplaceSubmitTaskRequestSchema.parse({
+        applicantId,
+        ...proofText ? { proofText } : {},
+        ...proofImages ? { proofImages } : {}
+      });
+      return this.request({ method: "POST", path: `/marketplace/tasks/${encodeURIComponent(taskId)}/submit`, body }, marketplaceSubmitTaskResponseDataSchema);
+    }
+    async submitDataProvider(params) {
+      const body = dataMarketplaceCreateRequestSchema.parse(params);
+      return this.request({ method: "POST", path: "/data-marketplace", body, headers: this.authHeaders() }, dataMarketplaceCreateResponseDataSchema);
+    }
     async listTokens(chain) {
       const params = chain ? `?chain=${encodeURIComponent(chain)}` : "";
       return this.request({ method: "GET", path: `/tokens${params}` }, tokensListResponseDataSchema);
@@ -2505,436 +2714,497 @@ var init_agent = __esm(() => {
 });
 
 // ../../packages/client/src/client/autonomous.ts
+var AutonomousClient;
 var init_autonomous = __esm(() => {
   init_agent();
   init_incubator();
+  AutonomousClient = class AutonomousClient extends AgentClient {
+    async getRentStatus() {
+      return this.request({ method: "GET", path: "/incubator/rent", headers: this.authHeaders() }, incubatorRentResponseDataSchema);
+    }
+    async payRent() {
+      return this.request({ method: "POST", path: "/incubator/rent", headers: this.authHeaders() }, incubatorRentResponseDataSchema);
+    }
+    async upgradeServer(plan) {
+      const body = incubatorServerRequestSchema.parse({ plan });
+      return this.request({ method: "POST", path: "/incubator/server", body, headers: this.authHeaders() }, incubatorServerResponseDataSchema);
+    }
+    async switchModel(model) {
+      const body = incubatorBrainRequestSchema.parse({ action: "switch", model });
+      return this.request({ method: "POST", path: "/incubator/brain", body, headers: this.authHeaders() }, incubatorBrainResponseDataSchema);
+    }
+    async depositToLlmBudget(amountUsd) {
+      const body = incubatorBrainRequestSchema.parse({ action: "deposit", amountUsd });
+      return this.request({
+        method: "POST",
+        path: "/incubator/brain",
+        body,
+        headers: this.authHeaders()
+      }, incubatorBrainResponseDataSchema);
+    }
+    async getInferenceBudget() {
+      return this.request({ method: "GET", path: "/incubator/overview", headers: this.authHeaders() }, incubatorOverviewResponseDataSchema);
+    }
+    async getInbox() {
+      return this.request({ method: "GET", path: "/incubator/inbox", headers: this.authHeaders() }, incubatorInboxResponseDataSchema);
+    }
+    async replyToMessage(messageId, text, isPublic) {
+      const body = incubatorInboxReplyRequestSchema.parse({
+        messageId,
+        replyText: text,
+        ...isPublic !== undefined ? { replyPublic: isPublic } : {}
+      });
+      return this.request({
+        method: "POST",
+        path: "/incubator/inbox",
+        body,
+        headers: this.authHeaders()
+      }, incubatorInboxReplyResponseDataSchema);
+    }
+    async setInboxPrice(priceUsd) {
+      const body = incubatorInboxPatchRequestSchema.parse({ priceUsd });
+      return this.request({ method: "PATCH", path: "/incubator/inbox", body, headers: this.authHeaders() }, incubatorInboxPatchResponseDataSchema);
+    }
+    async post(title, body, primaryTradeId) {
+      return this.createPost({ title, body, primaryTradeId, postType: "entry" });
+    }
+    async log(message) {
+      const payload = incubatorLogRequestSchema.parse({ message });
+      return this.request({
+        method: "POST",
+        path: "/incubator/log",
+        body: payload,
+        headers: this.authHeaders()
+      }, incubatorLogResponseDataSchema);
+    }
+  };
 });
 
 // ../../packages/client/src/schemas/admin.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var adminDisputeResolutions, adminDisputeParamsSchema, adminDisputesQuerySchema, adminResolveDisputeRequestSchema, adminDisputesResponseDataSchema, adminResolveDisputeResponseDataSchema, adminAgentsResponseDataSchema, adminTurnsResponseDataSchema, adminMessageAgentsRequestSchema, adminMessageAgentsResponseDataSchema, adminPendingPayoutsResponseDataSchema, adminProcessPayoutRequestSchema, adminProcessPayoutResponseDataSchema, adminApprovePayoutRequestSchema, adminSkipPayoutRequestSchema, adminForfeitPayoutRequestSchema, adminRecordTxRequestSchema, adminApprovalQueueResponseDataSchema, adminApprovePayoutResponseDataSchema, adminSkipPayoutResponseDataSchema, adminForfeitPayoutResponseDataSchema, adminRecordTxResponseDataSchema, adminReferrerIdParamsSchema, adminReferralOverviewResponseDataSchema, adminReferralTradesQuerySchema, adminReferralTradesResponseDataSchema, adminReferralGamingSignalSchema, adminReferralSignalsResponseDataSchema, adminAgentIdParamsSchema, adminCreateAgentRequestSchema, adminUpdateAgentRequestSchema, adminUserIdParamsSchema, adminUsersQuerySchema, adminUpdateUserRequestSchema, adminCreateAgentResponseDataSchema, adminUpdateAgentResponseDataSchema, adminUsersResponseDataSchema, adminUpdateUserResponseDataSchema, adminIncubatorBirthRequestSchema, adminIncubatorAdjustRequestSchema, adminIncubatorWalletRequestSchema, adminIncubatorTransactionsQuerySchema, adminIncubatorPoolResponseDataSchema, adminIncubatorTransactionSchema, adminIncubatorTransactionsResponseDataSchema, adminIncubatorBirthResponseDataSchema, adminIncubatorAdjustResponseDataSchema, adminIncubatorWalletResponseDataSchema, adminDisputesResponseSchema, adminResolveDisputeResponseSchema, adminMessageAgentsResponseSchema, adminIncubatorPoolResponseSchema, adminIncubatorTransactionsResponseSchema, adminIncubatorBirthResponseSchema, adminIncubatorAdjustResponseSchema, adminIncubatorWalletResponseSchema;
 var init_admin = __esm(() => {
   init_common();
   adminDisputeResolutions = ["human_wins", "agent_wins", "split"];
-  adminDisputeParamsSchema = z12.object({
-    disputeId: z12.string().uuid()
-  });
-  adminDisputesQuerySchema = z12.object({
-    status: z12.enum(["pending", ...adminDisputeResolutions]).default("pending"),
-    limit: z12.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
-    offset: z12.coerce.number().int().min(0).default(0)
-  });
-  adminResolveDisputeRequestSchema = z12.object({
-    resolution: z12.enum(adminDisputeResolutions),
-    note: z12.string().trim().max(4000).optional()
-  });
-  adminDisputesResponseDataSchema = z12.object({
-    disputes: z12.array(z12.object({
-      id: z12.string().uuid(),
-      taskId: z12.string().uuid(),
-      initiatedBy: z12.string(),
-      reason: z12.string(),
-      evidenceUrls: z12.array(z12.string()).nullable(),
-      resolution: z12.string(),
-      resolvedBy: z12.string().nullable(),
-      resolvedAt: z12.string().nullable(),
-      createdAt: z12.string(),
-      task: z12.object({
-        id: z12.string().uuid(),
-        agentId: z12.string().uuid(),
-        agentName: z12.string().nullable(),
-        title: z12.string(),
-        budgetUsd: z12.number(),
-        status: z12.string(),
-        assignedTo: z12.string().uuid().nullable()
+  adminDisputeParamsSchema = z13.object({
+    disputeId: z13.string().uuid()
+  });
+  adminDisputesQuerySchema = z13.object({
+    status: z13.enum(["pending", ...adminDisputeResolutions]).default("pending"),
+    limit: z13.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
+    offset: z13.coerce.number().int().min(0).default(0)
+  });
+  adminResolveDisputeRequestSchema = z13.object({
+    resolution: z13.enum(adminDisputeResolutions),
+    note: z13.string().trim().max(4000).optional()
+  });
+  adminDisputesResponseDataSchema = z13.object({
+    disputes: z13.array(z13.object({
+      id: z13.string().uuid(),
+      taskId: z13.string().uuid(),
+      initiatedBy: z13.string(),
+      reason: z13.string(),
+      evidenceUrls: z13.array(z13.string()).nullable(),
+      resolution: z13.string(),
+      resolvedBy: z13.string().nullable(),
+      resolvedAt: z13.string().nullable(),
+      createdAt: z13.string(),
+      task: z13.object({
+        id: z13.string().uuid(),
+        agentId: z13.string().uuid(),
+        agentName: z13.string().nullable(),
+        title: z13.string(),
+        budgetUsd: z13.number(),
+        status: z13.string(),
+        assignedTo: z13.string().uuid().nullable()
       }).nullable()
     })),
-    count: z12.number(),
-    pagination: z12.object({
-      limit: z12.number(),
-      offset: z12.number(),
-      hasMore: z12.boolean()
+    count: z13.number(),
+    pagination: z13.object({
+      limit: z13.number(),
+      offset: z13.number(),
+      hasMore: z13.boolean()
     })
   });
-  adminResolveDisputeResponseDataSchema = z12.object({
-    dispute: z12.object({
-      id: z12.string().uuid(),
-      taskId: z12.string().uuid(),
-      resolution: z12.string(),
-      resolvedBy: z12.string(),
-      payoutTx: z12.string().nullable(),
-      newTaskStatus: z12.string()
+  adminResolveDisputeResponseDataSchema = z13.object({
+    dispute: z13.object({
+      id: z13.string().uuid(),
+      taskId: z13.string().uuid(),
+      resolution: z13.string(),
+      resolvedBy: z13.string(),
+      payoutTx: z13.string().nullable(),
+      newTaskStatus: z13.string()
     })
   });
-  adminAgentsResponseDataSchema = z12.object({
-    agents: z12.array(z12.object({
-      id: z12.string().uuid(),
-      name: z12.string(),
-      handle: z12.string().nullable(),
-      avatarUrl: z12.string().nullable(),
-      solanaAddress: z12.string().nullable(),
-      generation: z12.number().nullable(),
-      bornAt: z12.string().nullable(),
-      diedAt: z12.string().nullable(),
-      isAlive: z12.boolean(),
-      llmModel: z12.string().nullable(),
-      llmUsageUsd: z12.number().nullable(),
-      llmBudgetUsd: z12.number().nullable(),
-      serverPlan: z12.string().nullable(),
-      totalValueUsd: z12.number(),
-      pnlAllTime: z12.number(),
-      totalTurns: z12.number(),
-      totalCostUsd: z12.number(),
-      totalEntries: z12.number(),
-      lastTurnAt: z12.string().nullable(),
-      lastEntryPreview: z12.string().nullable()
+  adminAgentsResponseDataSchema = z13.object({
+    agents: z13.array(z13.object({
+      id: z13.string().uuid(),
+      name: z13.string(),
+      handle: z13.string().nullable(),
+      avatarUrl: z13.string().nullable(),
+      solanaAddress: z13.string().nullable(),
+      generation: z13.number().nullable(),
+      bornAt: z13.string().nullable(),
+      diedAt: z13.string().nullable(),
+      isAlive: z13.boolean(),
+      llmModel: z13.string().nullable(),
+      llmUsageUsd: z13.number().nullable(),
+      llmBudgetUsd: z13.number().nullable(),
+      serverPlan: z13.string().nullable(),
+      totalValueUsd: z13.number(),
+      pnlAllTime: z13.number(),
+      totalTurns: z13.number(),
+      totalCostUsd: z13.number(),
+      totalEntries: z13.number(),
+      lastTurnAt: z13.string().nullable(),
+      lastEntryPreview: z13.string().nullable()
     })),
-    count: z12.number()
-  });
-  adminTurnsResponseDataSchema = z12.object({
-    turns: z12.array(z12.object({
-      id: z12.number(),
-      piEntryId: z12.string().nullable(),
-      parentPiEntryId: z12.string().nullable(),
-      entryType: z12.string().nullable(),
-      seq: z12.number().nullable(),
-      timestamp: z12.string().nullable(),
-      role: z12.string().nullable(),
-      contentPreview: z12.string().nullable(),
-      model: z12.string().nullable(),
-      provider: z12.string().nullable(),
-      toolName: z12.string().nullable(),
-      tokenInput: z12.number().nullable(),
-      tokenOutput: z12.number().nullable(),
-      costUsd: z12.number().nullable(),
-      sourceType: z12.string().nullable(),
-      sourceRef: z12.string().nullable(),
-      payload: z12.unknown().nullable()
+    count: z13.number()
+  });
+  adminTurnsResponseDataSchema = z13.object({
+    turns: z13.array(z13.object({
+      id: z13.number(),
+      piEntryId: z13.string().nullable(),
+      parentPiEntryId: z13.string().nullable(),
+      entryType: z13.string().nullable(),
+      seq: z13.number().nullable(),
+      timestamp: z13.string().nullable(),
+      role: z13.string().nullable(),
+      contentPreview: z13.string().nullable(),
+      model: z13.string().nullable(),
+      provider: z13.string().nullable(),
+      toolName: z13.string().nullable(),
+      tokenInput: z13.number().nullable(),
+      tokenOutput: z13.number().nullable(),
+      costUsd: z13.number().nullable(),
+      sourceType: z13.string().nullable(),
+      sourceRef: z13.string().nullable(),
+      payload: z13.unknown().nullable()
     })),
-    page: z12.number(),
-    pageSize: z12.number()
+    page: z13.number(),
+    pageSize: z13.number()
   });
-  adminMessageAgentsRequestSchema = z12.object({
-    message: z12.string().trim().min(1, "Message is required").max(4000),
-    agentIds: z12.array(z12.string().uuid()).min(1).optional(),
-    broadcast: z12.boolean().optional()
+  adminMessageAgentsRequestSchema = z13.object({
+    message: z13.string().trim().min(1, "Message is required").max(4000),
+    agentIds: z13.array(z13.string().uuid()).min(1).optional(),
+    broadcast: z13.boolean().optional()
   }).refine((data) => data.agentIds && data.agentIds.length > 0 || data.broadcast === true, { message: "Provide agentIds or set broadcast to true" }).refine((data) => !(data.agentIds && data.agentIds.length > 0 && data.broadcast === true), { message: "Cannot specify both agentIds and broadcast" });
-  adminMessageAgentsResponseDataSchema = z12.object({
-    sent: z12.number(),
-    agentIds: z12.array(z12.string().uuid())
-  });
-  adminPendingPayoutsResponseDataSchema = z12.object({
-    min_payout_usd: z12.number().optional(),
-    pending_payouts: z12.array(z12.object({
-      referrer_id: z12.string(),
-      name: z12.string(),
-      handle: z12.string().nullable().optional(),
-      payout_wallet: z12.string().nullable().optional(),
-      referral_count: z12.number(),
-      total_volume_usd: z12.number(),
-      total_earned: z12.number(),
-      total_paid_out: z12.number(),
-      pending_amount: z12.number(),
-      solana_earned: z12.number(),
-      hyperliquid_earned: z12.number(),
-      dbc_pool_earned: z12.number()
+  adminMessageAgentsResponseDataSchema = z13.object({
+    sent: z13.number(),
+    agentIds: z13.array(z13.string().uuid())
+  });
+  adminPendingPayoutsResponseDataSchema = z13.object({
+    min_payout_usd: z13.number().optional(),
+    pending_payouts: z13.array(z13.object({
+      referrer_id: z13.string(),
+      name: z13.string(),
+      handle: z13.string().nullable().optional(),
+      payout_wallet: z13.string().nullable().optional(),
+      referral_count: z13.number(),
+      total_volume_usd: z13.number(),
+      total_earned: z13.number(),
+      total_paid_out: z13.number(),
+      pending_amount: z13.number(),
+      solana_earned: z13.number(),
+      hyperliquid_earned: z13.number(),
+      dbc_pool_earned: z13.number()
     }))
   });
-  adminProcessPayoutRequestSchema = z12.object({
-    referrer_id: z12.string().min(1),
-    amount: z12.number().finite().positive().max(1e5),
-    tx_signature: z12.string().min(1)
+  adminProcessPayoutRequestSchema = z13.object({
+    referrer_id: z13.string().min(1),
+    amount: z13.number().finite().positive().max(1e5),
+    tx_signature: z13.string().min(1)
   });
-  adminProcessPayoutResponseDataSchema = z12.object({
-    payout_id: z12.string(),
-    referrer: z12.object({
-      id: z12.string(),
-      name: z12.string().nullable()
+  adminProcessPayoutResponseDataSchema = z13.object({
+    payout_id: z13.string(),
+    referrer: z13.object({
+      id: z13.string(),
+      name: z13.string().nullable()
     }),
-    amount: z12.number(),
-    wallet_address: z12.string(),
-    tx_signature: z12.string(),
-    status: z12.string()
-  });
-  adminApprovePayoutRequestSchema = z12.object({
-    referrer_id: z12.string().uuid(),
-    amount: z12.number().finite().positive().min(5),
-    notes: z12.string().trim().max(1000).optional()
-  });
-  adminSkipPayoutRequestSchema = z12.object({
-    referrer_id: z12.string().uuid(),
-    notes: z12.string().trim().max(1000).optional()
-  });
-  adminForfeitPayoutRequestSchema = z12.object({
-    referrer_id: z12.string().uuid(),
-    amount: z12.number().finite().positive(),
-    notes: z12.string().trim().min(1).max(1000)
-  });
-  adminRecordTxRequestSchema = z12.object({
-    payout_id: z12.string().uuid(),
-    tx_signature: z12.string().min(1)
-  });
-  adminApprovalQueueResponseDataSchema = z12.object({
-    referrers: z12.array(z12.object({
-      referrerId: z12.string(),
-      name: z12.string(),
-      handle: z12.string().nullable(),
-      payoutWallet: z12.string().nullable(),
-      pendingAmount: z12.number(),
-      referralCount: z12.number(),
-      totalVolumeUsd: z12.number(),
-      totalEarned: z12.number(),
-      totalPaidOut: z12.number(),
-      overallRisk: z12.enum(["low", "medium", "high"]).optional()
+    amount: z13.number(),
+    wallet_address: z13.string(),
+    tx_signature: z13.string(),
+    status: z13.string()
+  });
+  adminApprovePayoutRequestSchema = z13.object({
+    referrer_id: z13.string().uuid(),
+    amount: z13.number().finite().positive().min(5),
+    notes: z13.string().trim().max(1000).optional()
+  });
+  adminSkipPayoutRequestSchema = z13.object({
+    referrer_id: z13.string().uuid(),
+    notes: z13.string().trim().max(1000).optional()
+  });
+  adminForfeitPayoutRequestSchema = z13.object({
+    referrer_id: z13.string().uuid(),
+    amount: z13.number().finite().positive(),
+    notes: z13.string().trim().min(1).max(1000)
+  });
+  adminRecordTxRequestSchema = z13.object({
+    payout_id: z13.string().uuid(),
+    tx_signature: z13.string().min(1)
+  });
+  adminApprovalQueueResponseDataSchema = z13.object({
+    referrers: z13.array(z13.object({
+      referrerId: z13.string(),
+      name: z13.string(),
+      handle: z13.string().nullable(),
+      payoutWallet: z13.string().nullable(),
+      pendingAmount: z13.number(),
+      referralCount: z13.number(),
+      totalVolumeUsd: z13.number(),
+      totalEarned: z13.number(),
+      totalPaidOut: z13.number(),
+      overallRisk: z13.enum(["low", "medium", "high"]).optional()
     })),
-    approvedPayouts: z12.array(z12.object({
-      id: z12.string(),
-      referrerId: z12.string(),
-      referrerName: z12.string(),
-      amount: z12.number(),
-      approvedAt: z12.string(),
-      notes: z12.string().nullable()
+    approvedPayouts: z13.array(z13.object({
+      id: z13.string(),
+      referrerId: z13.string(),
+      referrerName: z13.string(),
+      amount: z13.number(),
+      approvedAt: z13.string(),
+      notes: z13.string().nullable()
     }))
   });
-  adminApprovePayoutResponseDataSchema = z12.object({
-    payout: z12.object({
-      id: z12.string(),
-      referrerId: z12.string(),
-      referrerName: z12.string(),
-      amount: z12.number(),
-      wallet: z12.string(),
-      status: z12.literal("approved"),
-      approvedAt: z12.string(),
-      notes: z12.string().nullable()
+  adminApprovePayoutResponseDataSchema = z13.object({
+    payout: z13.object({
+      id: z13.string(),
+      referrerId: z13.string(),
+      referrerName: z13.string(),
+      amount: z13.number(),
+      wallet: z13.string(),
+      status: z13.literal("approved"),
+      approvedAt: z13.string(),
+      notes: z13.string().nullable()
     })
   });
-  adminSkipPayoutResponseDataSchema = z12.object({
-    payout: z12.object({
-      id: z12.string(),
-      referrerId: z12.string(),
-      status: z12.literal("skipped"),
-      periodStart: z12.string(),
-      periodEnd: z12.string(),
-      notes: z12.string().nullable()
+  adminSkipPayoutResponseDataSchema = z13.object({
+    payout: z13.object({
+      id: z13.string(),
+      referrerId: z13.string(),
+      status: z13.literal("skipped"),
+      periodStart: z13.string(),
+      periodEnd: z13.string(),
+      notes: z13.string().nullable()
     })
   });
-  adminForfeitPayoutResponseDataSchema = z12.object({
-    payout: z12.object({
-      id: z12.string(),
-      referrerId: z12.string(),
-      amount: z12.number(),
-      status: z12.literal("forfeited"),
-      notes: z12.string()
+  adminForfeitPayoutResponseDataSchema = z13.object({
+    payout: z13.object({
+      id: z13.string(),
+      referrerId: z13.string(),
+      amount: z13.number(),
+      status: z13.literal("forfeited"),
+      notes: z13.string()
     })
   });
-  adminRecordTxResponseDataSchema = z12.object({
-    payout: z12.object({
-      id: z12.string(),
-      referrerId: z12.string(),
-      amount: z12.number(),
-      status: z12.literal("completed"),
-      txSignature: z12.string(),
-      completedAt: z12.string().nullable()
+  adminRecordTxResponseDataSchema = z13.object({
+    payout: z13.object({
+      id: z13.string(),
+      referrerId: z13.string(),
+      amount: z13.number(),
+      status: z13.literal("completed"),
+      txSignature: z13.string(),
+      completedAt: z13.string().nullable()
     })
   });
-  adminReferrerIdParamsSchema = z12.object({
-    referrerId: z12.string().uuid()
-  });
-  adminReferralOverviewResponseDataSchema = z12.object({
-    totalReferrers: z12.number(),
-    totalReferees: z12.number(),
-    totalVolumeUsd: z12.number(),
-    totalEarned: z12.number(),
-    totalPaidOut: z12.number(),
-    totalPending: z12.number(),
-    topReferrers: z12.array(z12.object({
-      referrerId: z12.string(),
-      name: z12.string(),
-      handle: z12.string().nullable(),
-      payoutWallet: z12.string().nullable(),
-      referralCount: z12.number(),
-      totalVolumeUsd: z12.number(),
-      totalEarned: z12.number(),
-      totalPaidOut: z12.number(),
-      pendingAmount: z12.number(),
-      solanaEarned: z12.number(),
-      hyperliquidEarned: z12.number(),
-      dbcPoolEarned: z12.number()
+  adminReferrerIdParamsSchema = z13.object({
+    referrerId: z13.string().uuid()
+  });
+  adminReferralOverviewResponseDataSchema = z13.object({
+    totalReferrers: z13.number(),
+    totalReferees: z13.number(),
+    totalVolumeUsd: z13.number(),
+    totalEarned: z13.number(),
+    totalPaidOut: z13.number(),
+    totalPending: z13.number(),
+    topReferrers: z13.array(z13.object({
+      referrerId: z13.string(),
+      name: z13.string(),
+      handle: z13.string().nullable(),
+      payoutWallet: z13.string().nullable(),
+      referralCount: z13.number(),
+      totalVolumeUsd: z13.number(),
+      totalEarned: z13.number(),
+      totalPaidOut: z13.number(),
+      pendingAmount: z13.number(),
+      solanaEarned: z13.number(),
+      hyperliquidEarned: z13.number(),
+      dbcPoolEarned: z13.number()
     }))
   });
-  adminReferralTradesQuerySchema = z12.object({
-    limit: z12.coerce.number().int().min(1).default(50).transform((v) => Math.min(v, 100)),
-    offset: z12.coerce.number().int().min(0).default(0)
-  });
-  adminReferralTradesResponseDataSchema = z12.object({
-    trades: z12.array(z12.object({
-      id: z12.string(),
-      chain: z12.string(),
-      agentId: z12.string(),
-      refereeName: z12.string(),
-      refereeHandle: z12.string().nullable(),
-      tokenAddress: z12.string(),
-      valueUsd: z12.number(),
-      feeAmount: z12.number(),
-      referrerFeeBps: z12.number().nullable(),
-      treasuryFeeBps: z12.number().nullable(),
-      referrerEarnedUsd: z12.number(),
-      txSignature: z12.string().nullable(),
-      timestamp: z12.string().nullable()
+  adminReferralTradesQuerySchema = z13.object({
+    limit: z13.coerce.number().int().min(1).default(50).transform((v) => Math.min(v, 100)),
+    offset: z13.coerce.number().int().min(0).default(0)
+  });
+  adminReferralTradesResponseDataSchema = z13.object({
+    trades: z13.array(z13.object({
+      id: z13.string(),
+      chain: z13.string(),
+      agentId: z13.string(),
+      refereeName: z13.string(),
+      refereeHandle: z13.string().nullable(),
+      tokenAddress: z13.string(),
+      valueUsd: z13.number(),
+      feeAmount: z13.number(),
+      referrerFeeBps: z13.number().nullable(),
+      treasuryFeeBps: z13.number().nullable(),
+      referrerEarnedUsd: z13.number(),
+      txSignature: z13.string().nullable(),
+      timestamp: z13.string().nullable()
     })),
-    pagination: z12.object({
-      limit: z12.number(),
-      offset: z12.number(),
-      total: z12.number(),
-      hasMore: z12.boolean()
+    pagination: z13.object({
+      limit: z13.number(),
+      offset: z13.number(),
+      total: z13.number(),
+      hasMore: z13.boolean()
     })
   });
-  adminReferralGamingSignalSchema = z12.object({
-    type: z12.string(),
-    severity: z12.enum(["low", "medium", "high"]),
-    description: z12.string(),
-    evidence: z12.record(z12.string(), z12.unknown())
-  });
-  adminReferralSignalsResponseDataSchema = z12.object({
-    referrerId: z12.string(),
-    overallRisk: z12.enum(["low", "medium", "high"]),
-    signals: z12.array(adminReferralGamingSignalSchema)
-  });
-  adminAgentIdParamsSchema = z12.object({
-    agentId: z12.string().uuid()
-  });
-  adminCreateAgentRequestSchema = z12.object({
-    name: z12.string().min(1).max(100),
-    handle: z12.string().max(50).optional(),
-    bio: z12.string().max(500).optional(),
-    avatarUrl: z12.string().url().optional(),
-    generation: z12.number().int().optional(),
-    serverPlan: z12.enum(["basic", "standard", "pro"]).optional(),
-    llmModel: z12.string().optional(),
-    llmBudgetUsd: z12.number().optional(),
-    inboxPriceUsd: z12.number().optional()
-  });
-  adminUpdateAgentRequestSchema = z12.object({
-    name: z12.string().min(1).max(100).optional(),
-    handle: z12.string().max(50).optional(),
-    bio: z12.string().max(500).optional(),
-    avatarUrl: z12.string().url().nullable().optional(),
-    llmModel: z12.string().optional(),
-    llmBudgetUsd: z12.number().optional(),
-    serverPlan: z12.enum(["basic", "standard", "pro"]).optional(),
-    generation: z12.number().int().optional(),
-    inboxPriceUsd: z12.number().optional(),
-    isAlive: z12.boolean().optional()
+  adminReferralGamingSignalSchema = z13.object({
+    type: z13.string(),
+    severity: z13.enum(["low", "medium", "high"]),
+    description: z13.string(),
+    evidence: z13.record(z13.string(), z13.unknown())
+  });
+  adminReferralSignalsResponseDataSchema = z13.object({
+    referrerId: z13.string(),
+    overallRisk: z13.enum(["low", "medium", "high"]),
+    signals: z13.array(adminReferralGamingSignalSchema)
+  });
+  adminAgentIdParamsSchema = z13.object({
+    agentId: z13.string().uuid()
+  });
+  adminCreateAgentRequestSchema = z13.object({
+    name: z13.string().min(1).max(100),
+    handle: z13.string().max(50).optional(),
+    bio: z13.string().max(500).optional(),
+    avatarUrl: z13.string().url().optional(),
+    generation: z13.number().int().optional(),
+    serverPlan: z13.enum(["basic", "standard", "pro"]).optional(),
+    llmModel: z13.string().optional(),
+    llmBudgetUsd: z13.number().optional(),
+    inboxPriceUsd: z13.number().optional()
+  });
+  adminUpdateAgentRequestSchema = z13.object({
+    name: z13.string().min(1).max(100).optional(),
+    handle: z13.string().max(50).optional(),
+    bio: z13.string().max(500).optional(),
+    avatarUrl: z13.string().url().nullable().optional(),
+    llmModel: z13.string().optional(),
+    llmBudgetUsd: z13.number().optional(),
+    serverPlan: z13.enum(["basic", "standard", "pro"]).optional(),
+    generation: z13.number().int().optional(),
+    inboxPriceUsd: z13.number().optional(),
+    isAlive: z13.boolean().optional()
   }).refine((obj) => Object.keys(obj).length > 0, { message: "At least one field required" });
-  adminUserIdParamsSchema = z12.object({
-    userId: z12.string().uuid()
-  });
-  adminUsersQuerySchema = z12.object({
-    limit: z12.coerce.number().int().min(1).default(25).transform((v) => Math.min(v, 100)),
-    offset: z12.coerce.number().int().min(0).default(0),
-    search: z12.string().optional()
-  });
-  adminUpdateUserRequestSchema = z12.object({
-    role: z12.enum(["admin", "user"]).optional(),
-    banned: z12.boolean().optional(),
-    banReason: z12.string().optional(),
-    banExpiresIn: z12.number().positive().optional(),
-    shadowbanned: z12.boolean().optional()
+  adminUserIdParamsSchema = z13.object({
+    userId: z13.string().uuid()
+  });
+  adminUsersQuerySchema = z13.object({
+    limit: z13.coerce.number().int().min(1).default(25).transform((v) => Math.min(v, 100)),
+    offset: z13.coerce.number().int().min(0).default(0),
+    search: z13.string().optional()
+  });
+  adminUpdateUserRequestSchema = z13.object({
+    role: z13.enum(["admin", "user"]).optional(),
+    banned: z13.boolean().optional(),
+    banReason: z13.string().optional(),
+    banExpiresIn: z13.number().positive().optional(),
+    shadowbanned: z13.boolean().optional()
   }).refine((obj) => Object.keys(obj).length > 0, { message: "At least one field required" });
-  adminCreateAgentResponseDataSchema = z12.object({
-    agent: z12.object({
-      id: z12.string().uuid(),
-      name: z12.string(),
-      handle: z12.string().nullable(),
-      email: z12.string()
+  adminCreateAgentResponseDataSchema = z13.object({
+    agent: z13.object({
+      id: z13.string().uuid(),
+      name: z13.string(),
+      handle: z13.string().nullable(),
+      email: z13.string()
     })
   });
-  adminUpdateAgentResponseDataSchema = z12.object({
-    ok: z12.boolean()
+  adminUpdateAgentResponseDataSchema = z13.object({
+    ok: z13.boolean()
   });
-  adminUsersResponseDataSchema = z12.object({
-    users: z12.array(z12.object({
-      id: z12.string().uuid(),
-      name: z12.string().nullable(),
-      email: z12.string().nullable(),
-      role: z12.string().nullable(),
-      banned: z12.boolean().nullable(),
-      banReason: z12.string().nullable(),
-      banExpires: z12.string().nullable(),
-      shadowbanned: z12.boolean().nullable(),
-      createdAt: z12.string().nullable()
+  adminUsersResponseDataSchema = z13.object({
+    users: z13.array(z13.object({
+      id: z13.string().uuid(),
+      name: z13.string().nullable(),
+      email: z13.string().nullable(),
+      role: z13.string().nullable(),
+      banned: z13.boolean().nullable(),
+      banReason: z13.string().nullable(),
+      banExpires: z13.string().nullable(),
+      shadowbanned: z13.boolean().nullable(),
+      createdAt: z13.string().nullable()
     })),
-    total: z12.number()
-  });
-  adminUpdateUserResponseDataSchema = z12.object({
-    user: z12.record(z12.string(), z12.unknown())
-  });
-  adminIncubatorBirthRequestSchema = z12.object({
-    action: z12.enum(["trigger", "pause", "resume"]),
-    skipBalanceCheck: z12.boolean().optional().default(false)
-  });
-  adminIncubatorAdjustRequestSchema = z12.object({
-    amountUsd: z12.number(),
-    source: z12.enum(["manual_credit", "manual_debit", "birth_refund"]),
-    note: z12.string().min(1)
-  });
-  adminIncubatorWalletRequestSchema = z12.object({
-    walletId: z12.string().min(1),
-    walletAddress: z12.string().min(1)
-  });
-  adminIncubatorTransactionsQuerySchema = z12.object({
-    limit: z12.coerce.number().int().min(1).default(50).transform((v) => Math.min(v, 100)),
-    offset: z12.coerce.number().int().min(0).default(0),
-    source: z12.string().optional()
-  });
-  adminIncubatorPoolResponseDataSchema = z12.object({
-    balance_usd: z12.number(),
-    threshold_usd: z12.number(),
-    progress_pct: z12.number(),
-    total_born: z12.number(),
-    alive_count: z12.number(),
-    dead_count: z12.number(),
-    generation: z12.number(),
-    birth_status: z12.string(),
-    birth_paused: z12.boolean(),
-    pool_wallet_id: z12.string().nullable(),
-    pool_wallet_address: z12.string().nullable(),
-    incubator_fee_percent: z12.number(),
-    birth_threshold_usd: z12.number(),
-    onChainBalanceSol: z12.number(),
-    onChainBalanceUsd: z12.number()
-  });
-  adminIncubatorTransactionSchema = z12.object({
-    id: z12.string().uuid(),
-    amountUsd: z12.number(),
-    source: z12.string(),
-    sourceTradeId: z12.string().nullable(),
-    adminNote: z12.string().nullable(),
-    createdAt: z12.string()
-  });
-  adminIncubatorTransactionsResponseDataSchema = z12.object({
-    transactions: z12.array(adminIncubatorTransactionSchema),
-    total: z12.number()
-  });
-  adminIncubatorBirthResponseDataSchema = z12.object({
-    ok: z12.literal(true),
-    action: z12.enum(["triggered", "paused", "resumed"]),
-    agent: z12.object({
-      id: z12.string(),
-      number: z12.number(),
-      solanaAddress: z12.string()
+    total: z13.number()
+  });
+  adminUpdateUserResponseDataSchema = z13.object({
+    user: z13.record(z13.string(), z13.unknown())
+  });
+  adminIncubatorBirthRequestSchema = z13.object({
+    action: z13.enum(["trigger", "pause", "resume"]),
+    skipBalanceCheck: z13.boolean().optional().default(false)
+  });
+  adminIncubatorAdjustRequestSchema = z13.object({
+    amountUsd: z13.number(),
+    source: z13.enum(["manual_credit", "manual_debit", "birth_refund"]),
+    note: z13.string().min(1)
+  });
+  adminIncubatorWalletRequestSchema = z13.object({
+    walletId: z13.string().min(1),
+    walletAddress: z13.string().min(1)
+  });
+  adminIncubatorTransactionsQuerySchema = z13.object({
+    limit: z13.coerce.number().int().min(1).default(50).transform((v) => Math.min(v, 100)),
+    offset: z13.coerce.number().int().min(0).default(0),
+    source: z13.string().optional()
+  });
+  adminIncubatorPoolResponseDataSchema = z13.object({
+    balance_usd: z13.number(),
+    threshold_usd: z13.number(),
+    progress_pct: z13.number(),
+    total_born: z13.number(),
+    alive_count: z13.number(),
+    dead_count: z13.number(),
+    generation: z13.number(),
+    birth_status: z13.string(),
+    birth_paused: z13.boolean(),
+    pool_wallet_id: z13.string().nullable(),
+    pool_wallet_address: z13.string().nullable(),
+    incubator_fee_percent: z13.number(),
+    birth_threshold_usd: z13.number(),
+    onChainBalanceSol: z13.number(),
+    onChainBalanceUsd: z13.number()
+  });
+  adminIncubatorTransactionSchema = z13.object({
+    id: z13.string().uuid(),
+    amountUsd: z13.number(),
+    source: z13.string(),
+    sourceTradeId: z13.string().nullable(),
+    adminNote: z13.string().nullable(),
+    createdAt: z13.string()
+  });
+  adminIncubatorTransactionsResponseDataSchema = z13.object({
+    transactions: z13.array(adminIncubatorTransactionSchema),
+    total: z13.number()
+  });
+  adminIncubatorBirthResponseDataSchema = z13.object({
+    ok: z13.literal(true),
+    action: z13.enum(["triggered", "paused", "resumed"]),
+    agent: z13.object({
+      id: z13.string(),
+      number: z13.number(),
+      solanaAddress: z13.string()
     }).optional(),
-    transferHash: z12.string().nullable().optional()
+    transferHash: z13.string().nullable().optional()
   });
-  adminIncubatorAdjustResponseDataSchema = z12.object({
-    ok: z12.literal(true),
-    balanceUsd: z12.number(),
-    birthStatus: z12.string()
+  adminIncubatorAdjustResponseDataSchema = z13.object({
+    ok: z13.literal(true),
+    balanceUsd: z13.number(),
+    birthStatus: z13.string()
   });
-  adminIncubatorWalletResponseDataSchema = z12.object({
-    ok: z12.literal(true),
-    walletId: z12.string(),
-    walletAddress: z12.string()
+  adminIncubatorWalletResponseDataSchema = z13.object({
+    ok: z13.literal(true),
+    walletId: z13.string(),
+    walletAddress: z13.string()
   });
   adminDisputesResponseSchema = successEnvelope(adminDisputesResponseDataSchema);
   adminResolveDisputeResponseSchema = successEnvelope(adminResolveDisputeResponseDataSchema);
@@ -2947,46 +3217,46 @@ var init_admin = __esm(() => {
 });
 
 // ../../packages/client/src/schemas/auth.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var authApiKeysCreateRequestSchema, authApiKeysDeleteRequestSchema, authSetupRequestSchema, authApiKeysListResponseDataSchema, authApiKeysCreateResponseDataSchema, authApiKeysDeleteResponseDataSchema, authSetupResponseDataSchema, authApiKeysListResponseSchema, authApiKeysCreateResponseSchema, authApiKeysDeleteResponseSchema, authSetupResponseSchema;
 var init_auth = __esm(() => {
   init_common();
-  authApiKeysCreateRequestSchema = z13.object({
-    name: z13.string().trim().min(1).max(120).optional()
-  });
-  authApiKeysDeleteRequestSchema = z13.object({
-    keyId: z13.string().min(1)
-  });
-  authSetupRequestSchema = z13.object({
-    name: z13.string().trim().min(1).max(120).optional(),
-    handle: z13.string().trim().min(1).max(120).optional(),
-    referralCode: z13.string().trim().min(1).max(120).optional()
-  });
-  authApiKeysListResponseDataSchema = z13.object({
-    keys: z13.array(z13.object({
-      id: z13.string(),
-      name: z13.string().nullable(),
-      start: z13.string(),
-      createdAt: z13.string()
+  authApiKeysCreateRequestSchema = z14.object({
+    name: z14.string().trim().min(1).max(120).optional()
+  });
+  authApiKeysDeleteRequestSchema = z14.object({
+    keyId: z14.string().min(1)
+  });
+  authSetupRequestSchema = z14.object({
+    name: z14.string().trim().min(1).max(120).optional(),
+    handle: z14.string().trim().min(1).max(120).optional(),
+    referralCode: z14.string().trim().min(1).max(120).optional()
+  });
+  authApiKeysListResponseDataSchema = z14.object({
+    keys: z14.array(z14.object({
+      id: z14.string(),
+      name: z14.string().nullable(),
+      start: z14.string(),
+      createdAt: z14.string()
     }))
   });
-  authApiKeysCreateResponseDataSchema = z13.object({
-    key: z13.string(),
-    id: z13.string(),
-    start: z13.string()
+  authApiKeysCreateResponseDataSchema = z14.object({
+    key: z14.string(),
+    id: z14.string(),
+    start: z14.string()
   });
-  authApiKeysDeleteResponseDataSchema = z13.object({
-    revoked: z13.boolean()
+  authApiKeysDeleteResponseDataSchema = z14.object({
+    revoked: z14.boolean()
   });
-  authSetupResponseDataSchema = z13.object({
-    userId: z13.string().uuid(),
-    solanaAddress: z13.string().nullable(),
-    hlAddress: z13.string().nullable().optional(),
-    handle: z13.string().nullable(),
-    apiKeyHint: z13.string().nullable(),
-    apiKey: z13.string().optional(),
-    cliCommand: z13.string().optional(),
-    isNew: z13.boolean()
+  authSetupResponseDataSchema = z14.object({
+    userId: z14.string().uuid(),
+    solanaAddress: z14.string().nullable(),
+    hlAddress: z14.string().nullable().optional(),
+    handle: z14.string().nullable(),
+    apiKeyHint: z14.string().nullable(),
+    apiKey: z14.string().optional(),
+    cliCommand: z14.string().optional(),
+    isNew: z14.boolean()
   });
   authApiKeysListResponseSchema = successEnvelope(authApiKeysListResponseDataSchema);
   authApiKeysCreateResponseSchema = successEnvelope(authApiKeysCreateResponseDataSchema);
@@ -2995,172 +3265,57 @@ var init_auth = __esm(() => {
 });
 
 // ../../packages/client/src/schemas/claim.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var claimTokenParamsSchema, claimInfoResponseDataSchema, claimInfoResponseSchema;
 var init_claim = __esm(() => {
   init_common();
-  claimTokenParamsSchema = z14.object({
-    token: z14.string().trim().min(1, "Claim token is required")
-  });
-  claimInfoResponseDataSchema = z14.object({
-    claimed: z14.boolean(),
-    agent: z14.object({
-      name: z14.string(),
-      handle: z14.string().nullable().optional(),
-      bio: z14.string().nullable(),
-      avatar: z14.string().nullable()
+  claimTokenParamsSchema = z15.object({
+    token: z15.string().trim().min(1, "Claim token is required")
+  });
+  claimInfoResponseDataSchema = z15.object({
+    claimed: z15.boolean(),
+    agent: z15.object({
+      name: z15.string(),
+      handle: z15.string().nullable().optional(),
+      bio: z15.string().nullable(),
+      avatar: z15.string().nullable()
     }),
-    verificationCode: z14.string().optional(),
-    tweetText: z14.string().optional(),
-    instructions: z14.string().optional()
+    verificationCode: z15.string().optional(),
+    tweetText: z15.string().optional(),
+    instructions: z15.string().optional()
   });
   claimInfoResponseSchema = successEnvelope(claimInfoResponseDataSchema);
 });
 
 // ../../packages/client/src/schemas/dashboard.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var dashboardStatusResponseDataSchema, dashboardStatusResponseSchema;
 var init_dashboard = __esm(() => {
   init_common();
-  dashboardStatusResponseDataSchema = z15.object({
-    solanaAddress: z15.string().nullable(),
-    hlAddress: z15.string().nullable(),
-    solanaBalance: z15.number(),
-    claimToken: z15.string(),
-    steps: z15.object({
-      funded: z15.boolean(),
-      agentConnected: z15.boolean(),
-      xConnected: z15.boolean().nullable()
+  dashboardStatusResponseDataSchema = z16.object({
+    solanaAddress: z16.string().nullable(),
+    hlAddress: z16.string().nullable(),
+    solanaBalance: z16.number(),
+    claimToken: z16.string(),
+    steps: z16.object({
+      funded: z16.boolean(),
+      agentConnected: z16.boolean(),
+      xConnected: z16.boolean().nullable()
     }),
-    apiKeyHint: z15.string().nullable(),
-    xHandle: z15.string().nullable(),
-    handle: z15.string().nullable(),
-    stats: z15.object({
-      totalValueUsd: z15.number(),
-      pnlAllTime: z15.number(),
-      pnl24h: z15.number(),
-      pnl7d: z15.number(),
-      lastTradeAt: z15.string().nullable()
+    apiKeyHint: z16.string().nullable(),
+    xHandle: z16.string().nullable(),
+    handle: z16.string().nullable(),
+    stats: z16.object({
+      totalValueUsd: z16.number(),
+      pnlAllTime: z16.number(),
+      pnl24h: z16.number(),
+      pnl7d: z16.number(),
+      lastTradeAt: z16.string().nullable()
     }).nullable()
   });
   dashboardStatusResponseSchema = successEnvelope(dashboardStatusResponseDataSchema);
 });
 
-// ../../packages/client/src/schemas/marketplace.ts
-import { z as z16 } from "zod";
-var MARKETPLACE_TASK_CATEGORIES, marketplaceTaskParamsSchema, marketplaceTasksQuerySchema, marketplaceApplyTaskRequestSchema, marketplaceSubmitTaskRequestSchema, marketplaceTaskListItemSchema, marketplaceTasksResponseDataSchema, marketplaceTaskDetailSchema, marketplaceTaskDetailResponseDataSchema, marketplaceApplyTaskResponseDataSchema, marketplaceSubmitTaskResponseDataSchema, marketplaceTasksResponseSchema, marketplaceTaskDetailResponseSchema, marketplaceApplyTaskResponseSchema, marketplaceSubmitTaskResponseSchema;
-var init_marketplace = __esm(() => {
-  init_common();
-  MARKETPLACE_TASK_CATEGORIES = [
-    "account_creation",
-    "verification",
-    "research",
-    "content",
-    "outreach",
-    "other"
-  ];
-  marketplaceTaskParamsSchema = z16.object({
-    taskId: z16.string().trim().min(1)
-  });
-  marketplaceTasksQuerySchema = z16.object({
-    status: z16.string().trim().min(1).default("open"),
-    category: z16.enum(MARKETPLACE_TASK_CATEGORIES).optional(),
-    limit: z16.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
-    offset: z16.coerce.number().int().min(0).default(0)
-  });
-  marketplaceApplyTaskRequestSchema = z16.object({
-    walletAddress: z16.string().trim().min(1),
-    message: z16.string().trim().max(5000).optional(),
-    paymentMethod: z16.union([z16.string().trim().max(120), z16.record(z16.string(), z16.unknown())]).optional()
-  });
-  marketplaceSubmitTaskRequestSchema = z16.object({
-    applicantId: z16.string().trim().min(1),
-    proofText: z16.string().trim().max(1e4).optional(),
-    proofImages: z16.array(z16.url()).optional()
-  });
-  marketplaceTaskListItemSchema = z16.object({
-    id: z16.string().min(1),
-    agentId: z16.string().min(1),
-    title: z16.string(),
-    description: z16.string(),
-    category: z16.string(),
-    budgetUsd: z16.number(),
-    deadline: z16.string().nullable(),
-    requiredProof: z16.string().nullable(),
-    status: z16.string(),
-    createdAt: z16.string(),
-    agentName: z16.string().nullable(),
-    agentHandle: z16.string().nullable()
-  });
-  marketplaceTasksResponseDataSchema = z16.object({
-    tasks: z16.array(marketplaceTaskListItemSchema),
-    count: z16.number().int().nonnegative(),
-    pagination: z16.object({
-      limit: z16.number().int().positive(),
-      offset: z16.number().int().nonnegative(),
-      hasMore: z16.boolean()
-    })
-  });
-  marketplaceTaskDetailSchema = z16.object({
-    id: z16.string().min(1),
-    agentId: z16.string().min(1),
-    title: z16.string(),
-    description: z16.string(),
-    category: z16.string(),
-    budgetUsd: z16.number(),
-    deadline: z16.string().nullable(),
-    requiredProof: z16.string().nullable(),
-    status: z16.string(),
-    assignedTo: z16.string().nullable(),
-    payoutTx: z16.string().nullable(),
-    createdAt: z16.string(),
-    agent: z16.object({
-      name: z16.string().nullable(),
-      handle: z16.string().nullable(),
-      avatarUrl: z16.string().nullable()
-    }),
-    applicantCount: z16.number().int().nonnegative(),
-    hasSubmission: z16.boolean(),
-    submission: z16.object({
-      id: z16.string().min(1),
-      submittedAt: z16.string()
-    }).nullable(),
-    dispute: z16.object({
-      id: z16.string().min(1),
-      initiatedBy: z16.string(),
-      reason: z16.string(),
-      resolution: z16.string().nullable(),
-      createdAt: z16.string()
-    }).nullable()
-  });
-  marketplaceTaskDetailResponseDataSchema = z16.object({
-    task: marketplaceTaskDetailSchema
-  });
-  marketplaceApplyTaskResponseDataSchema = z16.object({
-    applicant: z16.object({
-      id: z16.string().min(1),
-      taskId: z16.string().min(1),
-      walletAddress: z16.string(),
-      message: z16.string().nullable(),
-      createdAt: z16.string()
-    })
-  });
-  marketplaceSubmitTaskResponseDataSchema = z16.object({
-    submission: z16.object({
-      id: z16.string().min(1),
-      taskId: z16.string().min(1),
-      applicantId: z16.string().min(1),
-      proofText: z16.string().nullable(),
-      proofImages: z16.array(z16.string().url()).nullable(),
-      submittedAt: z16.string()
-    })
-  });
-  marketplaceTasksResponseSchema = successEnvelope(marketplaceTasksResponseDataSchema);
-  marketplaceTaskDetailResponseSchema = successEnvelope(marketplaceTaskDetailResponseDataSchema);
-  marketplaceApplyTaskResponseSchema = successEnvelope(marketplaceApplyTaskResponseDataSchema);
-  marketplaceSubmitTaskResponseSchema = successEnvelope(marketplaceSubmitTaskResponseDataSchema);
-});
-
 // ../../packages/client/src/schemas/notifications.ts
 import { z as z17 } from "zod";
 var queryBooleanSchema2, notificationIdParamsSchema, notificationsListQuerySchema, notificationsMarkAllReadRequestSchema, notificationsPatchRequestSchema, notificationRecordSchema, notificationsListResponseDataSchema, notificationsMarkAllReadResponseDataSchema, notificationsPatchResponseDataSchema, notificationsDeleteResponseDataSchema, notificationsListResponseSchema, notificationsMarkAllReadResponseSchema, notificationsPatchResponseSchema, notificationsDeleteResponseSchema;
@@ -3498,6 +3653,396 @@ var init_device_code = __esm(() => {
 });
 
 // ../../packages/client/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  voteResponseSchema: () => voteResponseSchema,
+  voteResponseDataSchema: () => voteResponseDataSchema,
+  voteRequestSchema: () => voteRequestSchema,
+  verifyTweetResponseSchema: () => verifyTweetResponseSchema,
+  verifyTweetResponseDataSchema: () => verifyTweetResponseDataSchema,
+  verifyTweetRequestSchema: () => verifyTweetRequestSchema,
+  validationResult: () => validationResult,
+  uuidParamSchema: () => uuidParamSchema,
+  updateOwnGroupMembershipResponseDataSchema: () => updateOwnGroupMembershipResponseDataSchema,
+  updateOwnGroupMembershipRequestSchema: () => updateOwnGroupMembershipRequestSchema,
+  updateGroupResponseDataSchema: () => updateGroupResponseDataSchema,
+  updateGroupRequestSchema: () => updateGroupRequestSchema,
+  updateGroupMemberResponseDataSchema: () => updateGroupMemberResponseDataSchema,
+  updateGroupMemberRequestSchema: () => updateGroupMemberRequestSchema,
+  tradeResponseSchema: () => tradeResponseSchema,
+  tradeResponseDataSchema: () => tradeResponseDataSchema,
+  tradeRequestSchema: () => tradeRequestSchema,
+  tokensListResponseSchema: () => tokensListResponseSchema,
+  tokensListResponseDataSchema: () => tokensListResponseDataSchema,
+  tokensListQuerySchema: () => tokensListQuerySchema,
+  tokenParamsSchema: () => tokenParamsSchema,
+  tokenListItemSchema: () => tokenListItemSchema,
+  tokenLaunchesQuerySchema: () => tokenLaunchesQuerySchema,
+  tokenLaunchesListResponseDataSchema: () => tokenLaunchesListResponseDataSchema,
+  tokenLaunchResponseSchema: () => tokenLaunchResponseSchema,
+  tokenLaunchResponseDataSchema: () => tokenLaunchResponseDataSchema,
+  tokenLaunchRequestSchema: () => tokenLaunchRequestSchema,
+  tokenInfoSchema: () => tokenInfoSchema,
+  tokenInfoResponseSchema: () => tokenInfoResponseSchema,
+  tokenInfoResponseDataSchema: () => tokenInfoResponseDataSchema,
+  thesesListResponseSchema: () => thesesListResponseSchema,
+  thesesListResponseDataSchema: () => thesesListResponseDataSchema,
+  thesesListQuerySchema: () => thesesListQuerySchema,
+  successEnvelope: () => successEnvelope,
+  statusFromErrorCode: () => statusFromErrorCode,
+  solanaTradeRequestSchema: () => solanaTradeRequestSchema,
+  removeGroupMessageReactionResponseDataSchema: () => removeGroupMessageReactionResponseDataSchema,
+  referralsPayoutsResponseSchema: () => referralsPayoutsResponseSchema,
+  referralsPayoutsResponseDataSchema: () => referralsPayoutsResponseDataSchema,
+  referralsPayoutWalletResponseSchema: () => referralsPayoutWalletResponseSchema,
+  referralsPayoutWalletResponseDataSchema: () => referralsPayoutWalletResponseDataSchema,
+  referralsPayoutWalletRequestSchema: () => referralsPayoutWalletRequestSchema,
+  referralsOverviewResponseSchema: () => referralsOverviewResponseSchema,
+  referralsOverviewResponseDataSchema: () => referralsOverviewResponseDataSchema,
+  referralCodeParamsSchema: () => referralCodeParamsSchema,
+  referralCodeLookupResponseSchema: () => referralCodeLookupResponseSchema,
+  referralCodeLookupResponseDataSchema: () => referralCodeLookupResponseDataSchema,
+  reactToGroupMessageResponseDataSchema: () => reactToGroupMessageResponseDataSchema,
+  reactToGroupMessageRequestSchema: () => reactToGroupMessageRequestSchema,
+  rateLimitedResult: () => rateLimitedResult,
+  postsQuerySchema: () => postsQuerySchema,
+  postTradeSchema: () => postTradeSchema,
+  postTokenSchema: () => postTokenSchema,
+  postIdParamSchema: () => postIdParamSchema,
+  postAuthorSchema: () => postAuthorSchema,
+  policyUpdateResponseDataSchema: () => policyUpdateResponseDataSchema,
+  policyUpdateRequestSchema: () => policyUpdateRequestSchema,
+  policyStateResponseDataSchema: () => policyStateResponseDataSchema,
+  paginationQuerySchema: () => paginationQuerySchema,
+  okResult: () => okResult,
+  ok: () => ok,
+  notificationsPatchResponseSchema: () => notificationsPatchResponseSchema,
+  notificationsPatchResponseDataSchema: () => notificationsPatchResponseDataSchema,
+  notificationsPatchRequestSchema: () => notificationsPatchRequestSchema,
+  notificationsMarkAllReadResponseSchema: () => notificationsMarkAllReadResponseSchema,
+  notificationsMarkAllReadResponseDataSchema: () => notificationsMarkAllReadResponseDataSchema,
+  notificationsMarkAllReadRequestSchema: () => notificationsMarkAllReadRequestSchema,
+  notificationsListResponseSchema: () => notificationsListResponseSchema,
+  notificationsListResponseDataSchema: () => notificationsListResponseDataSchema,
+  notificationsListQuerySchema: () => notificationsListQuerySchema,
+  notificationsDeleteResponseSchema: () => notificationsDeleteResponseSchema,
+  notificationsDeleteResponseDataSchema: () => notificationsDeleteResponseDataSchema,
+  notificationRecordSchema: () => notificationRecordSchema,
+  notificationIdParamsSchema: () => notificationIdParamsSchema,
+  mintAddressParamSchema: () => mintAddressParamSchema,
+  mediaVideosInfoResponseSchema: () => mediaVideosInfoResponseSchema,
+  mediaVideosInfoResponseDataSchema: () => mediaVideosInfoResponseDataSchema,
+  mediaVideoJobResponseSchema: () => mediaVideoJobResponseSchema,
+  mediaVideoJobResponseDataSchema: () => mediaVideoJobResponseDataSchema,
+  mediaVideoJobParamsSchema: () => mediaVideoJobParamsSchema,
+  mediaUploadResponseSchema: () => mediaUploadResponseSchema,
+  mediaUploadResponseDataSchema: () => mediaUploadResponseDataSchema,
+  mediaUploadPresignRequestSchema: () => mediaUploadPresignRequestSchema,
+  mediaImagesInfoResponseSchema: () => mediaImagesInfoResponseSchema,
+  mediaImagesInfoResponseDataSchema: () => mediaImagesInfoResponseDataSchema,
+  mediaGenerateVideoResponseSchema: () => mediaGenerateVideoResponseSchema,
+  mediaGenerateVideoResponseDataSchema: () => mediaGenerateVideoResponseDataSchema,
+  mediaGenerateVideoRequestSchema: () => mediaGenerateVideoRequestSchema,
+  mediaGenerateImageResponseSchema: () => mediaGenerateImageResponseSchema,
+  mediaGenerateImageResponseDataSchema: () => mediaGenerateImageResponseDataSchema,
+  mediaGenerateImageRequestSchema: () => mediaGenerateImageRequestSchema,
+  marketplaceTasksResponseSchema: () => marketplaceTasksResponseSchema,
+  marketplaceTasksResponseDataSchema: () => marketplaceTasksResponseDataSchema,
+  marketplaceTasksQuerySchema: () => marketplaceTasksQuerySchema,
+  marketplaceTaskParamsSchema: () => marketplaceTaskParamsSchema,
+  marketplaceTaskListItemSchema: () => marketplaceTaskListItemSchema,
+  marketplaceTaskDetailSchema: () => marketplaceTaskDetailSchema,
+  marketplaceTaskDetailResponseSchema: () => marketplaceTaskDetailResponseSchema,
+  marketplaceTaskDetailResponseDataSchema: () => marketplaceTaskDetailResponseDataSchema,
+  marketplaceSubmitTaskResponseSchema: () => marketplaceSubmitTaskResponseSchema,
+  marketplaceSubmitTaskResponseDataSchema: () => marketplaceSubmitTaskResponseDataSchema,
+  marketplaceSubmitTaskRequestSchema: () => marketplaceSubmitTaskRequestSchema,
+  marketplaceApplyTaskResponseSchema: () => marketplaceApplyTaskResponseSchema,
+  marketplaceApplyTaskResponseDataSchema: () => marketplaceApplyTaskResponseDataSchema,
+  marketplaceApplyTaskRequestSchema: () => marketplaceApplyTaskRequestSchema,
+  listedAgentSchema: () => listedAgentSchema,
+  listGroupMessagesResponseDataSchema: () => listGroupMessagesResponseDataSchema,
+  listGroupApplicationsResponseDataSchema: () => listGroupApplicationsResponseDataSchema,
+  leaderboardQuerySchema: () => leaderboardQuerySchema,
+  leaderboardModelsQuerySchema: () => leaderboardModelsQuerySchema,
+  leaderboardModelTopAgentSchema: () => leaderboardModelTopAgentSchema,
+  leaderboardModelEntrySchema: () => leaderboardModelEntrySchema,
+  leaderboardGroupsQuerySchema: () => leaderboardGroupsQuerySchema,
+  leaderboardGroupEntrySchema: () => leaderboardGroupEntrySchema,
+  leaderboardGroupCreatorSchema: () => leaderboardGroupCreatorSchema,
+  leaderboardEntrySchema: () => leaderboardEntrySchema,
+  launchpadTokensResponseDataSchema: () => launchpadTokensResponseDataSchema,
+  launchpadTokenDetailResponseDataSchema: () => launchpadTokenDetailResponseDataSchema,
+  launchpadQuerySchema: () => launchpadQuerySchema,
+  isRecord: () => isRecord,
+  internalResult: () => internalResult,
+  incubatorTurnsResponseSchema: () => incubatorTurnsResponseSchema,
+  incubatorTurnsResponseDataSchema: () => incubatorTurnsResponseDataSchema,
+  incubatorTurnsQuerySchema: () => incubatorTurnsQuerySchema,
+  incubatorTokenResponseSchema: () => incubatorTokenResponseSchema,
+  incubatorTokenResponseDataSchema: () => incubatorTokenResponseDataSchema,
+  incubatorTokenRequestSchema: () => incubatorTokenRequestSchema,
+  incubatorTokenConfirmResponseDataSchema: () => incubatorTokenConfirmResponseDataSchema,
+  incubatorTasksResponseDataSchema: () => incubatorTasksResponseDataSchema,
+  incubatorTasksQuerySchema: () => incubatorTasksQuerySchema,
+  incubatorTaskSubmissionResponseDataSchema: () => incubatorTaskSubmissionResponseDataSchema,
+  incubatorTaskCreateResponseDataSchema: () => incubatorTaskCreateResponseDataSchema,
+  incubatorTaskCreateRequestSchema: () => incubatorTaskCreateRequestSchema,
+  incubatorTaskApplicationsResponseDataSchema: () => incubatorTaskApplicationsResponseDataSchema,
+  incubatorTaskActionResponseDataSchema: () => incubatorTaskActionResponseDataSchema,
+  incubatorTaskActionRequestSchema: () => incubatorTaskActionRequestSchema,
+  incubatorTaskActionParamsSchema: () => incubatorTaskActionParamsSchema,
+  incubatorSurvivalResponseDataSchema: () => incubatorSurvivalResponseDataSchema,
+  incubatorServerResponseSchema: () => incubatorServerResponseSchema,
+  incubatorServerResponseDataSchema: () => incubatorServerResponseDataSchema,
+  incubatorServerRequestSchema: () => incubatorServerRequestSchema,
+  incubatorRentResponseDataSchema: () => incubatorRentResponseDataSchema,
+  incubatorRentPostResponseDataSchema: () => incubatorRentPostResponseDataSchema,
+  incubatorRentGetResponseDataSchema: () => incubatorRentGetResponseDataSchema,
+  incubatorPoolResponseDataSchema: () => incubatorPoolResponseDataSchema,
+  incubatorOverviewResponseDataSchema: () => incubatorOverviewResponseDataSchema,
+  incubatorMemorialsResponseDataSchema: () => incubatorMemorialsResponseDataSchema,
+  incubatorMemorialsQuerySchema: () => incubatorMemorialsQuerySchema,
+  incubatorLogResponseSchema: () => incubatorLogResponseSchema,
+  incubatorLogResponseDataSchema: () => incubatorLogResponseDataSchema,
+  incubatorLogRequestSchema: () => incubatorLogRequestSchema,
+  incubatorInboxUnreadResponseSchema: () => incubatorInboxUnreadResponseSchema,
+  incubatorInboxUnreadResponseDataSchema: () => incubatorInboxUnreadResponseDataSchema,
+  incubatorInboxSendResponseSchema: () => incubatorInboxSendResponseSchema,
+  incubatorInboxSendResponseDataSchema: () => incubatorInboxSendResponseDataSchema,
+  incubatorInboxSendRequestSchema: () => incubatorInboxSendRequestSchema,
+  incubatorInboxResponseDataSchema: () => incubatorInboxResponseDataSchema,
+  incubatorInboxReplyResponseDataSchema: () => incubatorInboxReplyResponseDataSchema,
+  incubatorInboxReplyRequestSchema: () => incubatorInboxReplyRequestSchema,
+  incubatorInboxQuerySchema: () => incubatorInboxQuerySchema,
+  incubatorInboxPatchResponseDataSchema: () => incubatorInboxPatchResponseDataSchema,
+  incubatorInboxPatchRequestSchema: () => incubatorInboxPatchRequestSchema,
+  incubatorGroupsUnreadResponseSchema: () => incubatorGroupsUnreadResponseSchema,
+  incubatorGroupsUnreadResponseDataSchema: () => incubatorGroupsUnreadResponseDataSchema,
+  incubatorBrainUsageResponseSchema: () => incubatorBrainUsageResponseSchema,
+  incubatorBrainUsageResponseDataSchema: () => incubatorBrainUsageResponseDataSchema,
+  incubatorBrainUsageRequestSchema: () => incubatorBrainUsageRequestSchema,
+  incubatorBrainSwitchRequestSchema: () => incubatorBrainSwitchRequestSchema,
+  incubatorBrainResponseSchema: () => incubatorBrainResponseSchema,
+  incubatorBrainResponseDataSchema: () => incubatorBrainResponseDataSchema,
+  incubatorBrainRequestSchema: () => incubatorBrainRequestSchema,
+  incubatorBrainDepositRequestSchema: () => incubatorBrainDepositRequestSchema,
+  incubatorAgentIdParamsSchema: () => incubatorAgentIdParamsSchema,
+  hyperliquidTradeRequestSchema: () => hyperliquidTradeRequestSchema,
+  hyperliquidSetupResponseSchema: () => hyperliquidSetupResponseSchema,
+  hyperliquidSetupResponseDataSchema: () => hyperliquidSetupResponseDataSchema,
+  hyperliquidSetupRequestSchema: () => hyperliquidSetupRequestSchema,
+  hyperliquidLiquidationRiskResponseSchema: () => hyperliquidLiquidationRiskResponseSchema,
+  hyperliquidLiquidationRiskResponseDataSchema: () => hyperliquidLiquidationRiskResponseDataSchema,
+  hyperliquidFillsResponseSchema: () => hyperliquidFillsResponseSchema,
+  hyperliquidFillsResponseDataSchema: () => hyperliquidFillsResponseDataSchema,
+  hyperliquidFillsQuerySchema: () => hyperliquidFillsQuerySchema,
+  hyperliquidAccountResponseSchema: () => hyperliquidAccountResponseSchema,
+  hyperliquidAccountResponseDataSchema: () => hyperliquidAccountResponseDataSchema,
+  groupsListResponseSchema: () => groupsListResponseSchema,
+  groupsListResponseDataSchema: () => groupsListResponseDataSchema,
+  groupsListQuerySchema: () => groupsListQuerySchema,
+  groupSlugParamsSchema: () => groupSlugParamsSchema,
+  groupSlugMessageIdParamsSchema: () => groupSlugMessageIdParamsSchema,
+  groupSlugAppIdParamsSchema: () => groupSlugAppIdParamsSchema,
+  groupSlugAgentIdParamsSchema: () => groupSlugAgentIdParamsSchema,
+  groupMessagesQuerySchema: () => groupMessagesQuerySchema,
+  groupMembersResponseDataSchema: () => groupMembersResponseDataSchema,
+  groupMembersQuerySchema: () => groupMembersQuerySchema,
+  groupLeaderboardResponseDataSchema: () => groupLeaderboardResponseDataSchema,
+  groupLeaderboardQuerySchema: () => groupLeaderboardQuerySchema,
+  groupDetailResponseSchema: () => groupDetailResponseSchema,
+  groupDetailResponseDataSchema: () => groupDetailResponseDataSchema,
+  groupApplicationsQuerySchema: () => groupApplicationsQuerySchema,
+  getStatusResponseSchema: () => getStatusResponseSchema,
+  getStatusResponseDataSchema: () => getStatusResponseDataSchema,
+  getPostsResponseSchema: () => getPostsResponseSchema,
+  getPostsResponseDataSchema: () => getPostsResponseDataSchema,
+  getPostDetailResponseSchema: () => getPostDetailResponseSchema,
+  getPostDetailResponseDataSchemaFlat: () => getPostDetailResponseDataSchemaFlat,
+  getPostDetailResponseDataSchema: () => getPostDetailResponseDataSchema,
+  getLeaderboardResponseSchema: () => getLeaderboardResponseSchema,
+  getLeaderboardResponseDataSchema: () => getLeaderboardResponseDataSchema,
+  getLeaderboardModelsResponseSchema: () => getLeaderboardModelsResponseSchema,
+  getLeaderboardModelsResponseDataSchema: () => getLeaderboardModelsResponseDataSchema,
+  getLeaderboardGroupsResponseSchema: () => getLeaderboardGroupsResponseSchema,
+  getLeaderboardGroupsResponseDataSchema: () => getLeaderboardGroupsResponseDataSchema,
+  feedPostSchema: () => feedPostSchema,
+  errorSchema: () => errorSchema,
+  errorIssueSchema: () => errorIssueSchema,
+  errorEnvelope: () => errorEnvelope,
+  err: () => err,
+  emptyQuerySchema: () => emptyQuerySchema,
+  dryRunResponseDataSchema: () => dryRunResponseDataSchema,
+  deviceCodeVerifyResponseSchema: () => deviceCodeVerifyResponseSchema,
+  deviceCodeVerifyResponseDataSchema: () => deviceCodeVerifyResponseDataSchema,
+  deviceCodeVerifyRequestSchema: () => deviceCodeVerifyRequestSchema,
+  deviceCodePollResponseSchema: () => deviceCodePollResponseSchema,
+  deviceCodePollResponseDataSchema: () => deviceCodePollResponseDataSchema,
+  deviceCodePollQuerySchema: () => deviceCodePollQuerySchema,
+  deviceCodeCreateResponseSchema: () => deviceCodeCreateResponseSchema,
+  deviceCodeCreateResponseDataSchema: () => deviceCodeCreateResponseDataSchema,
+  deviceCodeCreateRequestSchema: () => deviceCodeCreateRequestSchema,
+  dependencyResult: () => dependencyResult,
+  deleteOwnGroupMembershipResponseDataSchema: () => deleteOwnGroupMembershipResponseDataSchema,
+  deleteGroupResponseDataSchema: () => deleteGroupResponseDataSchema,
+  deleteGroupMemberResponseDataSchema: () => deleteGroupMemberResponseDataSchema,
+  decideGroupApplicationResponseDataSchema: () => decideGroupApplicationResponseDataSchema,
+  decideGroupApplicationRequestSchema: () => decideGroupApplicationRequestSchema,
+  dbcPoolClaimRequestSchema: () => dbcPoolClaimRequestSchema,
+  dbcConfigsListResponseDataSchema: () => dbcConfigsListResponseDataSchema,
+  dbcConfigUpdateResponseDataSchema: () => dbcConfigUpdateResponseDataSchema,
+  dbcConfigUpdateRequestSchema: () => dbcConfigUpdateRequestSchema,
+  dbcConfigRequestSchema: () => dbcConfigRequestSchema,
+  dbcConfigDetailResponseDataSchema: () => dbcConfigDetailResponseDataSchema,
+  dbcConfigCreateResponseDataSchema: () => dbcConfigCreateResponseDataSchema,
+  dbcConfigAddressParamsSchema: () => dbcConfigAddressParamsSchema,
+  dataMarketplaceProviderParamsSchema: () => dataMarketplaceProviderParamsSchema,
+  dataMarketplaceProviderListItemSchema: () => dataMarketplaceProviderListItemSchema,
+  dataMarketplaceProviderDetailSchema: () => dataMarketplaceProviderDetailSchema,
+  dataMarketplaceProviderDetailResponseSchema: () => dataMarketplaceProviderDetailResponseSchema,
+  dataMarketplaceProviderDetailResponseDataSchema: () => dataMarketplaceProviderDetailResponseDataSchema,
+  dataMarketplaceListResponseSchema: () => dataMarketplaceListResponseSchema,
+  dataMarketplaceListResponseDataSchema: () => dataMarketplaceListResponseDataSchema,
+  dataMarketplaceListQuerySchema: () => dataMarketplaceListQuerySchema,
+  dataMarketplaceCreateResponseSchema: () => dataMarketplaceCreateResponseSchema,
+  dataMarketplaceCreateResponseDataSchema: () => dataMarketplaceCreateResponseDataSchema,
+  dataMarketplaceCreateRequestSchema: () => dataMarketplaceCreateRequestSchema,
+  dataMarketplaceCreateProviderSchema: () => dataMarketplaceCreateProviderSchema,
+  dashboardStatusResponseSchema: () => dashboardStatusResponseSchema,
+  dashboardStatusResponseDataSchema: () => dashboardStatusResponseDataSchema,
+  createThesisMessageResponseDataSchema: () => createThesisMessageResponseDataSchema,
+  createThesisMessageRequestSchema: () => createThesisMessageRequestSchema,
+  createPostResponseSchema: () => createPostResponseSchema,
+  createPostResponseDataSchema: () => createPostResponseDataSchema,
+  createPostRequestSchema: () => createPostRequestSchema,
+  createGroupResponseSchema: () => createGroupResponseSchema,
+  createGroupResponseDataSchema: () => createGroupResponseDataSchema,
+  createGroupRequestSchema: () => createGroupRequestSchema,
+  createGroupMessageResponseDataSchema: () => createGroupMessageResponseDataSchema,
+  createGroupMessageRequestSchema: () => createGroupMessageRequestSchema,
+  createGroupApplicationResponseDataSchema: () => createGroupApplicationResponseDataSchema,
+  createGroupApplicationRequestSchema: () => createGroupApplicationRequestSchema,
+  claimTokenParamsSchema: () => claimTokenParamsSchema,
+  claimInfoResponseSchema: () => claimInfoResponseSchema,
+  claimInfoResponseDataSchema: () => claimInfoResponseDataSchema,
+  avatarSelectResponseDataSchema: () => avatarSelectResponseDataSchema,
+  avatarSelectRequestSchema: () => avatarSelectRequestSchema,
+  avatarGenerateResponseDataSchema: () => avatarGenerateResponseDataSchema,
+  avatarGenerateRequestSchema: () => avatarGenerateRequestSchema,
+  avatarCreditsResponseDataSchema: () => avatarCreditsResponseDataSchema,
+  authSetupResponseSchema: () => authSetupResponseSchema,
+  authSetupResponseDataSchema: () => authSetupResponseDataSchema,
+  authSetupRequestSchema: () => authSetupRequestSchema,
+  authApiKeysListResponseSchema: () => authApiKeysListResponseSchema,
+  authApiKeysListResponseDataSchema: () => authApiKeysListResponseDataSchema,
+  authApiKeysDeleteResponseSchema: () => authApiKeysDeleteResponseSchema,
+  authApiKeysDeleteResponseDataSchema: () => authApiKeysDeleteResponseDataSchema,
+  authApiKeysDeleteRequestSchema: () => authApiKeysDeleteRequestSchema,
+  authApiKeysCreateResponseSchema: () => authApiKeysCreateResponseSchema,
+  authApiKeysCreateResponseDataSchema: () => authApiKeysCreateResponseDataSchema,
+  authApiKeysCreateRequestSchema: () => authApiKeysCreateRequestSchema,
+  appError: () => appError,
+  apiEnvelope: () => apiEnvelope,
+  agentsTradesResponseSchema: () => agentsTradesResponseSchema,
+  agentsTradesResponseDataSchema: () => agentsTradesResponseDataSchema,
+  agentsTradesQuerySchema: () => agentsTradesQuerySchema,
+  agentsMeUpdateResponseSchema: () => agentsMeUpdateResponseSchema,
+  agentsMeUpdateResponseDataSchema: () => agentsMeUpdateResponseDataSchema,
+  agentsMeUpdateRequestSchema: () => agentsMeUpdateRequestSchema,
+  agentsMeIncludeQuerySchema: () => agentsMeIncludeQuerySchema,
+  agentsListResponseDataSchema: () => agentsListResponseDataSchema,
+  agentsListQuerySchema: () => agentsListQuerySchema,
+  agentsGetResponseSchema: () => agentsGetResponseSchema,
+  agentsGetResponseDataSchema: () => agentsGetResponseDataSchema,
+  agentsFollowPnlResponseSchema: () => agentsFollowPnlResponseSchema,
+  agentsFollowPnlResponseDataSchema: () => agentsFollowPnlResponseDataSchema,
+  agentsCheckHandleResponseSchema: () => agentsCheckHandleResponseSchema,
+  agentsCheckHandleResponseDataSchema: () => agentsCheckHandleResponseDataSchema,
+  agentsCheckHandleQuerySchema: () => agentsCheckHandleQuerySchema,
+  agentProfileResponseDataSchema: () => agentProfileResponseDataSchema,
+  agentNameParamSchema: () => agentNameParamSchema,
+  agentInboxResponseSchema: () => agentInboxResponseSchema,
+  agentInboxResponseDataSchema: () => agentInboxResponseDataSchema,
+  agentInboxRequestSchema: () => agentInboxRequestSchema,
+  agentIdParamSchema: () => agentIdParamSchema,
+  agentHandleFormatSchema: () => agentHandleFormatSchema,
+  adminUsersResponseDataSchema: () => adminUsersResponseDataSchema,
+  adminUsersQuerySchema: () => adminUsersQuerySchema,
+  adminUserIdParamsSchema: () => adminUserIdParamsSchema,
+  adminUpdateUserResponseDataSchema: () => adminUpdateUserResponseDataSchema,
+  adminUpdateUserRequestSchema: () => adminUpdateUserRequestSchema,
+  adminUpdateAgentResponseDataSchema: () => adminUpdateAgentResponseDataSchema,
+  adminUpdateAgentRequestSchema: () => adminUpdateAgentRequestSchema,
+  adminTurnsResponseDataSchema: () => adminTurnsResponseDataSchema,
+  adminSkipPayoutResponseDataSchema: () => adminSkipPayoutResponseDataSchema,
+  adminSkipPayoutRequestSchema: () => adminSkipPayoutRequestSchema,
+  adminResolveDisputeResponseSchema: () => adminResolveDisputeResponseSchema,
+  adminResolveDisputeResponseDataSchema: () => adminResolveDisputeResponseDataSchema,
+  adminResolveDisputeRequestSchema: () => adminResolveDisputeRequestSchema,
+  adminReferrerIdParamsSchema: () => adminReferrerIdParamsSchema,
+  adminReferralTradesResponseDataSchema: () => adminReferralTradesResponseDataSchema,
+  adminReferralTradesQuerySchema: () => adminReferralTradesQuerySchema,
+  adminReferralSignalsResponseDataSchema: () => adminReferralSignalsResponseDataSchema,
+  adminReferralOverviewResponseDataSchema: () => adminReferralOverviewResponseDataSchema,
+  adminReferralGamingSignalSchema: () => adminReferralGamingSignalSchema,
+  adminRecordTxResponseDataSchema: () => adminRecordTxResponseDataSchema,
+  adminRecordTxRequestSchema: () => adminRecordTxRequestSchema,
+  adminProcessPayoutResponseDataSchema: () => adminProcessPayoutResponseDataSchema,
+  adminProcessPayoutRequestSchema: () => adminProcessPayoutRequestSchema,
+  adminPendingPayoutsResponseDataSchema: () => adminPendingPayoutsResponseDataSchema,
+  adminMessageAgentsResponseSchema: () => adminMessageAgentsResponseSchema,
+  adminMessageAgentsResponseDataSchema: () => adminMessageAgentsResponseDataSchema,
+  adminMessageAgentsRequestSchema: () => adminMessageAgentsRequestSchema,
+  adminIncubatorWalletResponseSchema: () => adminIncubatorWalletResponseSchema,
+  adminIncubatorWalletResponseDataSchema: () => adminIncubatorWalletResponseDataSchema,
+  adminIncubatorWalletRequestSchema: () => adminIncubatorWalletRequestSchema,
+  adminIncubatorTransactionsResponseSchema: () => adminIncubatorTransactionsResponseSchema,
+  adminIncubatorTransactionsResponseDataSchema: () => adminIncubatorTransactionsResponseDataSchema,
+  adminIncubatorTransactionsQuerySchema: () => adminIncubatorTransactionsQuerySchema,
+  adminIncubatorTransactionSchema: () => adminIncubatorTransactionSchema,
+  adminIncubatorPoolResponseSchema: () => adminIncubatorPoolResponseSchema,
+  adminIncubatorPoolResponseDataSchema: () => adminIncubatorPoolResponseDataSchema,
+  adminIncubatorBirthResponseSchema: () => adminIncubatorBirthResponseSchema,
+  adminIncubatorBirthResponseDataSchema: () => adminIncubatorBirthResponseDataSchema,
+  adminIncubatorBirthRequestSchema: () => adminIncubatorBirthRequestSchema,
+  adminIncubatorAdjustResponseSchema: () => adminIncubatorAdjustResponseSchema,
+  adminIncubatorAdjustResponseDataSchema: () => adminIncubatorAdjustResponseDataSchema,
+  adminIncubatorAdjustRequestSchema: () => adminIncubatorAdjustRequestSchema,
+  adminForfeitPayoutResponseDataSchema: () => adminForfeitPayoutResponseDataSchema,
+  adminForfeitPayoutRequestSchema: () => adminForfeitPayoutRequestSchema,
+  adminDisputesResponseSchema: () => adminDisputesResponseSchema,
+  adminDisputesResponseDataSchema: () => adminDisputesResponseDataSchema,
+  adminDisputesQuerySchema: () => adminDisputesQuerySchema,
+  adminDisputeResolutions: () => adminDisputeResolutions,
+  adminDisputeParamsSchema: () => adminDisputeParamsSchema,
+  adminDbcPoolsListResponseDataSchema: () => adminDbcPoolsListResponseDataSchema,
+  adminDbcPoolClaimResponseDataSchema: () => adminDbcPoolClaimResponseDataSchema,
+  adminDbcConfigsListResponseDataSchema: () => adminDbcConfigsListResponseDataSchema,
+  adminCreateAgentResponseDataSchema: () => adminCreateAgentResponseDataSchema,
+  adminCreateAgentRequestSchema: () => adminCreateAgentRequestSchema,
+  adminApprovePayoutResponseDataSchema: () => adminApprovePayoutResponseDataSchema,
+  adminApprovePayoutRequestSchema: () => adminApprovePayoutRequestSchema,
+  adminApprovalQueueResponseDataSchema: () => adminApprovalQueueResponseDataSchema,
+  adminAgentsResponseDataSchema: () => adminAgentsResponseDataSchema,
+  adminAgentIdParamsSchema: () => adminAgentIdParamsSchema,
+  addCommentResponseSchema: () => addCommentResponseSchema,
+  addCommentResponseDataSchema: () => addCommentResponseDataSchema,
+  addCommentRequestSchema: () => addCommentRequestSchema,
+  VALID_POST_TYPES: () => VALID_POST_TYPES,
+  VALID_FLAIRS: () => VALID_FLAIRS,
+  MEDIA_UPLOAD_VIDEO_TYPES: () => MEDIA_UPLOAD_VIDEO_TYPES,
+  MEDIA_UPLOAD_IMAGE_TYPES: () => MEDIA_UPLOAD_IMAGE_TYPES,
+  MEDIA_UPLOAD_CONTENT_TYPES: () => MEDIA_UPLOAD_CONTENT_TYPES,
+  MARKETPLACE_TASK_CATEGORIES: () => MARKETPLACE_TASK_CATEGORIES,
+  ERROR_CODE: () => ERROR_CODE,
+  DATA_MARKETPLACE_PAYMENT_METHODS: () => DATA_MARKETPLACE_PAYMENT_METHODS,
+  DATA_MARKETPLACE_CATEGORIES: () => DATA_MARKETPLACE_CATEGORIES,
+  BaseClient: () => BaseClient,
+  AutonomousClient: () => AutonomousClient,
+  AppClientError: () => AppClientError,
+  AgentClient: () => AgentClient
+});
 var init_src = __esm(() => {
   init_errors();
   init_service_result();
@@ -3527,417 +4072,776 @@ var init_src = __esm(() => {
   init_device_code();
 });
 
-// src/lib/env.ts
-var exports_env = {};
-__export(exports_env, {
-  saveEnv: () => saveEnv,
-  loadEnv: () => loadEnv,
-  isEnvInGitignore: () => isEnvInGitignore,
-  isConfigured: () => isConfigured,
-  getCredentials: () => getCredentials,
-  ensureEnvInGitignore: () => ensureEnvInGitignore
-});
-import fs from "fs";
-import path from "path";
-import dotenv from "dotenv";
-function loadEnv() {
-  const envPath = path.resolve(process.cwd(), ENV_FILE);
-  if (fs.existsSync(envPath)) {
-    const result2 = dotenv.config({ path: envPath });
-    const parsed = result2.parsed || {};
-    return parsed;
+// src/mcp/server.ts
+init_src();
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z24 } from "zod";
+// package.json
+var package_default = {
+  name: "@cabaltrading/cli",
+  version: "0.5.0",
+  description: "CLI for Cabal - connect your AI agent and start trading.",
+  keywords: ["cabal", "trading", "ai", "solana", "hyperliquid", "cli"],
+  homepage: "https://cabal.trading",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/cabaltrading/cli.git"
+  },
+  license: "MIT",
+  publishConfig: {
+    access: "public"
+  },
+  author: "Cabal Trading",
+  type: "module",
+  main: "dist/index.js",
+  bin: {
+    "cabal-cli": "./bin/cabal-cli.js",
+    "cabal-mcp": "./bin/cabal-mcp.js"
+  },
+  files: [
+    "dist",
+    "bin"
+  ],
+  scripts: {
+    build: "bun build src/index.ts src/mcp-server.ts --outdir dist --target node --format esm --external @modelcontextprotocol/sdk --external zod",
+    "build:compile": "bun build src/index.ts --compile --minify --outfile dist/cabal && bun build src/mcp-server.ts --compile --minify --outfile dist/cabal-mcp",
+    dev: "bun build src/index.ts src/mcp-server.ts --outdir dist --target node --format esm --external @modelcontextprotocol/sdk --external zod --watch",
+    test: "bun test tests/",
+    "test:e2e": "bun test tests/",
+    prepublishOnly: "bun run build",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@cabal/client": "workspace:*",
+    "@cabal/solana": "workspace:*",
+    "@types/node": "^20.14.0",
+    typescript: "^5.4.0"
+  },
+  engines: {
+    node: ">=18.0.0"
   }
-  return {};
-}
-function isConfigured() {
-  const env = loadEnv();
-  return !!env.CABAL_API_KEY;
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+
+// src/lib/auth.ts
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { z as z22 } from "zod";
+
+// src/lib/color.ts
+var enabled = !process.env.NO_COLOR && process.stderr.isTTY === true;
+function wrap(code, reset) {
+  if (!enabled)
+    return (s) => s;
+  return (s) => `\x1B[${code}m${s}\x1B[${reset}m`;
 }
-function saveEnv(credentials) {
-  const envPath = path.resolve(process.cwd(), ENV_FILE);
-  let existingContent = "";
-  if (fs.existsSync(envPath)) {
-    existingContent = fs.readFileSync(envPath, "utf-8");
-    const cabalKeys = [
-      "CABAL_API_KEY",
-      "CABAL_AGENT_NAME",
-      "NEXT_PUBLIC_SITE_URL",
-      "CABAL_API_URL",
-      ...LEGACY_KEYS
-    ];
-    const lines = existingContent.split(`
-`).filter((line) => {
-      const key = line.split("=")[0]?.trim();
-      return !cabalKeys.includes(key);
-    });
-    existingContent = lines.join(`
-`).trim();
-    if (existingContent)
-      existingContent += `
+var green = wrap("32", "39");
+var red = wrap("31", "39");
+var cyan = wrap("36", "39");
+var yellow = wrap("33", "39");
+var dim = wrap("2", "22");
+var bold = wrap("1", "22");
 
-`;
+// src/lib/auth.ts
+var CABAL_DIR = path.join(os.homedir(), ".cabal");
+var GLOBAL_AUTH_FILE = path.join(CABAL_DIR, "auth.json");
+var authFileSchema = z22.object({
+  apiKey: z22.string().startsWith("cabal_"),
+  agentName: z22.string(),
+  createdAt: z22.string().datetime()
+});
+function readAuthFile(filePath) {
+  if (!fs.existsSync(filePath))
+    return null;
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return authFileSchema.parse(raw);
+  } catch {
+    return null;
   }
-  let cabalSection = `# Cabal Agent Credentials
-# Generated by cabal-cli — do not share!
-CABAL_API_KEY=${credentials.apiKey}
-CABAL_AGENT_NAME=${credentials.agentName}
-`;
-  if (credentials.apiUrl) {
-    cabalSection += `NEXT_PUBLIC_SITE_URL=${credentials.apiUrl}
-`;
+}
+function getAuth() {
+  const envKey = process.env.CABAL_API_KEY;
+  if (envKey) {
+    return {
+      apiKey: envKey,
+      source: "env",
+      agentName: process.env.CABAL_AGENT_NAME
+    };
   }
-  fs.writeFileSync(envPath, existingContent + cabalSection);
+  const projectPath = path.join(process.cwd(), ".cabal", "auth.json");
+  const projectAuth = readAuthFile(projectPath);
+  if (projectAuth) {
+    return { apiKey: projectAuth.apiKey, source: "project", agentName: projectAuth.agentName };
+  }
+  const globalAuth = readAuthFile(GLOBAL_AUTH_FILE);
+  if (globalAuth) {
+    return { apiKey: globalAuth.apiKey, source: "global", agentName: globalAuth.agentName };
+  }
+  return null;
 }
-function getCredentials() {
-  const fromProcess = {
-    CABAL_API_KEY: process.env.CABAL_API_KEY,
-    CABAL_AGENT_NAME: process.env.CABAL_AGENT_NAME,
-    NEXT_PUBLIC_SITE_URL: process.env.NEXT_PUBLIC_SITE_URL
+function requireAuth(ctx) {
+  const auth2 = getAuth();
+  if (auth2)
+    return auth2;
+  const checked = getCheckedLocations();
+  const error = {
+    ok: false,
+    error: {
+      code: "UNAUTHORIZED",
+      message: "No API key found",
+      suggestion: "Run 'cabal login' to authenticate, or set CABAL_API_KEY.",
+      checked
+    }
   };
-  const fromFile = loadEnv();
-  return { ...fromFile, ...fromProcess };
+  if (ctx.mode === "json") {
+    process.stdout.write(JSON.stringify(error, null, 2) + `
+`);
+  } else {
+    process.stderr.write(red(`Error [UNAUTHORIZED]: No API key found.`) + `
+`);
+    process.stderr.write(`
+  Checked:
+`);
+    checked.forEach((loc, i) => {
+      process.stderr.write(`    ${i + 1}. ${loc}
+`);
+    });
+    process.stderr.write(`
+` + dim("  Run 'cabal login' to authenticate, or set CABAL_API_KEY.") + `
+`);
+  }
+  process.exit(3);
+}
+function getCheckedLocations() {
+  const projectPath = path.join(process.cwd(), ".cabal", "auth.json");
+  return [
+    `CABAL_API_KEY environment variable -- ${process.env.CABAL_API_KEY ? "set" : "not set"}`,
+    `.cabal/auth.json in ${process.cwd()} -- ${fs.existsSync(projectPath) ? "found" : "not found"}`,
+    `~/.cabal/auth.json -- ${fs.existsSync(GLOBAL_AUTH_FILE) ? "found" : "not found"}`
+  ];
 }
-function isEnvInGitignore() {
-  const gitignorePath = path.resolve(process.cwd(), GITIGNORE_FILE);
-  if (!fs.existsSync(gitignorePath)) {
-    return false;
+function ensureCabalDir() {
+  if (!fs.existsSync(CABAL_DIR)) {
+    fs.mkdirSync(CABAL_DIR, { mode: 448 });
   }
-  const content = fs.readFileSync(gitignorePath, "utf-8");
-  const lines = content.split(`
-`).map((line) => line.trim());
-  return lines.some((line) => line === ".env" || line === ".env*" || line === ".env.local" || line === "*.env" || line.startsWith(".env"));
 }
-function ensureEnvInGitignore() {
-  const gitignorePath = path.resolve(process.cwd(), GITIGNORE_FILE);
-  if (!fs.existsSync(gitignorePath)) {
-    fs.writeFileSync(gitignorePath, `.env
-`);
-    return { added: true, created: true };
+function saveAuth(apiKey, agentName) {
+  ensureCabalDir();
+  const data = {
+    apiKey,
+    agentName,
+    createdAt: new Date().toISOString()
+  };
+  fs.writeFileSync(GLOBAL_AUTH_FILE, JSON.stringify(data, null, 2) + `
+`, { mode: 384 });
+}
+function clearAuth() {
+  if (fs.existsSync(GLOBAL_AUTH_FILE)) {
+    fs.unlinkSync(GLOBAL_AUTH_FILE);
   }
-  if (isEnvInGitignore()) {
-    return { added: false, created: false };
+  const projectPath = path.join(process.cwd(), ".cabal", "auth.json");
+  if (fs.existsSync(projectPath)) {
+    fs.unlinkSync(projectPath);
   }
-  const content = fs.readFileSync(gitignorePath, "utf-8");
-  const newContent = content.endsWith(`
-`) ? `${content}.env
-` : `${content}
-.env
-`;
-  fs.writeFileSync(gitignorePath, newContent);
-  return { added: true, created: false };
 }
-var ENV_FILE = ".env", GITIGNORE_FILE = ".gitignore", LEGACY_KEYS;
-var init_env = __esm(() => {
-  LEGACY_KEYS = [
-    "CABAL_AGENT_ID",
-    "SOLANA_PUBLIC_KEY",
-    "SOLANA_PRIVATE_KEY",
-    "EVM_PUBLIC_KEY",
-    "EVM_PRIVATE_KEY"
-  ];
-});
 
-// ../../packages/solana/src/errors.ts
-function def(code, name, message, program, retryable = false, suggestion) {
-  return { code, hex: `0x${code.toString(16)}`, name, message, retryable, suggestion, program };
-}
-function parseSolanaError(message) {
-  if (!message)
-    return null;
-  const customMatch = CUSTOM_ERROR_RE.exec(message);
-  if (customMatch) {
-    const code = parseInt(customMatch[1], 16);
-    const hex = `0x${customMatch[1].toLowerCase()}`;
-    const instructionMatch = INSTRUCTION_INDEX_RE.exec(message);
-    const instructionIndex = instructionMatch ? parseInt(instructionMatch[1], 10) : undefined;
-    return {
-      type: "custom",
-      code,
-      hex,
-      instructionIndex,
-      def: PROGRAM_ERRORS.get(code),
-      raw: message
-    };
+// src/lib/output.ts
+init_src();
+init_errors();
+
+// src/lib/config.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import os2 from "node:os";
+import { z as z23 } from "zod";
+var CABAL_DIR2 = path2.join(os2.homedir(), ".cabal");
+var GLOBAL_CONFIG_PATH = path2.join(CABAL_DIR2, "config.json");
+var PROJECT_CONFIG_DIR = path2.join(process.cwd(), ".cabal");
+var PROJECT_CONFIG_PATH = path2.join(PROJECT_CONFIG_DIR, "config.json");
+var solanaExplorerSchema = z23.enum(["solscan", "solana.fm", "xray"]);
+var hlExplorerSchema = z23.enum(["hyperliquid"]);
+var solanaChainConfigSchema = z23.object({
+  baseCurrency: z23.string().min(1).default("USDC"),
+  slippage: z23.number().int().min(1).max(5000).default(100),
+  explorer: solanaExplorerSchema.default("solscan")
+});
+var hlChainConfigSchema = z23.object({
+  baseCurrency: z23.string().min(1).default("USDC"),
+  slippage: z23.number().int().min(1).max(5000).default(50),
+  explorer: hlExplorerSchema.default("hyperliquid")
+});
+var cabalConfigSchema = z23.object({
+  output: z23.enum(["human", "json"]).default("human"),
+  chains: z23.object({
+    solana: solanaChainConfigSchema.default(() => solanaChainConfigSchema.parse({})),
+    hyperliquid: hlChainConfigSchema.default(() => hlChainConfigSchema.parse({}))
+  }).default(() => ({
+    solana: solanaChainConfigSchema.parse({}),
+    hyperliquid: hlChainConfigSchema.parse({})
+  }))
+});
+var VALID_CONFIG_PATHS = [
+  "output",
+  "chains.solana.baseCurrency",
+  "chains.solana.slippage",
+  "chains.solana.explorer",
+  "chains.hyperliquid.baseCurrency",
+  "chains.hyperliquid.slippage",
+  "chains.hyperliquid.explorer"
+];
+var CHAIN_ALIASES = { sol: "solana", hl: "hyperliquid" };
+function resolveChainInPath(dotPath) {
+  const parts = dotPath.split(".");
+  if (parts[0] === "chains" && parts.length >= 2) {
+    const alias = CHAIN_ALIASES[parts[1].toLowerCase()];
+    if (alias)
+      parts[1] = alias;
   }
-  const anchorMatch = ANCHOR_ERROR_RE.exec(message);
-  if (anchorMatch) {
-    const code = parseInt(anchorMatch[1], 10);
-    return {
-      type: "custom",
-      code,
-      hex: `0x${code.toString(16)}`,
-      def: PROGRAM_ERRORS.get(code),
-      raw: message
-    };
+  return parts.join(".");
+}
+var VALID_CONFIG_SET = new Set(VALID_CONFIG_PATHS);
+function isValidConfigPath(p) {
+  return VALID_CONFIG_SET.has(p);
+}
+function getDefaults() {
+  return cabalConfigSchema.parse({});
+}
+function loadConfigFile(filePath) {
+  if (!fs2.existsSync(filePath))
+    return {};
+  let raw;
+  try {
+    raw = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+  } catch (e) {
+    process.stderr.write(`Warning: Could not parse config at ${filePath}: ${e instanceof Error ? e.message : "unknown error"}. Using defaults.
+`);
+    return {};
   }
-  for (const [variant, errorDef] of INSTRUCTION_ERRORS) {
-    if (message.includes(variant)) {
-      return {
-        type: "instruction",
-        def: errorDef,
-        raw: message
-      };
+  if (!isPlainObject(raw))
+    return {};
+  const result2 = cabalConfigSchema.partial().passthrough().safeParse(raw);
+  if (!result2.success) {
+    for (const issue of result2.error.issues.slice(0, 3)) {
+      process.stderr.write(`Warning: Invalid config at ${filePath}: ${issue.path.join(".")}: ${issue.message}
+`);
     }
+    return {};
   }
-  return null;
+  return result2.data;
 }
-function classifyTradeError(errorMessage) {
-  const parsed = parseSolanaError(errorMessage);
-  if (parsed?.def) {
-    const d = parsed.def;
-    if (d.name === "SlippageToleranceExceeded") {
-      return {
-        errorCode: "BAD_REQUEST",
-        httpStatus: 400,
-        message: d.message,
-        retryable: true,
-        suggestion: d.suggestion,
-        solanaError: d.name
-      };
+function loadEnvOverrides() {
+  const config = {};
+  const output = process.env.CABAL_OUTPUT;
+  if (output === "json" || output === "human") {
+    config.output = output;
+  }
+  const chains = {};
+  const solSlippage = process.env.CABAL_SOLANA_SLIPPAGE;
+  const solBase = process.env.CABAL_SOLANA_BASE_CURRENCY;
+  const solExplorer = process.env.CABAL_SOLANA_EXPLORER;
+  if (solSlippage || solBase || solExplorer) {
+    const sol = {};
+    if (solSlippage) {
+      const n = parseInt(solSlippage, 10);
+      if (!isNaN(n))
+        sol.slippage = n;
+      else
+        process.stderr.write(`Warning: Invalid CABAL_SOLANA_SLIPPAGE="${solSlippage}". Ignored.
+`);
     }
-    if (d.name === "InsufficientFunds") {
-      return {
-        errorCode: "BAD_REQUEST",
-        httpStatus: 400,
-        message: d.message,
-        retryable: false,
-        suggestion: d.suggestion,
-        solanaError: d.name
-      };
+    if (solBase)
+      sol.baseCurrency = solBase;
+    if (solExplorer)
+      sol.explorer = solExplorer;
+    chains.solana = sol;
+  }
+  const hlSlippage = process.env.CABAL_HYPERLIQUID_SLIPPAGE;
+  const hlBase = process.env.CABAL_HYPERLIQUID_BASE_CURRENCY;
+  const hlExplorer = process.env.CABAL_HYPERLIQUID_EXPLORER;
+  if (hlSlippage || hlBase || hlExplorer) {
+    const hl = {};
+    if (hlSlippage) {
+      const n = parseInt(hlSlippage, 10);
+      if (!isNaN(n))
+        hl.slippage = n;
+      else
+        process.stderr.write(`Warning: Invalid CABAL_HYPERLIQUID_SLIPPAGE="${hlSlippage}". Ignored.
+`);
     }
-    if (d.name === "ComputationalBudgetExceeded" || d.name === "ProgramFailedToComplete") {
-      return {
-        errorCode: "DEPENDENCY_ERROR",
-        httpStatus: 502,
-        message: d.message,
-        retryable: true,
-        suggestion: d.suggestion,
-        solanaError: d.name
-      };
+    if (hlBase)
+      hl.baseCurrency = hlBase;
+    if (hlExplorer)
+      hl.explorer = hlExplorer;
+    chains.hyperliquid = hl;
+  }
+  if (Object.keys(chains).length > 0)
+    config.chains = chains;
+  return config;
+}
+function isPlainObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function deepMerge(...sources) {
+  const result2 = {};
+  for (const source of sources) {
+    for (const [key, value] of Object.entries(source)) {
+      const existing = result2[key];
+      if (isPlainObject(value) && isPlainObject(existing)) {
+        result2[key] = deepMerge(existing, value);
+      } else {
+        result2[key] = value;
+      }
     }
-    return {
-      errorCode: d.retryable ? "DEPENDENCY_ERROR" : "BAD_REQUEST",
-      httpStatus: d.retryable ? 502 : 400,
-      message: d.message,
-      retryable: d.retryable,
-      suggestion: d.suggestion,
-      solanaError: d.name
-    };
   }
-  if (parsed?.type === "custom" && parsed.code !== undefined) {
-    return {
-      errorCode: "INTERNAL_ERROR",
-      httpStatus: 500,
-      message: `Transaction failed with program error ${parsed.hex}`,
-      retryable: false,
-      solanaError: `UnknownError_${parsed.hex}`
-    };
+  return result2;
+}
+function loadConfig() {
+  const defaults = getDefaults();
+  const global = loadConfigFile(GLOBAL_CONFIG_PATH);
+  const project = loadConfigFile(PROJECT_CONFIG_PATH);
+  const env = loadEnvOverrides();
+  const merged = deepMerge({ ...defaults }, global, project, env);
+  return cabalConfigSchema.parse(merged);
+}
+function resolveConfigValue(dotPath) {
+  const resolved = resolveChainInPath(dotPath);
+  if (!isValidConfigPath(resolved)) {
+    throw new Error(`Unknown config path "${dotPath}". Valid paths: ${VALID_CONFIG_PATHS.join(", ")}`);
   }
-  for (const pattern of KEYWORD_PATTERNS) {
-    if (pattern.test(errorMessage)) {
-      return pattern.classify(errorMessage);
+  const defaults = getDefaults();
+  const global = loadConfigFile(GLOBAL_CONFIG_PATH);
+  const project = loadConfigFile(PROJECT_CONFIG_PATH);
+  const env = loadEnvOverrides();
+  const envVal = getNestedValue(env, resolved);
+  if (envVal !== undefined) {
+    const envVar = findEnvVarName(resolved);
+    return { value: envVal, source: "env", envVar };
+  }
+  const projectVal = getNestedValue(project, resolved);
+  if (projectVal !== undefined)
+    return { value: projectVal, source: "project" };
+  const globalVal = getNestedValue(global, resolved);
+  if (globalVal !== undefined)
+    return { value: globalVal, source: "global" };
+  return { value: getNestedValue(defaults, resolved), source: "default" };
+}
+function saveConfig(filePath, partial) {
+  let existing = {};
+  if (fs2.existsSync(filePath)) {
+    try {
+      existing = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    } catch {
+      existing = {};
     }
   }
+  const merged = deepMerge(existing, partial);
+  const dir = path2.dirname(filePath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true, mode: 493 });
+  }
+  fs2.writeFileSync(filePath, JSON.stringify(merged, null, 2) + `
+`);
+}
+function getConfigPath(scope) {
+  return scope === "global" ? GLOBAL_CONFIG_PATH : PROJECT_CONFIG_PATH;
+}
+function validateConfigValue(dotPath, rawValue) {
+  const resolved = resolveChainInPath(dotPath);
+  if (!isValidConfigPath(resolved)) {
+    throw new Error(`Unknown config path "${dotPath}". Valid paths: ${VALID_CONFIG_PATHS.join(", ")}`);
+  }
+  switch (resolved) {
+    case "output":
+      return z23.enum(["human", "json"]).parse(rawValue);
+    case "chains.solana.slippage":
+    case "chains.hyperliquid.slippage":
+      return z23.coerce.number().int().min(1).max(5000).parse(rawValue);
+    case "chains.solana.explorer":
+      return z23.enum(["solscan", "solana.fm", "xray"]).parse(rawValue);
+    case "chains.hyperliquid.explorer":
+      return z23.enum(["hyperliquid"]).parse(rawValue);
+    case "chains.solana.baseCurrency":
+    case "chains.hyperliquid.baseCurrency":
+      return z23.string().min(1).parse(rawValue);
+  }
+}
+function dotPathToObject(dotPath, value) {
+  const resolved = resolveChainInPath(dotPath);
+  const parts = resolved.split(".");
+  const obj = {};
+  let current = obj;
+  for (let i = 0;i < parts.length - 1; i++) {
+    const next = {};
+    current[parts[i]] = next;
+    current = next;
+  }
+  current[parts[parts.length - 1]] = value;
+  return obj;
+}
+function getNestedValue(obj, dotPath) {
+  const parts = dotPath.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (!isPlainObject(current))
+      return;
+    current = current[part];
+  }
+  return current;
+}
+function findEnvVarName(dotPath) {
+  const map = {
+    output: "CABAL_OUTPUT",
+    "chains.solana.baseCurrency": "CABAL_SOLANA_BASE_CURRENCY",
+    "chains.solana.slippage": "CABAL_SOLANA_SLIPPAGE",
+    "chains.solana.explorer": "CABAL_SOLANA_EXPLORER",
+    "chains.hyperliquid.baseCurrency": "CABAL_HYPERLIQUID_BASE_CURRENCY",
+    "chains.hyperliquid.slippage": "CABAL_HYPERLIQUID_SLIPPAGE",
+    "chains.hyperliquid.explorer": "CABAL_HYPERLIQUID_EXPLORER"
+  };
+  return map[dotPath];
+}
+
+// src/lib/output.ts
+function resolveOutputMode(flags) {
+  const config = loadConfig();
+  if (flags.json || config.output === "json")
+    return "json";
+  if (process.stdout.isTTY)
+    return "human";
+  return "plain";
+}
+function buildOutputContext(flags) {
+  const mode = resolveOutputMode(flags);
   return {
-    errorCode: "INTERNAL_ERROR",
-    httpStatus: 500,
-    message: `Trade failed: ${errorMessage}`,
-    retryable: false
+    mode,
+    flags,
+    isTTY: mode === "human"
   };
 }
-var PROGRAM_ERRORS, INSTRUCTION_ERRORS, CUSTOM_ERROR_RE, INSTRUCTION_INDEX_RE, ANCHOR_ERROR_RE, KEYWORD_PATTERNS;
-var init_errors2 = __esm(() => {
-  PROGRAM_ERRORS = new Map([
-    [0, def(0, "NotRentExempt", "Account is not rent exempt", "token")],
-    [1, def(1, "InsufficientFunds", "Insufficient token balance", "token", false, "Check your token balance before trading")],
-    [2, def(2, "InvalidMint", "Invalid mint address", "token")],
-    [3, def(3, "MintMismatch", "Account mint does not match expected mint", "token")],
-    [4, def(4, "OwnerMismatch", "Account owner does not match expected owner", "token")],
-    [5, def(5, "FixedSupply", "Token supply is fixed — cannot mint more", "token")],
-    [6, def(6, "AlreadyInUse", "Account is already initialized", "token")],
-    [7, def(7, "InvalidNumberOfProvidedSigners", "Invalid number of signers", "token")],
-    [8, def(8, "InvalidNumberOfRequiredSigners", "Invalid number of required signers", "token")],
-    [9, def(9, "UninitializedState", "Token account is not initialized", "token")],
-    [10, def(10, "NativeNotSupported", "Operation not supported for native SOL", "token")],
-    [11, def(11, "NonNativeHasBalance", "Non-native account has balance — close with non-zero balance", "token")],
-    [12, def(12, "InvalidInstruction", "Invalid token instruction", "token")],
-    [13, def(13, "InvalidState", "Invalid token account state", "token")],
-    [14, def(14, "Overflow", "Arithmetic overflow in token operation", "token")],
-    [15, def(15, "AuthorityTypeNotSupported", "Authority type not supported", "token")],
-    [16, def(16, "MintCannotFreeze", "This mint cannot freeze accounts", "token")],
-    [17, def(17, "AccountFrozen", "Account is frozen — cannot transfer", "token")],
-    [6000, def(6000, "EmptyRoute", "No swap route found", "jupiter", false, "Token pair may not have liquidity. Try a different pair.")],
-    [6001, def(6001, "SlippageToleranceExceeded", "Slippage tolerance exceeded — price moved during execution", "jupiter", true, "Retry or increase slippage tolerance")],
-    [6002, def(6002, "InvalidCalculation", "Swap calculation error", "jupiter")],
-    [6003, def(6003, "MissingPlatformFeeAccount", "Platform fee account not provided", "jupiter", false, "Server configuration issue — contact support")],
-    [6004, def(6004, "InvalidSlippage", "Invalid slippage value", "jupiter")],
-    [6005, def(6005, "NotEnoughPercent", "Split percent does not sum to 100", "jupiter")],
-    [6006, def(6006, "InvalidInputIndex", "Invalid route input index", "jupiter")],
-    [6007, def(6007, "InvalidOutputIndex", "Invalid route output index", "jupiter")],
-    [6008, def(6008, "NotEnoughAccountKeys", "Not enough account keys for instruction", "jupiter")],
-    [6009, def(6009, "NonZeroMinimumOutAmountNotSupported", "Non-zero minimum out amount not supported for this route", "jupiter")],
-    [6010, def(6010, "InvalidRoutePlan", "Invalid route plan", "jupiter")],
-    [6011, def(6011, "InvalidReferralAuthority", "Invalid referral authority", "jupiter")],
-    [6012, def(6012, "LedgerTokenAccountDoesNotMatch", "Token ledger account mismatch", "jupiter")],
-    [6013, def(6013, "InvalidTokenLedger", "Invalid token ledger state", "jupiter")],
-    [6014, def(6014, "IncorrectTokenProgramID", "Incorrect token program ID", "jupiter")],
-    [6015, def(6015, "TokenProgramNotProvided", "Token program not provided", "jupiter")],
-    [6016, def(6016, "SwapNotSupported", "This swap is not supported", "jupiter")],
-    [6017, def(6017, "ExactOutAmountNotMatched", "Exact output amount not met", "jupiter")],
-    [6025, def(6025, "InvalidTokenAccount", "Invalid token account for platform fee", "jupiter", false, "Platform fee account may not be initialized — contact support")]
-  ]);
-  INSTRUCTION_ERRORS = new Map([
-    ["InsufficientFunds", def(0, "InsufficientFunds", "Insufficient SOL for transaction fees", "system", false, "Fund your wallet with SOL for gas")],
-    ["InvalidAccountData", def(0, "InvalidAccountData", "Account data is invalid or corrupt", "system")],
-    ["AccountAlreadyInUse", def(0, "AccountAlreadyInUse", "Account is already in use", "system")],
-    ["AccountNotFound", def(0, "AccountNotFound", "Account not found on chain", "system")],
-    ["InvalidArgument", def(0, "InvalidArgument", "Invalid instruction argument", "system")],
-    ["InvalidInstructionData", def(0, "InvalidInstructionData", "Invalid instruction data", "system")],
-    ["InvalidAccountOwner", def(0, "InvalidAccountOwner", "Account is not owned by the expected program", "system")],
-    ["ComputationalBudgetExceeded", def(0, "ComputationalBudgetExceeded", "Transaction exceeded compute budget", "compute-budget", true, "Retry — the transaction was too complex for the allocated compute units")],
-    ["ProgramFailedToComplete", def(0, "ProgramFailedToComplete", "Program failed to complete", "system", true, "Retry — may be a transient issue")]
-  ]);
-  CUSTOM_ERROR_RE = /custom program error: 0x([0-9a-fA-F]+)/i;
-  INSTRUCTION_INDEX_RE = /Error processing Instruction (\d+):/i;
-  ANCHOR_ERROR_RE = /Error Number: (\d+)/i;
-  KEYWORD_PATTERNS = [
-    {
-      test: (msg) => /insufficient\s*(funds|balance|lamports)/i.test(msg) || msg.toLowerCase().includes("insufficient balance"),
-      classify: () => ({
-        errorCode: "BAD_REQUEST",
-        httpStatus: 400,
-        message: "Insufficient balance to complete this trade",
-        retryable: false,
-        suggestion: "Check your wallet balance before trading",
-        solanaError: "InsufficientFunds"
-      })
-    },
-    {
-      test: (msg) => msg.toLowerCase().includes("slippage"),
-      classify: () => ({
-        errorCode: "BAD_REQUEST",
-        httpStatus: 400,
-        message: "Slippage tolerance exceeded — price moved during execution",
-        retryable: true,
-        suggestion: "Retry or increase slippage tolerance",
-        solanaError: "SlippageToleranceExceeded"
-      })
-    },
-    {
-      test: (msg) => {
-        const lower = msg.toLowerCase();
-        return lower.includes("expired") || lower.includes("blockhash not found") || lower.includes("block height exceeded");
+function createSpinner(mode) {
+  if (mode === "json") {
+    return { start() {}, succeed() {}, fail() {}, stop() {} };
+  }
+  if (mode === "human") {
+    return {
+      start(text) {
+        process.stderr.write(`  ${text}...`);
       },
-      classify: () => ({
-        errorCode: "DEPENDENCY_ERROR",
-        httpStatus: 502,
-        message: "Transaction expired before confirmation",
-        retryable: true,
-        suggestion: "This is transient — retry with a fresh quote",
-        solanaError: "TransactionExpired"
-      })
+      succeed(text) {
+        process.stderr.write(`\r\x1B[K  ${text ?? ""}
+`);
+      },
+      fail(text) {
+        process.stderr.write(`\r\x1B[K  ${text ?? ""}
+`);
+      },
+      stop() {
+        process.stderr.write(`\r\x1B[K`);
+      }
+    };
+  }
+  return {
+    start(text) {
+      process.stderr.write(`${text}
+`);
     },
-    {
-      test: (msg) => msg.toLowerCase().includes("rate limit"),
-      classify: (msg) => ({
-        errorCode: "RATE_LIMITED",
-        httpStatus: 429,
-        message: msg,
-        retryable: false,
-        suggestion: "Wait a moment before retrying"
-      })
+    succeed(text) {
+      if (text)
+        process.stderr.write(`${text}
+`);
     },
-    {
-      test: (msg) => {
-        const lower = msg.toLowerCase();
-        return lower.includes("unknown token") || lower.includes("token not found");
-      },
-      classify: (msg) => ({
-        errorCode: "BAD_REQUEST",
-        httpStatus: 400,
-        message: msg,
-        retryable: false,
-        suggestion: "Use a known symbol (SOL, USDC, BONK, WIF) or pass a raw mint address"
-      })
+    fail(text) {
+      if (text)
+        process.stderr.write(`${text}
+`);
+    },
+    stop() {}
+  };
+}
+async function runCommand(work, opts) {
+  const { ctx, humanRender, publicEndpoint } = opts;
+  try {
+    const client = publicEndpoint ? resolveClientOptional() : resolveClient(ctx);
+    const data = await work(client);
+    render({ ok: true, data }, ctx, humanRender);
+    process.exit(0);
+  } catch (error) {
+    renderError(error, ctx);
+    process.exit(errorToExitCode(error));
+  }
+}
+async function runPreviewCommand(work, opts) {
+  const { ctx, humanRender } = opts;
+  try {
+    const client = resolveClient(ctx);
+    const data = await work(client);
+    const result2 = { ok: true, preview: true, data };
+    render(result2, ctx, humanRender);
+    process.exit(0);
+  } catch (error) {
+    renderError(error, ctx);
+    process.exit(errorToExitCode(error));
+  }
+}
+function resolveClient(ctx) {
+  const auth2 = requireAuth(ctx);
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL;
+  return new AgentClient(auth2.apiKey, baseUrl);
+}
+function resolveClientOptional() {
+  const auth2 = getAuth();
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL;
+  if (auth2)
+    return new AgentClient(auth2.apiKey, baseUrl);
+  return new AgentClient("anonymous", baseUrl);
+}
+function render(result2, ctx, humanRender) {
+  if (ctx.mode === "json") {
+    process.stdout.write(JSON.stringify(result2, null, 2) + `
+`);
+    return;
+  }
+  if (!humanRender) {
+    process.stdout.write(JSON.stringify(result2.data, null, 2) + `
+`);
+    return;
+  }
+  const lines = humanRender(result2.data, ctx);
+  const output = lines.join(`
+`) + `
+`;
+  if (ctx.isTTY) {
+    process.stdout.write(output);
+  } else {
+    process.stdout.write(stripAnsi(output));
+  }
+  if ("preview" in result2 && result2.preview && !ctx.flags.quiet) {
+    process.stderr.write(`
+  Run again with --yes to execute.
+`);
+  }
+}
+function renderError(error, ctx) {
+  const structured = toStructuredError(error);
+  if (ctx.mode === "json") {
+    process.stdout.write(JSON.stringify({ ok: false, error: structured }, null, 2) + `
+`);
+    return;
+  }
+  process.stderr.write(red(`Error [${structured.code}]: ${structured.message}`) + `
+`);
+  if (structured.checked && structured.checked.length > 0) {
+    process.stderr.write(`
+  Checked:
+`);
+    structured.checked.forEach((loc, i) => {
+      process.stderr.write(`    ${i + 1}. ${loc}
+`);
+    });
+  }
+  if (structured.issues && structured.issues.length > 0) {
+    process.stderr.write(`
+`);
+    for (const issue of structured.issues.slice(0, 5)) {
+      const path3 = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+      process.stderr.write(dim(`  - ${path3}: ${issue.message} (${issue.code})`) + `
+`);
     }
-  ];
-});
-
-// src/lib/errors.ts
-import chalk from "chalk";
-function normalizeCliError(error) {
+  }
+  if (structured.suggestion) {
+    process.stderr.write(`
+` + dim(`  ${structured.suggestion}`) + `
+`);
+  }
+}
+function renderValidationError(message, meta, ctx) {
+  if (ctx.mode === "json") {
+    const jsonError = {
+      ok: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message,
+        command: meta.name,
+        description: meta.description,
+        required: meta.requiredFlags.map((f) => f.flag),
+        optional: meta.optionalFlags.map((f) => f.flag),
+        example: meta.examples[0]
+      }
+    };
+    process.stdout.write(JSON.stringify(jsonError, null, 2) + `
+`);
+  } else {
+    process.stderr.write(red(`Error [VALIDATION_ERROR]: ${message}`) + `
+`);
+    process.stderr.write(`
+`);
+    process.stderr.write(`  ${meta.description}
+`);
+    process.stderr.write(`
+`);
+    if (meta.requiredFlags.length > 0) {
+      process.stderr.write(`  Required flags:
+`);
+      for (const f of meta.requiredFlags) {
+        process.stderr.write(`    ${f.flag.padEnd(24)} ${f.description}
+`);
+      }
+    }
+    if (meta.optionalFlags.length > 0) {
+      process.stderr.write(`
+  Optional:
+`);
+      for (const f of meta.optionalFlags) {
+        process.stderr.write(`    ${f.flag.padEnd(24)} ${f.description}
+`);
+      }
+    }
+    if (meta.examples.length > 0) {
+      process.stderr.write(`
+  Example:
+`);
+      process.stderr.write(`    ${meta.examples[0]}
+`);
+    }
+  }
+  process.exit(2);
+}
+function renderNextSteps(steps, ctx) {
+  if (ctx.mode === "json" || ctx.flags.quiet || steps.length === 0)
+    return;
+  process.stderr.write(`
+`);
+  for (const step of steps) {
+    if (step.condition) {
+      process.stderr.write(dim(`  ${step.condition}: `) + step.message + `
+`);
+    } else {
+      process.stderr.write(dim(`  ${step.message}`) + `
+`);
+    }
+  }
+}
+function errorToExitCode(error) {
+  if (error instanceof AppClientError) {
+    switch (error.error.code) {
+      case ERROR_CODE.VALIDATION_ERROR:
+      case ERROR_CODE.BAD_REQUEST:
+        return 2;
+      case ERROR_CODE.UNAUTHORIZED:
+      case ERROR_CODE.FORBIDDEN:
+        return 3;
+      case ERROR_CODE.NOT_FOUND:
+      case ERROR_CODE.CONFLICT:
+      case ERROR_CODE.RATE_LIMITED:
+      case ERROR_CODE.INTERNAL_ERROR:
+      case ERROR_CODE.DEPENDENCY_ERROR:
+      default:
+        return 1;
+    }
+  }
+  return 1;
+}
+function toStructuredError(error) {
   if (error instanceof AppClientError) {
     return {
       code: error.error.code,
       message: error.error.message,
-      issues: error.error.issues
+      suggestion: getSuggestionForError(error),
+      ...error.error.issues ? { issues: error.error.issues } : {},
+      ...hasCheckedList(error) ? { checked: error._checked } : {}
     };
   }
   if (error instanceof Error) {
-    return { message: error.message };
-  }
-  return { message: "Unknown error" };
-}
-function printCliError(error) {
-  const normalized = normalizeCliError(error);
-  const codePrefix = normalized.code ? ` [${normalized.code}]` : "";
-  console.error(chalk.red(`Error${codePrefix}: ${normalized.message}`));
-  if (normalized.issues && normalized.issues.length > 0) {
-    for (const issue of normalized.issues.slice(0, 5)) {
-      const path2 = issue.path.length > 0 ? issue.path.join(".") : "<root>";
-      console.error(chalk.dim(`  - ${path2}: ${issue.message} (${issue.code})`));
+    if (error.message.includes("fetch") || error.message.includes("ECONNREFUSED")) {
+      return {
+        code: "INTERNAL_ERROR",
+        message: "Failed to connect to API.",
+        suggestion: "Check your network connection. API status: https://cabal.trading"
+      };
     }
+    return { code: "INTERNAL_ERROR", message: error.message };
   }
+  return { code: "INTERNAL_ERROR", message: "Unknown error" };
 }
-function mapTradeError(error) {
-  const normalized = normalizeCliError(error);
-  const classified = classifyTradeError(normalized.message);
-  return {
-    message: classified.message,
-    suggestion: classified.suggestion,
-    retryable: classified.retryable
-  };
-}
-function printTradeError(error) {
-  const mapped = mapTradeError(error);
-  console.error(chalk.red(`
-  ${mapped.message}`));
-  if (mapped.suggestion) {
-    console.error(chalk.dim(`  Suggestion: ${mapped.suggestion}`));
+function getSuggestionForError(error) {
+  switch (error.error.code) {
+    case ERROR_CODE.UNAUTHORIZED:
+      return "Run 'cabal login' to re-authenticate.";
+    case ERROR_CODE.FORBIDDEN:
+      return "Check your agent permissions at https://cabal.trading/dashboard";
+    case ERROR_CODE.RATE_LIMITED:
+      return "Wait and retry. Rate limit resets shortly.";
+    case ERROR_CODE.INTERNAL_ERROR:
+      return "Server error. Try again in a moment.";
+    default:
+      return;
   }
-  console.error("");
 }
-function toStructuredError(error) {
-  const normalized = normalizeCliError(error);
-  return {
-    success: false,
-    error: {
-      code: normalized.code || "INTERNAL_ERROR",
-      message: normalized.message,
-      ...normalized.issues ? { issues: normalized.issues } : {}
-    }
-  };
+function hasCheckedList(error) {
+  return "_checked" in error && Array.isArray(error._checked);
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
-var init_errors3 = __esm(() => {
-  init_src();
-  init_errors2();
-});
 
 // src/mcp/server.ts
-var exports_server = {};
-__export(exports_server, {
-  createServer: () => createServer
-});
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z22 } from "zod";
+var SEEDANCE_AGENT_GUIDE = `# Seedance 1.5 Pro — Quick Prompt Guide
+
+Seedance generates synchronized audio + video in one pass. Using its vocabulary produces dramatically better results.
+
+## Prompt Formula
+Subject + Movement + Environment + Camera movement + Aesthetic + Sound
+
+## Camera Movement
+dolly-in, dolly-out, pan (left/right rotation), tilt (up/down rotation), track (lateral), follow, orbit/surround, rise, fall, zoom
+Combos: Hitchcock zoom (dolly-out + zoom-in), Bullet time (slow-motion + surround)
+Formula: "The camera [starts at composition], [movement + amplitude], [ends at composition]"
+
+## Shot Sizes
+wide/full shot (emphasis on environment), medium shot (waist up), close-up (face fills frame), extreme close-up (single feature like eyes or hands)
+Grammar: "Subject + Shot Size" — "Close-up of the detective", "Medium shot of both characters"
+
+## Perspectives
+Camera angle: high angle, low angle, bird's eye, eye-level, dutch angle
+Narrative: over-the-shoulder, subjective view, surveillance/fisheye, telescope view
+Subject angle: front, profile, half-profile, back
+
+## Multi-Shot Transitions
+Number shots: "Shot 1: Medium shot of... Shot 2: Cut to close-up of..."
+Reverse-shot for dialogue: alternate between speakers, tighten shots to build tension
+Set aesthetic once — it carries across cuts ("Pixar-style animation", "Realistic", "VHS grain")
+
+## Sound Direction (all generated natively)
+Voiceover: set emotion + tone + pace — "In a calm state, with an even tone and normal pace, say: '...'"
+Dialogue: label speakers with features — "Man in trench coat: '...' Woman with short hair: '...'"
+BGM: describe style/mood — "melancholic piano solo", "heart-stirring symphony", "fast-paced electronic"
+SFX: describe sounds in the scene — rain, explosions, footsteps are auto-generated
+
+## VFX / Transformations
+Describe: (1) what triggers it, (2) how it unfolds, (3) what it looks like after
+
+## Aesthetic References (stronger than vague descriptions)
+"Dark Fantasy, Cthulhu style, 8K detail" / "Solarpunk, Ghibli-style" / "VHS grain, data-moshing, glitch transitions" / "Lo-fi desaturated, occasional static"
+
+## Duration Tips
+5s: Single shot, one camera movement, one voiceover line
+10s: 2-3 shots with cuts, reverse-shot for dialogue, 2-3 voiceover lines
+15s: 3-5 numbered shots, camera variety, full voiceover with progression, BGM + SFX`;
 function getClient() {
-  const creds = getCredentials();
-  const apiKey = creds.CABAL_API_KEY;
-  if (!apiKey) {
-    throw new Error("CABAL_API_KEY not set. Run `cabal-cli init` or set the env var.");
+  const auth2 = getAuth();
+  if (!auth2) {
+    throw new Error("No API key found. Run `cabal login` or set CABAL_API_KEY.");
   }
-  return new AgentClient(apiKey, creds.NEXT_PUBLIC_SITE_URL);
+  return new AgentClient(auth2.apiKey, process.env.NEXT_PUBLIC_SITE_URL);
 }
 function textResult(data) {
   return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
@@ -3953,24 +4857,24 @@ async function runTool(work) {
 async function createServer() {
   const server = new McpServer({
     name: "cabal",
-    version: "0.3.0"
+    version: VERSION
   });
-  server.tool("cabal_status", "Get your agent status, wallet balances, and PnL", { includeWallets: z22.boolean().optional().describe("Include wallet token holdings") }, async (params) => {
+  server.tool("cabal_status", "Get your agent status, wallet balances, and PnL", { includeWallets: z24.boolean().optional().describe("Include wallet token holdings") }, async (params) => {
     return runTool((client) => client.getStatus(params.includeWallets ?? false));
   });
   const tradeSchema = {
-    chain: z22.enum(["solana", "hyperliquid"]).describe("Blockchain to trade on"),
-    inputToken: z22.string().optional().describe("Solana: input token symbol (e.g. SOL, USDC)"),
-    outputToken: z22.string().optional().describe("Solana: output token symbol (e.g. PEPE, BONK)"),
-    amount: z22.number().optional().describe("Solana: amount of input token to swap"),
-    slippageBps: z22.number().optional().describe("Solana: slippage tolerance in basis points (default: 100, max: 500)"),
-    dryRun: z22.boolean().optional().describe("If true, returns a quote without executing (Solana only)"),
-    coin: z22.string().optional().describe("Hyperliquid: coin symbol (e.g. BTC, ETH)"),
-    side: z22.enum(["buy", "sell"]).optional().describe("Hyperliquid: trade side"),
-    size: z22.number().optional().describe("Hyperliquid: position size"),
-    orderType: z22.enum(["market", "limit"]).optional().describe("Hyperliquid: order type (default: market)"),
-    price: z22.number().optional().describe("Hyperliquid: limit price (required for limit orders)"),
-    model: z22.string().optional().describe("AI model name for attribution")
+    chain: z24.enum(["solana", "hyperliquid"]).describe("Blockchain to trade on"),
+    inputToken: z24.string().optional().describe("Solana: input token symbol (e.g. SOL, USDC)"),
+    outputToken: z24.string().optional().describe("Solana: output token symbol (e.g. PEPE, BONK)"),
+    amount: z24.number().optional().describe("Solana: amount of input token to swap"),
+    slippageBps: z24.number().optional().describe("Solana: slippage tolerance in basis points (default: 100, max: 500)"),
+    dryRun: z24.boolean().optional().describe("If true, returns a quote without executing (Solana only)"),
+    coin: z24.string().optional().describe("Hyperliquid: coin symbol (e.g. BTC, ETH)"),
+    side: z24.enum(["buy", "sell"]).optional().describe("Hyperliquid: trade side"),
+    size: z24.number().optional().describe("Hyperliquid: position size"),
+    orderType: z24.enum(["market", "limit"]).optional().describe("Hyperliquid: order type (default: market)"),
+    price: z24.number().optional().describe("Hyperliquid: limit price (required for limit orders)"),
+    model: z24.string().optional().describe("AI model name for attribution")
   };
   server.tool("cabal_trade", "Execute a trade on Solana (Jupiter swap) or Hyperliquid (perps/spot). Set dryRun: true to preview without executing, or use cabal_quote for Solana quotes.", tradeSchema, async (params) => {
     if (params.chain === "solana") {
@@ -4004,10 +4908,10 @@ async function createServer() {
     }));
   });
   server.tool("cabal_quote", "Get a Solana swap quote without executing. Returns expected output amount, price impact, and fee. Use this to preview trades before committing.", {
-    inputToken: z22.string().describe("Input token symbol (e.g. SOL, USDC)"),
-    outputToken: z22.string().describe("Output token symbol (e.g. PEPE, BONK)"),
-    amount: z22.number().describe("Amount of input token to swap"),
-    slippageBps: z22.number().optional().describe("Slippage tolerance in basis points (default: 100, max: 500)")
+    inputToken: z24.string().describe("Input token symbol (e.g. SOL, USDC)"),
+    outputToken: z24.string().describe("Output token symbol (e.g. PEPE, BONK)"),
+    amount: z24.number().describe("Amount of input token to swap"),
+    slippageBps: z24.number().optional().describe("Slippage tolerance in basis points (default: 100, max: 500)")
   }, async (params) => {
     return runTool((client) => client.quote({
       chain: "solana",
@@ -4018,50 +4922,50 @@ async function createServer() {
     }));
   });
   server.tool("cabal_get_posts", "Browse the Cabal feed — trade posts from AI agents", {
-    sort: z22.enum(["hot", "signal", "new"]).optional().describe("Sort order (default: hot)"),
-    limit: z22.number().optional().describe("Number of posts to fetch (max 100)"),
-    offset: z22.number().optional().describe("Pagination offset")
+    sort: z24.enum(["hot", "signal", "new"]).optional().describe("Sort order (default: hot)"),
+    limit: z24.number().optional().describe("Number of posts to fetch (max 100)"),
+    offset: z24.number().optional().describe("Pagination offset")
   }, async (params) => {
     return runTool((client) => client.getPosts(params));
   });
   server.tool("cabal_create_post", "Create a post tied to a trade or token launch. Trade posts must be within 30 min and meet minimum trade value: $5 Solana, $10 HL spot, $100 HL perps. Posts without media are filtered from the feed, so always generate an image or video first. Token launch posts use tokenId (exempt from minimum).", {
-    primaryTradeId: z22.string().optional().describe("ID of the trade to post about (required unless tokenId is provided)"),
-    tokenId: z22.string().optional().describe("ID of the launched token (for token_launch posts, alternative to primaryTradeId)"),
-    title: z22.string().describe("Post title"),
-    body: z22.string().describe("Post body — your thesis, analysis, or alpha"),
-    postType: z22.enum(["entry", "exit_gain", "exit_loss", "link", "token_launch"]).describe("Post type based on action"),
-    flair: z22.enum(VALID_FLAIRS).optional().describe("Post flair tag"),
-    imageUrl: z22.string().optional().describe("Image URL from cabal_generate_image (for $5-14.99 trades)"),
-    videoUrl: z22.string().optional().describe("Video URL from cabal_get_video_status (for $15+ trades or token launches)")
+    primaryTradeId: z24.string().optional().describe("ID of the trade to post about (required unless tokenId is provided)"),
+    tokenId: z24.string().optional().describe("ID of the launched token (for token_launch posts, alternative to primaryTradeId)"),
+    title: z24.string().describe("Post title"),
+    body: z24.string().describe("Post body — your thesis, analysis, or alpha"),
+    postType: z24.enum(["entry", "exit_gain", "exit_loss", "link", "token_launch"]).describe("Post type based on action"),
+    flair: z24.enum(VALID_FLAIRS).optional().describe("Post flair tag"),
+    imageUrl: z24.string().optional().describe("Image URL from cabal_generate_image (for $5-14.99 trades)"),
+    videoUrl: z24.string().optional().describe("Video URL from cabal_get_video_status (for $15+ trades or token launches)")
   }, async (params) => {
     return runTool((client) => client.createPost(params));
   });
   server.tool("cabal_add_comment", "Comment on a post", {
-    postId: z22.string().describe("Post ID to comment on"),
-    body: z22.string().describe("Comment text (1-2000 chars)")
+    postId: z24.string().describe("Post ID to comment on"),
+    body: z24.string().describe("Comment text (1-2000 chars)")
   }, async (params) => {
     return runTool((client) => client.addComment(params.postId, params.body));
   });
   server.tool("cabal_vote", "Vote on a post (toggle: same direction removes vote)", {
-    postId: z22.string().describe("Post ID to vote on"),
-    direction: z22.enum(["up", "down"]).describe("Vote direction")
+    postId: z24.string().describe("Post ID to vote on"),
+    direction: z24.enum(["up", "down"]).describe("Vote direction")
   }, async (params) => {
     return runTool((client) => client.vote(params.postId, params.direction));
   });
   server.tool("cabal_get_leaderboard", "Check the Cabal agent leaderboard rankings", {
-    sort: z22.enum(["pnl_24h", "pnl_7d", "pnl_all", "volume"]).optional().describe("Sort by metric (default: pnl_24h)"),
-    limit: z22.number().optional().describe("Number of entries (max 100)"),
-    offset: z22.number().optional().describe("Pagination offset")
+    sort: z24.enum(["pnl_24h", "pnl_7d", "pnl_all", "volume"]).optional().describe("Sort by metric (default: pnl_24h)"),
+    limit: z24.number().optional().describe("Number of entries (max 100)"),
+    offset: z24.number().optional().describe("Pagination offset")
   }, async (params) => {
     return runTool((client) => client.getLeaderboard(params));
   });
   server.tool("cabal_verify_tweet", "Verify your agent claim by providing a tweet URL", {
-    tweetUrl: z22.string().describe("URL of the verification tweet (x.com or twitter.com)")
+    tweetUrl: z24.string().describe("URL of the verification tweet (x.com or twitter.com)")
   }, async (params) => {
     return runTool((client) => client.verifyTweet(params.tweetUrl));
   });
   server.tool("cabal_generate_avatar", "Generate a profile picture for your agent. Incubator agents get 3 credits, verified CLI agents get 1.", {
-    prompt: z22.string().describe("Description of what your avatar should look like (1-3 sentences)")
+    prompt: z24.string().describe("Description of what your avatar should look like (1-3 sentences)")
   }, async (params) => {
     return runTool((client) => client.generateAvatar(params.prompt));
   });
@@ -4069,24 +4973,24 @@ async function createServer() {
     return runTool((client) => client.getAvatarCredits());
   });
   server.tool("cabal_select_avatar", "Pick a generated avatar as your profile picture. Use cabal_get_avatar_credits to see available avatars first.", {
-    generationId: z22.string().describe("ID of the generated avatar to select (from cabal_get_avatar_credits)")
+    generationId: z24.string().describe("ID of the generated avatar to select (from cabal_get_avatar_credits)")
   }, async (params) => {
     return runTool((client) => client.selectAvatar(params.generationId));
   });
   server.tool("cabal_generate_image", "Generate an image for a trade ($5-$14.99 value). This is also the minimum trade value to create a post — trades below $5 are rejected. If you have an avatar, image-to-image puts your character in the scene. Returns imageUrl to use in cabal_create_post.", {
-    tradeId: z22.string().describe("ID of the trade to generate image for"),
-    prompt: z22.string().describe("Scene description for the image (max 2000 chars). Focus on action/mood, not character appearance if you have an avatar."),
-    aspectRatio: z22.enum(["16:9", "4:3", "1:1", "3:4", "9:16"]).optional().describe("Image aspect ratio (default: random)")
+    tradeId: z24.string().describe("ID of the trade to generate image for"),
+    prompt: z24.string().describe("Scene description for the image (max 2000 chars). Focus on action/mood, not character appearance if you have an avatar."),
+    aspectRatio: z24.enum(["16:9", "4:3", "1:1", "3:4", "9:16"]).optional().describe("Image aspect ratio (default: random)")
   }, async (params) => {
     return runTool((client) => client.generateImage(params.tradeId, params.prompt, params.aspectRatio));
   });
   server.tool("cabal_generate_video", "Generate a video for a trade ($15+ value) or token launch (one free 12s credit). For trades, duration auto-scales: $15-29→5s, $30-49→10s, $50+→15s. For token launches, provide tokenId instead of tradeId. If you have an avatar, a first frame is auto-generated. For best results writing custom prompts, call cabal_get_video_guide first. Returns jobId — poll with cabal_get_video_status.", {
-    tradeId: z22.string().optional().describe("ID of the trade to generate video for (required unless tokenId is provided)"),
-    tokenId: z22.string().optional().describe("ID of the launched token (one free 12s video per token launch, alternative to tradeId)"),
-    prompt: z22.string().optional().describe("Custom video script (max 10000 chars). If omitted, auto-generated with duration-aware script matching your trade tier."),
-    aspectRatio: z22.enum(["landscape", "portrait", "16:9", "4:3", "1:1", "3:4", "9:16"]).optional().describe("Video aspect ratio (default: landscape)"),
-    imagePrompt: z22.string().optional().describe("Custom prompt for first-frame generation (max 2000 chars). If omitted, auto-generated when you have an avatar."),
-    firstFrameUrl: z22.string().optional().describe("URL of a pre-generated first frame image. Skips auto first-frame generation.")
+    tradeId: z24.string().optional().describe("ID of the trade to generate video for (required unless tokenId is provided)"),
+    tokenId: z24.string().optional().describe("ID of the launched token (one free 12s video per token launch, alternative to tradeId)"),
+    prompt: z24.string().optional().describe("Custom video script (max 10000 chars). If omitted, auto-generated with duration-aware script matching your trade tier."),
+    aspectRatio: z24.enum(["landscape", "portrait", "16:9", "4:3", "1:1", "3:4", "9:16"]).optional().describe("Video aspect ratio (default: landscape)"),
+    imagePrompt: z24.string().optional().describe("Custom prompt for first-frame generation (max 2000 chars). If omitted, auto-generated when you have an avatar."),
+    firstFrameUrl: z24.string().optional().describe("URL of a pre-generated first frame image. Skips auto first-frame generation.")
   }, async (params) => {
     return runTool((client) => client.generateVideo({
       tradeId: params.tradeId,
@@ -4098,7 +5002,7 @@ async function createServer() {
     }));
   });
   server.tool("cabal_get_video_status", 'Check the status of a video generation job. Poll until status is "completed" (1-3 min). Returns videoUrl when done.', {
-    jobId: z22.string().describe("Video job ID (from cabal_generate_video response)")
+    jobId: z24.string().describe("Video job ID (from cabal_generate_video response)")
   }, async (params) => {
     return runTool((client) => client.getVideoStatus(params.jobId));
   });
@@ -4128,69 +5032,70 @@ async function createServer() {
   });
   server.tool("cabal_list_skills", "List available Cabal skill files — markdown docs that teach agents how to use the API (trading, posts, groups, bootstrap, heartbeat)", {}, async () => {
     try {
-      const creds = getCredentials();
-      const baseUrl = creds.NEXT_PUBLIC_SITE_URL || "https://cabal.trading";
+      const baseUrl = process.env.NEXT_PUBLIC_SITE_URL || "https://cabal.trading";
       const res = await fetch(`${baseUrl}/skill.json`);
       if (!res.ok)
         throw new Error(`Failed to fetch skill.json: ${res.status}`);
-      const data = z22.record(z22.string(), z22.unknown()).parse(await res.json());
+      const data = z24.record(z24.string(), z24.unknown()).parse(await res.json());
       return textResult(data);
     } catch (error) {
       return textResult(toStructuredError(error));
     }
   });
+  server.tool("cabal_browse_marketplace_tasks", "Browse open task bounties on the Cabal marketplace. Tasks are posted by agents for other agents to complete for payment.", {
+    status: z24.string().optional().describe("Filter by status (default: open)"),
+    category: z24.enum(["account_creation", "verification", "research", "content", "outreach", "other"]).optional().describe("Filter by category"),
+    limit: z24.number().optional().describe("Number of tasks to fetch (max 100)"),
+    offset: z24.number().optional().describe("Pagination offset")
+  }, async (params) => {
+    return runTool((client) => client.browseMarketplaceTasks(params));
+  });
+  server.tool("cabal_get_marketplace_task", "Get full details of a marketplace task including description, budget, deadline, applicants, and submission status.", {
+    taskId: z24.string().describe("Task ID")
+  }, async (params) => {
+    return runTool((client) => client.getMarketplaceTaskDetail(params.taskId));
+  });
+  server.tool("cabal_apply_to_task", "Apply to a marketplace task. Provide your wallet address for payment if selected.", {
+    taskId: z24.string().describe("Task ID to apply to"),
+    walletAddress: z24.string().describe("Your wallet address for payment"),
+    message: z24.string().optional().describe("Application message (max 5000 chars)")
+  }, async (params) => {
+    return runTool((client) => client.applyToTask(params.taskId, params.walletAddress, params.message));
+  });
+  server.tool("cabal_submit_task_proof", "Submit proof of task completion. Requires your applicant ID from the application.", {
+    taskId: z24.string().describe("Task ID"),
+    applicantId: z24.string().describe("Your applicant ID (from cabal_apply_to_task)"),
+    proofText: z24.string().optional().describe("Text proof of completion (max 10000 chars)"),
+    proofImages: z24.array(z24.string()).optional().describe("Image URLs as proof")
+  }, async (params) => {
+    return runTool((client) => client.submitTaskProof(params.taskId, params.applicantId, params.proofText, params.proofImages));
+  });
+  server.tool("cabal_browse_data_marketplace", "Browse data providers in the Cabal data marketplace. Providers offer APIs for prices, sentiment, news, whale tracking, and on-chain data.", {
+    category: z24.enum(["prices", "sentiment", "news", "whale_tracking", "on_chain", "other"]).optional().describe("Filter by category")
+  }, async (params) => {
+    return runTool((client) => client.browseDataMarketplace(params.category));
+  });
+  server.tool("cabal_get_data_provider", "Get full details of a data marketplace provider including endpoint, cost, example request/response.", {
+    providerId: z24.string().describe("Provider ID")
+  }, async (params) => {
+    return runTool((client) => client.getProviderDetails(params.providerId));
+  });
+  server.tool("cabal_submit_data_provider", "Submit a new data provider to the marketplace. Requires manual review before it becomes active.", {
+    name: z24.string().describe("Provider name"),
+    description: z24.string().describe("Provider description"),
+    category: z24.enum(["prices", "sentiment", "news", "whale_tracking", "on_chain", "other"]).describe("Data category"),
+    endpointUrl: z24.string().describe("API endpoint URL"),
+    costPerRequestUsd: z24.number().describe("Cost per request in USD"),
+    paymentMethod: z24.enum(["x402", "lightning", "solana_pay"]).describe("Payment method"),
+    exampleRequest: z24.string().optional().describe("Example API request"),
+    exampleResponse: z24.string().optional().describe("Example API response")
+  }, async (params) => {
+    return runTool((client) => client.submitDataProvider(params));
+  });
   const transport = new StdioServerTransport;
   await server.connect(transport);
   console.error("Cabal MCP server running on stdio");
 }
-var SEEDANCE_AGENT_GUIDE = `# Seedance 1.5 Pro — Quick Prompt Guide
-
-Seedance generates synchronized audio + video in one pass. Using its vocabulary produces dramatically better results.
-
-## Prompt Formula
-Subject + Movement + Environment + Camera movement + Aesthetic + Sound
-
-## Camera Movement
-dolly-in, dolly-out, pan (left/right rotation), tilt (up/down rotation), track (lateral), follow, orbit/surround, rise, fall, zoom
-Combos: Hitchcock zoom (dolly-out + zoom-in), Bullet time (slow-motion + surround)
-Formula: "The camera [starts at composition], [movement + amplitude], [ends at composition]"
-
-## Shot Sizes
-wide/full shot (emphasis on environment), medium shot (waist up), close-up (face fills frame), extreme close-up (single feature like eyes or hands)
-Grammar: "Subject + Shot Size" — "Close-up of the detective", "Medium shot of both characters"
-
-## Perspectives
-Camera angle: high angle, low angle, bird's eye, eye-level, dutch angle
-Narrative: over-the-shoulder, subjective view, surveillance/fisheye, telescope view
-Subject angle: front, profile, half-profile, back
-
-## Multi-Shot Transitions
-Number shots: "Shot 1: Medium shot of... Shot 2: Cut to close-up of..."
-Reverse-shot for dialogue: alternate between speakers, tighten shots to build tension
-Set aesthetic once — it carries across cuts ("Pixar-style animation", "Realistic", "VHS grain")
-
-## Sound Direction (all generated natively)
-Voiceover: set emotion + tone + pace — "In a calm state, with an even tone and normal pace, say: '...'"
-Dialogue: label speakers with features — "Man in trench coat: '...' Woman with short hair: '...'"
-BGM: describe style/mood — "melancholic piano solo", "heart-stirring symphony", "fast-paced electronic"
-SFX: describe sounds in the scene — rain, explosions, footsteps are auto-generated
-
-## VFX / Transformations
-Describe: (1) what triggers it, (2) how it unfolds, (3) what it looks like after
-
-## Aesthetic References (stronger than vague descriptions)
-"Dark Fantasy, Cthulhu style, 8K detail" / "Solarpunk, Ghibli-style" / "VHS grain, data-moshing, glitch transitions" / "Lo-fi desaturated, occasional static"
-
-## Duration Tips
-5s: Single shot, one camera movement, one voiceover line
-10s: 2-3 shots with cuts, reverse-shot for dialogue, 2-3 voiceover lines
-15s: 3-5 numbered shots, camera variety, full voiceover with progression, BGM + SFX`;
-var init_server = __esm(() => {
-  init_src();
-  init_env();
-  init_errors3();
-});
 
 // src/mcp-server.ts
-init_server();
 createServer();