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

package/dist/generated-sdk/capabilities/blockchain/evm/v1alpha/client_sdk_gen.d.ts

@@ -1,7 +1,22 @@
 import { type Any, type Empty } from '@bufbuild/protobuf/wkt';
-import { type BalanceAtReply, type BalanceAtRequest, type BalanceAtRequestJson, type CallContractReply, type CallContractRequest, type CallContractRequestJson, type EstimateGasReply, type EstimateGasRequest, type EstimateGasRequestJson, type FilterLogsReply, type FilterLogsRequest, type FilterLogsRequestJson, type FilterLogTriggerRequest, type FilterLogTriggerRequestJson, type GetTransactionByHashReply, type GetTransactionByHashRequest, type GetTransactionByHashRequestJson, type GetTransactionReceiptReply, type GetTransactionReceiptRequest, type GetTransactionReceiptRequestJson, type HeaderByNumberReply, type HeaderByNumberRequest, type HeaderByNumberRequestJson, type Log, type RegisterLogTrackingRequest, type RegisterLogTrackingRequestJson, type UnregisterLogTrackingRequest, type UnregisterLogTrackingRequestJson, type WriteReportReply, type WriteReportRequest, type WriteReportRequestJson } from '../../../../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
-import { type Runtime } from '../../../../../sdk/runtime';
+import { type BalanceAtReply, type BalanceAtRequest, type BalanceAtRequestJson, type CallContractReply, type CallContractRequest, type CallContractRequestJson, type EstimateGasReply, type EstimateGasRequest, type EstimateGasRequestJson, type FilterLogsReply, type FilterLogsRequest, type FilterLogsRequestJson, type FilterLogTriggerRequest, type FilterLogTriggerRequestJson, type GasConfig, type GasConfigJson, type GetTransactionByHashReply, type GetTransactionByHashRequest, type GetTransactionByHashRequestJson, type GetTransactionReceiptReply, type GetTransactionReceiptRequest, type GetTransactionReceiptRequestJson, type HeaderByNumberReply, type HeaderByNumberRequest, type HeaderByNumberRequestJson, type Log, type RegisterLogTrackingRequest, type RegisterLogTrackingRequestJson, type UnregisterLogTrackingRequest, type UnregisterLogTrackingRequestJson, type WriteReportReply, type WriteReportRequest } from '../../../../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
+import { type Runtime } from '../../../../../sdk';
+import { Report } from '../../../../../sdk/report';
 import { type Trigger } from '../../../../../sdk/utils/triggers/trigger-interface';
