skedyul 1.2.51 → 1.3.0

package/dist/ratelimit/backends/index.d.ts

@@ -0,0 +1,10 @@
+import { platformRateLimitBackend } from './platform';
+import { memoryRateLimitBackend } from './memory';
+import type { RateLimitBackend } from '../types';
+/**
+ * Resolve the active rate limit backend.
+ * Uses platform proxy by default; falls back to in-memory when configured or on local errors.
+ */
+export declare function getRateLimitBackend(): RateLimitBackend;
+export declare function resetRateLimitBackendForTests(): void;
+export { platformRateLimitBackend, memoryRateLimitBackend };

package/dist/ratelimit/backends/memory.d.ts

@@ -0,0 +1,14 @@
+import type { RateLimitBackend, Lease, QueueLimits } from '../types';
+/**
+ * In-process rate limit backend for local development.
+ */
+export declare class MemoryRateLimitBackend implements RateLimitBackend {
+    private readonly queues;
+    private readonly leases;
+    private getState;
+    private grant;
+    private drainWaiters;
+    acquire(queueKey: string, limits: QueueLimits, timeoutMs?: number): Promise<Lease>;
+    release(lease: Lease): Promise<void>;
+}
+export declare const memoryRateLimitBackend: MemoryRateLimitBackend;

package/dist/ratelimit/backends/platform.d.ts

@@ -0,0 +1,9 @@
+import type { RateLimitBackend, Lease, QueueLimits } from '../types';
+/**
+ * HTTP backend that delegates acquire/release to the Skedyul platform proxy.
+ */
+export declare class PlatformRateLimitBackend implements RateLimitBackend {
+    acquire(queueKey: string, limits: QueueLimits, timeoutMs?: number): Promise<Lease>;
+    release(lease: Lease): Promise<void>;
+}
+export declare const platformRateLimitBackend: PlatformRateLimitBackend;

package/dist/ratelimit/config-loader.d.ts

@@ -0,0 +1,10 @@
+import type { SkedyulConfig } from '../config/app-config';
+import type { QueueConfig, SerializableQueueConfig } from '../config/queue-config';
+/**
+ * Register in-process server config for queue resolution at runtime.
+ */
+export declare function registerQueueConfig(config: SkedyulConfig): void;
+export declare function clearRegisteredQueueConfig(): void;
+export declare function getQueueDefinitions(): Record<string, SerializableQueueConfig>;
+export declare function getQueueConfig(queueName: string): SerializableQueueConfig | undefined;
+export declare function getQueueConfigWithRetry(queueName: string): QueueConfig | undefined;

package/dist/ratelimit/context.d.ts

@@ -0,0 +1,7 @@
+import type { RateLimitExecutionContext, ActiveQueuedOperation } from './types';
+export declare function runWithRateLimitExecutionContext<T>(ctx: RateLimitExecutionContext, fn: () => T | Promise<T>): T | Promise<T>;
+export declare function getRateLimitExecutionContext(): RateLimitExecutionContext | undefined;
+export declare function runWithActiveQueuedOperation<T>(operation: ActiveQueuedOperation<T>, fn: () => Promise<T>): Promise<T>;
+export declare function getActiveQueuedOperation<T>(): ActiveQueuedOperation<T> | undefined;
+export declare function setActiveQueuedOperationLease(lease: ActiveQueuedOperation<unknown>['lease']): void;
+export declare function updateActiveQueuedOperationAttempt(attempt: number): void;

package/dist/ratelimit/errors.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Rate limit errors for queuedFetch.
+ */
+export declare class QueueContextError extends Error {
+    readonly code = "QUEUE_CONTEXT_ERROR";
+    constructor(message: string);
+}
+export declare class QueueNotFoundError extends Error {
+    readonly code = "QUEUE_NOT_FOUND";
+    constructor(queueName: string);
+}
+export declare class QueuedFetchExhaustedError extends Error {
+    readonly code = "QUEUED_FETCH_EXHAUSTED";
+    readonly attempts: number;
+    readonly maxRetries: number;
+    readonly causeError: unknown;
+    constructor(attempts: number, maxRetries: number, causeError: unknown);
+}
+export declare class RequeueOutsideContextError extends Error {
+    readonly code = "REQUEUE_OUTSIDE_CONTEXT";
+    constructor();
+}
+export declare class RateLimitBackendError extends Error {
+    readonly code = "RATE_LIMIT_BACKEND_ERROR";
+    readonly statusCode?: number;
+    constructor(message: string, statusCode?: number);
+}

