@versori/run 0.4.0-alpha.1 → 0.4.0-alpha.10

package/esm/deps/jsr.io/@std/encoding/1.0.10/_common64.d.ts

@@ -0,0 +1,35 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+export declare const padding: number;
+export declare const alphabet: Record<Base64Alphabet, Uint8Array>;
+export declare const rAlphabet: Record<Base64Alphabet, Uint8Array>;
+/**
+ * Options for encoding and decoding base64 strings.
+ */
+export interface Base64Options {
+    /** The base64 alphabet. Defaults to "base64" */
+    alphabet?: Base64Alphabet;
+}
+/**
+ * The base64 alphabets.
+ */
+export type Base64Alphabet = "base64" | "base64url";
+/**
+ * Calculate the output size needed to encode a given input size for
+ * {@linkcode encodeIntoBase64}.
+ *
+ * @param originalSize The size of the input buffer.
+ * @returns The size of the output buffer.
+ *
+ * @example Basic Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { calcSizeBase64 } from "@std/encoding/unstable-base64";
+ *
+ * assertEquals(calcSizeBase64(1), 4);
+ * ```
+ */
+export declare function calcSizeBase64(originalSize: number): number;
+export declare function encode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array, padding: number): number;
+export declare function decode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array, padding: number): number;
+//# sourceMappingURL=_common64.d.ts.map

package/esm/deps/jsr.io/@std/encoding/1.0.10/_common64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_common64.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/_common64.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B,eAAO,MAAM,OAAO,QAAoB,CAAC;AACzC,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,cAAc,EAAE,UAAU,CAKvD,CAAC;AACF,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,cAAc,EAAE,UAAU,CAGxD,CAAC;AAMF;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEpD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,MAAM,CACpB,MAAM,EAAE,WAAW,EACnB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,GACd,MAAM,CA4BR;AAED,wBAAgB,MAAM,CACpB,MAAM,EAAE,WAAW,EACnB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,GACd,MAAM,CAmDR"}

package/esm/deps/jsr.io/@std/encoding/1.0.10/_common64.js

