@holocronlab/botruntime-sdk 6.13.3

package/dist/serve.d.ts

@@ -0,0 +1,38 @@
+import * as http from 'node:http';
+export type Request = {
+    body?: string;
+    path: string;
+    query: string;
+    method: string;
+    headers: {
+        [key: string]: string | undefined;
+    };
+};
+export type Response = {
+    body?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    status?: number;
+};
+export type Handler = (req: Request) => Promise<Response | void>;
+export declare function parseBody<T>(req: Request): T;
+/**
+ * Maps a thrown handler error to an HTTP response.
+ *
+ * A deliberately thrown `RuntimeError` indicates a handled, user-facing failure,
+ * and an `InvalidPayloadError` indicates a malformed request. Both preserve
+ * their original 4xx status so callers do not retry them.
+ *
+ * Any other error is treated as unhandled and returned as a 500 response so
+ * callers can consider it transient.
+ */
+export declare const handlerErrorToHttpResponse: ({ thrown, unexpectedErrorMessage, }: {
+    thrown: unknown;
+    unexpectedErrorMessage: string;
+}) => {
+    status: number;
+    body: string;
+    error: Error;
+};
+export declare function serve(handler: Handler, port?: number, callback?: (port: number) => void): Promise<http.Server>;

package/dist/utils/api-paging-utils.d.ts

@@ -0,0 +1,43 @@
+type _PageLister<R> = (t: {
+    nextToken?: string;
+}) => Promise<{
+    items: R[];
+    meta: {
+        nextToken?: string;
+    };
+}>;
+declare class AsyncCollection<T> implements AsyncIterableIterator<T> {
+    private _list;
+    private _nextToken?;
+    private _elementsBuffer;
+    private _isExhausted;
+    constructor(_list: _PageLister<T>);
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+    /**
+     * Get the next element from the collection and advance the iterator.
+     */
+    next(): Promise<IteratorResult<T, undefined>>;
+    /**
+     * Take the next n elements from the collection, advancing the iterator, and
+     * return them as an array.
+     */
+    take(amount: number): Promise<T[]>;
+    /**
+     * Take the next n pages of elements from the collection, advancing the
+     * iterator, and return the elements as an array.
+     */
+    takePage(amount: number): Promise<T[]>;
+    /**
+     * Take all remaining elements from in collection, moving the iterator to the
+     * end, and return them as an array.
+     */
+    takeAll(): Promise<T[]>;
+    /**
+     * Returns true if there are no more elements to fetch in the collection.
+     */
+    get isExhausted(): boolean;
+    private _fetchNextPageIntoBuffer;
+    private get _bufferIsEmpty();
+}
+export type { AsyncCollection };
+export declare const createAsyncCollection: <T>(listFn: _PageLister<T>) => AsyncCollection<T>;

package/dist/utils/api-paging-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/array-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const safePush: <T>(arr: T[] | undefined, ...values: T[]) => T[];
+export declare const unique: <T>(arr: T[]) => T[];

package/dist/utils/error-utils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Utility to throw an error in ternary or nullish coalescing expressions
+ */
+export declare const throwError: (thrown: string | Error) => never;

package/dist/utils/function-utils.d.ts

@@ -0,0 +1,2 @@
+export type Func<X extends any[], Y> = (...args: X) => Y;
+export declare const setName: <X extends any[], Y>(f: Func<X, Y>, name: string) => Func<X, Y>;

package/dist/utils/function-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * as records from './record-utils';
+export * as arrays from './array-utils';
+export * as types from './type-utils';
+export * as functions from './function-utils';

package/dist/utils/record-utils.d.ts

@@ -0,0 +1,6 @@
+export declare const pairs: <K extends string, V>(obj: Record<K, V>) => [K, V][];
+export declare const values: <K extends string, V>(obj: Record<K, V>) => V[];
+export declare const mapValues: <K extends string, V, R>(obj: Record<K, V>, fn: (value: V, key: K) => R) => Record<K, R>;
+export declare const mapKeys: <K1 extends string, K2 extends string, V>(obj: Record<K1, V>, fn: (key: K1) => K2) => Record<K2, V>;
+export declare const stripUndefinedProps: <K extends string, V>(obj: Record<K, V | undefined>) => Record<K, V>;
+export declare const mergeRecords: <K extends string, V>(a: Record<K, V>, b: Record<K, V>, merge: (v1: V, v2: V) => V) => Record<K, V>;

