skedyul 1.2.50 → 1.3.0

package/dist/config/app-config.d.ts

@@ -7,6 +7,8 @@ import type { ToolRegistry, WebhookRegistry, ToolMetadata, WebhookMetadata } fro
 import type { ServerHooks } from '../types/handlers';
 import type { CoreApiConfig } from '../core/types';
 import type { EnvSchema, ComputeLayer, ModelDefinition, RelationshipDefinition, ChannelDefinition, WorkflowDefinition, PageDefinition, NavigationConfig, AgentDefinition, SignalDefinition } from './types';
+import type { QueueRegistry, SerializableQueueConfig } from './queue-config';
+export type { QueueScope, QueueConfig, SerializableQueueConfig, QueueRegistry, } from './queue-config';
 /**
  * Install configuration - defines per-install env vars and SHARED models.
  * This is configured by users during app installation.
@@ -102,6 +104,8 @@ export interface SkedyulConfig {
     agents?: AgentDefinition[];
     /** Build configuration for the integration */
     build?: BuildConfig;
+    /** Rate-limit queue definitions for queuedFetch */
+    queues?: QueueRegistry;
 }
 /**
  * Serializable config (for database storage).
@@ -120,6 +124,8 @@ export interface SerializableSkedyulConfig {
     provision?: ProvisionConfig;
     /** Agent definitions (stored as-is) */
     agents?: AgentDefinition[];
+    /** Rate-limit queue definitions */
+    queues?: Record<string, SerializableQueueConfig>;
 }
 /**
  * Define a Skedyul app configuration with full type safety.

package/dist/config/index.d.ts

@@ -9,7 +9,7 @@
  * - All definition types extend BaseDefinition
  */
 export * from './types';
-export type { InstallConfig, ProvisionConfig, BuildConfig, CorsOptions, SkedyulConfig, SerializableSkedyulConfig, } from './app-config';
+export type { InstallConfig, ProvisionConfig, BuildConfig, CorsOptions, SkedyulConfig, SerializableSkedyulConfig, QueueScope, QueueConfig, SerializableQueueConfig, QueueRegistry, } from './app-config';
 export { defineConfig } from './app-config';
 export { defineModel, defineChannel, definePage, defineWorkflow, defineAgent, defineEnv, defineNavigation, } from './define';
 export { CONFIG_FILE_NAMES, loadConfig, validateConfig } from './loader';

package/dist/config/queue-config.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Rate-limit queue configuration for skedyul.config queues.
+ */
+export type QueueScope = 'provision' | 'install' | 'provision_endpoint' | 'install_endpoint' | 'global';
+/**
+ * Serializable queue config (stored in DB / .skedyul/config.json).
+ */
+export interface SerializableQueueConfig {
+    scope: QueueScope;
+    /** Override endpoint handle for provision_endpoint / install_endpoint scopes */
+    endpoint?: string;
+    /** Max in-flight operations (concurrency cap) */
+    maxConcurrent?: number;
+    /** Minimum ms between operation starts */
+    minTime?: number;
+    /** Token bucket: max operations per refresh window */
+    reservoir?: number;
+    reservoirRefreshAmount?: number;
+    reservoirRefreshInterval?: number;
+    /** SDK-level retries inside queuedFetch */
+    maxRetries?: number;
+    retryDelayMs?: number;
+    /** Hard timeout for acquire wait + fn execution (ms) */
+    timeout?: number;
+}
+/**
+ * Full queue config including non-serializable retry predicate.
+ */
+export interface QueueConfig extends SerializableQueueConfig {
+    /** Predicate for whether a thrown error should trigger requeue */
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+}
+export type QueueRegistry = Record<string, QueueConfig>;

package/dist/dedicated/server.js

@@ -87,6 +87,16 @@ var CoreApiService = class {
 };
 var coreApiService = new CoreApiService();
 
