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

package/dist/sdk/utils/index.js

@@ -1,7 +1,4 @@
-export * from './error-boundary';
-export { withErrorBoundary } from './error-boundary';
 export * from './hex-utils';
-export * from './send-response-value';
 export * from './values/consensus_aggregators';
 export * from './values/serializer_types';
 export * from './values/value';

package/dist/sdk/utils/values/consensus_aggregators.d.ts

@@ -22,6 +22,6 @@ export declare class ConsensusFieldAggregation<T, U> {
     constructor(fieldDescriptor?: ConsensusDescriptor | undefined, t?: T | undefined, u?: U | undefined);
 }
 export type ConsensusAggregationFields<T extends object> = {
-    [K in keyof T]: () => ConsensusFieldAggregation<T[K], true>;
+    [K in keyof T as K extends '$typeName' ? never : K]: () => ConsensusFieldAggregation<T[K], true>;
 };
 export declare function ConsensusAggregationByFields<T extends object>(aggregation: ConsensusAggregationFields<T>): ConsensusAggregation<T, true>;

package/dist/sdk/{runtime → wasm}/host-bindings.d.ts

@@ -3,7 +3,6 @@ export declare const hostBindings: {
     switchModes: (args_0: Mode, ...args: unknown[]) => void;
     log: (args_0: string, ...args: unknown[]) => void;
     sendResponse: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
-    randomSeed: (args_0: Mode.DON | Mode.NODE, ...args: unknown[]) => number;
     versionV2: (...args: unknown[]) => void;
     callCapability: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     awaitCapabilities: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>;

package/dist/sdk/{runtime → wasm}/host-bindings.js

@@ -8,10 +8,6 @@ const globalHostBindingsSchema = z.object({
         .function()
         .args(z.union([z.instanceof(Uint8Array), z.custom()]))
         .returns(z.number()),
-    randomSeed: z
-        .function()
-        .args(z.union([z.literal(Mode.DON), z.literal(Mode.NODE)]))
-        .returns(z.number()),
     versionV2: z.function().args().returns(z.void()),
     callCapability: z
         .function()

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

@@ -0,0 +1 @@
+export { Runner } from './runner';

package/dist/sdk/wasm/index.js

@@ -0,0 +1 @@
+export { Runner } from './runner';

package/dist/sdk/wasm/runner.d.ts

@@ -0,0 +1,14 @@
+import { type ExecuteRequest, type ExecutionResult } from '../../generated/sdk/v1alpha/sdk_pb';
+import { type ConfigHandlerParams } from '../utils/config';
+import type { SecretsProvider, Workflow } from '../workflow';
+import { Runtime } from './runtime';
+export declare class Runner<TConfig> {
+    private readonly config;
+    private readonly request;
+    private constructor();
+    static newRunner<TConfig, TIntermediateConfig = TConfig>(configHandlerParams?: ConfigHandlerParams<TConfig, TIntermediateConfig>): Promise<Runner<TConfig>>;
+    private static getRequest;
+    run(initFn: (config: TConfig, secretsProvider: SecretsProvider) => Promise<Workflow<TConfig>> | Workflow<TConfig>): Promise<void>;
+    handleExecutionPhase<TConfig>(req: ExecuteRequest, workflow: Workflow<TConfig>, runtime: Runtime<TConfig>): Promise<ExecutionResult>;
+    handleSubscribePhase(req: ExecuteRequest, workflow: Workflow<TConfig>): ExecutionResult;
+}

package/dist/sdk/wasm/runner.js

@@ -0,0 +1,114 @@
+import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
+import { ExecuteRequestSchema, ExecutionResultSchema, TriggerSubscriptionRequestSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { configHandler } from '../utils/config';
+import { Value } from '../utils';
+import { hostBindings } from './host-bindings';
+import { Runtime } from './runtime';
+export class Runner {
+    config;
+    request;
+    constructor(config, request) {
+        this.config = config;
+        this.request = request;
+    }
+    static async newRunner(configHandlerParams) {
+        hostBindings.versionV2();
+        const request = Runner.getRequest();
+        const config = await configHandler(request, configHandlerParams);
+        return new Runner(config, request);
+    }
+    static getRequest() {
+        const argsString = hostBindings.getWasiArgs();
+        const args = JSON.parse(argsString);
+        // SDK expects exactly 2 args:
+        // 1st is the script name
+        // 2nd is the base64 encoded request
+        if (args.length !== 2) {
+            throw new Error('Invalid request: must contain payload');
+        }
+        const base64Request = args[1];
+        const bytes = Buffer.from(base64Request, 'base64');
+        return fromBinary(ExecuteRequestSchema, bytes);
+    }
+    async run(initFn) {
+        const runtime = new Runtime(this.config, 0, this.request.maxResponseSize);
+        var result;
+        try {
+            const workflow = await initFn(this.config, {
+                getSecret: runtime.getSecret.bind(runtime),
+            });
+            switch (this.request.request.case) {
+                case 'subscribe':
+                    result = this.handleSubscribePhase(this.request, workflow);
+                    break;
+                case 'trigger':
+                    result = this.handleExecutionPhase(this.request, workflow, runtime);
+                    break;
+            }
+        }
+        catch (e) {
+            const err = e instanceof Error ? e.message : String(e);
+            result = create(ExecutionResultSchema, {
+                result: { case: 'error', value: err },
+            });
+        }
+        const awaitedResult = await result;
+        hostBindings.sendResponse(toBinary(ExecutionResultSchema, awaitedResult));
+    }
+    async handleExecutionPhase(req, workflow, runtime) {
+        if (req.request.case !== 'trigger') {
+            throw new Error('cannot handle non-trigger request as a trigger');
+        }
+        const triggerMsg = req.request.value;
+        const index = Number(triggerMsg.id);
+        if (Number.isFinite(index) && index >= 0 && index < workflow.length) {
+            const entry = workflow[index];
+            const schema = entry.trigger.outputSchema();
+            const payloadAny = triggerMsg.payload;
+            /**
+             * Note: do not hardcode method name; routing by id is authoritative.
+             *
+             * This matches the GO SDK behavior, which also just checks for the id.
+             *
+             * @see https://github.com/smartcontractkit/cre-sdk-go/blob/5a41d81e3e072008484e85dc96d746401aafcba2/cre/wasm/runner.go#L81
+             * */
+            const decoded = fromBinary(schema, payloadAny.value);
+            const adapted = await entry.trigger.adapt(decoded);
+            try {
+                const result = await entry.fn(runtime, adapted);
+                const wrapped = Value.wrap(result);
+                return create(ExecutionResultSchema, {
+                    result: { case: 'value', value: wrapped.proto() },
+                });
+            }
+            catch (e) {
+                const err = e instanceof Error ? e.message : String(e);
+                return create(ExecutionResultSchema, {
+                    result: { case: 'error', value: err },
+                });
+            }
+        }
+        return create(ExecutionResultSchema, {
+            result: { case: 'error', value: 'trigger not found' },
+        });
+    }
+    handleSubscribePhase(req, workflow) {
+        if (req.request.case !== 'subscribe') {
+            return create(ExecutionResultSchema, {
+                result: { case: 'error', value: 'subscribe request expected' },
+            });
+        }
+        // Build TriggerSubscriptionRequest from the workflow entries
+        const subscriptions = workflow.map((entry) => ({
+            id: entry.trigger.capabilityId(),
+            method: entry.trigger.method(),
+            payload: entry.trigger.configAsAny(),
+        }));
+        const subscriptionRequest = create(TriggerSubscriptionRequestSchema, {
+            subscriptions,
+        });
+        return create(ExecutionResultSchema, {
+            result: { case: 'triggerSubscriptions', value: subscriptionRequest },
+        });
+    }
+}

package/dist/sdk/wasm/runner.test.d.ts

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

package/dist/sdk/wasm/runner.test.js

@@ -0,0 +1,270 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test';
+import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack, EmptySchema } from '@bufbuild/protobuf/wkt';
+import { ConfigSchema, OutputsSchema, } from '../../generated/capabilities/internal/basictrigger/v1/basic_trigger_pb';
+import { AwaitSecretsRequestSchema, AwaitSecretsResponseSchema, ExecuteRequestSchema, ExecutionResultSchema, GetSecretsRequestSchema, SecretResponseSchema, SecretResponsesSchema, SecretSchema, TriggerSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { BasicCapability as BasicTriggerCapability } from '../../generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen';
+import { cre } from '../cre';
+import { Value } from '../utils';
+import { Runner } from './runner';
+const anyConfig = Buffer.from('config');
+const anyMaxResponseSize = 2048n;
+const basicTrigger = new BasicTriggerCapability();
+const capID = BasicTriggerCapability.CAPABILITY_ID;
+const subscribeRequest = create(ExecuteRequestSchema, {
+    request: { case: 'subscribe', value: create(EmptySchema) },
+    maxResponseSize: anyMaxResponseSize,
+    config: anyConfig,
+});
+const anyExecuteRequest = create(ExecuteRequestSchema, {
+    request: {
+        case: 'trigger',
+        value: create(TriggerSchema, {
+            id: 0n,
+            payload: anyPack(OutputsSchema, create(OutputsSchema, { coolOutput: 'hi' })),
+        }),
+    },
+    maxResponseSize: anyMaxResponseSize,
+    config: anyConfig,
+});
+const mockHostBindings = {
+    sendResponse: mock(() => {
+        return 0;
+    }),
+    versionV2: mock(() => { }),
+    getWasiArgs: mock(() => {
+        throw new Error('override for tests');
+    }),
+    getSecrets: mock((data, maxResponseSize) => {
+        throw new Error('override for tests');
+    }),
+    awaitSecrets: mock((data, maxResponseSize) => {
+        throw new Error('override for tests');
+    }),
+};
+const proxyHostBindings = {
+    sendResponse: (data) => {
+        return mockHostBindings.sendResponse(data);
+    },
+    versionV2: () => {
+        return mockHostBindings.versionV2();
+    },
+    getWasiArgs: () => {
+        return mockHostBindings.getWasiArgs();
+    },
+    switchModes: mock(() => { }),
+    log: (message) => {
+        throw new Error('log called unexpectedly in test');
+    },
+    callCapability: (data) => {
+        throw new Error('callCapability called unexpectedly in test');
+    },
+    awaitCapabilities: (data, id) => {
+        throw new Error('awaitCapabilities called unexpectedly in test');
+    },
+    getSecrets: (data, id) => {
+        return mockHostBindings.getSecrets(data, id);
+    },
+    awaitSecrets: (data, id) => {
+        return mockHostBindings.awaitSecrets(data, id);
+    },
+    now: () => {
+        throw new Error('now called unexpectedly in test');
+    },
+};
+Object.assign(globalThis, proxyHostBindings);
+afterEach(() => {
+    mock.restore();
+});
+describe('runner', () => {
+    describe('run', () => {
+        test('gathers subscriptions', async () => {
+            var sentResponse = null;
+            mockHostBindings.sendResponse = mock((input) => {
+                sentResponse = fromBinary(ExecutionResultSchema, input);
+                return 0;
+            });
+            const runner = await getTestRunner(subscribeRequest);
+            await runner.run(async (_, secretsProvider) => {
+                return [
+                    cre.handler(basicTrigger.trigger({ name: 'foo', number: 10 }), () => {
+                        throw new Error('Must not be called during registration to tiggers');
+                    }),
+                ];
+            });
+            expect(sentResponse).toBeDefined();
+            expect(sentResponse.result.case).toBe('triggerSubscriptions');
+            const responseValue = sentResponse.result.value;
+            expect(responseValue.subscriptions.length).toBe(1);
+            expect(responseValue.subscriptions[0].id).toBe(capID);
+            expect(responseValue.subscriptions[0].method).toBe('Trigger');
+            expect(responseValue.subscriptions[0].payload).toBeDefined();
+            const actualConfig = anyUnpack(responseValue.subscriptions[0].payload, ConfigSchema);
+            expect(actualConfig.name).toBe('foo');
+            expect(actualConfig.number).toBe(10);
+        });
+        test('executes workflow', async () => {
+            var sentResponse = null;
+            mockHostBindings.sendResponse = mock((input) => {
+                sentResponse = fromBinary(ExecutionResultSchema, input);
+                return 0;
+            });
+            const runner = await getTestRunner(anyExecuteRequest);
+            await runner.run(async (_, secretsProvider) => {
+                return [
+                    cre.handler(basicTrigger.trigger({ name: 'foo', number: 10 }), (runtime, trigger) => {
+                        expect(runtime.config).toBe(anyConfig.toString());
+                        expect(trigger.coolOutput).toBe('hi');
+                        return 10;
+                    }),
+                ];
+            });
+            expect(sentResponse).toBeDefined();
+            expect(sentResponse.result.case).toBe('value');
+            expect(Value.wrap(sentResponse.result.value).unwrapToType({ instance: 10 })).toBe(10);
+        });
+    });
+    test('executes subscribe error', async () => {
+        var sentResponse = null;
+        const anyError = 'error';
+        mockHostBindings.sendResponse = mock((input) => {
+            sentResponse = fromBinary(ExecutionResultSchema, input);
+            expect(sentResponse.result.case).toBe('error');
+            expect(sentResponse.result.value).toBe(anyError);
+            return 0;
+        });
+        const runner = await getTestRunner(subscribeRequest);
+        await runner.run((_, secretsProvider) => {
+            throw new Error(anyError);
+        });
+    });
+    test('executes subscribe resolve error', async () => {
+        var sentResponse = null;
+        const anyError = 'error';
+        mockHostBindings.sendResponse = mock((input) => {
+            sentResponse = fromBinary(ExecutionResultSchema, input);
+            expect(sentResponse.result.case).toBe('error');
+            expect(sentResponse.result.value).toBe(anyError);
+            return 0;
+        });
+        const runner = await getTestRunner(subscribeRequest);
+        await runner.run(async (_, secretsProvider) => {
+            return Promise.reject(new Error(anyError));
+        });
+    });
+    test('executes trigger error', async () => {
+        var sentResponse = null;
+        const anyError = 'error';
+        mockHostBindings.sendResponse = mock((input) => {
+            sentResponse = fromBinary(ExecutionResultSchema, input);
+            expect(sentResponse.result.case).toBe('error');
+            expect(sentResponse.result.value).toBe(anyError);
+            return 0;
+        });
+        const runner = await getTestRunner(anyExecuteRequest);
+        await runner.run(async (_, secretsProvider) => {
+            throw new Error(anyError);
+        });
+    });
+    test('executes workflow with multiple triggers', async () => {
+        var sentResponse = null;
+        mockHostBindings.sendResponse = mock((input) => {
+            sentResponse = fromBinary(ExecutionResultSchema, input);
+            return 0;
+        });
+        const testRequest = structuredClone(anyExecuteRequest);
+        const trigger = testRequest.request.value;
+        trigger.id = 1n;
+        const runner = await getTestRunner(testRequest);
+        await runner.run(async (_, secretsProvider) => {
+            return [
+                cre.handler(basicTrigger.trigger({ name: 'foo', number: 10 }), (runtime, trigger) => {
+                    expect(runtime.config).toBe(anyConfig.toString());
+                    expect(trigger.coolOutput).toBe('hi');
+                    return 10;
+                }),
+                cre.handler(basicTrigger.trigger({ name: 'bar', number: 20 }), (runtime, trigger) => {
+                    expect(runtime.config).toBe(anyConfig.toString());
+                    expect(trigger.coolOutput).toBe('hi');
+                    return 20;
+                }),
+                cre.handler(basicTrigger.trigger({ name: 'baz', number: 30 }), (runtime, trigger) => {
+                    expect(runtime.config).toBe(anyConfig.toString());
+                    expect(trigger.coolOutput).toBe('hi');
+                    return 30;
+                }),
+            ];
+        });
+        expect(sentResponse).toBeDefined();
+        expect(sentResponse.result.case).toBe('value');
+        expect(Value.wrap(sentResponse.result.value).unwrapToType({ instance: 10 })).toBe(20);
+    });
+    test('get secrets passes max response size', async () => {
+        const anySecretResponse = create(SecretResponseSchema, {
+            response: {
+                case: 'secret',
+                value: create(SecretSchema, { id: 'Bar', namespace: 'Foo', owner: 'Baz', value: 'Qux' }),
+            },
+        });
+        const anySecretsResponse = create(SecretResponsesSchema, {
+            responses: [anySecretResponse],
+        });
+        mockHostBindings.getSecrets = (data, maxResponseSize) => {
+            const dataBytes = Array.isArray(data) ? new Uint8Array(data) : data;
+            const secretsRequest = fromBinary(GetSecretsRequestSchema, dataBytes);
+            expect(secretsRequest.requests.length).toBe(1);
+            expect(secretsRequest.requests[0].namespace).toBe('Foo');
+            expect(secretsRequest.requests[0].id).toBe('Bar');
+            expect(secretsRequest.callbackId).toBe(0);
+            expect(maxResponseSize).toBe(Number(anyMaxResponseSize));
+            return 0;
+        };
+        mockHostBindings.awaitSecrets = (data, maxResponseSize) => {
+            const dataBytes = Array.isArray(data) ? new Uint8Array(data) : data;
+            const awaitSecretsRequest = fromBinary(AwaitSecretsRequestSchema, dataBytes);
+            expect(awaitSecretsRequest.ids.length).toBe(1);
+            expect(awaitSecretsRequest.ids[0]).toBe(0);
+            expect(maxResponseSize).toBe(Number(anyMaxResponseSize));
+            // Create the proper AwaitSecretsResponse with a map
+            const awaitSecretsResponse = create(AwaitSecretsResponseSchema, {
+                responses: {
+                    0: anySecretsResponse,
+                },
+            });
+            return toBinary(AwaitSecretsResponseSchema, awaitSecretsResponse);
+        };
+        const dr = getTestRunner(subscribeRequest);
+        await (await dr).run(async (_, secretsProvider) => {
+            const secret = await secretsProvider.getSecret({ namespace: 'Foo', id: 'Bar' }).result();
+            expect(secret.namespace).toBe('Foo');
+            expect(secret.id).toBe('Bar');
+            expect(secret.owner).toBe('Baz');
+            expect(secret.value).toBe('Qux');
+            return [cre.handler(basicTrigger.trigger({}), () => 10)];
+        });
+        expect(true).toBe(true);
+    });
+});
+function assertEnv(r) {
+    let ran = false;
+    const verifyEnv = (config, _) => {
+        ran = true;
+        expect(config).toBe(anyConfig.toString());
+        return [];
+    };
+    r.run(verifyEnv);
+    expect(ran).toBe(true);
+}
+function getTestRunner(request) {
+    const serialized = toBinary(ExecuteRequestSchema, request);
+    const encoded = Buffer.from(serialized).toString('base64');
+    // Update the mock to return the specific request
+    mockHostBindings.getWasiArgs = mock(() => JSON.stringify(['program', encoded]));
+    return Runner.newRunner({
+        configParser: (b) => {
+            const stringConfig = Buffer.from(b).toString();
+            expect(stringConfig).toBe(anyConfig.toString());
+            return stringConfig;
+        },
+    });
+}

package/dist/sdk/wasm/runtime.d.ts

@@ -0,0 +1,7 @@
+import { NodeRuntimeImpl, RuntimeImpl } from '../impl/runtime-impl';
+export declare class Runtime<C> extends RuntimeImpl<C> {
+    constructor(config: C, nextCallId: number, maxResponseSize: bigint);
+}
+export declare class NodeRuntime<C> extends NodeRuntimeImpl<C> {
+    constructor(config: C, nextCallId: number, maxResponseSize: bigint);
+}

package/dist/sdk/wasm/runtime.js

@@ -0,0 +1,55 @@
+import { fromBinary, toBinary } from '@bufbuild/protobuf';
+import { AwaitCapabilitiesRequestSchema, AwaitCapabilitiesResponseSchema, AwaitSecretsRequestSchema, AwaitSecretsResponseSchema, CapabilityRequestSchema, GetSecretsRequestSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { NodeRuntimeImpl, RuntimeImpl } from '../impl/runtime-impl';
+import { hostBindings } from './host-bindings';
+export class Runtime extends RuntimeImpl {
+    constructor(config, nextCallId, maxResponseSize) {
+        super(config, nextCallId, WasmRuntimeHelpers.getInstance(), maxResponseSize);
+    }
+}
+export class NodeRuntime extends NodeRuntimeImpl {
+    constructor(config, nextCallId, maxResponseSize) {
+        super(config, nextCallId, WasmRuntimeHelpers.getInstance(), maxResponseSize);
+    }
+}
+class WasmRuntimeHelpers {
+    static instance;
+    constructor() { }
+    now() {
+        return hostBindings.now();
+    }
+    static getInstance() {
+        if (!WasmRuntimeHelpers.instance) {
+            WasmRuntimeHelpers.instance = new WasmRuntimeHelpers();
+        }
+        return WasmRuntimeHelpers.instance;
+    }
+    call(request) {
+        return hostBindings.callCapability(toBinary(CapabilityRequestSchema, request)) >= 0;
+    }
+    await(request, maxResponseSize) {
+        // Convert bigint to integer for WASM host binding
+        // it's an i32, so we shouldn't need to trunc it (all i32 numbers are within the range of float64 without percision loss), but somehow it makes a difference...
+        const responseSize = Math.trunc(Number(maxResponseSize));
+        const response = hostBindings.awaitCapabilities(toBinary(AwaitCapabilitiesRequestSchema, request), responseSize);
+        const responseBytes = Array.isArray(response) ? new Uint8Array(response) : response;
+        return fromBinary(AwaitCapabilitiesResponseSchema, responseBytes);
+    }
+    getSecrets(request, maxResponseSize) {
+        // Convert bigint to integer for WASM host binding
+        // it's an i32, so we shouldn't need to trunc it (all i32 numbers are within the range of float64 without percision loss), but somehow it makes a difference...
+        const responseSize = Math.trunc(Number(maxResponseSize));
+        return hostBindings.getSecrets(toBinary(GetSecretsRequestSchema, request), responseSize) >= 0;
+    }
+    awaitSecrets(request, maxResponseSize) {
+        // Convert bigint to integer for WASM host binding
+        // it's an i32, so we shouldn't need to trunc it (all i32 numbers are within the range of float64 without percision loss), but somehow it makes a difference...
+        const responseSize = Math.trunc(Number(maxResponseSize));
+        const response = hostBindings.awaitSecrets(toBinary(AwaitSecretsRequestSchema, request), responseSize);
+        const responseBytes = Array.isArray(response) ? new Uint8Array(response) : response;
+        return fromBinary(AwaitSecretsResponseSchema, responseBytes);
+    }
+    switchModes(mode) {
+        hostBindings.switchModes(mode);
+    }
+}

package/dist/sdk/workflow.d.ts

@@ -1,19 +1,17 @@
 import type { Message } from '@bufbuild/protobuf';
-import type { CapabilityResponse } from '../generated/sdk/v1alpha/sdk_pb';
-import { type Runtime } from './runtime/runtime';
-import { type ConfigHandlerParams } from './utils/config';
+import type { Secret, SecretRequest, SecretRequestJson } from '../generated/sdk/v1alpha/sdk_pb';
+import { type Runtime } from './runtime';
 import type { Trigger } from './utils/triggers/trigger-interface';
-export type HandlerFn<TConfig, TTriggerOutput> = (config: TConfig, runtime: Runtime, triggerOutput: TTriggerOutput) => Promise<unknown> | unknown;
-export interface HandlerEntry<TConfig = unknown, TRawTriggerOutput extends Message<string> = Message<string>, TTriggerOutput = TRawTriggerOutput> {
+import type { CreSerializable } from './utils';
+export type HandlerFn<TConfig, TTriggerOutput, TResult> = (runtime: Runtime<TConfig>, triggerOutput: TTriggerOutput) => Promise<CreSerializable<TResult>> | CreSerializable<TResult>;
+export interface HandlerEntry<TConfig, TRawTriggerOutput extends Message<string>, TTriggerOutput, TResult> {
     trigger: Trigger<TRawTriggerOutput, TTriggerOutput>;
-    fn: HandlerFn<TConfig, TTriggerOutput>;
-}
-export type Workflow<TConfig = unknown> = ReadonlyArray<HandlerEntry<TConfig, any, any>>;
-export declare const handler: <TRawTriggerOutput extends Message<string>, TTriggerOutput = TRawTriggerOutput, TConfig = unknown>(trigger: Trigger<TRawTriggerOutput, TTriggerOutput>, fn: HandlerFn<TConfig, TTriggerOutput>) => HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput>;
-export declare class Runner<TConfig> {
-    private readonly config;
-    private readonly runtime;
-    private constructor();
-    static newRunner<T>(configHandlerParams?: ConfigHandlerParams): Promise<Runner<T>>;
-    run(initFn: (config: TConfig) => Promise<Workflow<TConfig>> | Workflow<TConfig>): Promise<CapabilityResponse | void>;
+    fn: HandlerFn<TConfig, TTriggerOutput, TResult>;
 }
+export type Workflow<TConfig> = ReadonlyArray<HandlerEntry<TConfig, any, any, any>>;
+export declare const handler: <TRawTriggerOutput extends Message<string>, TTriggerOutput, TConfig, TResult>(trigger: Trigger<TRawTriggerOutput, TTriggerOutput>, fn: HandlerFn<TConfig, TTriggerOutput, TResult>) => HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput, TResult>;
+export type SecretsProvider = {
+    getSecret(request: SecretRequest | SecretRequestJson): {
+        result: () => Promise<Secret>;
+    };
+};

package/dist/sdk/workflow.js

@@ -1,25 +1,5 @@
-import { handleExecuteRequest } from './engine/execute';
-import { runtime } from './runtime/runtime';
-import { configHandler } from './utils/config';
-import { getRequest } from './utils/get-request';
+import {} from './runtime';
 export const handler = (trigger, fn) => ({
     trigger,
     fn,
 });
-export class Runner {
-    config;
-    runtime;
-    constructor(config) {
-        this.config = config;
-        this.runtime = runtime;
-    }
-    static async newRunner(configHandlerParams = {}) {
-        const config = await configHandler(configHandlerParams);
-        return new Runner(config);
-    }
-    async run(initFn) {
-        const req = getRequest();
-        const workflow = await initFn(this.config);
-        return await handleExecuteRequest(req, workflow, this.config, this.runtime);
-    }
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainlink/cre-sdk",
-  "version": "0.0.1-alpha",
+  "version": "0.0.2-alpha",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,7 +44,7 @@
   "dependencies": {
     "@bufbuild/protobuf": "2.6.3",
     "@bufbuild/protoc-gen-es": "2.6.3",
-    "@chainlink/cre-sdk-javy-plugin": "0.0.1-alpha",
+    "@chainlink/cre-sdk-javy-plugin": "0.0.2-alpha",
     "@standard-schema/spec": "1.0.0",
     "viem": "2.34.0",
     "zod": "3.25.76"

package/dist/sdk/engine/execute.d.ts

@@ -1,4 +0,0 @@
-import { type CapabilityResponse, type ExecuteRequest } from '../../generated/sdk/v1alpha/sdk_pb';
-import type { Runtime } from '../runtime/runtime';
-import type { Workflow } from '../workflow';
-export declare const handleExecuteRequest: <TConfig>(req: ExecuteRequest, workflow: Workflow<TConfig>, config: TConfig, runtime: Runtime) => Promise<CapabilityResponse | undefined>;

package/dist/sdk/engine/execute.js

@@ -1,12 +0,0 @@
-import { Mode, } from '../../generated/sdk/v1alpha/sdk_pb';
-import { handleExecutionPhase } from './handleExecutionPhase';
-import { handleSubscribePhase } from './handleSubscribePhase';
-export const handleExecuteRequest = async (req, workflow, config, runtime) => {
-    if (req.request.case === 'subscribe') {
-        return handleSubscribePhase(req, workflow);
-    }
-    if (req.request.case === 'trigger') {
-        runtime.switchModes(Mode.DON);
-        return handleExecutionPhase(req, workflow, config, runtime);
-    }
-};