@chainlink/cre-sdk 0.0.0 → 0.0.2-alpha

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,5 @@
+/// <reference types="./sdk/types/global" />
+export * from './sdk';
+export * from './sdk/runtime';
+export * from './sdk/utils';
+export * from './sdk/wasm';

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

@@ -0,0 +1,20 @@
+/**
+ * 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 { HTTPCapability } from '../../generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen';
+import { CronCapability } from '../../generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen';
+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 declare const cre: {
+    capabilities: {
+        CronCapability: typeof CronCapability;
+        HTTPCapability: typeof HTTPCapability;
+        HTTPClient: typeof HTTPClient;
+        EVMClient: typeof EVMClient;
+    };
+    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

@@ -0,0 +1,19 @@
+/**
+ * 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 { HTTPCapability } from '../../generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen';
+import { CronCapability } from '../../generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen';
+import { prepareRuntime } from '../utils/prepare-runtime';
+import { handler } from '../workflow';
+prepareRuntime();
+export const cre = {
+    capabilities: {
+        CronCapability,
+        HTTPCapability,
+        HTTPClient,
+        EVMClient,
+    },
+    handler,
+};

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;
+    }
+}

package/dist/sdk/impl/runtime-impl.d.ts

@@ -0,0 +1,38 @@
+import { type Message } from '@bufbuild/protobuf';
+import { type AwaitCapabilitiesRequest, type AwaitCapabilitiesResponse, type AwaitSecretsRequest, type AwaitSecretsResponse, type CapabilityRequest, type GetSecretsRequest, Mode, type Secret, type SecretRequest, type SecretRequestJson } from '../../generated/sdk/v1alpha/sdk_pb';
+import type { BaseRuntime, CallCapabilityParams, NodeRuntime, Runtime } from '../runtime';
+import { type ConsensusAggregation, type PrimitiveTypes, type UnwrapOptions } from '../utils';
+export declare class BaseRuntimeImpl<C> implements BaseRuntime<C> {
+    config: C;
+    nextCallId: number;
+    protected helpers: RuntimeHelpers;
+    protected maxResponseSize: bigint;
+    private mode;
+    modeError?: Error;
+    constructor(config: C, nextCallId: number, helpers: RuntimeHelpers, maxResponseSize: bigint, mode: Mode);
+    callCapability<I extends Message, O extends Message>({ capabilityId, method, payload, inputSchema, outputSchema, }: CallCapabilityParams<I, O>): {
+        result: () => Promise<O>;
+    };
+    getNextCallId(): number;
+    now(): Date;
+}
+export declare class NodeRuntimeImpl<C> extends BaseRuntimeImpl<C> implements NodeRuntime<C> {
+    _isNodeRuntime: true;
+    constructor(config: C, nextCallId: number, helpers: RuntimeHelpers, maxResponseSize: bigint);
+}
+export declare class RuntimeImpl<C> extends BaseRuntimeImpl<C> implements Runtime<C> {
+    private nextNodeCallId;
+    constructor(config: C, nextCallId: number, helpers: RuntimeHelpers, maxResponseSize: bigint);
+    runInNodeMode<TArgs extends any[], TOutput>(fn: (nodeRuntime: NodeRuntime<C>, ...args: TArgs) => Promise<TOutput> | TOutput, consesusAggretation: ConsensusAggregation<TOutput, true>, unwrapOptions?: TOutput extends PrimitiveTypes ? never : UnwrapOptions<TOutput>): (...args: TArgs) => Promise<TOutput>;
+    getSecret(request: SecretRequest | SecretRequestJson): {
+        result: () => Promise<Secret>;
+    };
+}
+export interface RuntimeHelpers {
+    call(request: CapabilityRequest): boolean;
+    await(request: AwaitCapabilitiesRequest, maxResponseSize: bigint): AwaitCapabilitiesResponse;
+    getSecrets(request: GetSecretsRequest, maxResponseSize: bigint): boolean;
+    awaitSecrets(request: AwaitSecretsRequest, maxResponseSize: bigint): AwaitSecretsResponse;
+    switchModes(mode: Mode): void;
+    now(): number;
+}

package/dist/sdk/impl/runtime-impl.js

@@ -0,0 +1,190 @@
+import { create } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
+import { AwaitCapabilitiesRequestSchema, AwaitSecretsRequestSchema, CapabilityRequestSchema, GetSecretsRequestSchema, Mode, SecretRequestSchema, SimpleConsensusInputsSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { ConsensusCapability } from '../../generated-sdk/capabilities/internal/consensus/v1alpha/consensus_sdk_gen';
+import { Value, } from '../utils';
+import { CapabilityError } from '../utils/capabilities/capability-error';
+import { DonModeError, NodeModeError, SecretsError } from '../errors';
+export class BaseRuntimeImpl {
+    config;
+    nextCallId;
+    helpers;
+    maxResponseSize;
+    mode;
+    // modeError must only be set from within NodeRuntimeImpl
+    modeError;
+    constructor(config, nextCallId, helpers, maxResponseSize, mode) {
+        this.config = config;
+        this.nextCallId = nextCallId;
+        this.helpers = helpers;
+        this.maxResponseSize = maxResponseSize;
+        this.mode = mode;
+    }
+    callCapability({ capabilityId, method, payload, inputSchema, outputSchema, }) {
+        if (this.modeError) {
+            return { result: () => Promise.reject(this.modeError) };
+        }
+        // nextCallId tracks the unique id for a request to the WASM host.
+        // to avoid collisions of the ID in different modes, it is
+        // incremented in DON mode and decremented in Node mode.
+        // eg. - first call don mode: nextCallId = 1
+        //     - second call: nextCallId = 2
+        //     - first call node mode: nextCallId = -1
+        //     - second call node mode: nextCallId = -2
+        //     - etc...
+        const anyPayload = anyPack(inputSchema, payload);
+        const callbackId = this.nextCallId;
+        if (this.mode == Mode.DON)
+            this.nextCallId++;
+        else
+            this.nextCallId--;
+        const req = create(CapabilityRequestSchema, {
+            id: capabilityId,
+            method,
+            payload: anyPayload,
+            callbackId,
+        });
+        if (!this.helpers.call(req)) {
+            return {
+                result: () => {
+                    return Promise.reject(new CapabilityError(`Capability not found ${capabilityId}`, {
+                        callbackId,
+                        method,
+                        capabilityId,
+                    }));
+                },
+            };
+        }
+        return {
+            result: async () => {
+                const awaitRequest = create(AwaitCapabilitiesRequestSchema, { ids: [callbackId] });
+                const awaitResponse = this.helpers.await(awaitRequest, this.maxResponseSize);
+                const capabilityResponse = awaitResponse.responses[callbackId];
+                if (!capabilityResponse) {
+                    throw new CapabilityError(`No response found for callback ID ${callbackId}`, {
+                        capabilityId,
+                        method,
+                        callbackId,
+                    });
+                }
+                const response = capabilityResponse.response;
+                switch (response.case) {
+                    case 'payload':
+                        return anyUnpack(response.value, outputSchema);
+                    case 'error':
+                        throw new CapabilityError(`Error ${response.value}`, {
+                            capabilityId,
+                            method,
+                            callbackId,
+                        });
+                    default:
+                        throw new CapabilityError(`Error cannot unwrap ${response.case}`, {
+                            capabilityId,
+                            method,
+                            callbackId,
+                        });
+                }
+            },
+        };
+    }
+    getNextCallId() {
+        return this.nextCallId;
+    }
+    now() {
+        // ns to ms
+        return new Date(this.helpers.now() / 1000000);
+    }
+}
+export class NodeRuntimeImpl extends BaseRuntimeImpl {
+    _isNodeRuntime = true;
+    constructor(config, nextCallId, helpers, maxResponseSize) {
+        helpers.switchModes(Mode.NODE);
+        super(config, nextCallId, helpers, maxResponseSize, Mode.NODE);
+    }
+}
+export class RuntimeImpl extends BaseRuntimeImpl {
+    nextNodeCallId = -1;
+    constructor(config, nextCallId, helpers, maxResponseSize) {
+        helpers.switchModes(Mode.DON);
+        super(config, nextCallId, helpers, maxResponseSize, Mode.DON);
+    }
+    runInNodeMode(fn, consesusAggretation, unwrapOptions) {
+        return async (...args) => {
+            this.modeError = new DonModeError();
+            const nodeRuntime = new NodeRuntimeImpl(this.config, this.nextNodeCallId, this.helpers, this.maxResponseSize);
+            const consensusInput = create(SimpleConsensusInputsSchema, {
+                descriptors: consesusAggretation.descriptor,
+            });
+            if (consesusAggretation.defaultValue) {
+                // This cast is safe, since ConsensusAggregation can only have true its second argument if T extends CreSerializable<TOutput>
+                consensusInput.default = Value.from(consesusAggretation.defaultValue).proto();
+            }
+            try {
+                const observation = await fn(nodeRuntime, ...args);
+                // This cast is safe, since ConsensusAggregation can only have true its second argument if T extends CreSerializable<TOutput>
+                consensusInput.observation = {
+                    case: 'value',
+                    value: Value.from(observation).proto(),
+                };
+            }
+            catch (e) {
+                consensusInput.observation = { case: 'error', value: e.message || String(e) };
+            }
+            finally {
+                // Always restore DON mode before invoking consensus
+                this.modeError = undefined;
+                this.nextNodeCallId = nodeRuntime.nextCallId;
+                nodeRuntime.modeError = new NodeModeError();
+                this.helpers.switchModes(Mode.DON);
+            }
+            const consensus = new ConsensusCapability();
+            const result = await consensus.simple(this, consensusInput).result();
+            const wrappedValue = Value.wrap(result);
+            return unwrapOptions
+                ? wrappedValue.unwrapToType(unwrapOptions)
+                : wrappedValue.unwrap();
+        };
+    }
+    getSecret(request) {
+        if (this.modeError) {
+            return { result: () => Promise.reject(this.modeError) };
+        }
+        const secretRequest = request.$typeName
+            ? create(SecretRequestSchema, request)
+            : request;
+        const id = this.nextCallId;
+        this.nextCallId++;
+        const secretsReq = create(GetSecretsRequestSchema, {
+            callbackId: id,
+            requests: [request],
+        });
+        if (!this.helpers.getSecrets(secretsReq, this.maxResponseSize)) {
+            return {
+                result: () => Promise.reject(new SecretsError(secretRequest, 'host is not making the secrets request')),
+            };
+        }
+        return {
+            result: async () => {
+                const awaitRequest = create(AwaitSecretsRequestSchema, { ids: [id] });
+                const awaitResponse = this.helpers.awaitSecrets(awaitRequest, this.maxResponseSize);
+                const secretsResponse = awaitResponse.responses[id];
+                if (!secretsResponse) {
+                    throw new SecretsError(secretRequest, 'no response');
+                }
+                const responses = secretsResponse.responses;
+                if (responses.length != 1) {
+                    throw new SecretsError(secretRequest, 'invalid value returned from host');
+                }
+                const response = responses[0].response;
+                switch (response.case) {
+                    case 'secret':
+                        return response.value;
+                    case 'error':
+                        throw new SecretsError(secretRequest, response.value.error);
+                    default:
+                        throw new SecretsError(secretRequest, 'cannot unmashal returned value from host');
+                }
+            },
+        };
+    }
+}

package/dist/sdk/impl/runtime-impl.test.d.ts

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

package/dist/sdk/impl/runtime-impl.test.js

@@ -0,0 +1,334 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test';
+import { create } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
+import { InputSchema, OutputSchema as OutputSchema, } from '../../generated/capabilities/internal/actionandtrigger/v1/action_and_trigger_pb';
+import { InputsSchema, OutputsSchema, } from '../../generated/capabilities/internal/basicaction/v1/basic_action_pb';
+import { NodeInputsSchema, NodeOutputsSchema, } from '../../generated/capabilities/internal/nodeaction/v1/node_action_pb';
+import { AggregationType, AwaitCapabilitiesResponseSchema, CapabilityResponseSchema, ConsensusDescriptorSchema, FieldsMapSchema, Mode, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { BasicCapability } from '../../generated-sdk/capabilities/internal/actionandtrigger/v1/basic_sdk_gen';
+import { BasicActionCapability } from '../../generated-sdk/capabilities/internal/basicaction/v1/basicaction_sdk_gen';
+import { ConsensusCapability } from '../../generated-sdk/capabilities/internal/consensus/v1alpha/consensus_sdk_gen';
+import { BasicActionCapability as NodeActionCapability } from '../../generated-sdk/capabilities/internal/nodeaction/v1/basicaction_sdk_gen';
+import { ConsensusAggregationByFields, consensusMedianAggregation, median, Value, } from '../utils';
+import { CapabilityError } from '../utils/capabilities/capability-error';
+import { DonModeError, NodeModeError } from '../errors';
+import { RuntimeImpl } from './runtime-impl';
+// Helper function to create a RuntimeHelpers mock with error-throwing defaults
+function createRuntimeHelpersMock(overrides = {}) {
+    // Create default implementation that throws errors for all methods
+    const defaultMock = {
+        call: mock(() => {
+            throw new Error('Method not implemented: call');
+        }),
+        await: mock(() => {
+            throw new Error('Method not implemented: await');
+        }),
+        getSecrets: mock(() => {
+            throw new Error('Method not implemented: getSecrets');
+        }),
+        awaitSecrets: mock(() => {
+            throw new Error('Method not implemented: awaitSecrets');
+        }),
+        // switchModes is used in every test, most will ignore it, so it's safe to default to a no-op.
+        switchModes: mock(() => { }),
+        now: mock(() => {
+            throw new Error('Method not implemented: now');
+        }),
+    };
+    // Return a merged object with overrides taking precedence
+    return { ...defaultMock, ...overrides };
+}
+const anyMaxSize = 1024n * 1024n;
+// Store original prototypes for manual restoration
+const originalConsensusSimple = ConsensusCapability.prototype.simple;
+const originalNodeActionPerformAction = NodeActionCapability.prototype.performAction;
+afterEach(() => {
+    // Restore all mocks after each test
+    mock.restore();
+    // Manually restore prototype methods
+    ConsensusCapability.prototype.simple = originalConsensusSimple;
+    NodeActionCapability.prototype.performAction = originalNodeActionPerformAction;
+});
+describe('test runtime', () => {
+    describe('test call capability', () => {
+        // TODO:
+        test.skip('runs async - proper async implementation in progress', async () => {
+            const anyResult1 = 'ok1';
+            const anyResult2 = 'ok2';
+            var expectedCall = 1;
+            var expectedAwait = 2;
+            const input1 = create(InputsSchema, { inputThing: true });
+            const input2 = create(InputSchema, { name: 'input' });
+            const helpers = createRuntimeHelpersMock({
+                call: mock((request) => {
+                    switch (request.callbackId) {
+                        case 1:
+                            return expectCapabilityCall(request, input1, InputsSchema, BasicActionCapability.CAPABILITY_ID, expectedCall++);
+                        case 2:
+                            return expectCapabilityCall(request, input2, InputSchema, BasicCapability.CAPABILITY_ID, expectedCall++);
+                        default:
+                            throw new Error(`Unexpected call with callbackId: ${request.callbackId}`);
+                    }
+                }),
+                await: mock((request) => {
+                    expect(request.ids.length).toEqual(1);
+                    var payload;
+                    const id = request.ids[0];
+                    switch (id) {
+                        case 1:
+                            expect(1).toEqual(expectedAwait);
+                            expectedAwait--;
+                            payload = anyPack(OutputsSchema, create(OutputsSchema, { adaptedThing: anyResult1 }));
+                            break;
+                        case 2:
+                            expect(2).toEqual(expectedAwait);
+                            expectedAwait--;
+                            payload = anyPack(OutputSchema, create(OutputSchema, { welcome: anyResult2 }));
+                            break;
+                        default:
+                            throw new Error(`Unexpected await with id: ${request.ids[0]}`);
+                    }
+                    return create(AwaitCapabilitiesResponseSchema, {
+                        responses: {
+                            [id]: create(CapabilityResponseSchema, {
+                                response: { case: 'payload', value: payload },
+                            }),
+                        },
+                    });
+                }),
+            });
+            const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+            const workflowAction1 = new BasicActionCapability();
+            const call1 = workflowAction1.performAction(runtime, input1);
+            const workflowAction2 = new BasicCapability();
+            const call2 = workflowAction2.action(runtime, input2);
+            const result2 = await call2.result();
+            expect(result2.welcome).toEqual(anyResult2);
+            const result1 = await call1.result();
+            expect(result1.adaptedThing).toEqual(anyResult1);
+        });
+        test('call capability errors', async () => {
+            const helpers = createRuntimeHelpersMock({
+                call: mock((_) => {
+                    return false;
+                }),
+            });
+            const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+            const workflowAction1 = new BasicActionCapability();
+            const call1 = workflowAction1
+                .performAction(runtime, create(InputsSchema, { inputThing: true }))
+                .result();
+            expect(call1).rejects.toThrow(new CapabilityError(`Capability not found ${BasicActionCapability.CAPABILITY_ID}`, {
+                callbackId: 1,
+                capabilityId: BasicActionCapability.CAPABILITY_ID,
+                method: 'PerformAction',
+            }));
+        });
+        test('capability errors are returned to the caller', async () => {
+            const anyError = 'error';
+            const helpers = createRuntimeHelpersMock({
+                call: mock((_) => {
+                    return true;
+                }),
+                await: mock((request) => {
+                    expect(request.ids.length).toEqual(1);
+                    return create(AwaitCapabilitiesResponseSchema, {
+                        responses: {
+                            [request.ids[0]]: create(CapabilityResponseSchema, {
+                                response: { case: 'error', value: anyError },
+                            }),
+                        },
+                    });
+                }),
+            });
+            const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+            const workflowAction1 = new BasicActionCapability();
+            const call1 = workflowAction1
+                .performAction(runtime, create(InputsSchema, { inputThing: true }))
+                .result();
+            expect(call1).rejects.toThrow(new CapabilityError('Error ' + anyError, {
+                callbackId: 1,
+                capabilityId: BasicActionCapability.CAPABILITY_ID,
+                method: 'PerformAction',
+            }));
+        });
+        test('await errors', async () => {
+            const anyError = 'error';
+            const helpers = createRuntimeHelpersMock({
+                call: mock((_) => {
+                    return true;
+                }),
+                await: mock((_) => {
+                    throw new Error(anyError);
+                }),
+            });
+            const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+            const workflowAction1 = new BasicActionCapability();
+            const call1 = workflowAction1
+                .performAction(runtime, create(InputsSchema, { inputThing: true }))
+                .result();
+            expect(call1).rejects.toThrow(new CapabilityError(anyError, {
+                callbackId: 1,
+                capabilityId: BasicActionCapability.CAPABILITY_ID,
+                method: 'PerformAction',
+            }));
+        });
+        test('await missing response', async () => {
+            const helpers = createRuntimeHelpersMock({
+                call: mock((_) => {
+                    return true;
+                }),
+                await: mock((_) => {
+                    return create(AwaitCapabilitiesResponseSchema, { responses: {} });
+                }),
+            });
+            const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+            const workflowAction1 = new BasicActionCapability();
+            const call1 = workflowAction1
+                .performAction(runtime, create(InputsSchema, { inputThing: true }))
+                .result();
+            expect(call1).rejects.toThrow(new CapabilityError('No response found for callback ID 1', {
+                callbackId: 1,
+                capabilityId: BasicActionCapability.CAPABILITY_ID,
+                method: 'PerformAction',
+            }));
+        });
+    });
+});
+describe('test now conversts to date', () => {
+    test('now converts to date', () => {
+        const helpers = createRuntimeHelpersMock({
+            now: mock(() => 1716153600000),
+        });
+        const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+        const now = runtime.now();
+        expect(now).toEqual(new Date(1716153600000 / 1000000));
+    });
+});
+describe('test run in node mode', () => {
+    test('successful consensus', async () => {
+        const anyObservation = 10;
+        const anyMedian = 11;
+        const modes = [];
+        const helpers = createRuntimeHelpersMock({
+            switchModes: mock((mode) => {
+                modes.push(mode);
+            }),
+        });
+        ConsensusCapability.prototype.simple = mock((_, inputs) => {
+            expect(modes).toEqual([Mode.DON, Mode.NODE, Mode.DON]);
+            expect(inputs.default).toBeUndefined();
+            const consensusDescriptor = create(ConsensusDescriptorSchema, {
+                descriptor: {
+                    case: 'fieldsMap',
+                    value: create(FieldsMapSchema, {
+                        fields: {
+                            outputThing: create(ConsensusDescriptorSchema, {
+                                descriptor: { case: 'aggregation', value: AggregationType.MEDIAN },
+                            }),
+                        },
+                    }),
+                },
+            });
+            expect(inputs.descriptors).toEqual(consensusDescriptor);
+            expect(inputs.$typeName).not.toBeUndefined();
+            const inputsProto = inputs;
+            expect(inputsProto.observation.case).toEqual('value');
+            expect(Value.wrap(inputsProto.observation.value).unwrapToType({
+                factory: () => create(NodeOutputsSchema),
+            }).outputThing).toEqual(anyObservation);
+            return {
+                result: async () => Value.from(create(NodeOutputsSchema, { outputThing: anyMedian })).proto(),
+            };
+        });
+        NodeActionCapability.prototype.performAction = mock((_, __) => {
+            expect(modes).toEqual([Mode.DON, Mode.NODE]);
+            return {
+                result: async () => create(NodeOutputsSchema, { outputThing: anyObservation }),
+            };
+        });
+        const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+        const result = await runtime.runInNodeMode(async (nodeRuntime) => {
+            const capability = new NodeActionCapability();
+            return await capability
+                .performAction(nodeRuntime, create(NodeInputsSchema, { inputThing: true }))
+                .result();
+        }, ConsensusAggregationByFields({ outputThing: median }))();
+        expect(result.outputThing).toEqual(anyMedian);
+    });
+    test('failed consensus', async () => {
+        const anyError = 'error';
+        const helpers = createRuntimeHelpersMock({
+            switchModes: mock((_) => { }),
+        });
+        ConsensusCapability.prototype.simple = mock((_, inputs) => {
+            expect(inputs.default).toBeUndefined();
+            expect(inputs.descriptors).toEqual(create(ConsensusDescriptorSchema, {
+                descriptor: { case: 'aggregation', value: AggregationType.MEDIAN },
+            }));
+            expect(inputs.$typeName).not.toBeUndefined();
+            const inputsProto = inputs;
+            expect(inputsProto.observation.case).toEqual('error');
+            expect(inputsProto.observation.value).toEqual(anyError);
+            return { result: async () => Promise.reject(new Error(anyError)) };
+        });
+        const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+        const result = runtime.runInNodeMode(async (nodeRuntime) => {
+            throw new Error(anyError);
+        }, consensusMedianAggregation())();
+        expect(result).rejects.toThrow(new Error(anyError));
+    });
+    test('node runtime in don mode fails', async () => {
+        const helpers = createRuntimeHelpersMock({
+            switchModes: mock((_) => { }),
+            call: mock((_) => {
+                expect(false).toBe(true);
+                return false;
+            }),
+        });
+        ConsensusCapability.prototype.simple = mock((_, __) => {
+            return { result: async () => Promise.resolve(Value.from(0).proto()) };
+        });
+        const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+        var nrt;
+        await runtime.runInNodeMode(async (nodeRuntime) => {
+            nrt = nodeRuntime;
+            return 0;
+        }, consensusMedianAggregation())();
+        const capability = new NodeActionCapability();
+        expect(nrt).toBeDefined();
+        expect(capability.performAction(nrt, create(NodeInputsSchema, { inputThing: true })).result()).rejects.toThrow(new NodeModeError());
+    });
+    test('don runtime in node mode fails', async () => {
+        const helpers = createRuntimeHelpersMock({
+            switchModes: mock((_) => { }),
+        });
+        ConsensusCapability.prototype.simple = mock((_, inputs) => {
+            expect(inputs.default).toBeUndefined();
+            expect(inputs.descriptors).toEqual(create(ConsensusDescriptorSchema, {
+                descriptor: { case: 'aggregation', value: AggregationType.MEDIAN },
+            }));
+            expect(inputs.$typeName).not.toBeUndefined();
+            const inputsProto = inputs;
+            expect(inputsProto.observation.case).toEqual('error');
+            expect(inputsProto.observation.value).toEqual(new DonModeError().message);
+            return { result: async () => Promise.reject(new DonModeError()) };
+        });
+        const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+        const result = runtime.runInNodeMode(async (_) => {
+            const capability = new BasicActionCapability();
+            await capability.performAction(runtime, create(InputsSchema, { inputThing: true })).result();
+            return 0;
+        }, consensusMedianAggregation())();
+        expect(result).rejects.toThrow(new DonModeError());
+    });
+});
+function expectCapabilityCall(request, expectedPayload, desc, expectedCapabilityId, expectedCallbackId) {
+    expect(request.id).toEqual(expectedCapabilityId);
+    expect(request.method).toEqual('PerformAction');
+    expect(request.callbackId).toEqual(expectedCallbackId);
+    expect(request.payload).toBeDefined();
+    const payload = anyUnpack(request.payload, desc);
+    expect(payload).toEqual(expectedPayload);
+    return true;
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cre';
+export type * from './runtime';
+export * from './runtime';
+export * from './workflow';

package/dist/sdk/index.js

@@ -0,0 +1,3 @@
+export * from './cre';
+export * from './runtime';
+export * from './workflow';