@chainlink/cre-sdk 0.0.1-alpha → 0.0.3-alpha

package/dist/generated-sdk/capabilities/internal/consensus/v1alpha/consensus_sdk_gen.d.ts

@@ -1,26 +1,22 @@
-import { Mode, type ReportRequest, type ReportRequestJson, type ReportResponse, type SimpleConsensusInputs, type SimpleConsensusInputsJson } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { type ReportRequest, type ReportRequestJson, type ReportResponse, type SimpleConsensusInputs, type SimpleConsensusInputsJson } from '../../../../../generated/sdk/v1alpha/sdk_pb';
 import { type Value } from '../../../../../generated/values/v1/values_pb';
+import type { Runtime } from '../../../../../sdk/runtime';
 /**
  * Consensus Capability
  *
  * Capability ID: consensus@1.0.0-alpha
- * Default Mode: Mode.DON
  * Capability Name: consensus
  * Capability Version: 1.0.0-alpha
  */
 export declare class ConsensusCapability {
-    private readonly mode;
     /** The capability ID for this service */
     static readonly CAPABILITY_ID = "consensus@1.0.0-alpha";
-    /** The default execution mode for this capability */
-    static readonly DEFAULT_MODE = Mode.DON;
     static readonly CAPABILITY_NAME = "consensus";
     static readonly CAPABILITY_VERSION = "1.0.0-alpha";
-    constructor(mode?: Mode);
-    simple(input: SimpleConsensusInputs | SimpleConsensusInputsJson): {
-        result: () => Promise<Value>;
+    simple(runtime: Runtime<unknown>, input: SimpleConsensusInputs | SimpleConsensusInputsJson): {
+        result: () => Value;
     };
-    report(input: ReportRequest | ReportRequestJson): {
-        result: () => Promise<ReportResponse>;
+    report(runtime: Runtime<unknown>, input: ReportRequest | ReportRequestJson): {
+        result: () => ReportResponse;
     };
 }

package/dist/generated-sdk/capabilities/internal/consensus/v1alpha/consensus_sdk_gen.js

@@ -1,99 +1,51 @@
-import { fromBinary, fromJson, toBinary } from '@bufbuild/protobuf';
-import { Mode, ReportRequestSchema, ReportResponseSchema, SimpleConsensusInputsSchema, } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { fromJson } from '@bufbuild/protobuf';
+import { ReportRequestSchema, ReportResponseSchema, SimpleConsensusInputsSchema, } from '../../../../../generated/sdk/v1alpha/sdk_pb';
 import { ValueSchema } from '../../../../../generated/values/v1/values_pb';
-import { callCapability } from '../../../../../sdk/utils/capabilities/call-capability';
-import { CapabilityError } from '../../../../../sdk/utils/capabilities/capability-error';
-import { getTypeUrl } from '../../../../../sdk/utils/typeurl';
 /**
  * Consensus Capability
  *
  * Capability ID: consensus@1.0.0-alpha
- * Default Mode: Mode.DON
  * Capability Name: consensus
  * Capability Version: 1.0.0-alpha
  */
 export class ConsensusCapability {
-    mode;
     /** The capability ID for this service */
     static CAPABILITY_ID = 'consensus@1.0.0-alpha';
-    /** The default execution mode for this capability */
-    static DEFAULT_MODE = Mode.DON;
     static CAPABILITY_NAME = 'consensus';
     static CAPABILITY_VERSION = '1.0.0-alpha';
-    constructor(mode = ConsensusCapability.DEFAULT_MODE) {
-        this.mode = mode;
-    }
-    simple(input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    simple(runtime, input) {
+        const payload = input.$typeName
             ? input
             : fromJson(SimpleConsensusInputsSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(SimpleConsensusInputsSchema),
-            value: toBinary(SimpleConsensusInputsSchema, value),
-        };
         const capabilityId = ConsensusCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'Simple',
-            mode: this.mode,
             payload,
+            inputSchema: SimpleConsensusInputsSchema,
+            outputSchema: ValueSchema,
         });
         return {
-            result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'Simple',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'Simple',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(ValueSchema, response.value.value);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }
-    report(input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    report(runtime, input) {
+        const payload = input.$typeName
             ? input
             : fromJson(ReportRequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(ReportRequestSchema),
-            value: toBinary(ReportRequestSchema, value),
-        };
         const capabilityId = ConsensusCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'Report',
-            mode: this.mode,
             payload,
+            inputSchema: ReportRequestSchema,
+            outputSchema: ReportResponseSchema,
         });
         return {
-            result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'Report',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'Report',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(ReportResponseSchema, response.value.value);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }

package/dist/generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen.d.ts

@@ -1,23 +1,32 @@
 import { type Request, type RequestJson, type Response } from '../../../../../generated/capabilities/networking/http/v1alpha/client_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import type { NodeRuntime, Runtime } from '../../../../../sdk/runtime';
+import type { ConsensusAggregation, PrimitiveTypes, UnwrapOptions } from '../../../../../sdk/utils';
+export declare class SendRequester {
+    private readonly runtime;
+    private readonly client;
+    constructor(runtime: NodeRuntime<unknown>, client: ClientCapability);
+    sendRequest(input: Request | RequestJson): {
+        result: () => Response;
+    };
+}
 /**
  * Client Capability
  *
  * Capability ID: http-actions@1.0.0-alpha
- * Default Mode: Mode.NODE
  * Capability Name: http-actions
  * Capability Version: 1.0.0-alpha
  */
 export declare class ClientCapability {
-    private readonly mode;
     /** The capability ID for this service */
     static readonly CAPABILITY_ID = "http-actions@1.0.0-alpha";
-    /** The default execution mode for this capability */
-    static readonly DEFAULT_MODE = Mode.NODE;
     static readonly CAPABILITY_NAME = "http-actions";
     static readonly CAPABILITY_VERSION = "1.0.0-alpha";
-    constructor(mode?: Mode);
-    sendRequest(input: Request | RequestJson): {
-        result: () => Promise<Response>;
+    sendRequest(runtime: NodeRuntime<unknown>, input: Request | RequestJson): {
+        result: () => Response;
+    };
+    sendRequest<TArgs extends unknown[], TOutput>(runtime: Runtime<unknown>, fn: (sendRequester: SendRequester, ...args: TArgs) => TOutput, consensusAggregation: ConsensusAggregation<TOutput, true>, unwrapOptions?: TOutput extends PrimitiveTypes ? never : UnwrapOptions<TOutput>): (...args: TArgs) => {
+        result: () => TOutput;
     };
+    private sendRequestCallHelper;
+    private sendRequestSugarHelper;
 }

package/dist/generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen.js

@@ -1,63 +1,61 @@
-import { fromBinary, fromJson, toBinary } from '@bufbuild/protobuf';
+import { fromJson } from '@bufbuild/protobuf';
 import { RequestSchema, ResponseSchema, } from '../../../../../generated/capabilities/networking/http/v1alpha/client_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
-import { callCapability } from '../../../../../sdk/utils/capabilities/call-capability';
-import { CapabilityError } from '../../../../../sdk/utils/capabilities/capability-error';
-import { getTypeUrl } from '../../../../../sdk/utils/typeurl';
+export class SendRequester {
+    runtime;
+    client;
+    constructor(runtime, client) {
+        this.runtime = runtime;
+        this.client = client;
+    }
+    sendRequest(input) {
+        return this.client.sendRequest(this.runtime, input);
+    }
+}
 /**
  * Client Capability
  *
  * Capability ID: http-actions@1.0.0-alpha
- * Default Mode: Mode.NODE
  * Capability Name: http-actions
  * Capability Version: 1.0.0-alpha
  */
 export class ClientCapability {
-    mode;
     /** The capability ID for this service */
     static CAPABILITY_ID = 'http-actions@1.0.0-alpha';
-    /** The default execution mode for this capability */
-    static DEFAULT_MODE = Mode.NODE;
     static CAPABILITY_NAME = 'http-actions';
     static CAPABILITY_VERSION = '1.0.0-alpha';
-    constructor(mode = ClientCapability.DEFAULT_MODE) {
-        this.mode = mode;
+    sendRequest(...args) {
+        // Check if this is the sugar syntax overload (has function parameter)
+        if (typeof args[1] === 'function') {
+            const [runtime, fn, consensusAggregation, unwrapOptions] = args;
+            return this.sendRequestSugarHelper(runtime, fn, consensusAggregation, unwrapOptions);
+        }
+        // Otherwise, this is the basic call overload
+        const [runtime, input] = args;
+        return this.sendRequestCallHelper(runtime, input);
     }
-    sendRequest(input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    sendRequestCallHelper(runtime, input) {
+        const payload = input.$typeName
             ? input
             : fromJson(RequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(RequestSchema),
-            value: toBinary(RequestSchema, value),
-        };
         const capabilityId = ClientCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'SendRequest',
-            mode: this.mode,
             payload,
+            inputSchema: RequestSchema,
+            outputSchema: ResponseSchema,
         });
         return {
-            result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'SendRequest',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'SendRequest',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(ResponseSchema, response.value.value);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }
+    sendRequestSugarHelper(runtime, fn, consensusAggregation, unwrapOptions) {
+        const wrappedFn = (runtime, ...args) => {
+            const sendRequester = new SendRequester(runtime, this);
+            return fn(sendRequester, ...args);
+        };
+        return runtime.runInNodeMode(wrappedFn, consensusAggregation, unwrapOptions);
+    }
 }

package/dist/generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen.d.ts

@@ -1,35 +1,28 @@
 import { type Any } from '@bufbuild/protobuf/wkt';
 import { type Config, type ConfigJson, type Payload } from '../../../../../generated/capabilities/networking/http/v1alpha/trigger_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
 import { type Trigger } from '../../../../../sdk/utils/triggers/trigger-interface';
 /**
  * HTTP Capability
  *
  * Capability ID: http-trigger@1.0.0-alpha
- * Default Mode: Mode.DON
  * Capability Name: http-trigger
  * Capability Version: 1.0.0-alpha
  */
 export declare class HTTPCapability {
-    private readonly mode;
     /** The capability ID for this service */
     static readonly CAPABILITY_ID = "http-trigger@1.0.0-alpha";
-    /** The default execution mode for this capability */
-    static readonly DEFAULT_MODE = Mode.DON;
     static readonly CAPABILITY_NAME = "http-trigger";
     static readonly CAPABILITY_VERSION = "1.0.0-alpha";
-    constructor(mode?: Mode);
     trigger(config: ConfigJson): HTTPTrigger;
 }
 /**
  * Trigger implementation for Trigger
  */
 declare class HTTPTrigger implements Trigger<Payload, Payload> {
-    readonly mode: Mode;
     private readonly _capabilityId;
     private readonly _method;
     readonly config: Config;
-    constructor(mode: Mode, config: Config | ConfigJson, _capabilityId: string, _method: string);
+    constructor(config: Config | ConfigJson, _capabilityId: string, _method: string);
     capabilityId(): string;
     method(): string;
     outputSchema(): import("@bufbuild/protobuf/codegenv2").GenMessage<Payload, {

package/dist/generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen.js

@@ -1,44 +1,32 @@
-import { create, fromBinary, fromJson, toBinary } from '@bufbuild/protobuf';
-import { AnySchema } from '@bufbuild/protobuf/wkt';
+import { create, fromJson } from '@bufbuild/protobuf';
+import { AnySchema, anyPack } from '@bufbuild/protobuf/wkt';
 import { ConfigSchema, PayloadSchema, } from '../../../../../generated/capabilities/networking/http/v1alpha/trigger_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
-import { callCapability } from '../../../../../sdk/utils/capabilities/call-capability';
-import { CapabilityError } from '../../../../../sdk/utils/capabilities/capability-error';
 import {} from '../../../../../sdk/utils/triggers/trigger-interface';
-import { getTypeUrl } from '../../../../../sdk/utils/typeurl';
 /**
  * HTTP Capability
  *
  * Capability ID: http-trigger@1.0.0-alpha
- * Default Mode: Mode.DON
  * Capability Name: http-trigger
  * Capability Version: 1.0.0-alpha
  */
 export class HTTPCapability {
-    mode;
     /** The capability ID for this service */
     static CAPABILITY_ID = 'http-trigger@1.0.0-alpha';
-    /** The default execution mode for this capability */
-    static DEFAULT_MODE = Mode.DON;
     static CAPABILITY_NAME = 'http-trigger';
     static CAPABILITY_VERSION = '1.0.0-alpha';
-    constructor(mode = HTTPCapability.DEFAULT_MODE) {
-        this.mode = mode;
-    }
     trigger(config) {
-        return new HTTPTrigger(this.mode, config, HTTPCapability.CAPABILITY_ID, 'Trigger');
+        const capabilityId = HTTPCapability.CAPABILITY_ID;
+        return new HTTPTrigger(config, capabilityId, 'Trigger');
     }
 }
 /**
  * Trigger implementation for Trigger
  */
 class HTTPTrigger {
-    mode;
     _capabilityId;
     _method;
     config;
-    constructor(mode, config, _capabilityId, _method) {
-        this.mode = mode;
+    constructor(config, _capabilityId, _method) {
         this._capabilityId = _capabilityId;
         this._method = _method;
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
@@ -56,10 +44,7 @@ class HTTPTrigger {
         return PayloadSchema;
     }
     configAsAny() {
-        return create(AnySchema, {
-            typeUrl: getTypeUrl(ConfigSchema),
-            value: toBinary(ConfigSchema, this.config),
-        });
+        return anyPack(ConfigSchema, this.config);
     }
     /**
      * Transform the raw trigger output - override this method if needed

package/dist/generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen.d.ts

@@ -1,35 +1,28 @@
 import { type Any } from '@bufbuild/protobuf/wkt';
 import { type Config, type ConfigJson, type Payload } from '../../../../../generated/capabilities/scheduler/cron/v1/trigger_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
 import { type Trigger } from '../../../../../sdk/utils/triggers/trigger-interface';
 /**
  * Cron Capability
  *
  * Capability ID: cron-trigger@1.0.0
- * Default Mode: Mode.DON
  * Capability Name: cron-trigger
  * Capability Version: 1.0.0
  */
 export declare class CronCapability {
-    private readonly mode;
     /** The capability ID for this service */
     static readonly CAPABILITY_ID = "cron-trigger@1.0.0";
-    /** The default execution mode for this capability */
-    static readonly DEFAULT_MODE = Mode.DON;
     static readonly CAPABILITY_NAME = "cron-trigger";
     static readonly CAPABILITY_VERSION = "1.0.0";
-    constructor(mode?: Mode);
     trigger(config: ConfigJson): CronTrigger;
 }
 /**
  * Trigger implementation for Trigger
  */
 declare class CronTrigger implements Trigger<Payload, Payload> {
-    readonly mode: Mode;
     private readonly _capabilityId;
     private readonly _method;
     readonly config: Config;
-    constructor(mode: Mode, config: Config | ConfigJson, _capabilityId: string, _method: string);
+    constructor(config: Config | ConfigJson, _capabilityId: string, _method: string);
     capabilityId(): string;
     method(): string;
     outputSchema(): import("@bufbuild/protobuf/codegenv2").GenMessage<Payload, {

package/dist/generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen.js

@@ -1,44 +1,32 @@
-import { create, fromBinary, fromJson, toBinary } from '@bufbuild/protobuf';
-import { AnySchema } from '@bufbuild/protobuf/wkt';
+import { create, fromJson } from '@bufbuild/protobuf';
+import { AnySchema, anyPack } from '@bufbuild/protobuf/wkt';
 import { ConfigSchema, LegacyPayloadSchema, PayloadSchema, } from '../../../../../generated/capabilities/scheduler/cron/v1/trigger_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
-import { callCapability } from '../../../../../sdk/utils/capabilities/call-capability';
-import { CapabilityError } from '../../../../../sdk/utils/capabilities/capability-error';
 import {} from '../../../../../sdk/utils/triggers/trigger-interface';
-import { getTypeUrl } from '../../../../../sdk/utils/typeurl';
 /**
  * Cron Capability
  *
  * Capability ID: cron-trigger@1.0.0
- * Default Mode: Mode.DON
  * Capability Name: cron-trigger
  * Capability Version: 1.0.0
  */
 export class CronCapability {
-    mode;
     /** The capability ID for this service */
     static CAPABILITY_ID = 'cron-trigger@1.0.0';
-    /** The default execution mode for this capability */
-    static DEFAULT_MODE = Mode.DON;
     static CAPABILITY_NAME = 'cron-trigger';
     static CAPABILITY_VERSION = '1.0.0';
-    constructor(mode = CronCapability.DEFAULT_MODE) {
-        this.mode = mode;
-    }
     trigger(config) {
-        return new CronTrigger(this.mode, config, CronCapability.CAPABILITY_ID, 'Trigger');
+        const capabilityId = CronCapability.CAPABILITY_ID;
+        return new CronTrigger(config, capabilityId, 'Trigger');
     }
 }
 /**
  * Trigger implementation for Trigger
  */
 class CronTrigger {
-    mode;
     _capabilityId;
     _method;
     config;
-    constructor(mode, config, _capabilityId, _method) {
-        this.mode = mode;
+    constructor(config, _capabilityId, _method) {
         this._capabilityId = _capabilityId;
         this._method = _method;
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
@@ -56,10 +44,7 @@ class CronTrigger {
         return PayloadSchema;
     }
     configAsAny() {
-        return create(AnySchema, {
-            typeUrl: getTypeUrl(ConfigSchema),
-            value: toBinary(ConfigSchema, this.config),
-        });
+        return anyPack(ConfigSchema, this.config);
     }
     /**
      * Transform the raw trigger output - override this method if needed

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './sdk';
 export * from './sdk/runtime';
 export * from './sdk/utils';
+export * from './sdk/wasm';

package/dist/index.js

@@ -2,3 +2,4 @@
 export * from './sdk';
 export * from './sdk/runtime';
 export * from './sdk/utils';
+export * from './sdk/wasm';

package/dist/sdk/cre/index.d.ts

@@ -2,12 +2,14 @@
  * Public API for the CRE SDK.
  */
 import { ClientCapability as EVMClient } from '../../generated-sdk/capabilities/blockchain/evm/v1alpha/client_sdk_gen';
-import { ClientCapability as HTTPClient } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
+import { ClientCapability as HTTPClient, type SendRequester as HTTPSendRequester } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
 import { HTTPCapability } from '../../generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen';
 import { CronCapability } from '../../generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen';
-import { runInNodeMode } from '../runtime/run-in-node-mode';
-import { Runner } from '../workflow';
-export type { NodeRuntime, Runtime } from '../runtime/runtime';
+export type { Log as EVMLog } from '../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
+export type { Payload as HTTPPayload } from '../../generated/capabilities/networking/http/v1alpha/trigger_pb';
+export type { Payload as CronPayload } from '../../generated/capabilities/scheduler/cron/v1/trigger_pb';
+export type { NodeRuntime, Runtime } from '../runtime';
+export type { HTTPSendRequester };
 export declare const cre: {
     capabilities: {
         CronCapability: typeof CronCapability;
@@ -15,20 +17,5 @@ export declare const cre: {
         HTTPClient: typeof HTTPClient;
         EVMClient: typeof EVMClient;
     };
-    config: <TConfig>({ configParser, configSchema, }?: import("../utils/config").ConfigHandlerParams) => Promise<TConfig>;
-    handler: <TRawTriggerOutput extends import("@bufbuild/protobuf").Message<string>, TTriggerOutput = TRawTriggerOutput, TConfig = unknown>(trigger: import("../utils/triggers/trigger-interface").Trigger<TRawTriggerOutput, TTriggerOutput>, fn: import("../workflow").HandlerFn<TConfig, TTriggerOutput>) => import("../workflow").HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput>;
-    newRunner: typeof Runner.newRunner;
-    runInNodeMode: typeof runInNodeMode;
-    utils: {
-        fetch: (input: import("../utils/capabilities/http/fetch").CreFetchRequest) => Promise<{
-            statusCode: number;
-            headers: {
-                [key: string]: string;
-            };
-            body: string;
-        }>;
-    };
-    sendResponseValue: (value: import("../utils").Value) => void;
-    sendError: (error: string | Error) => void;
-    withErrorBoundary: (fn: () => Promise<void>) => Promise<void>;
+    handler: <TRawTriggerOutput extends import("@bufbuild/protobuf").Message<string>, TTriggerOutput, TConfig, TResult>(trigger: import("../utils/triggers/trigger-interface").Trigger<TRawTriggerOutput, TTriggerOutput>, fn: import("../workflow").HandlerFn<TConfig, TTriggerOutput, TResult>) => import("../workflow").HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput, TResult>;
 };

package/dist/sdk/cre/index.js

@@ -2,19 +2,12 @@
  * Public API for the CRE SDK.
  */
 import { ClientCapability as EVMClient } from '../../generated-sdk/capabilities/blockchain/evm/v1alpha/client_sdk_gen';
-import { ClientCapability as HTTPClient } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
+import { ClientCapability as HTTPClient, } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
 import { HTTPCapability } from '../../generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen';
 import { CronCapability } from '../../generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen';
-import { runInNodeMode } from '../runtime/run-in-node-mode';
-import { creFetch } from '../utils/capabilities/http/fetch';
-import { configHandler } from '../utils/config';
-import { withErrorBoundary } from '../utils/error-boundary';
 import { prepareRuntime } from '../utils/prepare-runtime';
-import { sendError } from '../utils/send-error';
-import { sendResponseValue } from '../utils/send-response-value';
-import { handler, Runner } from '../workflow';
+import { handler } from '../workflow';
 prepareRuntime();
-versionV2();
 export const cre = {
     capabilities: {
         CronCapability,
@@ -22,14 +15,5 @@ export const cre = {
         HTTPClient,
         EVMClient,
     },
-    config: configHandler,
     handler,
-    newRunner: Runner.newRunner,
-    runInNodeMode,
-    utils: {
-        fetch: creFetch,
-    },
-    sendResponseValue,
-    sendError,
-    withErrorBoundary,
 };

package/dist/sdk/errors.d.ts

@@ -0,0 +1,12 @@
+import { type SecretRequest } from '../generated/sdk/v1alpha/sdk_pb';
+export declare class DonModeError extends Error {
+    constructor();
+}
+export declare class NodeModeError extends Error {
+    constructor();
+}
+export declare class SecretsError extends Error {
+    sceretRequest: SecretRequest;
+    error: String;
+    constructor(sceretRequest: SecretRequest, error: String);
+}

package/dist/sdk/errors.js

@@ -0,0 +1,21 @@
+import { Mode } from '../generated/sdk/v1alpha/sdk_pb';
+export class DonModeError extends Error {
+    constructor() {
+        super('cannot use Runtime inside RunInNodeMode');
+    }
+}
+export class NodeModeError extends Error {
+    constructor() {
+        super('cannot use NodeRuntime outside RunInNodeMode');
+        this.name = 'NodeModeError';
+    }
+}
+export class SecretsError extends Error {
+    sceretRequest;
+    error;
+    constructor(sceretRequest, error) {
+        super(`error fetching ${sceretRequest}: ${error}`);
+        this.sceretRequest = sceretRequest;
+        this.error = error;
+    }
+}