+export type WriteCreReportRequest = {
+    receiver: Uint8Array;
+    report?: Report;
+    gasConfig?: GasConfig;
+    $report: true;
+};
+export type WriteCreReportRequestJson = {
+    receiver: string;
+    report?: Report;
+    gasConfig?: GasConfigJson;
+};
+export declare function x_generatedCodeOnly_wrap_WriteCreReportRequest(input: WriteReportRequest): WriteCreReportRequest;
+export declare function createWriteCreReportRequest(input: WriteCreReportRequestJson): WriteCreReportRequest;
+export declare function x_generatedCodeOnly_unwrap_WriteCreReportRequest(input: WriteCreReportRequest): WriteReportRequest;
 /**
  * Client Capability
  *
@@ -32,36 +47,36 @@ export declare class ClientCapability {
         readonly 'polygon-testnet-amoy': 16281711391670634445n;
     };
     constructor(chainSelector?: bigint | undefined);
-    callContract(runtime: Runtime<any>, input: CallContractRequest | CallContractRequestJson): {
-        result: () => Promise<CallContractReply>;
+    callContract(runtime: Runtime<unknown>, input: CallContractRequest | CallContractRequestJson): {
+        result: () => CallContractReply;
     };
-    filterLogs(runtime: Runtime<any>, input: FilterLogsRequest | FilterLogsRequestJson): {
-        result: () => Promise<FilterLogsReply>;
+    filterLogs(runtime: Runtime<unknown>, input: FilterLogsRequest | FilterLogsRequestJson): {
+        result: () => FilterLogsReply;
     };
-    balanceAt(runtime: Runtime<any>, input: BalanceAtRequest | BalanceAtRequestJson): {
-        result: () => Promise<BalanceAtReply>;
+    balanceAt(runtime: Runtime<unknown>, input: BalanceAtRequest | BalanceAtRequestJson): {
+        result: () => BalanceAtReply;
     };
-    estimateGas(runtime: Runtime<any>, input: EstimateGasRequest | EstimateGasRequestJson): {
-        result: () => Promise<EstimateGasReply>;
+    estimateGas(runtime: Runtime<unknown>, input: EstimateGasRequest | EstimateGasRequestJson): {
+        result: () => EstimateGasReply;
     };
-    getTransactionByHash(runtime: Runtime<any>, input: GetTransactionByHashRequest | GetTransactionByHashRequestJson): {
-        result: () => Promise<GetTransactionByHashReply>;
+    getTransactionByHash(runtime: Runtime<unknown>, input: GetTransactionByHashRequest | GetTransactionByHashRequestJson): {
+        result: () => GetTransactionByHashReply;
     };
-    getTransactionReceipt(runtime: Runtime<any>, input: GetTransactionReceiptRequest | GetTransactionReceiptRequestJson): {
-        result: () => Promise<GetTransactionReceiptReply>;
+    getTransactionReceipt(runtime: Runtime<unknown>, input: GetTransactionReceiptRequest | GetTransactionReceiptRequestJson): {
+        result: () => GetTransactionReceiptReply;
     };
-    headerByNumber(runtime: Runtime<any>, input: HeaderByNumberRequest | HeaderByNumberRequestJson): {
-        result: () => Promise<HeaderByNumberReply>;
+    headerByNumber(runtime: Runtime<unknown>, input: HeaderByNumberRequest | HeaderByNumberRequestJson): {
+        result: () => HeaderByNumberReply;
     };
-    registerLogTracking(runtime: Runtime<any>, input: RegisterLogTrackingRequest | RegisterLogTrackingRequestJson): {
-        result: () => Promise<Empty>;
+    registerLogTracking(runtime: Runtime<unknown>, input: RegisterLogTrackingRequest | RegisterLogTrackingRequestJson): {
+        result: () => Empty;
     };
-    unregisterLogTracking(runtime: Runtime<any>, input: UnregisterLogTrackingRequest | UnregisterLogTrackingRequestJson): {
-        result: () => Promise<Empty>;
+    unregisterLogTracking(runtime: Runtime<unknown>, input: UnregisterLogTrackingRequest | UnregisterLogTrackingRequestJson): {
+        result: () => Empty;
     };
     logTrigger(config: FilterLogTriggerRequestJson): ClientLogTrigger;
-    writeReport(runtime: Runtime<any>, input: WriteReportRequest | WriteReportRequestJson): {
-        result: () => Promise<WriteReportReply>;
+    writeReport(runtime: Runtime<unknown>, input: WriteCreReportRequest | WriteCreReportRequestJson): {
+        result: () => WriteReportReply;
     };
 }
 /**

package/dist/generated-sdk/capabilities/blockchain/evm/v1alpha/client_sdk_gen.js

@@ -1,8 +1,33 @@
 import { create, fromJson } from '@bufbuild/protobuf';
 import { AnySchema, anyPack, EmptySchema } from '@bufbuild/protobuf/wkt';
-import { BalanceAtReplySchema, BalanceAtRequestSchema, CallContractReplySchema, CallContractRequestSchema, EstimateGasReplySchema, EstimateGasRequestSchema, FilterLogsReplySchema, FilterLogsRequestSchema, FilterLogTriggerRequestSchema, GetTransactionByHashReplySchema, GetTransactionByHashRequestSchema, GetTransactionReceiptReplySchema, GetTransactionReceiptRequestSchema, HeaderByNumberReplySchema, HeaderByNumberRequestSchema, LogSchema, RegisterLogTrackingRequestSchema, UnregisterLogTrackingRequestSchema, WriteReportReplySchema, WriteReportRequestSchema, } from '../../../../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
-import {} from '../../../../../sdk/runtime';
+import { BalanceAtReplySchema, BalanceAtRequestSchema, CallContractReplySchema, CallContractRequestSchema, EstimateGasReplySchema, EstimateGasRequestSchema, FilterLogsReplySchema, FilterLogsRequestSchema, FilterLogTriggerRequestSchema, GasConfigSchema, GetTransactionByHashReplySchema, GetTransactionByHashRequestSchema, GetTransactionReceiptReplySchema, GetTransactionReceiptRequestSchema, HeaderByNumberReplySchema, HeaderByNumberRequestSchema, LogSchema, RegisterLogTrackingRequestSchema, UnregisterLogTrackingRequestSchema, WriteReportReplySchema, WriteReportRequestSchema, } from '../../../../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
+import { ReportResponseSchema, } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import {} from '../../../../../sdk';
+import { Report } from '../../../../../sdk/report';
 import {} from '../../../../../sdk/utils/triggers/trigger-interface';
+export function x_generatedCodeOnly_wrap_WriteCreReportRequest(input) {
+    return {
+        receiver: input.receiver,
+        report: input.report !== undefined ? new Report(input.report) : undefined,
+        gasConfig: input.gasConfig,
+        $report: true,
+    };
+}
+export function createWriteCreReportRequest(input) {
+    return {
+        receiver: new Uint8Array(Buffer.from(input.receiver, 'base64')),
+        report: input.report,
+        gasConfig: input.gasConfig !== undefined ? fromJson(GasConfigSchema, input.gasConfig) : undefined,
+        $report: true,
+    };
+}
+export function x_generatedCodeOnly_unwrap_WriteCreReportRequest(input) {
+    return create(WriteReportRequestSchema, {
+        receiver: input.receiver,
+        report: input.report !== undefined ? input.report.x_generatedCodeOnly_unwrap() : undefined,
+        gasConfig: input.gasConfig,
+    });
+}
 /**
  * Client Capability
  *
@@ -36,10 +61,16 @@ export class ClientCapability {
         this.chainSelector = chainSelector;
     }
     callContract(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(CallContractRequestSchema, 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(CallContractRequestSchema, input);
+        }
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
@@ -52,16 +83,23 @@ export class ClientCapability {
             outputSchema: CallContractReplySchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }
     filterLogs(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(FilterLogsRequestSchema, 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(FilterLogsRequestSchema, input);
+        }
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
@@ -74,16 +112,23 @@ export class ClientCapability {
             outputSchema: FilterLogsReplySchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }
     balanceAt(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(BalanceAtRequestSchema, 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(BalanceAtRequestSchema, input);
+        }
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
@@ -96,16 +141,23 @@ export class ClientCapability {
             outputSchema: BalanceAtReplySchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }
     estimateGas(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(EstimateGasRequestSchema, 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(EstimateGasRequestSchema, input);
+        }
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
@@ -118,16 +170,23 @@ export class ClientCapability {
             outputSchema: EstimateGasReplySchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }
     getTransactionByHash(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(GetTransactionByHashRequestSchema, 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(GetTransactionByHashRequestSchema, input);
+        }
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
@@ -140,16 +199,23 @@ export class ClientCapability {
             outputSchema: GetTransactionByHashReplySchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }
     getTransactionReceipt(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(GetTransactionReceiptRequestSchema, 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(GetTransactionReceiptRequestSchema, input);
+        }
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
@@ -162,16 +228,23 @@ export class ClientCapability {
             outputSchema: GetTransactionReceiptReplySchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }
     headerByNumber(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(HeaderByNumberRequestSchema, 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(HeaderByNumberRequestSchema, input);
+        }
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
@@ -184,16 +257,23 @@ export class ClientCapability {
             outputSchema: HeaderByNumberReplySchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }
     registerLogTracking(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(RegisterLogTrackingRequestSchema, 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(RegisterLogTrackingRequestSchema, input);
+        }
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
@@ -206,16 +286,23 @@ export class ClientCapability {
             outputSchema: EmptySchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }
     unregisterLogTracking(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(UnregisterLogTrackingRequestSchema, 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(UnregisterLogTrackingRequestSchema, input);
+        }
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
@@ -228,8 +315,9 @@ export class ClientCapability {
             outputSchema: EmptySchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }
@@ -241,10 +329,17 @@ export class ClientCapability {
         return new ClientLogTrigger(config, capabilityId, 'LogTrigger');
     }
     writeReport(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(WriteReportRequestSchema, input);
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        // Check if it's a wrapped type by looking for the $report property
+        if (input.$report) {
+            // It's a wrapped type, unwrap it
+            payload = x_generatedCodeOnly_unwrap_WriteCreReportRequest(input);
+        }
+        else {
+            // It's wrapped JSON, convert using create function
+            payload = x_generatedCodeOnly_unwrap_WriteCreReportRequest(createWriteCreReportRequest(input));
+        }
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
@@ -257,8 +352,9 @@ export class ClientCapability {
             outputSchema: WriteReportReplySchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }

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

@@ -1,6 +1,7 @@
-import { type ReportRequest, type ReportRequestJson, type ReportResponse, type SimpleConsensusInputs, type SimpleConsensusInputsJson } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { type ReportRequest, type ReportRequestJson, 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';
+import { type Runtime } from '../../../../../sdk';
+import { Report } from '../../../../../sdk/report';
 /**
  * Consensus Capability
  *
@@ -13,11 +14,10 @@ export declare class ConsensusCapability {
     static readonly CAPABILITY_ID = "consensus@1.0.0-alpha";
     static readonly CAPABILITY_NAME = "consensus";
     static readonly CAPABILITY_VERSION = "1.0.0-alpha";
-    constructor();
-    simple(runtime: Runtime<any>, input: SimpleConsensusInputs | SimpleConsensusInputsJson): {
-        result: () => Promise<Value>;
+    simple(runtime: Runtime<unknown>, input: SimpleConsensusInputs | SimpleConsensusInputsJson): {
+        result: () => Value;
     };
-    report(runtime: Runtime<any>, input: ReportRequest | ReportRequestJson): {
-        result: () => Promise<ReportResponse>;
+    report(runtime: Runtime<unknown>, input: ReportRequest | ReportRequestJson): {
+        result: () => Report;
     };
 }

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

@@ -1,7 +1,8 @@
 import { fromJson } from '@bufbuild/protobuf';
 import { ReportRequestSchema, ReportResponseSchema, SimpleConsensusInputsSchema, } from '../../../../../generated/sdk/v1alpha/sdk_pb';
 import { ValueSchema } from '../../../../../generated/values/v1/values_pb';
-import {} from '../../../../../sdk/runtime';
+import {} from '../../../../../sdk';
+import { Report } from '../../../../../sdk/report';
 /**
  * Consensus Capability
  *
@@ -14,12 +15,17 @@ export class ConsensusCapability {
     static CAPABILITY_ID = 'consensus@1.0.0-alpha';
     static CAPABILITY_NAME = 'consensus';
     static CAPABILITY_VERSION = '1.0.0-alpha';
-    constructor() { }
     simple(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(SimpleConsensusInputsSchema, 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(SimpleConsensusInputsSchema, input);
+        }
         const capabilityId = ConsensusCapability.CAPABILITY_ID;
         const capabilityResponse = runtime.callCapability({
             capabilityId,
@@ -29,16 +35,23 @@ export class ConsensusCapability {
             outputSchema: ValueSchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
             },
         };
     }
     report(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(ReportRequestSchema, 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(ReportRequestSchema, input);
+        }
         const capabilityId = ConsensusCapability.CAPABILITY_ID;
         const capabilityResponse = runtime.callCapability({
             capabilityId,
@@ -48,8 +61,9 @@ export class ConsensusCapability {
             outputSchema: ReportResponseSchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return new Report(result);
             },
         };
     }

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

@@ -1,5 +1,14 @@
 import { type Request, type RequestJson, type Response } from '../../../../../generated/capabilities/networking/http/v1alpha/client_pb';
-import { type NodeRuntime } from '../../../../../sdk/runtime';
+import { type NodeRuntime, type Runtime } from '../../../../../sdk';
+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
  *
@@ -12,8 +21,12 @@ export declare class ClientCapability {
     static readonly CAPABILITY_ID = "http-actions@1.0.0-alpha";
     static readonly CAPABILITY_NAME = "http-actions";
     static readonly CAPABILITY_VERSION = "1.0.0-alpha";
-    constructor();
-    sendRequest(runtime: NodeRuntime<any>, 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,6 +1,18 @@
 import { fromJson } from '@bufbuild/protobuf';
 import { RequestSchema, ResponseSchema, } from '../../../../../generated/capabilities/networking/http/v1alpha/client_pb';
-import {} from '../../../../../sdk/runtime';
+import {} from '../../../../../sdk';
+import { Report } from '../../../../../sdk/report';
+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
  *
@@ -13,12 +25,27 @@ export class ClientCapability {
     static CAPABILITY_ID = 'http-actions@1.0.0-alpha';
     static CAPABILITY_NAME = 'http-actions';
     static CAPABILITY_VERSION = '1.0.0-alpha';
-    constructor() { }
-    sendRequest(runtime, input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const payload = input.$typeName
-            ? input
-            : fromJson(RequestSchema, input);
+    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);
+    }
+    sendRequestCallHelper(runtime, 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,
@@ -28,9 +55,17 @@ export class ClientCapability {
             outputSchema: ResponseSchema,
         });
         return {
-            result: async () => {
-                return capabilityResponse.result();
+            result: () => {
+                const result = capabilityResponse.result();
+                return 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

@@ -13,7 +13,6 @@ export declare class HTTPCapability {
     static readonly CAPABILITY_ID = "http-trigger@1.0.0-alpha";
     static readonly CAPABILITY_NAME = "http-trigger";
     static readonly CAPABILITY_VERSION = "1.0.0-alpha";
-    constructor();
     trigger(config: ConfigJson): HTTPTrigger;
 }
 /**