@shuttl-io/core 0.2.0

package/dist/trigger/ApiTrigger.d.ts

@@ -0,0 +1,37 @@
+import { BaseTrigger, TriggerOutput } from "./ITrigger";
+import { IOutcome } from "../outcomes/IOutcomes";
+export interface IApiAuthenticator {
+    authenticate(args: ApiTriggerArgs): Promise<boolean>;
+}
+export interface ApiTriggerConfig {
+    readonly cors?: string[];
+    readonly authenticator?: IApiAuthenticator;
+}
+export interface ApiAuth {
+    readonly authType: "bearer" | "basic" | "api_key";
+    readonly value: string;
+}
+export interface ApiTriggerArgs {
+    readonly method: "POST" | "GET" | "PUT" | "PATCH" | "DELETE";
+    readonly hostName: string;
+    readonly headers?: Record<string, string> | undefined;
+    readonly body?: any;
+    readonly queryParams?: Record<string, string> | undefined;
+    readonly pathParams?: Record<string, string> | undefined;
+    readonly cookies?: Record<string, string> | undefined;
+    readonly auth?: ApiAuth | undefined;
+}
+/**
+ * Represents a trigger that can activate an agent via an API call.
+ * This API trigger is the default trigger for agents.
+ */
+export declare class ApiTrigger extends BaseTrigger {
+    triggerType: string;
+    triggerConfig: Record<string, unknown>;
+    outcome?: IOutcome;
+    private authenticator?;
+    constructor(config?: ApiTriggerConfig);
+    parseArgs(rawArgs: any): Promise<TriggerOutput>;
+    private createInputContent;
+    validate(rawArgs: any): Promise<Record<string, unknown>>;
+}

package/dist/trigger/ApiTrigger.js