package/dist/ratelimit/index.d.ts

@@ -0,0 +1,9 @@
+export { queuedFetch, requeue, resolveQueue, createQueueHandle, queuedFetchResponse, } from './queued-fetch';
+export type { QueueInput, QueueSelector, Lease, QueueLimits, ResolvedQueue, RateLimitExecutionContext, RateLimitBackend, } from './types';
+export { QueueContextError, QueueNotFoundError, QueuedFetchExhaustedError, RequeueOutsideContextError, RateLimitBackendError, } from './errors';
+export { registerQueueConfig, clearRegisteredQueueConfig, getQueueDefinitions, getQueueConfig, } from './config-loader';
+export { runWithRateLimitExecutionContext, getRateLimitExecutionContext, } from './context';
+export { resolveQueueKey, toQueueLimits } from './resolve-queue-key';
+export { defaultShouldRetry } from './should-retry';
+export { getRateLimitBackend, resetRateLimitBackendForTests, memoryRateLimitBackend, platformRateLimitBackend, } from './backends';
+export type { QueueScope, QueueConfig, SerializableQueueConfig, QueueRegistry, } from '../config/queue-config';

package/dist/ratelimit/queued-fetch.d.ts

@@ -0,0 +1,11 @@
+import type { QueueInput, ResolvedQueue } from './types';
+import type { RateLimitExecutionContext } from './types';
+export declare function resolveQueue(queueInput: QueueInput, ctxOverride?: RateLimitExecutionContext): ResolvedQueue;
+export declare function createQueueHandle(queueInput: QueueInput): {
+    run<T>(fn: () => Promise<T>): Promise<T>;
+};
+export declare function queuedFetch<T>(queueInput: QueueInput, fnOrPromise: (() => Promise<T>) | Promise<T>): Promise<T>;
+export declare function requeue<T = unknown>(): Promise<T>;
+export declare function queuedFetchResponse(queueInput: QueueInput, url: string, init?: RequestInit): Promise<Response>;
+/** @deprecated Use createQueueHandle */
+export declare const resolveQueueHandle: typeof createQueueHandle;

package/dist/ratelimit/resolve-queue-key.d.ts

@@ -0,0 +1,14 @@
+import type { SerializableQueueConfig } from '../config/queue-config';
+import type { RateLimitExecutionContext } from './types';
+/**
+ * Build the Redis queue key for a named queue definition.
+ * Must stay in sync with skedyul-core rate limit validation.
+ */
+export declare function resolveQueueKey(queueName: string, config: SerializableQueueConfig, ctx: RateLimitExecutionContext, subKey?: string): string;
+export declare function toQueueLimits(config: SerializableQueueConfig): {
+    maxConcurrent: number | undefined;
+    minTime: number | undefined;
+    reservoir: number | undefined;
+    reservoirRefreshAmount: number | undefined;
+    reservoirRefreshInterval: number | undefined;
+};

package/dist/ratelimit/should-retry.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Default retry predicate for queuedFetch — rate limits and transient 5xx.
+ */
+export declare function defaultShouldRetry(error: unknown, _attempt: number): boolean;
+export declare function sleep(ms: number): Promise<void>;

package/dist/ratelimit/types.d.ts