package/dist/utils/record-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/type-utils.d.ts

@@ -0,0 +1,63 @@
+export type Function<I extends any[] = any, O extends any = any> = (...args: I) => O;
+export type ValueOf<T> = T[keyof T];
+export type Merge<A extends object, B extends object> = Omit<A, keyof B> & B;
+export type Cast<T, U> = T extends U ? T : U;
+export type SafeCast<T, U> = [T] extends [never] ? U : Cast<T, U>;
+export type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+export type Default<T, U> = undefined extends T ? U : T;
+export type Not<X extends boolean> = X extends true ? false : true;
+export type And<X extends boolean, Y extends boolean> = X extends true ? (Y extends true ? true : false) : false;
+export type Or<X extends boolean, Y extends boolean> = X extends true ? true : Y extends true ? true : false;
+export type AtLeastOne<T> = [T, ...T[]];
+export type AtLeastOneProperty<T> = T extends undefined ? {} : {
+    [K in keyof T]?: T[K];
+} & {
+    [K in keyof T]: Pick<T, K>;
+}[keyof T];
+export type ExactlyOneProperty<T> = T extends undefined ? {} : {
+    [K in keyof T]: {
+        [P in K]: T[P];
+    } & {
+        [P in Exclude<keyof T, K>]?: never;
+    };
+}[keyof T];
+export type IsExtend<X, Y> = X extends Y ? true : false;
+export type IsEquivalent<X, Y> = IsExtend<X, Y> extends true ? IsExtend<Y, X> : false;
+export type IsIdentical<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type IsEqual<X, Y> = IsIdentical<Normalize<X>, Normalize<Y>>;
+/**
+ * For F1 function to extend F2 function,
+ * F2 input should extend F1 input so that if you call F1 thinking it is F2, it still works.
+ * IsStricterFunction is not an extension check as it allows F1 to require a stricter input than F2.
+ */
+export type IsStricterFunction<F1 extends Function, F2 extends Function> = And<IsExtend<ReturnType<F1>, ReturnType<F2>>, IsExtend<Parameters<F1>, Parameters<F2>>>;
+export type AssertExtends<_A extends B, B> = true;
+export type AssertNotExtends<A, B> = A extends B ? false : true;
+export type AssertTrue<_T extends true> = true;
+export type AssertAll<_T extends true[]> = true;
+export type Join<S extends (string | number | symbol)[]> = S extends [infer H, ...infer T] ? `${Cast<H, string>}${Join<Cast<T, string[]>>}` : S extends [infer H] ? Cast<H, string> : '';
+export type Split<S extends string | number | symbol, D extends string> = S extends `${infer H}${D}${infer T}` ? [H, ...Split<Cast<T, string>, D>] : [S];
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * removes string index signature from Record
+ */
+export type ToSealedRecord<R extends Record<string, any>> = {
+    [K in keyof R as string extends K ? never : K]: R[K];
+};
+type NormalizeTuple<T> = T extends [...infer A] ? {
+    [K in keyof A]: Normalize<A[K]>;
+} : never;
+type NormalizeObject<T extends object> = T extends infer O ? {
+    [K in keyof O]: Normalize<O[K]>;
+} : never;
+export type Normalize<T> = T extends (...args: infer A) => infer R ? (...args: NormalizeTuple<A>) => Normalize<R> : T extends Array<infer E> ? Array<Normalize<E>> : T extends ReadonlyArray<infer E> ? ReadonlyArray<Normalize<E>> : T extends Promise<infer R> ? Promise<Normalize<R>> : T extends Buffer ? Buffer : T extends object ? NormalizeObject<T> : T;
+type DeepPartialObject<T extends object> = T extends infer O ? {
+    [K in keyof O]?: DeepPartial<O[K]>;
+} : never;
+export type DeepPartial<T> = T extends (...args: infer A) => infer R ? (...args: DeepPartial<A>) => DeepPartial<R> : T extends Array<infer E> ? Array<DeepPartial<E>> : T extends ReadonlyArray<infer E> ? ReadonlyArray<DeepPartial<E>> : T extends Promise<infer R> ? Promise<DeepPartial<R>> : T extends Buffer ? Buffer : T extends object ? DeepPartialObject<T> : T;
+export type SafeOmit<T, K extends keyof T> = Omit<T, K>;
+export type StringKeys<T> = Extract<keyof T, string>;
+export type DistributivePick<T, K extends keyof T> = T extends any ? Pick<T, K> : never;
+export {};

