@theokit/sdk 2.29.0 → 2.30.0

package/dist/cron.d.cts

@@ -1,3 +1,3 @@
-import './run-q_P0vHlY.cjs';
-export { U as Cron } from './cron-yJoNUZxe.cjs';
+export { V as Cron } from './cron-t4oKI2Is.cjs';
+import './run-CLXKMRgq.cjs';
 import 'zod';

package/dist/cron.d.ts

@@ -1,3 +1,3 @@
-import './run-q_P0vHlY.js';
-export { U as Cron } from './cron-COSAehOL.js';
+export { V as Cron } from './cron-BNHJywtl.js';
+import './run-CLXKMRgq.js';
 import 'zod';

package/dist/cron.js

@@ -17766,15 +17766,31 @@ setAgentFacade({
 // src/cron.ts
 init_errors();
 
+// src/internal/cron/fire-handler.ts
+init_registry();
+
 // src/internal/cron/run-job.ts
 init_errors();
 init_agent_factory_registry();
 async function runCronJob(job) {
-  if (job.agent !== void 0) return runWithEphemeralAgent(job.agent, job.message);
-  if (job.agentId !== void 0) return runWithExistingAgent(job.agentId, job.message);
-  throw new ConfigurationError(`Cron job ${job.id} has neither agent nor agentId \u2014 cannot run.`, {
-    code: "cron_no_target"
-  });
+  if (job.workflow !== void 0) return job.workflow.run(job.inputData);
+  if (job.agent !== void 0) return runWithEphemeralAgent(job.agent, requireMessage(job));
+  if (job.agentId !== void 0) return runWithExistingAgent(job.agentId, requireMessage(job));
+  throw new ConfigurationError(
+    `Cron job ${job.id} has no target (agent, agentId, or workflow) \u2014 cannot run.`,
+    { code: "cron_no_target" }
+  );
+}
+function isAgentRun(outcome) {
+  return typeof outcome.wait === "function";
+}
+function requireMessage(job) {
+  if (job.message === void 0) {
+    throw new ConfigurationError(`Cron job ${job.id} is an agent target but has no message.`, {
+      code: "cron_missing_message"
+    });
+  }
+  return job.message;
 }
 async function runWithExistingAgent(agentId, message) {
   const info = await getAgentFacade().get(agentId).catch(() => void 0);
@@ -17792,6 +17808,37 @@ async function runWithEphemeralAgent(baseOptions, message) {
   return agent.send(message);
 }
 
+// src/internal/cron/fire-handler.ts
+async function fireCronJobAsTask(job) {
+  const fireTs = Date.now();
+  const taskId = `cron-${job.id}-${fireTs}`;
+  try {
+    await submit({
+      kind: "cron",
+      id: taskId,
+      allowReservedPrefix: true,
+      meta: { jobId: job.id, jobName: job.name, schedule: job.cron, firedAt: fireTs },
+      work: async (ctx) => {
+        const outcome = await runCronJob(job);
+        if (isAgentRun(outcome)) {
+          ctx.signal.addEventListener("abort", () => void outcome.cancel().catch(() => {
+          }), {
+            once: true
+          });
+          const result = await outcome.wait();
+          ctx.emit({ status: result.status, runId: outcome.id });
+          return { status: result.status, runId: outcome.id };
+        }
+        ctx.emit({ status: outcome.status, runId: outcome.id });
+        return { status: outcome.status, runId: outcome.id };
+      }
+    });
+  } catch {
+    const outcome = await runCronJob(job);
+    if (isAgentRun(outcome)) await outcome.wait();
+  }
+}
+
 // src/internal/cron/store.ts
 var jobs = /* @__PURE__ */ new Map();
 function listJobs() {
@@ -17982,7 +18029,6 @@ function estimateNextRunAt(_cron, _timezone) {
 }
 
 // src/cron.ts
-init_registry();
 var Cron = class {
   constructor() {
   }
@@ -18049,7 +18095,8 @@ var Cron = class {
     return updateJobStatus(jobId, false);
   }
   /**
-   * Manually trigger a cron job off-schedule. Returns the resulting `Run`.
+   * Manually trigger a cron job off-schedule. Returns the resulting `Run`
+   * (agent target) or `WorkflowRun` (workflow target — SE35).
    *
    * @public
    */
@@ -18066,30 +18113,7 @@ var Cron = class {
    * @public
    */
   static start(options = {}) {
-    setCronFireHandler(async (job) => {
-      const fireTs = Date.now();
-      const taskId = `cron-${job.id}-${fireTs}`;
-      try {
-        await submit({
-          kind: "cron",
-          id: taskId,
-          allowReservedPrefix: true,
-          meta: { jobId: job.id, jobName: job.name, schedule: job.cron, firedAt: fireTs },
-          work: async (ctx) => {
-            const run = await runCronJob(job);
-            ctx.signal.addEventListener("abort", () => void run.cancel().catch(() => {
-            }), {
-              once: true
-            });
-            const result = await run.wait();
-            ctx.emit({ status: result.status, runId: run.id });
-            return { status: result.status, runId: run.id };
-          }
-        });
-      } catch {
-        await runCronJob(job).then((run) => run.wait());
-      }
-    });
+    setCronFireHandler(fireCronJobAsTask);
     startScheduler(options.cwd);
     return Promise.resolve();
   }
@@ -18113,17 +18137,7 @@ var Cron = class {
   }
 };
 async function createCronJob(options) {
-  if (options.agent !== void 0 && options.agentId !== void 0) {
-    throw new ConfigurationError(
-      "agent and agentId are mutually exclusive \u2014 pass either agent (ephemeral) or agentId (reuse).",
-      { code: "cron_agent_exclusive" }
-    );
-  }
-  if (options.agent === void 0 && options.agentId === void 0) {
-    throw new ConfigurationError("Cron job requires either agent or agentId", {
-      code: "cron_missing_agent"
-    });
-  }
+  validateCronTarget(options);
   validateCronExpression(options.cron);
   const timezone = options.timezone ?? "UTC";
   validateTimezone(timezone);
@@ -18134,20 +18148,51 @@ async function createCronJob(options) {
     id: generateCronId(),
     cron: options.cron,
     timezone,
-    message: options.message,
     enabled: options.enabled ?? true,
     status: options.enabled === false ? "paused" : "scheduled",
     runtime,
     createdAt: now,
     nextRunAt: estimateNextRunAt(options.cron),
     ...options.name !== void 0 ? { name: options.name } : {},
+    ...options.message !== void 0 ? { message: options.message } : {},
     ...options.agent !== void 0 ? { agent: options.agent } : {},
-    ...options.agentId !== void 0 ? { agentId: options.agentId } : {}
+    ...options.agentId !== void 0 ? { agentId: options.agentId } : {},
+    ...options.workflow !== void 0 ? { workflow: options.workflow } : {},
+    ...options.inputData !== void 0 ? { inputData: options.inputData } : {}
   };
   upsertJob(job);
   return job;
 }
+function validateCronTarget(options) {
+  const targets = [options.agent, options.agentId, options.workflow].filter(
+    (t) => t !== void 0
+  ).length;
+  if (targets > 1) {
+    throw new ConfigurationError(
+      "agent, agentId, and workflow are mutually exclusive \u2014 pass exactly one target.",
+      { code: "cron_ambiguous_target" }
+    );
+  }
+  if (targets === 0) {
+    throw new ConfigurationError(
+      "Cron job requires exactly one target: agent, agentId, or workflow.",
+      { code: "cron_no_target" }
+    );
+  }
+  if (options.workflow !== void 0 && options.message !== void 0) {
+    throw new ConfigurationError(
+      "A workflow cron target takes inputData, not a message \u2014 remove `message`.",
+      { code: "cron_workflow_message" }
+    );
+  }
+  if (options.workflow === void 0 && options.message === void 0) {
+    throw new ConfigurationError("An agent cron target requires a message.", {
+      code: "cron_missing_message"
+    });
+  }
+}
 function detectRuntime(options) {
+  if (options.workflow !== void 0) return "local";
   if (options.agentId !== void 0) {
     return options.agentId.startsWith("bc-") ? "cloud" : "local";
   }