@@ -0,0 +1,113 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+export const padding = "=".charCodeAt(0);
+export const alphabet = {
+    base64: new TextEncoder()
+        .encode("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"),
+    base64url: new TextEncoder()
+        .encode("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"),
+};
+export const rAlphabet = {
+    base64: new Uint8Array(128).fill(64), // alphabet.base64.length
+    base64url: new Uint8Array(128).fill(64),
+};
+alphabet.base64
+    .forEach((byte, i) => rAlphabet.base64[byte] = i);
+alphabet.base64url
+    .forEach((byte, i) => rAlphabet.base64url[byte] = i);
+/**
+ * Calculate the output size needed to encode a given input size for
+ * {@linkcode encodeIntoBase64}.
+ *
+ * @param originalSize The size of the input buffer.
+ * @returns The size of the output buffer.
+ *
+ * @example Basic Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { calcSizeBase64 } from "@std/encoding/unstable-base64";
+ *
+ * assertEquals(calcSizeBase64(1), 4);
+ * ```
+ */
+export function calcSizeBase64(originalSize) {
+    return ((originalSize + 2) / 3 | 0) * 4;
+}
+export function encode(buffer, i, o, alphabet, padding) {
+    i += 2;
+    for (; i < buffer.length; i += 3) {
+        const x = (buffer[i - 2] << 16) | (buffer[i - 1] << 8) | buffer[i];
+        buffer[o++] = alphabet[x >> 18];
+        buffer[o++] = alphabet[x >> 12 & 0x3F];
+        buffer[o++] = alphabet[x >> 6 & 0x3F];
+        buffer[o++] = alphabet[x & 0x3F];
+    }
+    switch (i) {
+        case buffer.length + 1: {
+            const x = buffer[i - 2] << 16;
+            buffer[o++] = alphabet[x >> 18];
+            buffer[o++] = alphabet[x >> 12 & 0x3F];
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            break;
+        }
+        case buffer.length: {
+            const x = (buffer[i - 2] << 16) | (buffer[i - 1] << 8);
+            buffer[o++] = alphabet[x >> 18];
+            buffer[o++] = alphabet[x >> 12 & 0x3F];
+            buffer[o++] = alphabet[x >> 6 & 0x3F];
+            buffer[o++] = padding;
+            break;
+        }
+    }
+    return o;
+}
+export function decode(buffer, i, o, alphabet, padding) {
+    for (let x = buffer.length - 2; x < buffer.length; ++x) {
+        if (buffer[x] === padding) {
+            for (let y = x + 1; y < buffer.length; ++y) {
+                if (buffer[y] !== padding) {
+                    throw new TypeError(`Cannot decode input as base64: Invalid character (${String.fromCharCode(buffer[y])})`);
+                }
+            }
+            buffer = buffer.subarray(0, x);
+            break;
+        }
+    }
+    if ((buffer.length - o) % 4 === 1) {
+        throw new RangeError(`Cannot decode input as base64: Length (${buffer.length - o}), excluding padding, must not have a remainder of 1 when divided by 4`);
+    }
+    i += 3;
+    for (; i < buffer.length; i += 4) {
+        const x = (getByte(buffer[i - 3], alphabet) << 18) |
+            (getByte(buffer[i - 2], alphabet) << 12) |
+            (getByte(buffer[i - 1], alphabet) << 6) |
+            getByte(buffer[i], alphabet);
+        buffer[o++] = x >> 16;
+        buffer[o++] = x >> 8 & 0xFF;
+        buffer[o++] = x & 0xFF;
+    }
+    switch (i) {
+        case buffer.length + 1: {
+            const x = (getByte(buffer[i - 3], alphabet) << 18) |
+                (getByte(buffer[i - 2], alphabet) << 12);
+            buffer[o++] = x >> 16;
+            break;
+        }
+        case buffer.length: {
+            const x = (getByte(buffer[i - 3], alphabet) << 18) |
+                (getByte(buffer[i - 2], alphabet) << 12) |
+                (getByte(buffer[i - 1], alphabet) << 6);
+            buffer[o++] = x >> 16;
+            buffer[o++] = x >> 8 & 0xFF;
+            break;
+        }
+    }
+    return o;
+}
+function getByte(char, alphabet) {
+    const byte = alphabet[char] ?? 64;
+    if (byte === 64) { // alphabet.Base64.length
+        throw new TypeError(`Cannot decode input as base64: Invalid character (${String.fromCharCode(char)})`);
+    }
+    return byte;
+}

package/esm/deps/jsr.io/@std/encoding/1.0.10/_common_detach.d.ts

@@ -0,0 +1,4 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+export declare function detach(buffer: Uint8Array_, maxSize: number): [Uint8Array_, number];
+//# sourceMappingURL=_common_detach.d.ts.map

package/esm/deps/jsr.io/@std/encoding/1.0.10/_common_detach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_common_detach.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/_common_detach.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B,wBAAgB,MAAM,CACpB,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,MAAM,GACd,CAAC,WAAW,EAAE,MAAM,CAAC,CAWvB"}

package/esm/deps/jsr.io/@std/encoding/1.0.10/_common_detach.js

@@ -0,0 +1,13 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+export function detach(buffer, maxSize) {
+    const originalSize = buffer.length;
+    if (buffer.byteOffset) {
+        const b = new Uint8Array(buffer.buffer);
+        b.set(buffer);
+        buffer = b.subarray(0, originalSize);
+    }
+    // deno-lint-ignore no-explicit-any
+    buffer = new Uint8Array(buffer.buffer.transfer(maxSize));
+    buffer.set(buffer.subarray(0, originalSize), maxSize - originalSize);
+    return [buffer, maxSize - originalSize];
+}

package/esm/deps/jsr.io/@std/encoding/1.0.10/_types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Proxy type of {@code Uint8Array<ArrayBuffer} or {@code Uint8Array} in TypeScript 5.7 or below respectively.
+ *
+ * This type is internal utility type and should not be used directly.
+ *
+ * @internal @private
+ */
+export type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
+//# sourceMappingURL=_types.d.ts.map

package/esm/deps/jsr.io/@std/encoding/1.0.10/_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/_types.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC"}

package/esm/deps/jsr.io/@std/encoding/1.0.10/_types.js

@@ -0,0 +1,2 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+export {};

package/esm/deps/jsr.io/@std/encoding/1.0.10/base64.d.ts