@@ -0,0 +1,106 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiTrigger = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const zod_1 = require("zod");
+const ITrigger_1 = require("./ITrigger");
+function assertNever(value) {
+    throw new Error(`Unexpected value: ${value}`);
+}
+const ApiTriggerSchema = zod_1.z.object({
+    method: zod_1.z.enum(["POST", "GET", "PUT", "PATCH", "DELETE"]),
+    hostName: zod_1.z.string(),
+    headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    body: zod_1.z.any().optional(),
+    queryParams: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    pathParams: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    cookies: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    auth: zod_1.z.object({
+        authType: zod_1.z.enum(["bearer", "basic", "api_key"]),
+        value: zod_1.z.string(),
+    }).optional(),
+});
+const fileAttachmentSchema = zod_1.z.object({
+    type: zod_1.z.literal("file"),
+    name: zod_1.z.string(),
+    content: zod_1.z.string(),
+    mimeType: zod_1.z.string().optional(),
+});
+const imageSchema = zod_1.z.object({
+    type: zod_1.z.literal("image"),
+    content: zod_1.z.string(),
+    name: zod_1.z.string(),
+    mimeType: zod_1.z.string().optional(),
+});
+const textSchema = zod_1.z.object({
+    type: zod_1.z.literal("text"),
+    content: zod_1.z.string(),
+});
+const bodySchema1 = zod_1.z.discriminatedUnion("type", [fileAttachmentSchema, imageSchema, textSchema]);
+const bodySchema = zod_1.z.union([bodySchema1, zod_1.z.array(bodySchema1)]);
+/**
+ * Represents a trigger that can activate an agent via an API call.
+ * This API trigger is the default trigger for agents.
+ */
+class ApiTrigger extends ITrigger_1.BaseTrigger {
+    constructor(config) {
+        super("api", config ?? {
+            cors: ["*"],
+            authenticator: async (_) => true,
+        });
+        this.triggerType = "api";
+        this.triggerConfig = {};
+        this.authenticator = config?.authenticator ?? undefined;
+    }
+    parseArgs(rawArgs) {
+        const args = ApiTriggerSchema.parse(rawArgs);
+        const body = bodySchema.parse(args.body);
+        if (!Array.isArray(body)) {
+            return Promise.resolve({ input: [this.createInputContent(body)] });
+        }
+        return Promise.resolve({ input: body.map((b) => this.createInputContent(b)) });
+    }
+    createInputContent(body) {
+        if (body.type === "text") {
+            return { typeName: "text", text: body.content };
+        }
+        if (body.type === "file") {
+            return { typeName: "file", fileData: {
+                    content: body.content,
+                    name: body.name,
+                    mimeType: body.mimeType,
+                } };
+        }
+        if (body.type === "image") {
+            return {
+                typeName: "image",
+                fileData: {
+                    content: body.content,
+                    name: body.name,
+                    mimeType: body.mimeType,
+                }
+            };
+        }
+        assertNever(body);
+    }
+    async validate(rawArgs) {
+        const args = ApiTriggerSchema.safeParse(rawArgs);
+        if (!args.success) {
+            return Promise.resolve({ error: "Invalid arguments", details: args.error.issues });
+        }
+        if (!this.authenticator) {
+            return Promise.resolve({});
+        }
+        const authenticator = this.authenticator;
+        const authenticated = await authenticator.authenticate(args.data);
+        if (!authenticated) {
+            return Promise.resolve({ error: "Unauthorized" });
+        }
+        return Promise.resolve({});
+    }
+}
+exports.ApiTrigger = ApiTrigger;
+_a = JSII_RTTI_SYMBOL_1;
+ApiTrigger[_a] = { fqn: "@shuttl-io/core.ApiTrigger", version: "0.2.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ApiTrigger.js","sourceRoot":"","sources":["../../src/trigger/ApiTrigger.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from \"zod\";\nimport { InputContent } from \"../models/types\";\nimport { BaseTrigger, TriggerOutput } from \"./ITrigger\";\nimport { IOutcome } from \"../outcomes/IOutcomes\";\n\nfunction assertNever(value: never): never {\n    throw new Error(`Unexpected value: ${value}`);\n}\n\nexport interface IApiAuthenticator {\n    authenticate(args: ApiTriggerArgs): Promise<boolean>;\n}\n\nexport interface ApiTriggerConfig {\n    readonly cors?: string[];\n    readonly authenticator?: IApiAuthenticator;\n}\n\nconst ApiTriggerSchema = z.object({\n    method: z.enum([\"POST\", \"GET\", \"PUT\", \"PATCH\", \"DELETE\"]),\n    hostName: z.string(),\n    headers: z.record(z.string(), z.string()).optional(),\n    body: z.any().optional(),\n    queryParams: z.record(z.string(), z.string()).optional(),\n    pathParams: z.record(z.string(), z.string()).optional(),\n    cookies: z.record(z.string(), z.string()).optional(),\n    auth: z.object({\n        authType: z.enum([\"bearer\", \"basic\", \"api_key\"]),\n        value: z.string(),\n    }).optional(),\n});\n\nconst fileAttachmentSchema = z.object({\n    type: z.literal(\"file\"),\n    name: z.string(),\n    content: z.string(),\n    mimeType: z.string().optional(),\n});\n\nconst imageSchema = z.object({\n    type: z.literal(\"image\"),\n    content: z.string(),\n    name: z.string(),\n    mimeType: z.string().optional(),\n});\n\nconst textSchema = z.object({\n    type: z.literal(\"text\"),\n    content: z.string(),\n});\n\nconst bodySchema1 = z.discriminatedUnion(\"type\", [fileAttachmentSchema, imageSchema, textSchema]);\n\nconst bodySchema = z.union([bodySchema1, z.array(bodySchema1)]);\n\nexport interface ApiAuth {\n    readonly authType: \"bearer\" | \"basic\" | \"api_key\";\n    readonly value: string;\n}\n\nexport interface ApiTriggerArgs {\n    readonly method: \"POST\" | \"GET\" | \"PUT\" | \"PATCH\" | \"DELETE\";\n    readonly hostName: string;\n    readonly headers?: Record<string, string> | undefined;\n    readonly body?: any;\n    readonly queryParams?: Record<string, string> | undefined;\n    readonly pathParams?: Record<string, string> | undefined;\n    readonly cookies?: Record<string, string> | undefined;\n    readonly auth?: ApiAuth | undefined;\n}\n\n/**\n * Represents a trigger that can activate an agent via an API call.\n * This API trigger is the default trigger for agents.\n */\nexport class ApiTrigger extends BaseTrigger  {\n    public triggerType: string = \"api\";\n    public triggerConfig: Record<string, unknown> = {};\n    public outcome?: IOutcome;\n    private authenticator?: IApiAuthenticator;\n\n    public constructor(config?: ApiTriggerConfig) {\n        super(\"api\", config ?? {\n            cors: [\"*\"],\n            authenticator: async (_: ApiTriggerArgs) => true,\n        } as any);\n        this.authenticator = config?.authenticator ?? undefined;\n    }\n\n    public parseArgs(rawArgs: any): Promise<TriggerOutput> {\n        const args = ApiTriggerSchema.parse(rawArgs);\n        const body = bodySchema.parse(args.body);\n        if (!Array.isArray(body)) {\n            return Promise.resolve({ input: [this.createInputContent(body)] });\n        }\n        return Promise.resolve({ input: body.map((b) => this.createInputContent(b)) });\n    }\n\n    private createInputContent(body: z.infer<typeof bodySchema1>): InputContent {\n        if (body.type === \"text\") {\n            return { typeName: \"text\", text: body.content };\n        }\n        if (body.type === \"file\") {\n            return { typeName: \"file\", fileData: {\n                content: body.content,\n                name: body.name,\n                mimeType: body.mimeType,\n            } };\n        }\n        if (body.type === \"image\") {\n            return { \n                typeName: \"image\", \n                fileData: {\n                    content: body.content,\n                    name: body.name,\n                    mimeType: body.mimeType,\n                }\n            };\n        }\n        assertNever(body);\n    }\n\n    public async validate(rawArgs: any): Promise<Record<string, unknown>> {\n        const args = ApiTriggerSchema.safeParse(rawArgs);\n        if (!args.success) {\n            return Promise.resolve({ error: \"Invalid arguments\", details: args.error.issues });\n        }\n        if (!this.authenticator) {\n            return Promise.resolve({});\n        }\n        const authenticator = this.authenticator;\n        const authenticated = await authenticator.authenticate(args.data);\n        if (!authenticated) {\n            return Promise.resolve({ error: \"Unauthorized\" });\n        }\n        return Promise.resolve({});\n    }\n}\n"]}