+// src/ratelimit/config-loader.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var cachedRuntimeQueues = null;
+var registeredServerConfig = null;
+function registerQueueConfig(config) {
+  registeredServerConfig = config;
+  cachedRuntimeQueues = config.queues ?? null;
+}
+
 // src/server/utils/schema.ts
 var z = __toESM(require("zod"));
 function normalizeBilling(billing) {
@@ -265,6 +275,14 @@ function runWithConfig(config, fn) {
   return requestConfigStorage.run(config, fn);
 }
 
+// src/ratelimit/context.ts
+var import_async_hooks2 = require("async_hooks");
+var executionContextStorage = new import_async_hooks2.AsyncLocalStorage();
+var activeOperationStorage = new import_async_hooks2.AsyncLocalStorage();
+function runWithRateLimitExecutionContext(ctx, fn) {
+  return executionContextStorage.run(ctx, fn);
+}
+
 // src/errors.ts
 var InstallError = class extends Error {
   // Optional: which field caused the error
@@ -284,8 +302,8 @@ var AppAuthInvalidError = class extends Error {
 };
 
 // src/server/context-logger.ts
-var import_async_hooks2 = require("async_hooks");
-var logContextStorage = new import_async_hooks2.AsyncLocalStorage();
+var import_async_hooks3 = require("async_hooks");
+var logContextStorage = new import_async_hooks3.AsyncLocalStorage();
 function runWithLogContext(context, fn) {
   return logContextStorage.run(context, fn);
 }
@@ -498,9 +516,17 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         baseUrl: toolEnv.SKEDYUL_API_URL ?? "",
         apiToken: toolEnv.SKEDYUL_API_TOKEN ?? ""
       };
+      const rateLimitContext = {
+        app,
+        appInstallationId: trigger === "provision" ? void 0 : rawContext.appInstallationId,
+        invocation,
+        isProvisionContext: trigger === "provision"
+      };
       const functionResult = await runWithConfig(requestConfig, async () => {
-        return await runWithLogContext({ invocation }, async () => {
-          return await fn(inputs, executionContext);
+        return await runWithRateLimitExecutionContext(rateLimitContext, async () => {
+          return await runWithLogContext({ invocation }, async () => {
+            return await fn(inputs, executionContext);
+          });
         });
       });
       const billing = normalizeBilling(functionResult.billing);
@@ -637,7 +663,7 @@ function printStartupLog(config, tools, port) {
 
 // src/server/route-handlers/adapters.ts
 function fromLambdaEvent(event) {
-  const path2 = event.path || event.rawPath || "/";
+  const path3 = event.path || event.rawPath || "/";
   const method = event.httpMethod || event.requestContext?.http?.method || "POST";
   const forwardedProto = event.headers?.["x-forwarded-proto"] ?? event.headers?.["X-Forwarded-Proto"];
   const protocol = forwardedProto ?? "https";
@@ -645,9 +671,9 @@ function fromLambdaEvent(event) {
   const queryString = event.queryStringParameters ? "?" + new URLSearchParams(
     event.queryStringParameters
   ).toString() : "";
-  const url = `${protocol}://${host}${path2}${queryString}`;
+  const url = `${protocol}://${host}${path3}${queryString}`;
   return {
-    path: path2,
+    path: path3,
     method,
     headers: event.headers,
     query: event.queryStringParameters ?? {},
@@ -729,8 +755,8 @@ function parseBodyByContentType(req) {
 }
 
 // src/server/route-handlers/handlers.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
 
 // src/server/core-api-handler.ts
 async function handleCoreMethod(method, params) {
@@ -898,7 +924,8 @@ function serializeConfig(config) {
       type: w.type ?? "WEBHOOK"
     })) : [],
     provision: isProvisionConfig(config.provision) ? config.provision : void 0,
-    agents: config.agents
+    agents: config.agents,
+    queues: config.queues
   };
 }
 function isProvisionConfig(value) {
@@ -1194,7 +1221,7 @@ async function handleOAuthCallback(parsedBody, hooks) {
 }
 
 // src/server/handlers/webhook-handler.ts
-function parseWebhookRequest(parsedBody, method, url, path2, headers, query, rawBody, appIdHeader, appVersionIdHeader) {
+function parseWebhookRequest(parsedBody, method, url, path3, headers, query, rawBody, appIdHeader, appVersionIdHeader) {
   const isEnvelope = typeof parsedBody === "object" && parsedBody !== null && "env" in parsedBody && "request" in parsedBody && "context" in parsedBody;
   if (isEnvelope) {
     const envelope = parsedBody;
@@ -1248,7 +1275,7 @@ function parseWebhookRequest(parsedBody, method, url, path2, headers, query, raw
   const webhookRequest = {
     method,
     url,
-    path: path2,
+    path: path3,
     headers,
     query,
     body: parsedBody,
@@ -1306,7 +1333,7 @@ function isMethodAllowed(webhookRegistry, handle, method) {
 
 // src/server/route-handlers/handlers.ts
 function getConfigFilePath() {
-  return process.env.LAMBDA_TASK_ROOT ? path.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json") : ".skedyul/config.json";
+  return process.env.LAMBDA_TASK_ROOT ? path2.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json") : ".skedyul/config.json";
 }
 function findToolInRegistry(registry, toolName) {
   for (const [key, t] of Object.entries(registry)) {
@@ -1345,8 +1372,8 @@ function handleHealthRoute(ctx) {
 function handleConfigRoute(ctx) {
   const configFilePath = getConfigFilePath();
   try {
-    if (fs.existsSync(configFilePath)) {
-      const fileConfig = JSON.parse(fs.readFileSync(configFilePath, "utf-8"));
+    if (fs2.existsSync(configFilePath)) {
+      const fileConfig = JSON.parse(fs2.readFileSync(configFilePath, "utf-8"));
       return { status: 200, body: fileConfig };
     }
   } catch (err) {
@@ -2031,6 +2058,7 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer) {
 installContextLogger();
 function createSkedyulServer(config) {
   mergeRuntimeEnv();
+  registerQueueConfig(config);
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
   if (config.coreApi?.service) {