@@ -0,0 +1,40 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+/**
+ * Converts data into a base64-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @param data The data to encode.
+ * @returns The base64-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeBase64("foobar"), "Zm9vYmFy");
+ * ```
+ */
+export declare function encodeBase64(data: ArrayBuffer | Uint8Array | string): string;
+/**
+ * Decodes a base64-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @param b64 The base64-encoded string to decode.
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeBase64("Zm9vYmFy"),
+ *   new TextEncoder().encode("foobar")
+ * );
+ * ```
+ */
+export declare function decodeBase64(b64: string): Uint8Array_;
+//# sourceMappingURL=base64.d.ts.map

package/esm/deps/jsr.io/@std/encoding/1.0.10/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/base64.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAQ5B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAW5E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAKrD"}

package/esm/deps/jsr.io/@std/encoding/1.0.10/base64.js

@@ -0,0 +1,82 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Utilities for
+ * {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4 | base64}
+ * encoding and decoding.
+ *
+ * ```ts
+ * import {
+ *   encodeBase64,
+ *   decodeBase64,
+ * } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const foobar = new TextEncoder().encode("foobar");
+ *
+ * assertEquals(encodeBase64(foobar), "Zm9vYmFy");
+ * assertEquals(decodeBase64("Zm9vYmFy"), foobar);
+ * ```
+ *
+ * @module
+ */
+import { calcSizeBase64, decode, encode } from "./_common64.js";
+import { detach } from "./_common_detach.js";
+const padding = "=".charCodeAt(0);
+const alphabet = new TextEncoder()
+    .encode("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
+const rAlphabet = new Uint8Array(128).fill(64); // alphabet.length
+alphabet.forEach((byte, i) => rAlphabet[byte] = i);
+/**
+ * Converts data into a base64-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @param data The data to encode.
+ * @returns The base64-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeBase64("foobar"), "Zm9vYmFy");
+ * ```
+ */
+export function encodeBase64(data) {
+    if (typeof data === "string") {
+        data = new TextEncoder().encode(data);
+    }
+    else if (data instanceof ArrayBuffer)
+        data = new Uint8Array(data).slice();
+    else
+        data = data.slice();
+    const [output, i] = detach(data, calcSizeBase64(data.length));
+    encode(output, i, 0, alphabet, padding);
+    return new TextDecoder().decode(output);
+}
+/**
+ * Decodes a base64-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @param b64 The base64-encoded string to decode.
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeBase64("Zm9vYmFy"),
+ *   new TextEncoder().encode("foobar")
+ * );
+ * ```
+ */
+export function decodeBase64(b64) {
+    const output = new TextEncoder().encode(b64);
+    // deno-lint-ignore no-explicit-any
+    return new Uint8Array(output.buffer
+        .transfer(decode(output, 0, 0, rAlphabet, padding)));
+}

package/{script/deps/jsr.io/@std/fs/1.0.19 → esm/deps/jsr.io/@std/fs/1.0.20}/exists.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.19/exists.ts"],"names":[],"mappings":"AAEA,iEAAiE;AACjE,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,CAAC,CAsClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAqCT"}
+{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.20/exists.ts"],"names":[],"mappings":"AAEA,iEAAiE;AACjE,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,CAAC,CAsClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAqCT"}

package/esm/deps/jsr.io/@std/log/0.224.14/rotating_file_handler.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _RotatingFileHandler_maxBytes, _RotatingFileHandler_maxBackupCount, _RotatingFileHandler_currentFileSize;
-import { existsSync } from "../../fs/1.0.19/exists.js";
+import { existsSync } from "../../fs/1.0.20/exists.js";
 import { FileHandler } from "./file_handler.js";
 import { encoderSymbol, filenameSymbol, fileSymbol, modeSymbol, openOptionsSymbol, } from "./_file_handler_symbols.js";
 /**

package/esm/mod.d.ts

@@ -1,3 +1,68 @@
+/**
+ * The Versori Run SDK is the backbone of the Versori AI integration platform. It provides a set of tools and
+ * abstractions for building integrations which can run in the cloud on Versori's infrastructure.
+ *
+ * # Getting Started
+ *
+ * First off, it's worth being familiar with the Versori AI platform, and understanding how Connectors, Connections
+ * and Projects fit together to make up an integration. This information is available on our primary documentation site,
+ * [Versori User Documentation](https://docs.versori.com).
+ *
+ * Our in-platform AI helps you build and test your integrations, and then deploy them to the cloud, however sometimes
+ * AI falls short and you may need to understand the underlying code to debug or extend your integrations; this is where
+ * this documentation comes in.
+ *
+ * # Structure of an integration
+ *
+ * An integration is made up of a {@linkcode Trigger} and one or more {@linkcode Task},
+ * to form a {@linkcode Workflow}. There are two main types of triggers, {@link schedule} and
+ * {@link webhook}, and two main types of tasks, {@link fn} and {@link http}.
+ *
+ * A simple integration might look like this:
+ *
+ * @example Make an authenticated request to httpbin.org every minute
+ *
+ * ```typescript
+ * import { fn, http, schedule, MemoryInterpreter } from '@versori/run';
+ *
+ * const workflow = schedule('every-minute', '* * * * *')
+ *     .then(
+ *         fn('log', (ctx) => {
+ *             ctx.log.debug('Hello, world!');
+ *
+ *             return 42;
+ *         })
+ *     )
+ *     .then(
+ *         http('httpbin', { connection: 'httpbin' }, async ({ fetch, log }) => {
+ *             // The `fetch` implementation passed on the context object is already authenticated and configured to
+ *             // prepend the base URL to the final request based on how the connection is configured from the Versori
+ *             // platform.
+ *             const resp = await fetch('/headers');
+ *
+ *             log.debug('response', { resp });
+ *
+ *             return resp.json();
+ *         })
+ *     );
+ *
+ * async function main(): Promise<void> {
+ *     const interpreter = new MemoryInterpreter();
+ *
+ *     interpreter.register(workflow);
+ *
+ *     await interpreter.start();
+ * }
+ *
+ * main().catch((err) => {
+ *     console.error('Failed to run workflow', err);
+ * });
+ * ```
+ *
+ * @module
+ */
 import "./_dnt.polyfills.js";
-export * from './src/mod.js';
+export * from './src/dsl/mod.js';
+export { durable, ExecutionError, MemoryInterpreter, type MemoryInterpreterOptions, } from './src/interpreter/mod.js';
+export * from './src/context/mod.js';
 //# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAC7B,cAAc,cAAc,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,OAAO,qBAAqB,CAAC;AAG7B,cAAc,kBAAkB,CAAC;AACjC,OAAO,EACH,OAAO,EACP,cAAc,EACd,iBAAiB,EACjB,KAAK,wBAAwB,GAChC,MAAM,0BAA0B,CAAC;AAClC,cAAc,sBAAsB,CAAC"}

package/esm/mod.js

@@ -1,2 +1,79 @@
+/*
+ * Copyright (c) 2025 Versori Group Inc
+ *
+ * Use of this software is governed by the Business Source License 1.1
+ * included in the LICENSE file at the root of this repository.
+ *
+ * Change Date: 2029-01-01
+ * Change License: Apache License, Version 2.0
+ *
+ * As of the Change Date, in accordance with the Business Source License,
+ * use of this software will be governed by the Apache License, Version 2.0.
+ */
+/**
+ * The Versori Run SDK is the backbone of the Versori AI integration platform. It provides a set of tools and
+ * abstractions for building integrations which can run in the cloud on Versori's infrastructure.
+ *
+ * # Getting Started
+ *
+ * First off, it's worth being familiar with the Versori AI platform, and understanding how Connectors, Connections
+ * and Projects fit together to make up an integration. This information is available on our primary documentation site,
+ * [Versori User Documentation](https://docs.versori.com).
+ *
+ * Our in-platform AI helps you build and test your integrations, and then deploy them to the cloud, however sometimes
+ * AI falls short and you may need to understand the underlying code to debug or extend your integrations; this is where
+ * this documentation comes in.
+ *
+ * # Structure of an integration
+ *
+ * An integration is made up of a {@linkcode Trigger} and one or more {@linkcode Task},
+ * to form a {@linkcode Workflow}. There are two main types of triggers, {@link schedule} and
+ * {@link webhook}, and two main types of tasks, {@link fn} and {@link http}.
+ *
+ * A simple integration might look like this:
+ *
+ * @example Make an authenticated request to httpbin.org every minute
+ *
+ * ```typescript
+ * import { fn, http, schedule, MemoryInterpreter } from '@versori/run';
+ *
+ * const workflow = schedule('every-minute', '* * * * *')
+ *     .then(
+ *         fn('log', (ctx) => {
+ *             ctx.log.debug('Hello, world!');
+ *
+ *             return 42;
+ *         })
+ *     )
+ *     .then(
+ *         http('httpbin', { connection: 'httpbin' }, async ({ fetch, log }) => {
+ *             // The `fetch` implementation passed on the context object is already authenticated and configured to
+ *             // prepend the base URL to the final request based on how the connection is configured from the Versori
+ *             // platform.
+ *             const resp = await fetch('/headers');
+ *
+ *             log.debug('response', { resp });
+ *
+ *             return resp.json();
+ *         })
+ *     );
+ *
+ * async function main(): Promise<void> {
+ *     const interpreter = new MemoryInterpreter();
+ *
+ *     interpreter.register(workflow);
+ *
+ *     await interpreter.start();
+ * }
+ *
+ * main().catch((err) => {
+ *     console.error('Failed to run workflow', err);
+ * });
+ * ```
+ *
+ * @module
+ */
 import "./_dnt.polyfills.js";
-export * from './src/mod.js';
+export * from './src/dsl/mod.js';
+export { durable, ExecutionError, MemoryInterpreter, } from './src/interpreter/mod.js';
+export * from './src/context/mod.js';

package/esm/src/connection/CredentialsProvider.d.ts

@@ -0,0 +1,23 @@
+import { Client } from '@connectrpc/connect';
+import { CredentialsProvider } from '../credentials/CredentialsProvider.js';
+import { VersoriConfigReader } from '../dsl/http/versori/configloader.js';
+import { credentialv1alpha1, oauth1v1, tokensv1 } from '../services/credentials/mod.js';
+import { PlatformApi } from '../services/platform/mod.js';
+export declare class CredentialsProviderImpl implements CredentialsProvider {
+    private readonly credentials;
+    private readonly tokens;
+    private readonly oauth1;
+    private readonly configReader;
+    private platformApi;
+    private readonly organisationId;
+    constructor(credentials: Client<typeof credentialv1alpha1.CredentialService>, tokens: Client<typeof tokensv1.TokenService>, oauth1: Client<typeof oauth1v1.AuthorizationService>, configReader: VersoriConfigReader, platformApi: PlatformApi);
+    getRaw(name: string, _activationId?: string): Promise<Uint8Array>;
+    getAccessToken(name: string, forceRefresh?: boolean, _activationId?: string): Promise<{
+        accessToken: string;
+        tokenType: string;
+        expiry: Date | undefined;
+    }>;
+    getOAuth1Metadata(name: string, _activationId?: string): Promise<oauth1v1.GetAuthorizationMetadataResponse>;
+    private getCredentialIDFromName;
+}
+//# sourceMappingURL=CredentialsProvider.d.ts.map

package/esm/src/connection/CredentialsProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredentialsProvider.d.ts","sourceRoot":"","sources":["../../../src/src/connection/CredentialsProvider.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAE1E,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AACxF,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE1D,qBAAa,uBAAwB,YAAW,mBAAmB;IAI3D,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,WAAW;IAPvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;gBAGnB,WAAW,EAAE,MAAM,CAAC,OAAO,kBAAkB,CAAC,iBAAiB,CAAC,EAChE,MAAM,EAAE,MAAM,CAAC,OAAO,QAAQ,CAAC,YAAY,CAAC,EAC5C,MAAM,EAAE,MAAM,CAAC,OAAO,QAAQ,CAAC,oBAAoB,CAAC,EACpD,YAAY,EAAE,mBAAmB,EAC1C,WAAW,EAAE,WAAW;IAK9B,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAWjE,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,EAAE,MAAM;;;;;IAc3E,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM;YAU9C,uBAAuB;CA4DxC"}

package/esm/src/connection/CredentialsProvider.js

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2025 Versori Group Inc
+ *
+ * Use of this software is governed by the Business Source License 1.1
+ * included in the LICENSE file at the root of this repository.
+ *
+ * Change Date: 2029-01-01
+ * Change License: Apache License, Version 2.0
+ *
+ * As of the Change Date, in accordance with the Business Source License,
+ * use of this software will be governed by the Apache License, Version 2.0.
+ */
+import { create } from '@bufbuild/protobuf';
+import { timestampMs } from '@bufbuild/protobuf/wkt';
+import { envVarOrgId } from '../internal/constants.js';
+import { credentialv1alpha1 } from '../services/credentials/mod.js';
+export class CredentialsProviderImpl {
+    constructor(credentials, tokens, oauth1, configReader, platformApi) {
+        Object.defineProperty(this, "credentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: credentials
+        });
+        Object.defineProperty(this, "tokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tokens
+        });
+        Object.defineProperty(this, "oauth1", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: oauth1
+        });
+        Object.defineProperty(this, "configReader", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: configReader
+        });
+        Object.defineProperty(this, "platformApi", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: platformApi
+        });
+        Object.defineProperty(this, "organisationId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.organisationId = Deno.env.get(envVarOrgId) || 'development';
+    }
+    async getRaw(name, _activationId) {
+        const credentialId = await this.getCredentialIDFromName(name, _activationId);
+        const response = await this.credentials.get({ id: credentialId, organisationId: '' });
+        if (!response.credential) {
+            throw new Error(`Failed to get credential: ${name}`);
+        }
+        const rawData = create(credentialv1alpha1.CredentialDataRawSchema, response.credential.data);
+        return rawData.raw;
+    }
+    async getAccessToken(name, forceRefresh, _activationId) {
+        const credentialId = await this.getCredentialIDFromName(name, _activationId);
+        const response = await this.tokens.getToken({ credentialId: credentialId, forceRefresh: forceRefresh || false });
+        if (!response.token) {
+            throw new Error(`Failed to get token for credential: ${name}`);
+        }
+        return {
+            accessToken: response.token.accessToken,
+            tokenType: response.token.tokenType,
+            expiry: response.token.expiry ? new Date(timestampMs(response.token.expiry)) : undefined,
+        };
+    }
+    async getOAuth1Metadata(name, _activationId) {
+        const credentialId = await this.getCredentialIDFromName(name, _activationId);
+        const response = await this.oauth1.getAuthorizationMetadata({ credentialId: credentialId });
+        if (!response) {
+            throw new Error(`Failed to get OAuth1 metadata for credential: ${name}`);
+        }
+        return response;
+    }
+    async getCredentialIDFromName(name, activationId) {
+        // fin connection config from versori file
+        const conn = this.configReader.getCnxMapping(name);
+        if (!conn) {
+            return '';
+        }
+        // if connection is dynamic try and load the activation
+        if (conn.dynamic) {
+            if (!activationId) {
+                throw new Error(`Connection ${name} is dynamic, but no activation ID was found on the context`);
+            }
+            if (!conn.templateId) {
+                throw new Error(`Connection ${name} is dynamic, but no template ID was found on the config`);
+            }
+            const { data: dynamicConn } = await this.platformApi.getActivationConnection({
+                path: {
+                    activation_id: activationId,
+                    env_system_id: conn.templateId,
+                    organisation_id: this.organisationId,
+                },
+            });
+            if (!dynamicConn) {
+                throw new Error(`Connection ${name} not found`);
+            }
+            if (!dynamicConn.credentials[0]?.credential?.id) {
+                throw new Error(`Connection ${name} has no credentials defined on it`);
+            }
+            return dynamicConn.credentials[0].credential?.id;
+        }
+        // connection is not dynamic try and load static connection
+        if (!conn.connId) {
+            throw new Error(`Connection ${name} is static, but no connection ID was found on the config`);
+        }
+        const { data: staticConn } = await this.platformApi.getConnection({
+            path: {
+                organisation_id: this.organisationId,
+                connection_id: conn.connId,
+            },
+        });
+        if (!staticConn?.credentials[0]?.credential?.id) {
+            throw new Error(`Connection ${name}/${conn.connId} has no credentials defined on it`);
+        }
+        return staticConn.credentials[0].credential.id;
+    }
+}