@k2b/cloud 0.46.0 → 0.47.0

package/src/start.ts

@@ -0,0 +1,36 @@
+// Keep this entry independent of the platform barrel and application modules.
+import { initializeClients } from "./runtime/clients";
+import { bindConnections, hasConnections } from "./runtime/connections";
+import { resolveConnections } from "./runtime/resolve-connections";
+
+export type PlatformStartOptions = {
+  appId: string;
+  /** Core and Gateway always use infrastructure environment values. */
+  source?: "env";
+};
+
+/** Initialize before importing any application module, also in dev and data workers. */
+export const initializePlatform = async ({ appId, source }: PlatformStartOptions): Promise<void> => {
+  if (!/^[a-z][a-z0-9-]{0,79}$/.test(appId)) throw new Error("Platform start requires a valid appId");
+  if (hasConnections()) throw new Error("Platform has already started");
+  if (appId === "core" || appId === "gateway") source = "env";
+  // Slice 6b seam: validate the app key and fetch missing values from Core here,
+  // then pass the typed response to resolveConnections({ appId, core }).
+  // A present key must never silently fall back to the legacy env mode.
+  if (source !== "env" && (process.env.CLOUD_APP_KEY?.trim() || process.env.CLOUD_APP_KEY_FILE?.trim())) {
+    throw new Error("Core connection bootstrap is not available yet");
+  }
+  const resolved = resolveConnections({ appId });
+  bindConnections(resolved);
+  try {
+    await initializeClients();
+  } catch (error) {
+    bindConnections(undefined);
+    throw error;
+  }
+};
+
+export const startPlatform = async <T>({ load, ...options }: PlatformStartOptions & { load: () => Promise<T> }): Promise<T> => {
+  await initializePlatform(options);
+  return load();
+};

package/src/workflows/ai/index.ts

@@ -1,4 +1,5 @@
 export { startWorkflowAiRuntime, stopWorkflowAiRuntime, submitWorkflowAiTask, type WorkflowAiRuntimeOptions } from "./runtime";
+export { getWorkflowAiBudget } from "./settings";
 export {
   createWorkflowAiTask,
   getWorkflowAiTask,

package/src/workflows/ai/runtime.ts

@@ -7,8 +7,10 @@ import { resolveAiWorkflowModel, runAiStructured } from "../../ai/structured";
 import { executeAiTask } from "../../ai/task-execution";
 import { resolveApplicationAiTaskModel } from "../../ai/task-model";
 import { isAiSettingsError } from "../../ai/validate";
-import { env } from "../../config/env";
+import { DEFAULT_WORKFLOW_AI_BUDGET } from "../../config/workflow-ai";
+import { coreSettings } from "../../services/settings/api";
 import { WorkflowAiAdmissionError, workflowAiModelHash } from "./policy";
+import { getWorkflowAiBudget } from "./settings";
 
 import {
   claimWorkflowAiTask,
@@ -44,13 +46,14 @@ export type WorkflowAiProcessOptions = Required<Omit<WorkflowAiRuntimeOptions, "
   attemptTimeoutMs?: number;
 };
 
+let workerBudget = DEFAULT_WORKFLOW_AI_BUDGET;
 const workflowAiJob = lazySync((sync) =>
   sync.job<{ taskId: string }>({
     id: WORKFLOW_AI_JOB_ID,
     whenFull: "reject",
     owner: "cloud",
     delivery: {
-      maxInFlight: env.WORKFLOW_AI_BUDGET.globalConcurrent,
+      maxInFlight: workerBudget.globalConcurrent,
       ackWaitMs: 30_000,
       maxAttempts: MAX_ATTEMPTS,
       backoffMs: [1_000, 2_000],
@@ -137,6 +140,7 @@ export const processWorkflowAiTask = async (
   ctx: { signal: AbortSignal; heartbeat(): Promise<void> },
   options: WorkflowAiProcessOptions,
 ): Promise<void> => {
+  const attemptTimeoutMs = options.attemptTimeoutMs ?? (await coreSettings.get<number>("ai.workflow_attempt_timeout_ms"));
   const task = await claimWorkflowAiTask(taskId);
   if (!task) {
     const terminal = await getWorkflowAiTask(taskId);
@@ -150,7 +154,7 @@ export const processWorkflowAiTask = async (
   const deadline = setTimeout(() => {
     timedOut = true;
     controller.abort(new Error("Workflow AI attempt deadline exceeded. Retry the workflow or inspect the provider."));
-  }, options.attemptTimeoutMs ?? env.WORKFLOW_AI_ATTEMPT_TIMEOUT_MS);
+  }, attemptTimeoutMs);
   let canceled = false;
   let monitorError: unknown;
   let checking = false;
@@ -230,9 +234,12 @@ let recovery: Promise<void> | null = null;
 let shutdown: AbortController | null = null;
 
 const recover = (): Promise<void> => {
-  recovery ??= expireWorkflowAiTasks(env.WORKFLOW_AI_QUEUE_TIMEOUT_MS).finally(() => {
-    recovery = null;
-  });
+  recovery ??= coreSettings
+    .get<number>("ai.workflow_queue_timeout_ms")
+    .then((timeout) => expireWorkflowAiTasks(timeout))
+    .finally(() => {
+      recovery = null;
+    });
   return recovery;
 };
 
@@ -242,14 +249,15 @@ export const startWorkflowAiRuntime = async (input: WorkflowAiRuntimeOptions = {
     runStructured: input.runStructured ?? runAiStructured,
     maxAttempts: MAX_ATTEMPTS,
     cancelPollMs: input.cancelPollMs ?? DEFAULT_CANCEL_POLL_MS,
-    attemptTimeoutMs: input.attemptTimeoutMs ?? env.WORKFLOW_AI_ATTEMPT_TIMEOUT_MS,
+    attemptTimeoutMs: input.attemptTimeoutMs,
   };
+  workerBudget = await getWorkflowAiBudget();
   const next = workflowAiJob();
   activeJob = next;
   const controller = new AbortController();
   shutdown = controller;
   try {
-    activeWorker = await next.process({ concurrency: env.WORKFLOW_AI_BUDGET.globalConcurrent }, async (context) => {
+    activeWorker = await next.process({ concurrency: workerBudget.globalConcurrent }, async (context) => {
       try {
         await processWorkflowAiTask(
           context.input.taskId,

package/src/workflows/ai/settings.ts

@@ -0,0 +1,5 @@
+import { workflowAiBudgetSchema } from "../../config/workflow-ai";
+import { coreSettings } from "../../services/settings/api";
+
+export const getWorkflowAiBudget = async () =>
+  workflowAiBudgetSchema.parse(JSON.parse(await coreSettings.get<string>("ai.workflow_budget")));