skedyul 1.7.30 → 1.7.31

package/dist/cli/index.js

@@ -3646,6 +3646,14 @@ var AppAuthInvalidError = class extends Error {
     this.name = "AppAuthInvalidError";
   }
 };
+var TokenRefreshRequiredError = class extends Error {
+  constructor(message = "Access token expired", options) {
+    super(message);
+    this.code = "TOKEN_REFRESH_REQUIRED";
+    this.name = "TokenRefreshRequiredError";
+    this.tokenKey = options?.tokenKey;
+  }
+};
 
 // src/ratelimit/errors.ts
 var RateLimitExceededError = class extends Error {
@@ -3961,6 +3969,24 @@ function createCallToolHandler(registry, state, onMaxRequests) {
           }
         };
       }
+      if (error instanceof TokenRefreshRequiredError) {
+        return {
+          success: false,
+          output: null,
+          billing: { credits: 0 },
+          meta: {
+            success: false,
+            message: error.message,
+            toolName
+          },
+          error: {
+            code: error.code,
+            message: error.message,
+            category: "auth",
+            ...error.tokenKey ? { details: { tokenKey: error.tokenKey } } : {}
+          }
+        };
+      }
       if (error instanceof AppAuthInvalidError) {
         return {
           output: null,
@@ -4714,6 +4740,76 @@ async function handleOAuthCallback(parsedBody, hooks) {
   }
 }
 
+// src/server/handlers/refresh-token-handler.ts
+async function handleRefreshToken(parsedBody, hooks) {
+  if (!hooks?.refresh_token) {
+    return {
+      status: 404,
+      body: { error: "Refresh token handler not configured" }
+    };
+  }
+  const body = parsedBody ?? {};
+  if (!body.env || typeof body.env !== "object" || Array.isArray(body.env)) {
+    return {
+      status: 400,
+      body: {
+        error: {
+          code: -32602,
+          message: "Missing envelope format: expected { env }"
+        }
+      }
+    };
+  }
+  const refreshContext = {
+    env: body.env,
+    invocation: body.invocation,
+    log: createContextLogger()
+  };
+  const requestConfig = {
+    baseUrl: body.env.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+    apiToken: body.env.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+  };
+  try {
+    const refreshHook = hooks.refresh_token;
+    const refreshHandler = typeof refreshHook === "function" ? refreshHook : refreshHook.handler;
+    const result = await withRequestEnv(body.env, async () => {
+      return await runWithConfig(requestConfig, async () => {
+        return await runWithLogContext({ invocation: body.invocation }, async () => {
+          return await refreshHandler(refreshContext);
+        });
+      });
+    });
+    return {
+      status: 200,
+      body: {
+        env: result.env ?? {}
+      }
+    };
+  } catch (err) {
+    if (err instanceof AppAuthInvalidError) {
+      return {
+        status: 401,
+        body: {
+          error: {
+            code: err.code,
+            message: err.message
+          }
+        }
+      };
+    }
+    const errorMessage = err instanceof Error ? err.message : String(err ?? "Unknown error");
+    return {
+      status: 500,
+      body: {
+        error: {
+          code: -32603,
+          message: errorMessage
+        }
+      }
+    };
+  }
+}
+
 // src/types/webhook.ts
 function isRuntimeWebhookContext(ctx) {
   return "appInstallationId" in ctx && ctx.appInstallationId !== void 0;
@@ -4817,6 +4913,33 @@ async function executeWebhookHandler(handle, webhookRegistry, data) {
       });
     });
   } catch (err) {
+    if (err instanceof TokenRefreshRequiredError) {
+      return {
+        status: 200,
+        body: {
+          success: false,
+          error: {
+            code: err.code,
+            message: err.message,
+            category: "auth",
+            ...err.tokenKey ? { details: { tokenKey: err.tokenKey } } : {}
+          }
+        }
+      };
+    }
+    if (err instanceof AppAuthInvalidError) {
+      return {
+        status: 200,
+        body: {
+          success: false,
+          error: {
+            code: err.code,
+            message: err.message,
+            category: "auth"
+          }
+        }
+      };
+    }
     console.error(`Webhook handler '${handle}' error:`, err);
     return {
       status: 500,
@@ -5019,6 +5142,14 @@ async function handleOAuthCallbackRoute(req, ctx) {
   const result = await handleOAuthCallback(parseResult.data, ctx.config.hooks);
   return { status: result.status, body: result.body };
 }
+async function handleRefreshTokenRoute(req, ctx) {
+  const parseResult = parseJsonBody(req);
+  if (!parseResult.success) {
+    return parseResult.error;
+  }
+  const result = await handleRefreshToken(parseResult.data, ctx.config.hooks);
+  return { status: result.status, body: result.body };
+}
 async function handleWebhookRoute(req, handle, ctx) {
   if (!ctx.webhookRegistry) {
     return { status: 404, body: { error: `Webhook handler '${handle}' not found` } };
@@ -5510,6 +5641,21 @@ async function handleBatchOperationRoute(req, ctx) {
         { allowed: true, afterMs: err.retryAfterMs }
       );
     }
+    if (err instanceof TokenRefreshRequiredError) {
+      return softFailureResponse({
+        code: err.code,
+        message: err.message,
+        category: "auth",
+        ...err.tokenKey ? { details: { tokenKey: err.tokenKey } } : {}
+      });
+    }
+    if (err instanceof AppAuthInvalidError) {
+      return softFailureResponse({
+        code: err.code,
+        message: err.message,
+        category: "auth"
+      });
+    }
     log.error("Batch operation failed", err);
     return {
       status: 500,
@@ -5594,6 +5740,9 @@ async function routeRequest(req, ctx) {
     if (req.path === "/oauth_callback" && req.method === "POST") {
       return handleOAuthCallbackRoute(req, ctx);
     }
+    if (req.path === "/refresh_token" && req.method === "POST") {
+      return handleRefreshTokenRoute(req, ctx);
+    }
     if (req.path === "/health" && req.method === "GET") {
       return handleHealthRoute(ctx);
     }
@@ -10632,7 +10781,16 @@ var SkillYAMLSchema = import_v47.z.object({
   tools: SkillToolsSchema.optional(),
   // CRM context - specifies which models/fields to include in schema
   crmContext: CRMContextSchema.optional(),
+  /**
+   * Entity field handles this skill is allowed to write while loaded.
+   * Writing outside this list is reported as an unowned write.
+   */
   ownedFields: import_v47.z.array(import_v47.z.string()).optional(),
+  /**
+   * Entity field handles this skill must have written before it replies.
+   * Only handles mapped in the install's AppCrmMap are enforced.
+   */
+  requiredWrites: import_v47.z.array(import_v47.z.string()).optional(),
   // Quality evaluators owned by this skill
   evaluators: import_v47.z.array(SkillEvaluatorSchema).optional(),
   // Few-shot examples
@@ -10649,6 +10807,7 @@ var SkillYAMLV2Schema = import_v47.z.object({
   tools: import_v47.z.array(SkillToolDefinitionSchema).optional(),
   crmContext: CRMContextSchema.optional(),
   ownedFields: import_v47.z.array(import_v47.z.string()).optional(),
+  requiredWrites: import_v47.z.array(import_v47.z.string()).optional(),
   evaluators: import_v47.z.array(SkillEvaluatorSchema).optional(),
   examples: import_v47.z.array(SkillExampleSchema).optional()
 });
@@ -10664,8 +10823,8 @@ var SkillRefSchema = import_v47.z.union([
     description: import_v47.z.string().optional(),
     // For AI SDK Agent Skills discovery
     /**
-     * @deprecated Ignored. The agent must call system:skill:load each turn.
-     * Kept so existing agent YAML still validates.
+     * Pre-seed this skill as loaded before the first model step, so the agent
+     * does not have to call system:skill:load for it.
      */
     alwaysLoad: import_v47.z.boolean().optional(),
     // Version selection (pick one):
@@ -10673,10 +10832,14 @@ var SkillRefSchema = import_v47.z.union([
     // Pin to specific version number
     versions: import_v47.z.array(SkillVersionWeightSchema).optional(),
     // A/B testing weights
-    // Legacy support:
-    instructions: import_v47.z.string().optional(),
-    // Inline instructions (deprecated)
-    enabled: import_v47.z.boolean().optional()
+    /**
+     * @deprecated Not implemented. Instructions come from the skill file.
+     */
+    instructions: import_v47.z.string().optional().describe("Not implemented"),
+    /**
+     * @deprecated Not implemented. Remove the skill from `skills` instead.
+     */
+    enabled: import_v47.z.boolean().optional().describe("Not implemented")
   })
 ]);
 var SkillMetadataSchema = import_v47.z.object({
@@ -10795,7 +10958,11 @@ var ContextValidationResultSchema = import_v48.z.object({
   issues: import_v48.z.array(ContextIssueSchema)
 });
 var SandboxConfigSchema = import_v48.z.object({
-  enabled: import_v48.z.boolean().optional(),
+  /**
+   * @deprecated Not implemented. Sandbox mode is chosen by the caller
+   * (playground, scenario replay, CLI), never by the agent file.
+   */
+  enabled: import_v48.z.boolean().optional().describe("Not implemented"),
   /** @deprecated Use 'context' instead of 'mockContext' */
   mockContext: AgentContextSchema.optional(),
   context: AgentContextSchema.optional()
@@ -10967,24 +11134,87 @@ var ResponsesBehaviorConfigSchema = import_v49.z.object({
    * @default false
    */
   allowSilent: import_v49.z.boolean().optional(),
+  /**
+   * Strip em dashes, smart quotes and bullet leaders from outbound messages.
+   * @default false
+   */
+  humanize: import_v49.z.boolean().optional(),
   /**
    * Message splitting configuration.
-   * Controls whether and how the agent splits responses into multiple messages.
+   * @deprecated Not implemented — accepted but never applied at runtime.
    */
   messageSplitting: import_v49.z.object({
+    enabled: import_v49.z.boolean(),
+    prompt: import_v49.z.string().optional()
+  }).optional().describe("Not implemented"),
+  /**
+   * Response gate configuration.
+   * Automatically detects acknowledgment messages and recommends skipping
+   * responses when a scheduled follow-up already exists.
+   */
+  responseGate: import_v49.z.object({
     /**
-     * Whether to allow natural message splitting.
-     * When true, the agent may split responses into multiple messages
-     * when it improves conversational flow.
+     * Whether the response gate is enabled.
+     * When true, the platform evaluates incoming messages for acknowledgment
+     * patterns and may recommend skipping a response if scheduled follow-ups exist.
+     * @default true (when allowSilent is true)
      */
-    enabled: import_v49.z.boolean(),
+    enabled: import_v49.z.boolean().optional(),
     /**
-     * Custom prompt to override the default message splitting guidance.
-     * If not provided, uses sensible defaults for when to split vs. keep together.
+     * Whether to hard-block sends when gate recommends skip.
+     * When true, system:message:send is blocked unless overrideGate is provided.
+     * When false (default), returns an error encouraging skip but allows override.
+     * @default false
      */
-    prompt: import_v49.z.string().optional()
+    strictMode: import_v49.z.boolean().optional(),
+    /**
+     * Minimum confidence threshold for acknowledgment detection.
+     * Only recommend skip when confidence meets this threshold.
+     * @default 0.7
+     */
+    minAckConfidence: import_v49.z.number().min(0).max(1).optional()
   }).optional()
 });
+var ConversationPolicyLevelSchema = import_v49.z.enum(["off", "prompt", "reject"]);
+var ConversationBehaviorConfigSchema = import_v49.z.object({
+  /** Do not re-ask something the customer already answered. */
+  repeatQuestions: ConversationPolicyLevelSchema.optional(),
+  /** Do not send skill example wording verbatim. */
+  exampleCopy: ConversationPolicyLevelSchema.optional(),
+  /**
+   * A named delay or a promised check-in should produce a scheduled send.
+   * `prompt` reprompts once and accepts the turn either way; `reject` fails
+   * the turn when no scheduled send follows.
+   */
+  namedDelayFollowUp: ConversationPolicyLevelSchema.optional(),
+  /**
+   * Keep the turn to one message. Prompt-only — the hard count comes from
+   * `behavior.responses.maxImmediate`.
+   */
+  oneMessagePerTurn: ConversationPolicyLevelSchema.optional(),
+  /**
+   * Skip rather than send filler. Prompt-only, and only stated when
+   * `behavior.responses.allowSilent` is set.
+   */
+  fillerBan: ConversationPolicyLevelSchema.optional(),
+  /**
+   * A bare acknowledgement does not cancel a pending follow-up. Prompt-only,
+   * and only stated when the thread has pending scheduled messages.
+   */
+  cancelPendingOnAck: ConversationPolicyLevelSchema.optional(),
+  /**
+   * Ask one thing at a time. `reject` blocks a send that asks more than one
+   * question. Defaults to `off` at runtime: an agent that collects several
+   * answers in one message is a legitimate design.
+   */
+  oneQuestionPerMessage: ConversationPolicyLevelSchema.optional(),
+  /**
+   * Fallback when every send this turn was rejected by a policy gate.
+   * `send` releases the last rejected message, `skip` records a skip.
+   * @default "send"
+   */
+  onPolicyRejectExhausted: import_v49.z.enum(["send", "skip"]).optional()
+});
 var SchedulingDelaySchema = import_v49.z.object({
   /** Time unit amount */
   amount: import_v49.z.number(),
@@ -11032,15 +11262,53 @@ var BehaviorConfigV3Schema = import_v49.z.object({
    * Scheduling behavior - controls when the agent schedules follow-up messages.
    * Patterns define triggers like "user indicates they'll return later".
    */
-  scheduling: SchedulingBehaviorConfigSchema.optional()
+  scheduling: SchedulingBehaviorConfigSchema.optional(),
+  /**
+   * Conversation policy - which conversational rules this agent wants, and
+   * whether each is stated in the prompt or enforced at runtime.
+   */
+  conversation: ConversationBehaviorConfigSchema.optional(),
+  /**
+   * Mention a long gap since the last message when one has passed.
+   * @default false
+   */
+  acknowledgeTimeGaps: import_v49.z.boolean().optional(),
+  /**
+   * Gap that counts as long for `acknowledgeTimeGaps`, e.g. "3 days".
+   */
+  timeGapThreshold: import_v49.z.string().optional()
+});
+var AgentSettingV3Schema = import_v49.z.object({
+  /** Setting key, resolved against the install's AgentConfig and env. */
+  key: import_v49.z.string().min(1),
+  /** Human label shown to the model and in the console. */
+  label: import_v49.z.string().optional(),
+  /**
+   * Prompt guidance for this setting. `{{value}}` interpolates the install
+   * value and `{{workplace}}` the workplace name.
+   */
+  guidance: import_v49.z.string().optional(),
+  /**
+   * Marks a setting as supplying a platform value rather than prose.
+   * `persona_name` overrides the agent's persona name for this install.
+   */
+  role: import_v49.z.enum(["persona_name"]).optional()
 });
 var PromptsConfigV3Schema = import_v49.z.object({
   /** Main system prompt with workflow instructions */
   system: import_v49.z.string().optional(),
-  /** Injected during second pass when skills were loaded but tools not used */
-  recovery: import_v49.z.string().optional(),
-  /** Injected during follow-up passes when context needs updating */
-  followUp: import_v49.z.string().optional(),
+  /**
+   * Injected during second pass when skills were loaded but tools not used.
+   * @deprecated Ignored on the durable turn path; only the legacy stream path
+   * reads it. Put the guidance in `system` instead.
+   */
+  recovery: import_v49.z.string().optional().describe("Not implemented"),
+  /**
+   * Injected during follow-up passes when context needs updating.
+   * @deprecated Ignored on the durable turn path; only the legacy stream path
+   * reads it. Put the guidance in `system` instead.
+   */
+  followUp: import_v49.z.string().optional().describe("Not implemented"),
   /** Thread list title generation (system + user template with {{var}} placeholders) */
   titleEnrichment: import_v49.z.object({
     system: import_v49.z.string().optional(),
@@ -11060,18 +11328,23 @@ var AgentYAMLV3Schema = import_v49.z.object({
   // Tools - Always-available tools before any skill loads
   // Examples: system:settings:business_information:get
   tools: import_v49.z.array(AgentToolRefSchema).optional(),
+  /**
+   * Settings - Install-scoped values the agent asks for by key.
+   * Rendered into the prompt with the label and guidance declared here.
+   */
+  settings: import_v49.z.array(AgentSettingV3Schema).optional(),
   /**
    * Events - When the agent activates
    * @deprecated Not yet implemented - this is a planned feature for event-driven agents.
    * Fields are accepted but not used at runtime.
    */
-  events: EventsConfigSchema.optional(),
+  events: EventsConfigSchema.optional().describe("Not implemented"),
   /**
    * Memory - How the agent remembers
    * @deprecated Not yet implemented - this is a planned feature.
    * Fields are accepted but not used at runtime.
    */
-  memory: MemoryConfigV3Schema.optional(),
+  memory: MemoryConfigV3Schema.optional().describe("Not implemented"),
   // Policies - Business rules for the agent
   policies: PoliciesConfigV3Schema.optional(),
   // Runtime - Execution configuration (model + personaModel)
@@ -11125,13 +11398,15 @@ Get Options:
   --json            Output as JSON
 
 Deploy Options:
-  --file, -f        Path to agent definition file (.agent.yml or .agent.json)
+  --file, -f        Path to agent definition file (.agent.yml, .agent.json, or .agent-pack.yaml)
   --workplace, -w   Workplace subdomain (required)
   --draft           Deploy as draft (not published)
+  --upload          Force multipart upload (for large files >500KB)
   --json            Output as JSON
 
-  Supports both legacy (multi-stage) and v3 (skills-based) agent formats.
-  V3 agents use skills, events, and memory instead of stages.
+  Supports v3 (skills-based) agents and agent-pack bundles.
+  Agent-pack files (.agent-pack.yaml) include embedded skills, evaluators, and scenarios.
+  Files larger than 500KB automatically use multipart upload.
 
 Publish Options:
   --workplace, -w   Workplace subdomain (required)
@@ -11447,12 +11722,14 @@ async function handleUpdate2(args2) {
   console.log('Note: "update" is deprecated. Use "deploy" instead.');
   await handleDeploy(args2);
 }
+var MULTIPART_THRESHOLD = 500 * 1024;
 async function handleDeploy(args2) {
   const { flags } = parseArgs(args2);
   const filePath = flags.file || flags.f;
   const workplace = flags.workplace || flags.w;
   const isDraft = Boolean(flags.draft);
   const jsonOutput = Boolean(flags.json);
+  const forceUpload = Boolean(flags.upload);
   if (!filePath) {
     console.error("Error: --file (-f) is required");
     console.error("Usage: skedyul agents deploy --file ./agent.yml --workplace gym-demo");
@@ -11466,11 +11743,25 @@ async function handleDeploy(args2) {
   let agent;
   let content;
   let isV3;
+  let isAgentPack = false;
   try {
-    const result = await loadAgentFile(filePath);
-    agent = result.agent;
-    content = result.content;
-    isV3 = result.isV3;
+    const absolutePath = path22.resolve(filePath);
+    content = fs22.readFileSync(absolutePath, "utf-8");
+    const rawContent = (0, import_yaml2.parse)(content);
+    isAgentPack = rawContent?.kind === "skedyul.agent-pack";
+    if (isAgentPack) {
+      const agentObj = rawContent.agent;
+      if (!agentObj) {
+        throw new Error('Agent-pack missing "agent" field');
+      }
+      agent = agentObj;
+      isV3 = true;
+    } else {
+      const result = await loadAgentFile(filePath);
+      agent = result.agent;
+      content = result.content;
+      isV3 = result.isV3;
+    }
   } catch (error) {
     if (jsonOutput) {
       console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
@@ -11491,37 +11782,46 @@ async function handleDeploy(args2) {
     }
     process.exit(1);
   }
+  const fileSize = Buffer.byteLength(content, "utf8");
+  const useMultipart = forceUpload || fileSize > MULTIPART_THRESHOLD || isAgentPack;
   if (!jsonOutput) {
     let agentType;
-    if (isV3) {
+    if (isAgentPack) {
+      agentType = "agent-pack (bundled)";
+    } else if (isV3) {
       agentType = "v3 (skills-based)";
     } else {
       agentType = isMultiStageAgent(agent) ? "multi-stage" : "single-stage";
     }
     console.log("");
     console.log(`Deploying ${agentType} agent "${agent.name}" to ${workplace}${isDraft ? " (draft)" : ""}`);
+    if (useMultipart) {
+      console.log(`  Using multipart upload (${(fileSize / 1024).toFixed(1)} KB)`);
+    }
     console.log("");
   }
   try {
-    const response = await fetch(`${serverUrl}/api/cli/agents`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify({
+    let result;
+    if (useMultipart) {
+      result = await deployAgentMultipart({
+        serverUrl,
+        token,
         workplaceId: workplaceToken.workplaceId,
         subdomain: workplaceToken.workplaceSubdomain,
-        action: "deploy",
-        yamlContent: content,
+        filePath,
+        content,
         publish: !isDraft
-      })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(errorData.error || `Request failed: ${response.statusText}`);
+      });
+    } else {
+      result = await deployAgentJson({
+        serverUrl,
+        token,
+        workplaceId: workplaceToken.workplaceId,
+        subdomain: workplaceToken.workplaceSubdomain,
+        content,
+        publish: !isDraft
+      });
     }
-    const result = await response.json();
     if (!result.success) {
       throw new Error(result.error || "Failed to deploy agent");
     }
@@ -11549,6 +11849,12 @@ async function handleDeploy(args2) {
         console.log(`  Tools:     ${result.agent.tools.length} bound`);
       }
     }
+    if (result.deployedSkills?.length) {
+      console.log(`  Skills:    ${result.deployedSkills.length} deployed`);
+      for (const skill of result.deployedSkills) {
+        console.log(`    - ${skill.handle} v${skill.version}`);
+      }
+    }
     console.log("");
   } catch (error) {
     if (jsonOutput) {
@@ -11559,6 +11865,50 @@ async function handleDeploy(args2) {
     process.exit(1);
   }
 }
+async function deployAgentJson(params) {
+  const response = await fetch(`${params.serverUrl}/api/cli/agents`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${params.token}`
+    },
+    body: JSON.stringify({
+      workplaceId: params.workplaceId,
+      subdomain: params.subdomain,
+      action: "deploy",
+      yamlContent: params.content,
+      publish: params.publish
+    })
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(errorData.error || `Request failed: ${response.statusText}`);
+  }
+  return response.json();
+}
+async function deployAgentMultipart(params) {
+  const formData = new FormData();
+  const blob = new Blob([params.content], { type: "text/yaml" });
+  const fileName = path22.basename(params.filePath);
+  formData.append("file", blob, fileName);
+  formData.append("metadata", JSON.stringify({
+    workplaceId: params.workplaceId,
+    subdomain: params.subdomain,
+    publish: params.publish
+  }));
+  const response = await fetch(`${params.serverUrl}/api/cli/agents/upload`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${params.token}`
+    },
+    body: formData
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(errorData.error || `Request failed: ${response.statusText}`);
+  }
+  return response.json();
+}
 async function handlePublish(args2) {
   const { flags, positional } = parseArgs(args2);
   const handle = positional[0];
@@ -13211,8 +13561,11 @@ Deploy Options:
   --workplace, -w   Workplace subdomain (required)
   --draft           Deploy as draft (not published)
   --label           Version label (e.g., "experiment-shorter-prompts")
+  --upload          Force multipart upload (for large files >500KB)
   --json            Output as JSON
 
+  Note: Files larger than 500KB automatically use multipart upload.
+
 Publish Options:
   --workplace, -w   Workplace subdomain (required)
   --version, -v     Version number to publish (required)
@@ -13419,6 +13772,7 @@ async function handleGet3(args2) {
     process.exit(1);
   }
 }
+var MULTIPART_THRESHOLD2 = 500 * 1024;
 async function handleDeploy2(args2) {
   const { flags } = parseArgs(args2);
   const filePath = flags.file || flags.f;
@@ -13426,6 +13780,7 @@ async function handleDeploy2(args2) {
   const isDraft = Boolean(flags.draft);
   const versionLabel = flags.label;
   const jsonOutput = Boolean(flags.json);
+  const forceUpload = Boolean(flags.upload);
   if (!filePath) {
     console.error("Error: --file (-f) is required");
     console.error("Usage: skedyul skills deploy --file ./skill.yml --workplace crux");
@@ -13462,36 +13817,38 @@ async function handleDeploy2(args2) {
     }
     process.exit(1);
   }
+  const fileSize = Buffer.byteLength(content, "utf8");
+  const useMultipart = forceUpload || fileSize > MULTIPART_THRESHOLD2;
   if (!jsonOutput) {
     console.log("");
     console.log(`Deploying skill "${skill.name}" to ${workplace}${isDraft ? " (draft)" : ""}`);
+    if (useMultipart) {
+      console.log(`  Using multipart upload (${(fileSize / 1024).toFixed(1)} KB)`);
+    }
     console.log("");
   }
   try {
-    const response = await fetch(`${serverUrl}/api/cli/skills`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify({
-        action: "deploy",
+    let result;
+    if (useMultipart) {
+      result = await deploySkillMultipart({
+        serverUrl,
+        token,
         workplaceId: workplaceToken.workplaceId,
-        yamlContent: content,
+        filePath,
+        content,
         publish: !isDraft,
         versionLabel
-      })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      if (errorData.details) {
-        const detailsStr = errorData.details.map((d) => `  - ${d.path}: ${d.message}`).join("\n");
-        throw new Error(`${errorData.error}
-${detailsStr}`);
-      }
-      throw new Error(errorData.error || `Request failed: ${response.statusText}`);
+      });
+    } else {
+      result = await deploySkillJson({
+        serverUrl,
+        token,
+        workplaceId: workplaceToken.workplaceId,
+        content,
+        publish: !isDraft,
+        versionLabel
+      });
     }
-    const result = await response.json();
     if (!result.success) {
       throw new Error(result.error || "Failed to deploy skill");
     }
@@ -13518,6 +13875,60 @@ ${detailsStr}`);
     process.exit(1);
   }
 }
+async function deploySkillJson(params) {
+  const response = await fetch(`${params.serverUrl}/api/cli/skills`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${params.token}`
+    },
+    body: JSON.stringify({
+      action: "deploy",
+      workplaceId: params.workplaceId,
+      yamlContent: params.content,
+      publish: params.publish,
+      versionLabel: params.versionLabel
+    })
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    if (errorData.details) {
+      const detailsStr = errorData.details.map((d) => `  - ${d.path}: ${d.message}`).join("\n");
+      throw new Error(`${errorData.error}
+${detailsStr}`);
+    }
+    throw new Error(errorData.error || `Request failed: ${response.statusText}`);
+  }
+  return response.json();
+}
+async function deploySkillMultipart(params) {
+  const formData = new FormData();
+  const blob = new Blob([params.content], { type: "text/yaml" });
+  const fileName = path24.basename(params.filePath);
+  formData.append("file", blob, fileName);
+  formData.append("metadata", JSON.stringify({
+    workplaceId: params.workplaceId,
+    publish: params.publish,
+    versionLabel: params.versionLabel
+  }));
+  const response = await fetch(`${params.serverUrl}/api/cli/skills/upload`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${params.token}`
+    },
+    body: formData
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    if (errorData.details) {
+      const detailsStr = errorData.details.map((d) => `  - ${d.path}: ${d.message}`).join("\n");
+      throw new Error(`${errorData.error}
+${detailsStr}`);
+    }
+    throw new Error(errorData.error || `Request failed: ${response.statusText}`);
+  }
+  return response.json();
+}
 async function handlePublish2(args2) {
   const { flags, positional } = parseArgs(args2);
   const handle = positional[0];