@@ -0,0 +1,43 @@
+import type { SerializableQueueConfig } from '../config/queue-config';
+import type { AppInfo } from '../types/shared';
+import type { InvocationContext } from '../types/invocation';
+export interface RateLimitExecutionContext {
+    app: AppInfo;
+    appInstallationId?: string;
+    invocation?: InvocationContext;
+    isProvisionContext?: boolean;
+}
+export interface QueueSelector {
+    queue: string;
+    key?: string;
+}
+export type QueueInput = string | QueueSelector;
+export interface Lease {
+    leaseId: string;
+    acquiredAt: number;
+    queueKey: string;
+}
+export interface QueueLimits {
+    maxConcurrent?: number;
+    minTime?: number;
+    reservoir?: number;
+    reservoirRefreshAmount?: number;
+    reservoirRefreshInterval?: number;
+}
+export interface ResolvedQueue {
+    name: string;
+    queueKey: string;
+    config: SerializableQueueConfig;
+    limits: QueueLimits;
+}
+export interface RateLimitBackend {
+    acquire(queueKey: string, limits: QueueLimits, timeoutMs?: number): Promise<Lease>;
+    release(lease: Lease): Promise<void>;
+}
+export interface ActiveQueuedOperation<T> {
+    queueInput: QueueInput;
+    fn: () => Promise<T>;
+    attempt: number;
+    resolved: ResolvedQueue;
+    lease: Lease | null;
+}

package/dist/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) {

package/dist/serverless/server.mjs

@@ -48,6 +48,16 @@ var CoreApiService = class {
 };
 var coreApiService = new CoreApiService();
 
+// src/ratelimit/config-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+var cachedRuntimeQueues = null;
+var registeredServerConfig = null;
+function registerQueueConfig(config) {
+  registeredServerConfig = config;
+  cachedRuntimeQueues = config.queues ?? null;
+}
+
 // src/server/utils/schema.ts
 import * as z from "zod";
 function normalizeBilling(billing) {
@@ -226,6 +236,14 @@ function runWithConfig(config, fn) {
   return requestConfigStorage.run(config, fn);
 }
 
+// src/ratelimit/context.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var executionContextStorage = new AsyncLocalStorage2();
+var activeOperationStorage = new AsyncLocalStorage2();
+function runWithRateLimitExecutionContext(ctx, fn) {
+  return executionContextStorage.run(ctx, fn);
+}
+
 // src/errors.ts
 var InstallError = class extends Error {
   // Optional: which field caused the error
@@ -245,8 +263,8 @@ var AppAuthInvalidError = class extends Error {
 };
 
 // src/server/context-logger.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-var logContextStorage = new AsyncLocalStorage2();
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+var logContextStorage = new AsyncLocalStorage3();
 function runWithLogContext(context, fn) {
   return logContextStorage.run(context, fn);
 }
@@ -459,9 +477,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);
@@ -598,7 +624,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";
@@ -606,9 +632,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 ?? {},
@@ -690,8 +716,8 @@ function parseBodyByContentType(req) {
 }
 
 // src/server/route-handlers/handlers.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 
 // src/server/core-api-handler.ts
 async function handleCoreMethod(method, params) {
@@ -859,7 +885,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) {
@@ -1155,7 +1182,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;
@@ -1209,7 +1236,7 @@ function parseWebhookRequest(parsedBody, method, url, path2, headers, query, raw
   const webhookRequest = {
     method,
     url,
-    path: path2,
+    path: path3,
     headers,
     query,
     body: parsedBody,
@@ -1267,7 +1294,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)) {
@@ -1306,8 +1333,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) {
@@ -1992,6 +2019,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skedyul",
-  "version": "1.2.51",
+  "version": "1.3.0",
   "description": "The Skedyul SDK for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -64,7 +64,7 @@
     "build": "rm -rf dist tsconfig.tsbuildinfo && tsc --emitDeclarationOnly && tsup",
     "db:generate": "echo 'No database generation needed for this package'",
     "dev": "npx nodemon --watch src --ext js,ts --exec \"pnpm run build\"",
-    "test": "tsc --project tsconfig.tests.json && node --test dist-tests/tests/server.test.js dist-tests/tests/cli.test.js dist-tests/tests/agent-schema-v3.test.js"
+    "test": "tsc --project tsconfig.tests.json && node --test dist-tests/tests/server.test.js dist-tests/tests/cli.test.js dist-tests/tests/agent-schema-v3.test.js dist-tests/tests/ratelimit.test.js"
   },
   "keywords": [
     "mcp",
@@ -90,6 +90,6 @@
     "@types/node": "^24.10.1",
     "open": "^10.1.0",
     "tsup": "^8.0.0",
-    "typescript": "^5.5.0"
+    "typescript": "^6.0.3"
   }
 }