package/dist/utils/type-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/version-utils.d.ts

@@ -0,0 +1,18 @@
+import { Package } from './package';
+import { PluginDefinition } from './plugin/definition';
+type GenericPackage = Exclude<Package, PluginDefinition>;
+/**
+ * Returns the major version range for a given package.
+ * Version utility helpers are only intended to be used with plugins.
+ **/
+export declare function allWithinMajorOf<T extends GenericPackage>(pkg: T): T & {
+    version: string;
+};
+/**
+ * Returns the minor version range for a given package.
+ * Version utility helpers are only intended to be used with plugins.
+ **/
+export declare function allWithinMinorOf<T extends GenericPackage>(pkg: T): T & {
+    version: string;
+};
+export {};

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION: string;

package/dist/zui.d.ts

@@ -0,0 +1,9 @@
+import '@holocronlab/botruntime-zui';
+declare module '@holocronlab/botruntime-zui' {
+    namespace z {
+        type GenericZuiSchema<A extends Record<string, z.ZodType> = Record<string, z.ZodType>, R extends z.ZodType = z.ZodType> = (typeArguments: A) => R;
+        type ZuiObjectSchema = z.ZodObject | z.ZodRecord;
+        type ZuiObjectOrRefSchema = ZuiObjectSchema | z.ZodRef;
+    }
+}
+export { z } from '@holocronlab/botruntime-zui';

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@holocronlab/botruntime-sdk",
+  "version": "6.13.3",
+  "description": "SDK for building bots and integrations on botruntime",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "readme.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HolocronLab/botruntime-packages",
+    "directory": "packages/botruntime-sdk"
+  },
+  "scripts": {
+    "check:type": "tsc -p ./tsconfig.json --noEmit",
+    "build:type": "tsc -p ./tsconfig.package.json --emitDeclarationOnly --declaration",
+    "build:browser": "ts-node -T ./build.ts --browser",
+    "build:node": "ts-node -T ./build.ts --node",
+    "build": "npm run build:type && npm run build:node && npm run build:browser",
+    "test": "vitest --run"
+  },
+  "keywords": [],
+  "author": "HolocronLab",
+  "license": "MIT",
+  "dependencies": {
+    "@holocronlab/botruntime-client": "^1.46.3",
+    "@holocronlab/botruntime-zui": "^2.3.0",
+    "browser-or-node": "^2.1.1",
+    "semver": "^7.3.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.16.4",
+    "@types/semver": "^7.3.11",
+    "esbuild": "^0.25.10",
+    "esbuild-plugin-polyfill-node": "^0.3.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3",
+    "vitest": "^2.1.8"
+  },
+  "peerDependencies": {
+    "esbuild": "^0.16.12"
+  },
+  "peerDependenciesMeta": {
+    "esbuild": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,11 @@
+# Botruntime SDK
+
+SDK for TypeScript. Made for building bots, plugins and integrations as code on botruntime.
+
+## Installation
+
+```bash
+npm install --save @holocronlab/botruntime-sdk # for npm
+yarn add @holocronlab/botruntime-sdk # for yarn
+pnpm add @holocronlab/botruntime-sdk # for pnpm
+```