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

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

@@ -1,5 +1,7 @@
 import { fromJson } from '@bufbuild/protobuf';
 import { RequestSchema, ResponseSchema, } from '../../../../../generated/capabilities/networking/http/v1alpha/client_pb';
+import {} from '../../../../../sdk';
+import { Report } from '../../../../../sdk/report';
 export class SendRequester {
     runtime;
     client;
@@ -34,9 +36,16 @@ export class ClientCapability {
         return this.sendRequestCallHelper(runtime, input);
     }
     sendRequestCallHelper(runtime, input) {
-        const payload = input.$typeName
-            ? input
-            : fromJson(RequestSchema, input);
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(RequestSchema, input);
+        }
         const capabilityId = ClientCapability.CAPABILITY_ID;
         const capabilityResponse = runtime.callCapability({
             capabilityId,
@@ -47,7 +56,8 @@ export class ClientCapability {
         });
         return {
             result: () => {
-                return capabilityResponse.result();
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }

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

@@ -1,6 +1,9 @@
 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 {} from '../../../../../sdk';
+import { Report } from '../../../../../sdk/report';
+import { hexToBytes } from '../../../../../sdk/utils/hex-utils';
 import {} from '../../../../../sdk/utils/triggers/trigger-interface';
 /**
  * HTTP Capability

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

@@ -1,6 +1,9 @@
 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 {} from '../../../../../sdk';
+import { Report } from '../../../../../sdk/report';
+import { hexToBytes } from '../../../../../sdk/utils/hex-utils';
 import {} from '../../../../../sdk/utils/triggers/trigger-interface';
 /**
  * Cron Capability

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './sdk';
 export * from './sdk/runtime';
 export * from './sdk/utils';
+export * from './sdk/utils/capabilities/http/http-helpers';
 export * from './sdk/wasm';

package/dist/index.js

@@ -2,4 +2,6 @@
 export * from './sdk';
 export * from './sdk/runtime';
 export * from './sdk/utils';
+// Export HTTP response helpers
+export * from './sdk/utils/capabilities/http/http-helpers';
 export * from './sdk/wasm';

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

@@ -5,7 +5,7 @@ import { ClientCapability as EVMClient } from '../../generated-sdk/capabilities/
 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';
-export type { Log as EVMLog } from '../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
+export { type Log as EVMLog, TxStatus, } 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';

package/dist/sdk/cre/index.js

@@ -7,6 +7,7 @@ import { HTTPCapability } from '../../generated-sdk/capabilities/networking/http
 import { CronCapability } from '../../generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen';
 import { prepareRuntime } from '../utils/prepare-runtime';
 import { handler } from '../workflow';
+export { TxStatus, } from '../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
 prepareRuntime();
 export const cre = {
     capabilities: {

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

@@ -1,6 +1,7 @@
 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 { BaseRuntime, CallCapabilityParams, NodeRuntime, ReportRequest, ReportRequestJson, Runtime } from '..';
+import type { Report } from '../report';
 import { type ConsensusAggregation, type PrimitiveTypes, type UnwrapOptions } from '../utils';
 export declare class BaseRuntimeImpl<C> implements BaseRuntime<C> {
     config: C;
@@ -30,6 +31,9 @@ export declare class RuntimeImpl<C> extends BaseRuntimeImpl<C> implements Runtim
     getSecret(request: SecretRequest | SecretRequestJson): {
         result: () => Secret;
     };
+    report(input: ReportRequest | ReportRequestJson): {
+        result: () => Report;
+    };
 }
 export interface RuntimeHelpers {
     call(request: CapabilityRequest): boolean;

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

@@ -38,10 +38,12 @@ export class BaseRuntimeImpl {
         //     - etc...
         const anyPayload = anyPack(inputSchema, payload);
         const callbackId = this.nextCallId;
-        if (this.mode === Mode.DON)
+        if (this.mode === Mode.DON) {
             this.nextCallId++;
-        else
+        }
+        else {
             this.nextCallId--;
+        }
         const req = create(CapabilityRequestSchema, {
             id: capabilityId,
             method,
@@ -210,4 +212,13 @@ export class RuntimeImpl extends BaseRuntimeImpl {
             },
         };
     }
+    report(input) {
+        const consensus = new ConsensusCapability();
+        const call = consensus.report(this, input);
+        return {
+            result: () => {
+                return call.result();
+            },
+        };
+    }
 }

package/dist/sdk/index.d.ts

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

package/dist/sdk/index.js

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

package/dist/sdk/report.d.ts

@@ -0,0 +1,6 @@
+import { type ReportResponse, type ReportResponseJson } from '../generated/sdk/v1alpha/sdk_pb';
+export declare class Report {
+    private readonly report;
+    constructor(report: ReportResponse | ReportResponseJson);
+    x_generatedCodeOnly_unwrap(): ReportResponse;
+}

package/dist/sdk/report.js

@@ -0,0 +1,14 @@
+import { fromJson } from '@bufbuild/protobuf';
+import { ReportResponseSchema, } from '../generated/sdk/v1alpha/sdk_pb';
+export class Report {
+    report;
+    constructor(report) {
+        this.report = report.$typeName
+            ? report
+            : fromJson(ReportResponseSchema, report);
+    }
+    // x_generatedCodeOnly_unwrap is meant to be used by the code generator only.
+    x_generatedCodeOnly_unwrap() {
+        return this.report;
+    }
+}

package/dist/sdk/runtime.d.ts

@@ -1,7 +1,9 @@
 import type { Message } from '@bufbuild/protobuf';
 import type { GenMessage } from '@bufbuild/protobuf/codegenv2';
+import type { ReportRequest, ReportRequestJson } from '../generated/sdk/v1alpha/sdk_pb';
 import type { ConsensusAggregation, PrimitiveTypes, UnwrapOptions } from './utils';
 import type { SecretsProvider } from '.';
+export type { ReportRequest, ReportRequestJson };
 export type CallCapabilityParams<I extends Message, O extends Message> = {
     capabilityId: string;
     method: string;
@@ -9,6 +11,7 @@ export type CallCapabilityParams<I extends Message, O extends Message> = {
     inputSchema: GenMessage<I>;
     outputSchema: GenMessage<O>;
 };
+import type { Report } from './report';
 export type BaseRuntime<C> = {
     config: C;
     callCapability<I extends Message, O extends Message>(params: CallCapabilityParams<I, O>): {
@@ -21,6 +24,9 @@ export type Runtime<C> = BaseRuntime<C> & SecretsProvider & {
     runInNodeMode<TArgs extends unknown[], TOutput>(fn: (nodeRuntime: NodeRuntime<C>, ...args: TArgs) => TOutput, consensusAggregation: ConsensusAggregation<TOutput, true>, unwrapOptions?: TOutput extends PrimitiveTypes ? never : UnwrapOptions<TOutput>): (...args: TArgs) => {
         result: () => TOutput;
     };
+    report(input: ReportRequest | ReportRequestJson): {
+        result: () => Report;
+    };
 };
 export type NodeRuntime<C> = BaseRuntime<C> & {
     readonly _isNodeRuntime: true;

package/dist/sdk/utils/capabilities/blockchain/blockchain-helpers.d.ts

@@ -0,0 +1,50 @@
+import type { CallMsgJson } from '../../../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
+import type { Address, Hex } from 'viem';
+/**
+ * EVM Capability Helper.
+ *
+ * `CallContractRequest`, used by EVM capability, has arguments for reading a contract as specified in the call message at a block height defined by blockNumber.
+ * That blockNumber can be:
+ *  - the latest mined block (`LATEST_BLOCK_NUMBER`) (default)
+ * 	- the last finalized block (`LAST_FINALIZED_BLOCK_NUMBER`)
+ *
+ * Using this constant will indicate that the call should be executed at the last finalized block.
+ */
+export declare const LAST_FINALIZED_BLOCK_NUMBER: {
+    absVal: string;
+    sign: string;
+};
+/**
+ * EVM Capability Helper.
+ *
+ * `CallContractRequest`, used by EVM capability, has arguments for reading a contract as specified in the call message at a block height defined by blockNumber.
+ * That blockNumber can be:
+ *  - the latest mined block (`LATEST_BLOCK_NUMBER`) (default)
+ * 	- the last finalized block (`LAST_FINALIZED_BLOCK_NUMBER`)
+ *
+ * Using this constant will indicate that the call should be executed at the latest mined block.
+ */
+export declare const LATEST_BLOCK_NUMBER: {
+    absVal: string;
+    sign: string;
+};
+export interface EncodeCallMsgPayload {
+    from: Address;
+    to: Address;
+    data: Hex;
+}
+/**
+ * Encodes a call message payload into a `CallMsgJson` protobuf structure, expected by the EVM capability.
+ *
+ * When creating a `CallContractRequest` 3 parameters are required:
+ *
+ * - `from` - The sender address.
+ * - `to` - The contract address.
+ * - `data` - The data to call the contract with.
+ *
+ * This helper wraps that data and packs into format acceptable by the EVM capability.
+ *
+ * @param payload - The call message payload to encode.
+ * @returns The encoded call message payload.
+ */
+export declare const encodeCallMsg: (payload: EncodeCallMsgPayload) => CallMsgJson;

package/dist/sdk/utils/capabilities/blockchain/blockchain-helpers.js

@@ -0,0 +1,48 @@
+import { hexToBase64 } from '../../hex-utils';
+/**
+ * EVM Capability Helper.
+ *
+ * `CallContractRequest`, used by EVM capability, has arguments for reading a contract as specified in the call message at a block height defined by blockNumber.
+ * That blockNumber can be:
+ *  - the latest mined block (`LATEST_BLOCK_NUMBER`) (default)
+ * 	- the last finalized block (`LAST_FINALIZED_BLOCK_NUMBER`)
+ *
+ * Using this constant will indicate that the call should be executed at the last finalized block.
+ */
+export const LAST_FINALIZED_BLOCK_NUMBER = {
+    absVal: Buffer.from([3]).toString('base64'), // 3 for finalized block
+    sign: '-1',
+};
+/**
+ * EVM Capability Helper.
+ *
+ * `CallContractRequest`, used by EVM capability, has arguments for reading a contract as specified in the call message at a block height defined by blockNumber.
+ * That blockNumber can be:
+ *  - the latest mined block (`LATEST_BLOCK_NUMBER`) (default)
+ * 	- the last finalized block (`LAST_FINALIZED_BLOCK_NUMBER`)
+ *
+ * Using this constant will indicate that the call should be executed at the latest mined block.
+ */
+export const LATEST_BLOCK_NUMBER = {
+    absVal: Buffer.from([2]).toString('base64'), // 2 for the latest block
+    sign: '-1',
+};
+/**
+ * Encodes a call message payload into a `CallMsgJson` protobuf structure, expected by the EVM capability.
+ *
+ * When creating a `CallContractRequest` 3 parameters are required:
+ *
+ * - `from` - The sender address.
+ * - `to` - The contract address.
+ * - `data` - The data to call the contract with.
+ *
+ * This helper wraps that data and packs into format acceptable by the EVM capability.
+ *
+ * @param payload - The call message payload to encode.
+ * @returns The encoded call message payload.
+ */
+export const encodeCallMsg = (payload) => ({
+    from: hexToBase64(payload.from),
+    to: hexToBase64(payload.to),
+    data: hexToBase64(payload.data),
+});

package/dist/sdk/utils/capabilities/http/http-helpers.d.ts

@@ -0,0 +1,112 @@
+import type { Response } from '../../../../generated/capabilities/networking/http/v1alpha/client_pb';
+/**
+ * HTTP Response Helper Functions
+ *
+ * These utility functions provide a convenient way to work with HTTP Response objects,
+ * mimicking the native Response API methods like .json(), .text(), and .arrayBuffer().
+ *
+ * @example
+ * ```typescript
+ * import { text, json, ok, getHeader } from './http-helpers'
+ *
+ * // Direct usage with Response object
+ * const response = sendRequester.sendRequest({ url: 'https://api.example.com/data' }).result()
+ *
+ * // Check if response is successful
+ * if (!ok(response)) {
+ *   throw new Error(`Request failed with status: ${response.statusCode}`)
+ * }
+ *
+ * // Get response as text (automatically trimmed)
+ * const responseText = text(response)
+ *
+ * // Parse JSON response
+ * const data = json(response)
+ *
+ * // Get specific header
+ * const contentType = getHeader(response, 'content-type')
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Function overload usage
+ * const responseFn = sendRequester.sendRequest({ url: 'https://api.example.com/data' })
+ *
+ * // Check if response is successful
+ * if (!ok(() => ({ result: responseFn.result() })).result()) {
+ *   const response = responseFn.result()
+ *   throw new Error(`Request failed with status: ${response.statusCode}`)
+ * }
+ *
+ * // Get response as text (automatically trimmed)
+ * const responseText = text(() => ({ result: responseFn.result() })).result()
+ * ```
+ */
+/**
+ * Returns the response body as a UTF-8 string, automatically trimmed
+ * @param response - The Response object
+ * @returns The body as a trimmed string
+ */
+export declare function text(response: Response): string;
+/**
+ * Returns the response body as a UTF-8 string, automatically trimmed
+ * @param responseFn - Function that returns an object with result function that returns Response
+ * @returns Object with result function that returns the body as a trimmed string
+ */
+export declare function text(responseFn: () => {
+    result: Response;
+}): {
+    result: () => string;
+};
+/**
+ * Parses the response body as JSON
+ * @param response - The Response object
+ * @returns The parsed JSON
+ * @throws Error if the body is not valid JSON
+ */
+export declare function json(response: Response): unknown;
+/**
+ * Parses the response body as JSON
+ * @param responseFn - Function that returns an object with result function that returns Response
+ * @returns Object with result function that returns the parsed JSON
+ * @throws Error if the body is not valid JSON
+ */
+export declare function json(responseFn: () => {
+    result: Response;
+}): {
+    result: () => unknown;
+};
+/**
+ * Gets a specific header value
+ * @param response - The Response object
+ * @param name - The header name (case-insensitive)
+ * @returns The header value or undefined if not found
+ */
+export declare function getHeader(response: Response, name: string): string | undefined;
+/**
+ * Gets a specific header value
+ * @param responseFn - Function that returns an object with result function that returns Response
+ * @param name - The header name (case-insensitive)
+ * @returns Object with result function that returns the header value or undefined if not found
+ */
+export declare function getHeader(responseFn: () => {
+    result: Response;
+}, name: string): {
+    result: () => string | undefined;
+};
+/**
+ * Checks if the response status indicates success (200-299)
+ * @param response - The Response object
+ * @returns True if the status code is in the 200-299 range
+ */
+export declare function ok(response: Response): boolean;
+/**
+ * Checks if the response status indicates success (200-299)
+ * @param responseFn - Function that returns an object with result function that returns Response
+ * @returns Object with result function that returns true if the status code is in the 200-299 range
+ */
+export declare function ok(responseFn: () => {
+    result: Response;
+}): {
+    result: () => boolean;
+};

package/dist/sdk/utils/capabilities/http/http-helpers.js

@@ -0,0 +1,44 @@
+export function text(responseOrFn) {
+    if (typeof responseOrFn === 'function') {
+        return {
+            result: () => text(responseOrFn().result),
+        };
+    }
+    else {
+        const decoder = new TextDecoder('utf-8');
+        return decoder.decode(responseOrFn.body).trim();
+    }
+}
+export function json(responseOrFn) {
+    if (typeof responseOrFn === 'function') {
+        return {
+            result: () => json(responseOrFn().result),
+        };
+    }
+    else {
+        const decoder = new TextDecoder('utf-8');
+        const textBody = decoder.decode(responseOrFn.body);
+        return JSON.parse(textBody);
+    }
+}
+export function getHeader(responseOrFn, name) {
+    if (typeof responseOrFn === 'function') {
+        return {
+            result: () => getHeader(responseOrFn().result, name),
+        };
+    }
+    else {
+        const lowerName = name.toLowerCase();
+        return Object.entries(responseOrFn.headers).find(([key]) => key.toLowerCase() === lowerName)?.[1];
+    }
+}
+export function ok(responseOrFn) {
+    if (typeof responseOrFn === 'function') {
+        return {
+            result: () => ok(responseOrFn().result),
+        };
+    }
+    else {
+        return responseOrFn.statusCode >= 200 && responseOrFn.statusCode < 300;
+    }
+}

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

@@ -1,3 +1,5 @@
+export * from './capabilities/blockchain/blockchain-helpers';
+export * from './capabilities/http/http-helpers';
 export * from './chain-selectors';
 export * from './hex-utils';
 export * from './values/consensus_aggregators';

package/dist/sdk/utils/index.js

@@ -1,3 +1,5 @@
+export * from './capabilities/blockchain/blockchain-helpers';
+export * from './capabilities/http/http-helpers';
 export * from './chain-selectors';
 export * from './hex-utils';
 export * from './values/consensus_aggregators';

package/dist/workflows/standard_tests/Makefile

@@ -0,0 +1,19 @@
+# Declare all matching test.wasm targets as phony
+.PHONY: FORCE
+FORCE:
+
+# Pattern rule to build test.wasm in any subdirectory
+%/test.wasm: FORCE
+	@echo "Building test: $*"
+	@case "$*" in \
+		*/*/*) \
+			echo "❌ Unsupported test path depth: $*"; \
+			exit 1; \
+			;; \
+		*/*) \
+			cd ../.. && bun compile:workflow src/standard_tests/$$(echo "$*" | cut -d'/' -f1)/$$(echo "$*" | cut -d'/' -f2)/test.ts .temp/standard_tests/$$(echo "$*" | cut -d'/' -f1)/$$(echo "$*" | cut -d'/' -f2)/test.wasm; \
+			;; \
+		*) \
+			cd ../.. && bun compile:workflow src/standard_tests/$*/test.ts .temp/standard_tests/$*/test.wasm; \
+			;; \
+	esac

package/dist/workflows/standard_tests/capability_calls_are_async/test.ts

@@ -0,0 +1,39 @@
+import { BasicActionCapability } from '@cre/generated-sdk/capabilities/internal/basicaction/v1/basicaction_sdk_gen'
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+
+const asyncCalls = (runtime: Runtime<Uint8Array>) => {
+	const basicAction = new BasicActionCapability()
+
+	const input1 = { inputThing: true }
+	const input2 = { inputThing: false }
+
+	// Notice: we call perform action on input1 and then input 2.
+	const p1 = basicAction.performAction(runtime, input1)
+	const p2 = basicAction.performAction(runtime, input2)
+
+	// We get results in the reverse order.
+	const r2 = p2.result()
+	const r1 = p1.result()
+
+	return `${r1.adaptedThing}${r2.adaptedThing}`
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+	return [cre.handler(basicTrigger.trigger({}), asyncCalls)]
+}
+
+export async function main() {
+	console.log(
+		`TS workflow: standard test: capability calls are async [${new Date().toISOString()}]`,
+	)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/config/test.ts

@@ -0,0 +1,23 @@
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+
+const sendBackConfig = (runtime: Runtime<Uint8Array>) => {
+	return runtime.config
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+	return [cre.handler(basicTrigger.trigger({}), sendBackConfig)]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: config [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/errors/test.ts

@@ -0,0 +1,24 @@
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+
+const simulateWorkflowFailure = (_: Runtime<Uint8Array>) => {
+	throw new Error('workflow execution failure')
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), simulateWorkflowFailure)]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: errors [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/logging/test.ts

@@ -0,0 +1,25 @@
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+
+const doLog = (runtime: Runtime<string>) => {
+	runtime.log('log from wasm!')
+	return runtime.config
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), doLog)]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: logging [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<string>({
+		configParser: (c) => c.toString(),
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/mode_switch/don_runtime_in_node_mode/test.ts

@@ -0,0 +1,33 @@
+import { BasicActionCapability } from '@cre/generated-sdk/capabilities/internal/basicaction/v1/basicaction_sdk_gen'
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { consensusIdenticalAggregation } from '@cre/sdk/utils'
+import { Runner } from '@cre/sdk/wasm'
+
+const handler = (runtime: Runtime<Uint8Array>) => {
+	return runtime
+		.runInNodeMode(() => {
+			const basicCap = new BasicActionCapability()
+			return basicCap.performAction(runtime, { inputThing: true }).result().adaptedThing
+		}, consensusIdenticalAggregation())()
+		.result()
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), handler)]
+}
+
+export async function main() {
+	console.log(
+		`TS workflow: standard test: mode_switch: successful_mode_switch [${new Date().toISOString()}]`,
+	)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()