package/dist/trigger/EmailTrigger.d.ts

@@ -0,0 +1,15 @@
+import { BaseTrigger, TriggerOutput } from "./ITrigger";
+import { IOutcome } from "../outcomes/IOutcomes";
+export interface EmailTriggerConfig {
+    readonly inboxName: string;
+    readonly domain: string;
+    readonly fromAddress: string;
+    readonly subjectPattern: string;
+    readonly folder: string;
+}
+export declare class EmailTrigger extends BaseTrigger {
+    triggerType: string;
+    outcome?: IOutcome;
+    constructor(config: EmailTriggerConfig);
+    parseArgs(_: any): Promise<TriggerOutput>;
+}

package/dist/trigger/EmailTrigger.js

@@ -0,0 +1,22 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailTrigger = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const ITrigger_1 = require("./ITrigger");
+class EmailTrigger extends ITrigger_1.BaseTrigger {
+    constructor(config) {
+        super("email", config);
+        this.triggerType = "email";
+    }
+    parseArgs(_) {
+        return Promise.resolve({ input: [{
+                    typeName: "text",
+                    text: "The email trigger is activated",
+                }] });
+    }
+}
+exports.EmailTrigger = EmailTrigger;
+_a = JSII_RTTI_SYMBOL_1;
+EmailTrigger[_a] = { fqn: "@shuttl-io/core.EmailTrigger", version: "0.2.0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRW1haWxUcmlnZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RyaWdnZXIvRW1haWxUcmlnZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEseUNBQXdEO0FBV3hELE1BQWEsWUFBYSxTQUFRLHNCQUFXO0lBSXpDLFlBQW1CLE1BQTBCO1FBQ3pDLEtBQUssQ0FBQyxPQUFPLEVBQUUsTUFBYSxDQUFDLENBQUM7UUFKM0IsZ0JBQVcsR0FBVyxPQUFPLENBQUM7SUFLckMsQ0FBQztJQUVNLFNBQVMsQ0FBQyxDQUFNO1FBQ25CLE9BQU8sT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLEtBQUssRUFBRSxDQUFDO29CQUM3QixRQUFRLEVBQUUsTUFBTTtvQkFDaEIsSUFBSSxFQUFFLGdDQUFnQztpQkFDekMsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNWLENBQUM7O0FBYkwsb0NBY0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCYXNlVHJpZ2dlciwgVHJpZ2dlck91dHB1dCB9IGZyb20gXCIuL0lUcmlnZ2VyXCI7XG5pbXBvcnQgeyBJT3V0Y29tZSB9IGZyb20gXCIuLi9vdXRjb21lcy9JT3V0Y29tZXNcIjtcblxuZXhwb3J0IGludGVyZmFjZSBFbWFpbFRyaWdnZXJDb25maWcge1xuICAgIHJlYWRvbmx5IGluYm94TmFtZTogc3RyaW5nO1xuICAgIHJlYWRvbmx5IGRvbWFpbjogc3RyaW5nO1xuICAgIHJlYWRvbmx5IGZyb21BZGRyZXNzOiBzdHJpbmc7XG4gICAgcmVhZG9ubHkgc3ViamVjdFBhdHRlcm46IHN0cmluZztcbiAgICByZWFkb25seSBmb2xkZXI6IHN0cmluZztcbn1cblxuZXhwb3J0IGNsYXNzIEVtYWlsVHJpZ2dlciBleHRlbmRzIEJhc2VUcmlnZ2VyIHtcbiAgICBwdWJsaWMgdHJpZ2dlclR5cGU6IHN0cmluZyA9IFwiZW1haWxcIjtcbiAgICBwdWJsaWMgb3V0Y29tZT86IElPdXRjb21lO1xuXG4gICAgcHVibGljIGNvbnN0cnVjdG9yKGNvbmZpZzogRW1haWxUcmlnZ2VyQ29uZmlnKSB7XG4gICAgICAgIHN1cGVyKFwiZW1haWxcIiwgY29uZmlnIGFzIGFueSk7XG4gICAgfVxuXG4gICAgcHVibGljIHBhcnNlQXJncyhfOiBhbnkpOiBQcm9taXNlPFRyaWdnZXJPdXRwdXQ+IHtcbiAgICAgICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSh7IGlucHV0OiBbe1xuICAgICAgICAgICAgdHlwZU5hbWU6IFwidGV4dFwiLFxuICAgICAgICAgICAgdGV4dDogXCJUaGUgZW1haWwgdHJpZ2dlciBpcyBhY3RpdmF0ZWRcIixcbiAgICAgICAgfV0gfSk7XG4gICAgfVxufSJdfQ==

package/dist/trigger/FileTrigger.d.ts

@@ -0,0 +1,14 @@
+import { IOutcome } from "../outcomes/IOutcomes";
+import { BaseTrigger, TriggerOutput } from "./ITrigger";
+export interface FileTriggerConfig {
+    readonly allowedExtensions: string[];
+    readonly maxFileSize: number;
+    readonly uploadPath: string;
+    readonly s3Bucket: string;
+}
+export declare class FileTrigger extends BaseTrigger {
+    triggerType: string;
+    outcome?: IOutcome;
+    constructor(config: FileTriggerConfig);
+    parseArgs(args: any): Promise<TriggerOutput>;
+}

package/dist/trigger/FileTrigger.js

@@ -0,0 +1,37 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTrigger = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const ITrigger_1 = require("./ITrigger");
+const zod_1 = require("zod");
+const FileTriggerSchema = zod_1.z.object({
+    content: zod_1.z.string(),
+    file_url: zod_1.z.string(),
+    mimeType: zod_1.z.string().optional(),
+    name: zod_1.z.string(),
+});
+class FileTrigger extends ITrigger_1.BaseTrigger {
+    constructor(config) {
+        super("file", config);
+        this.triggerType = "file";
+    }
+    parseArgs(args) {
+        const parsedArgs = FileTriggerSchema.safeParse(args);
+        if (!parsedArgs.success) {
+            throw new Error(parsedArgs.error.message);
+        }
+        return Promise.resolve({ input: [{
+                    typeName: "file",
+                    fileData: {
+                        content: parsedArgs.data.content,
+                        name: parsedArgs.data.name,
+                        mimeType: parsedArgs.data.mimeType,
+                    },
+                }] });
+    }
+}
+exports.FileTrigger = FileTrigger;
+_a = JSII_RTTI_SYMBOL_1;
+FileTrigger[_a] = { fqn: "@shuttl-io/core.FileTrigger", version: "0.2.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/trigger/ITrigger.d.ts

@@ -0,0 +1,90 @@
+import { InputContent, IModelResponseStream } from "../models/types";
+import { IOutcome } from "../outcomes/IOutcomes";
+export interface TriggerOutput {
+    readonly input: InputContent[];
+}
+export interface ITriggerInvoker {
+    invoke(prompt: InputContent[]): Promise<IModelResponseStream>;
+    defaultOutcome(stream: IModelResponseStream): Promise<void>;
+}
+/**
+ * Represents a serialized HTTP request from the serve command
+ */
+export interface SerializedHTTPRequest {
+    /** The HTTP method (POST, GET, etc.) */
+    readonly method: string;
+    /** The request path */
+    readonly path: string;
+    /** HTTP headers as key-value pairs with array values */
+    readonly headers: Record<string, string[]>;
+    /** Query parameters as key-value pairs with array values */
+    readonly query: Record<string, string[]>;
+    /** The request body (parsed JSON or raw) */
+    readonly body?: unknown;
+    /** The Content-Type header value */
+    readonly contentType: string;
+    /** The remote address of the client */
+    readonly remoteAddr: string;
+    /** The host header value */
+    readonly host: string;
+    /** The HTTP protocol version */
+    readonly proto: string;
+    /** Timestamp of when the request was received */
+    readonly timestamp: string;
+}
+/**
+ * Represents a trigger that can activate an agent. Triggers can take any arguments and then return what the input should be for the agent.
+ * Triggers also can validate the arguments and return an error if the arguments are invalid.
+ */
+export interface ITrigger {
+    /**
+     * The unique name of this trigger instance.
+     * If not set, defaults to triggerType.
+     */
+    name: string;
+    /**
+     * The type of trigger.
+     */
+    triggerType: string;
+    /**
+     * The configuration for the trigger.
+     */
+    triggerConfig: Record<string, unknown>;
+    outcome?: IOutcome;
+    /**
+     * Activates the trigger and returns the input for the agent.
+     * @param args - The arguments for the trigger.
+     * @returns The input for the agent.
+     */
+    activate(args: any, invoker: ITriggerInvoker): Promise<void>;
+    /**
+     * Validates the arguments for the trigger.
+     * @param args - The arguments for the trigger.
+     * @returns The validation result.
+     */
+    validate?(args: any): Promise<Record<string, unknown>>;
+    /**
+     * binds the outcome to the trigger
+     * @param outcome - The outcome to bind to the trigger.
+     * @returns The bound outcome.
+     */
+    bindOutcome(outcome: IOutcome): ITrigger;
+    /**
+     * Sets the name of the trigger
+     * @param name - The name to set for the trigger
+     * @returns The trigger instance for chaining
+     */
+    withName(name: string): ITrigger;
+}
+export declare abstract class BaseTrigger implements ITrigger {
+    name: string;
+    triggerType: string;
+    triggerConfig: Record<string, unknown>;
+    outcome?: IOutcome;
+    constructor(triggerType: string, config: Record<string, unknown>);
+    abstract parseArgs(args: any): Promise<TriggerOutput>;
+    activate(args: any, invoker: ITriggerInvoker): Promise<void>;
+    bindOutcome(outcome: IOutcome): ITrigger;
+    withName(name: string): ITrigger;
+    validate(_: any): Promise<Record<string, unknown>>;
+}

package/dist/trigger/ITrigger.js

@@ -0,0 +1,38 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTrigger = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+class BaseTrigger {
+    constructor(triggerType, config) {
+        this.triggerConfig = {};
+        this.triggerType = triggerType;
+        this.name = triggerType; // Default name is the trigger type
+        this.triggerConfig = config;
+    }
+    async activate(args, invoker) {
+        const parsedArgs = await this.parseArgs(args);
+        const response = await invoker.invoke(parsedArgs.input);
+        if (this.outcome) {
+            await this.outcome.send(response);
+        }
+        else {
+            await invoker.defaultOutcome(response);
+        }
+    }
+    bindOutcome(outcome) {
+        this.outcome = outcome;
+        return this;
+    }
+    withName(name) {
+        this.name = name;
+        return this;
+    }
+    validate(_) {
+        return Promise.resolve({});
+    }
+}
+exports.BaseTrigger = BaseTrigger;
+_a = JSII_RTTI_SYMBOL_1;
+BaseTrigger[_a] = { fqn: "@shuttl-io/core.BaseTrigger", version: "0.2.0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVRyaWdnZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJpZ2dlci9JVHJpZ2dlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQXlGQSxNQUFzQixXQUFXO0lBTTdCLFlBQW1CLFdBQW1CLEVBQUUsTUFBK0I7UUFIaEUsa0JBQWEsR0FBNEIsRUFBRSxDQUFDO1FBSS9DLElBQUksQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFDO1FBQy9CLElBQUksQ0FBQyxJQUFJLEdBQUcsV0FBVyxDQUFDLENBQUMsbUNBQW1DO1FBQzVELElBQUksQ0FBQyxhQUFhLEdBQUcsTUFBTSxDQUFDO0lBQ2hDLENBQUM7SUFJTSxLQUFLLENBQUMsUUFBUSxDQUFDLElBQVMsRUFBRSxPQUF3QjtRQUNyRCxNQUFNLFVBQVUsR0FBRyxNQUFNLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDOUMsTUFBTSxRQUFRLEdBQUcsTUFBTSxPQUFPLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUN4RCxJQUFJLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNmLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDdEMsQ0FBQzthQUFNLENBQUM7WUFDSixNQUFNLE9BQU8sQ0FBQyxjQUFjLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDM0MsQ0FBQztJQUNMLENBQUM7SUFFTSxXQUFXLENBQUMsT0FBaUI7UUFDaEMsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQztJQUVNLFFBQVEsQ0FBQyxJQUFZO1FBQ3hCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQ2pCLE9BQU8sSUFBSSxDQUFDO0lBQ2hCLENBQUM7SUFFRCxRQUFRLENBQUMsQ0FBTTtRQUNYLE9BQU8sT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUMvQixDQUFDOztBQXBDTCxrQ0FxQ0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbnB1dENvbnRlbnQsIElNb2RlbFJlc3BvbnNlU3RyZWFtIH0gZnJvbSBcIi4uL21vZGVscy90eXBlc1wiO1xuaW1wb3J0IHsgSU91dGNvbWUgfSBmcm9tIFwiLi4vb3V0Y29tZXMvSU91dGNvbWVzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgVHJpZ2dlck91dHB1dCB7XG4gICAgcmVhZG9ubHkgaW5wdXQ6IElucHV0Q29udGVudFtdO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIElUcmlnZ2VySW52b2tlciB7XG4gICAgaW52b2tlKHByb21wdDogSW5wdXRDb250ZW50W10pOiBQcm9taXNlPElNb2RlbFJlc3BvbnNlU3RyZWFtPjtcbiAgICBkZWZhdWx0T3V0Y29tZShzdHJlYW06IElNb2RlbFJlc3BvbnNlU3RyZWFtKTogUHJvbWlzZTx2b2lkPjtcbn1cblxuLyoqXG4gKiBSZXByZXNlbnRzIGEgc2VyaWFsaXplZCBIVFRQIHJlcXVlc3QgZnJvbSB0aGUgc2VydmUgY29tbWFuZFxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNlcmlhbGl6ZWRIVFRQUmVxdWVzdCB7XG4gICAgLyoqIFRoZSBIVFRQIG1ldGhvZCAoUE9TVCwgR0VULCBldGMuKSAqL1xuICAgIHJlYWRvbmx5IG1ldGhvZDogc3RyaW5nO1xuICAgIC8qKiBUaGUgcmVxdWVzdCBwYXRoICovXG4gICAgcmVhZG9ubHkgcGF0aDogc3RyaW5nO1xuICAgIC8qKiBIVFRQIGhlYWRlcnMgYXMga2V5LXZhbHVlIHBhaXJzIHdpdGggYXJyYXkgdmFsdWVzICovXG4gICAgcmVhZG9ubHkgaGVhZGVyczogUmVjb3JkPHN0cmluZywgc3RyaW5nW10+O1xuICAgIC8qKiBRdWVyeSBwYXJhbWV0ZXJzIGFzIGtleS12YWx1ZSBwYWlycyB3aXRoIGFycmF5IHZhbHVlcyAqL1xuICAgIHJlYWRvbmx5IHF1ZXJ5OiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmdbXT47XG4gICAgLyoqIFRoZSByZXF1ZXN0IGJvZHkgKHBhcnNlZCBKU09OIG9yIHJhdykgKi9cbiAgICByZWFkb25seSBib2R5PzogdW5rbm93bjtcbiAgICAvKiogVGhlIENvbnRlbnQtVHlwZSBoZWFkZXIgdmFsdWUgKi9cbiAgICByZWFkb25seSBjb250ZW50VHlwZTogc3RyaW5nO1xuICAgIC8qKiBUaGUgcmVtb3RlIGFkZHJlc3Mgb2YgdGhlIGNsaWVudCAqL1xuICAgIHJlYWRvbmx5IHJlbW90ZUFkZHI6IHN0cmluZztcbiAgICAvKiogVGhlIGhvc3QgaGVhZGVyIHZhbHVlICovXG4gICAgcmVhZG9ubHkgaG9zdDogc3RyaW5nO1xuICAgIC8qKiBUaGUgSFRUUCBwcm90b2NvbCB2ZXJzaW9uICovXG4gICAgcmVhZG9ubHkgcHJvdG86IHN0cmluZztcbiAgICAvKiogVGltZXN0YW1wIG9mIHdoZW4gdGhlIHJlcXVlc3Qgd2FzIHJlY2VpdmVkICovXG4gICAgcmVhZG9ubHkgdGltZXN0YW1wOiBzdHJpbmc7XG59XG5cbi8qKlxuICogUmVwcmVzZW50cyBhIHRyaWdnZXIgdGhhdCBjYW4gYWN0aXZhdGUgYW4gYWdlbnQuIFRyaWdnZXJzIGNhbiB0YWtlIGFueSBhcmd1bWVudHMgYW5kIHRoZW4gcmV0dXJuIHdoYXQgdGhlIGlucHV0IHNob3VsZCBiZSBmb3IgdGhlIGFnZW50LlxuICogVHJpZ2dlcnMgYWxzbyBjYW4gdmFsaWRhdGUgdGhlIGFyZ3VtZW50cyBhbmQgcmV0dXJuIGFuIGVycm9yIGlmIHRoZSBhcmd1bWVudHMgYXJlIGludmFsaWQuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSVRyaWdnZXIge1xuICAgIC8qKlxuICAgICAqIFRoZSB1bmlxdWUgbmFtZSBvZiB0aGlzIHRyaWdnZXIgaW5zdGFuY2UuXG4gICAgICogSWYgbm90IHNldCwgZGVmYXVsdHMgdG8gdHJpZ2dlclR5cGUuXG4gICAgICovXG4gICAgbmFtZTogc3RyaW5nO1xuXG4gICAgLyoqXG4gICAgICogVGhlIHR5cGUgb2YgdHJpZ2dlci5cbiAgICAgKi9cbiAgICB0cmlnZ2VyVHlwZTogc3RyaW5nO1xuICAgIC8qKlxuICAgICAqIFRoZSBjb25maWd1cmF0aW9uIGZvciB0aGUgdHJpZ2dlci5cbiAgICAgKi9cbiAgICB0cmlnZ2VyQ29uZmlnOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcblxuICAgIG91dGNvbWU/OiBJT3V0Y29tZTtcblxuICAgIC8qKlxuICAgICAqIEFjdGl2YXRlcyB0aGUgdHJpZ2dlciBhbmQgcmV0dXJucyB0aGUgaW5wdXQgZm9yIHRoZSBhZ2VudC5cbiAgICAgKiBAcGFyYW0gYXJncyAtIFRoZSBhcmd1bWVudHMgZm9yIHRoZSB0cmlnZ2VyLlxuICAgICAqIEByZXR1cm5zIFRoZSBpbnB1dCBmb3IgdGhlIGFnZW50LlxuICAgICAqL1xuICAgIGFjdGl2YXRlKGFyZ3M6IGFueSwgaW52b2tlcjogSVRyaWdnZXJJbnZva2VyKTogUHJvbWlzZTx2b2lkPjtcblxuICAgIC8qKlxuICAgICAqIFZhbGlkYXRlcyB0aGUgYXJndW1lbnRzIGZvciB0aGUgdHJpZ2dlci5cbiAgICAgKiBAcGFyYW0gYXJncyAtIFRoZSBhcmd1bWVudHMgZm9yIHRoZSB0cmlnZ2VyLlxuICAgICAqIEByZXR1cm5zIFRoZSB2YWxpZGF0aW9uIHJlc3VsdC5cbiAgICAgKi9cbiAgICB2YWxpZGF0ZT8oYXJnczogYW55KTogUHJvbWlzZTxSZWNvcmQ8c3RyaW5nLCB1bmtub3duPj47XG5cbiAgICAvKipcbiAgICAgKiBiaW5kcyB0aGUgb3V0Y29tZSB0byB0aGUgdHJpZ2dlclxuICAgICAqIEBwYXJhbSBvdXRjb21lIC0gVGhlIG91dGNvbWUgdG8gYmluZCB0byB0aGUgdHJpZ2dlci5cbiAgICAgKiBAcmV0dXJucyBUaGUgYm91bmQgb3V0Y29tZS5cbiAgICAgKi9cbiAgICBiaW5kT3V0Y29tZShvdXRjb21lOiBJT3V0Y29tZSk6IElUcmlnZ2VyO1xuXG4gICAgLyoqXG4gICAgICogU2V0cyB0aGUgbmFtZSBvZiB0aGUgdHJpZ2dlclxuICAgICAqIEBwYXJhbSBuYW1lIC0gVGhlIG5hbWUgdG8gc2V0IGZvciB0aGUgdHJpZ2dlclxuICAgICAqIEByZXR1cm5zIFRoZSB0cmlnZ2VyIGluc3RhbmNlIGZvciBjaGFpbmluZ1xuICAgICAqL1xuICAgIHdpdGhOYW1lKG5hbWU6IHN0cmluZyk6IElUcmlnZ2VyO1xufVxuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQmFzZVRyaWdnZXIgaW1wbGVtZW50cyBJVHJpZ2dlciB7XG4gICAgcHVibGljIG5hbWU6IHN0cmluZztcbiAgICBwdWJsaWMgdHJpZ2dlclR5cGU6IHN0cmluZztcbiAgICBwdWJsaWMgdHJpZ2dlckNvbmZpZzogUmVjb3JkPHN0cmluZywgdW5rbm93bj4gPSB7fTtcbiAgICBwdWJsaWMgb3V0Y29tZT86IElPdXRjb21lO1xuXG4gICAgcHVibGljIGNvbnN0cnVjdG9yKHRyaWdnZXJUeXBlOiBzdHJpbmcsIGNvbmZpZzogUmVjb3JkPHN0cmluZywgdW5rbm93bj4pIHtcbiAgICAgICAgdGhpcy50cmlnZ2VyVHlwZSA9IHRyaWdnZXJUeXBlO1xuICAgICAgICB0aGlzLm5hbWUgPSB0cmlnZ2VyVHlwZTsgLy8gRGVmYXVsdCBuYW1lIGlzIHRoZSB0cmlnZ2VyIHR5cGVcbiAgICAgICAgdGhpcy50cmlnZ2VyQ29uZmlnID0gY29uZmlnO1xuICAgIH1cblxuICAgIHB1YmxpYyBhYnN0cmFjdCBwYXJzZUFyZ3MoYXJnczogYW55KTogUHJvbWlzZTxUcmlnZ2VyT3V0cHV0PjtcblxuICAgIHB1YmxpYyBhc3luYyBhY3RpdmF0ZShhcmdzOiBhbnksIGludm9rZXI6IElUcmlnZ2VySW52b2tlcik6IFByb21pc2U8dm9pZD4ge1xuICAgICAgICBjb25zdCBwYXJzZWRBcmdzID0gYXdhaXQgdGhpcy5wYXJzZUFyZ3MoYXJncyk7XG4gICAgICAgIGNvbnN0IHJlc3BvbnNlID0gYXdhaXQgaW52b2tlci5pbnZva2UocGFyc2VkQXJncy5pbnB1dCk7XG4gICAgICAgIGlmICh0aGlzLm91dGNvbWUpIHtcbiAgICAgICAgICAgIGF3YWl0IHRoaXMub3V0Y29tZS5zZW5kKHJlc3BvbnNlKTtcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgIGF3YWl0IGludm9rZXIuZGVmYXVsdE91dGNvbWUocmVzcG9uc2UpO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgcHVibGljIGJpbmRPdXRjb21lKG91dGNvbWU6IElPdXRjb21lKTogSVRyaWdnZXIge1xuICAgICAgICB0aGlzLm91dGNvbWUgPSBvdXRjb21lO1xuICAgICAgICByZXR1cm4gdGhpcztcbiAgICB9XG5cbiAgICBwdWJsaWMgd2l0aE5hbWUobmFtZTogc3RyaW5nKTogSVRyaWdnZXIge1xuICAgICAgICB0aGlzLm5hbWUgPSBuYW1lO1xuICAgICAgICByZXR1cm4gdGhpcztcbiAgICB9XG5cbiAgICB2YWxpZGF0ZShfOiBhbnkpOiBQcm9taXNlPFJlY29yZDxzdHJpbmcsIHVua25vd24+PiB7XG4gICAgICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoe30pO1xuICAgIH1cbn0iXX0=

package/dist/trigger/RateTrigger.d.ts

@@ -0,0 +1,23 @@
+import { BaseTrigger, TriggerOutput } from "./ITrigger";
+import { InputContent } from "../models/types";
+import { IOutcome } from "../outcomes/IOutcomes";
+export interface IRateTriggerOnTrigger {
+    onTrigger(): Promise<InputContent[]>;
+}
+export declare class Rate extends BaseTrigger {
+    triggerType: string;
+    triggerConfig: Record<string, unknown>;
+    outcome?: IOutcome;
+    private onTrigger;
+    private constructor();
+    parseArgs(_: any): Promise<TriggerOutput>;
+    withOnTrigger(onTrigger: IRateTriggerOnTrigger): Rate;
+    static milliseconds(value: number): Rate;
+    static seconds(value: number): Rate;
+    static minutes(value: number): Rate;
+    static hours(value: number): Rate;
+    static days(value: number): Rate;
+    static weeks(value: number): Rate;
+    static months(value: number): Rate;
+    static cron(expression: string, timezone?: string): Rate;
+}

package/dist/trigger/RateTrigger.js

@@ -0,0 +1,58 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rate = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const ITrigger_1 = require("./ITrigger");
+class Rate extends ITrigger_1.BaseTrigger {
+    constructor(config) {
+        super("rate", config);
+        this.triggerType = "rate";
+        this.triggerConfig = {};
+        this.onTrigger = config.onTrigger?.onTrigger ?? null;
+    }
+    async parseArgs(_) {
+        if (this.onTrigger) {
+            const input = await this.onTrigger();
+            return { input };
+        }
+        else {
+            return { input: [{
+                        typeName: "text",
+                        text: "The cron expression is " + this.triggerConfig.cronExpression + " and the timezone is " + this.triggerConfig.timezone,
+                    }] };
+        }
+    }
+    withOnTrigger(onTrigger) {
+        this.onTrigger = onTrigger.onTrigger;
+        return this;
+    }
+    static milliseconds(value) {
+        return new Rate({ ms_rate: value });
+    }
+    static seconds(value) {
+        return new Rate({ ms_rate: value * 1000 });
+    }
+    static minutes(value) {
+        return new Rate({ ms_rate: value * 60 * 1000 });
+    }
+    static hours(value) {
+        return new Rate({ ms_rate: value * 60 * 60 * 1000 });
+    }
+    static days(value) {
+        return new Rate({ ms_rate: value * 24 * 60 * 60 * 1000 });
+    }
+    static weeks(value) {
+        return new Rate({ ms_rate: value * 7 * 24 * 60 * 60 * 1000 });
+    }
+    static months(value) {
+        return new Rate({ ms_rate: value * 30 * 24 * 60 * 60 * 1000 });
+    }
+    static cron(expression, timezone) {
+        return new Rate({ cronExpression: expression, timezone: timezone ?? "UTC" });
+    }
+}
+exports.Rate = Rate;
+_a = JSII_RTTI_SYMBOL_1;
+Rate[_a] = { fqn: "@shuttl-io/core.Rate", version: "0.2.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/trigger/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./ApiTrigger";
+export * from "./RateTrigger";
+export * from "./ITrigger";
+export * from "./FileTrigger";
+export * from "./EmailTrigger";

package/dist/trigger/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ApiTrigger"), exports);
+__exportStar(require("./RateTrigger"), exports);
+__exportStar(require("./ITrigger"), exports);
+__exportStar(require("./FileTrigger"), exports);
+__exportStar(require("./EmailTrigger"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJpZ2dlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsK0NBQTZCO0FBQzdCLGdEQUE4QjtBQUM5Qiw2Q0FBMkI7QUFDM0IsZ0RBQThCO0FBQzlCLGlEQUErQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL0FwaVRyaWdnZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1JhdGVUcmlnZ2VyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9JVHJpZ2dlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vRmlsZVRyaWdnZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0VtYWlsVHJpZ2dlclwiOyJdfQ==

package/jest.config.js

@@ -0,0 +1,20 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  displayName: 'shuttl-lib',
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/tests'],
+  testMatch: ['**/*.test.ts'],
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  transform: {
+    '^.+\\.ts$': ['ts-jest', {
+      tsconfig: '<rootDir>/tsconfig.json',
+    }],
+  },
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/index.ts',
+  ],
+  coverageDirectory: 'coverage',
+};
+

package/node_modules/zod/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.