@chainlink/cre-sdk 1.0.1 → 1.0.3

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

@@ -186,7 +186,7 @@ export class RuntimeImpl extends BaseRuntimeImpl {
             // Step 3: Execute node function and capture result/error
             try {
                 const observation = fn(nodeRuntime, ...args);
-                this.captureObservation(consensusInput, observation);
+                this.captureObservation(consensusInput, observation, consensusAggregation.descriptor);
             }
             catch (e) {
                 this.captureError(consensusInput, e);
@@ -205,15 +205,19 @@ export class RuntimeImpl extends BaseRuntimeImpl {
         });
         if (consensusAggregation.defaultValue) {
             // Safe cast: ConsensusAggregation<T, true> implies T extends CreSerializable
-            consensusInput.default = Value.from(consensusAggregation.defaultValue).proto();
+            const defaultValue = Value.from(consensusAggregation.defaultValue).proto();
+            clearIgnoredFields(defaultValue, consensusAggregation.descriptor);
+            consensusInput.default = defaultValue;
         }
         return consensusInput;
     }
-    captureObservation(consensusInput, observation) {
+    captureObservation(consensusInput, observation, descriptor) {
         // Safe cast: ConsensusAggregation<T, true> implies T extends CreSerializable
+        const observationValue = Value.from(observation).proto();
+        clearIgnoredFields(observationValue, descriptor);
         consensusInput.observation = {
             case: 'value',
-            value: Value.from(observation).proto(),
+            value: observationValue,
         };
     }
     captureError(consensusInput, e) {
@@ -305,3 +309,31 @@ export class RuntimeImpl extends BaseRuntimeImpl {
         };
     }
 }
+function clearIgnoredFields(value, descriptor) {
+    if (!descriptor || !value) {
+        return;
+    }
+    const fieldsMap = descriptor.descriptor?.case === 'fieldsMap' ? descriptor.descriptor.value : undefined;
+    if (!fieldsMap) {
+        return;
+    }
+    if (value.value?.case === 'mapValue') {
+        const mapValue = value.value.value;
+        if (!mapValue || !mapValue.fields) {
+            return;
+        }
+        for (const [key, val] of Object.entries(mapValue.fields)) {
+            const nestedDescriptor = fieldsMap.fields[key];
+            if (!nestedDescriptor) {
+                delete mapValue.fields[key];
+                continue;
+            }
+            const nestedFieldsMap = nestedDescriptor.descriptor?.case === 'fieldsMap'
+                ? nestedDescriptor.descriptor.value
+                : undefined;
+            if (nestedFieldsMap && val.value?.case === 'mapValue') {
+                clearIgnoredFields(val, nestedDescriptor);
+            }
+        }
+    }
+}

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

@@ -68,7 +68,7 @@ export declare function text(responseFn: () => {
  * @returns The parsed JSON
  * @throws Error if the body is not valid JSON
  */
-export declare function json(response: Response): unknown;
+export declare function json(response: Response | ResponseTemplate): unknown;
 /**
  * Parses the response body as JSON
  * @param responseFn - Function that returns an object with result function that returns Response
@@ -76,7 +76,7 @@ export declare function json(response: Response): unknown;
  * @throws Error if the body is not valid JSON
  */
 export declare function json(responseFn: () => {
-    result: Response;
+    result: Response | ResponseTemplate;
 }): {
     result: () => unknown;
 };

package/dist/sdk/utils/config/index.js

@@ -7,7 +7,8 @@ async function standardValidate(schema, input) {
      * @see https://github.com/standard-schema/standard-schema?tab=readme-ov-file#how-do-i-accept-standard-schemas-in-my-library
      */
     if (result.issues) {
-        throw new Error(JSON.stringify(result.issues, null, 2));
+        const errorDetails = JSON.stringify(result.issues, null, 2);
+        throw new Error(`Config validation failed. Expectations were not matched:\n\n${errorDetails}`);
     }
     return result.value;
 }

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

@@ -1 +1,2 @@
 export { Runner } from './runner';
+export { sendErrorResponse } from './send-error-response';

package/dist/sdk/wasm/index.js

@@ -1 +1,2 @@
 export { Runner } from './runner';
+export { sendErrorResponse } from './send-error-response';

package/dist/sdk/wasm/send-error-response.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Prepares an error response payload from an error.
+ * This is a pure function that converts an error to a serialized ExecutionResult.
+ *
+ * @param error - The error to prepare
+ * @returns The serialized error response payload, or null if the error cannot be converted to a string
+ */
+export declare const prepareErrorResponse: (error: unknown) => Uint8Array | null;
+/**
+ * Sends an error response through the Javy bridge.
+ * This is used internally by the SDK as an error handler for the main() function,
+ * catching exceptions that bubbled up to the top level.
+ *
+ * @param error - The error to send
+ */
+export declare const sendErrorResponse: (error: unknown) => void;

package/dist/sdk/wasm/send-error-response.js

@@ -0,0 +1,43 @@
+import { create, toBinary } from '@bufbuild/protobuf';
+import { ExecutionResultSchema } from '../../generated/sdk/v1alpha/sdk_pb';
+import { hostBindings } from './host-bindings';
+/**
+ * Prepares an error response payload from an error.
+ * This is a pure function that converts an error to a serialized ExecutionResult.
+ *
+ * @param error - The error to prepare
+ * @returns The serialized error response payload, or null if the error cannot be converted to a string
+ */
+export const prepareErrorResponse = (error) => {
+    let errorMessage = null;
+    if (error instanceof Error) {
+        errorMessage = error.message;
+    }
+    else if (typeof error === 'string') {
+        errorMessage = error;
+    }
+    else {
+        errorMessage = String(error) || null;
+    }
+    if (typeof errorMessage !== 'string') {
+        return null;
+    }
+    const result = create(ExecutionResultSchema, {
+        result: { case: 'error', value: errorMessage },
+    });
+    return toBinary(ExecutionResultSchema, result);
+};
+/**
+ * Sends an error response through the Javy bridge.
+ * This is used internally by the SDK as an error handler for the main() function,
+ * catching exceptions that bubbled up to the top level.
+ *
+ * @param error - The error to send
+ */
+export const sendErrorResponse = (error) => {
+    const payload = prepareErrorResponse(error);
+    if (payload === null) {
+        return;
+    }
+    hostBindings.sendResponse(payload);
+};

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

@@ -0,0 +1,32 @@
+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 input = { inputThing: true }
+	const p = basicAction.performAction(runtime, input)
+
+	p.result()
+
+	return `We should not get here, result should throw an error`
+}
+
+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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainlink/cre-sdk",
-	"version": "1.0.1",
+	"version": "1.0.3",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -55,7 +55,7 @@
 	"dependencies": {
 		"@bufbuild/protobuf": "2.6.3",
 		"@bufbuild/protoc-gen-es": "2.6.3",
-		"@chainlink/cre-sdk-javy-plugin": "1.0.1",
+		"@chainlink/cre-sdk-javy-plugin": "1.0.2",
 		"@standard-schema/spec": "1.0.0",
 		"viem": "2.34.0",
 		"zod": "3.25.76"
@@ -67,7 +67,7 @@
 		"chain-selectors": "https://github.com/smartcontractkit/chain-selectors.git#8b963095ae797a3024c8e55822cced7bf618176f",
 		"fast-glob": "3.3.3",
 		"ts-proto": "2.7.5",
-		"typescript": "5.9.2",
+		"typescript": "5.9.3",
 		"yaml": "2.8.1"
 	},
 	"publishConfig": {
@@ -75,6 +75,11 @@
 	},
 	"author": "SmartContract Chainlink Limited SEZC",
 	"license": "BUSL-1.1",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/smartcontractkit/cre-sdk-typescript",
+		"directory": "packages/cre-sdk"
+	},
 	"engines": {
 		"bun": ">=1.2.21"
 	}

package/scripts/src/compile-to-js.ts

@@ -1,7 +1,8 @@
-import { existsSync } from 'node:fs'
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
 import { mkdir } from 'node:fs/promises'
 import path from 'node:path'
 import { $ } from 'bun'
+import { wrapWorkflowCode } from './workflow-wrapper'
 
 export const main = async (tsFilePath?: string, outputFilePath?: string) => {
 	const cliArgs = process.argv.slice(3)
@@ -32,26 +33,44 @@ export const main = async (tsFilePath?: string, outputFilePath?: string) => {
 	// Ensure the output directory exists
 	await mkdir(path.dirname(resolvedOutput), { recursive: true })
 
-	// Build step (emit next to output file, then overwrite)
-	await Bun.build({
-		entrypoints: [resolvedInput],
-		outdir: path.dirname(resolvedOutput),
-		target: 'browser',
-		format: 'esm',
-		naming: path.basename(resolvedOutput),
-	})
+	// Wrap workflow code with automatic error handling
+	const originalCode = readFileSync(resolvedInput, 'utf-8')
+	const wrappedCode = wrapWorkflowCode(originalCode, resolvedInput)
 
-	// The file Bun will emit before bundling
-	const builtFile = path.join(path.dirname(resolvedOutput), path.basename(resolvedOutput))
+	// Write wrapped code to temp file (in the same directory as input for module resolution)
+	const tempFile = path.join(
+		path.dirname(resolvedInput),
+		`.workflow-temp-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`,
+	)
+	writeFileSync(tempFile, wrappedCode, 'utf-8')
 
-	if (!existsSync(builtFile)) {
-		console.error(`❌ Expected file not found: ${builtFile}`)
-		process.exit(1)
-	}
+	try {
+		// Build step (emit next to output file, then overwrite)
+		await Bun.build({
+			entrypoints: [tempFile],
+			outdir: path.dirname(resolvedOutput),
+			target: 'browser',
+			format: 'esm',
+			naming: path.basename(resolvedOutput),
+		})
+
+		// The file Bun will emit before bundling
+		const builtFile = path.join(path.dirname(resolvedOutput), path.basename(resolvedOutput))
 
-	// Bundle into the final file (overwrite)
-	await $`bun build ${builtFile} --bundle --outfile=${resolvedOutput}`
+		if (!existsSync(builtFile)) {
+			console.error(`❌ Expected file not found: ${builtFile}`)
+			process.exit(1)
+		}
 
-	console.info(`✅ Built: ${resolvedOutput}`)
-	return resolvedOutput
+		// Bundle into the final file (overwrite)
+		await $`bun build ${builtFile} --bundle --outfile=${resolvedOutput}`
+
+		console.info(`✅ Built: ${resolvedOutput}`)
+		return resolvedOutput
+	} finally {
+		// Clean up temp file
+		if (existsSync(tempFile)) {
+			unlinkSync(tempFile)
+		}
+	}
 }

package/scripts/src/workflow-wrapper.test.ts

@@ -0,0 +1,335 @@
+import { describe, expect, test } from 'bun:test'
+import { wrapWorkflowCode } from './workflow-wrapper'
+
+describe('wrapWorkflowCode', () => {
+	describe('import handling', () => {
+		test('adds sendErrorResponse import when no @chainlink/cre-sdk import exists', () => {
+			const input = `export async function main() {
+  console.log('hello')
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain("import { sendErrorResponse } from '@chainlink/cre-sdk'")
+			expect(result).toContain('main().catch(sendErrorResponse)')
+		})
+
+		test('adds sendErrorResponse to existing @chainlink/cre-sdk import', () => {
+			const input = `import { Runner } from '@chainlink/cre-sdk'
+
+export async function main() {
+  const runner = await Runner.newRunner()
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain('Runner, sendErrorResponse')
+			expect(result).toContain('main().catch(sendErrorResponse)')
+			// Should not add a separate import
+			expect(result.match(/import.*from.*@chainlink\/cre-sdk/g)?.length).toBe(1)
+		})
+
+		test('does not duplicate sendErrorResponse if already imported', () => {
+			const input = `import { Runner, sendErrorResponse } from '@chainlink/cre-sdk'
+
+export async function main() {
+  const runner = await Runner.newRunner()
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			// Count occurrences of sendErrorResponse in imports
+			const importMatch = result.match(/import.*{[^}]*}.*from.*@chainlink\/cre-sdk/)?.[0]
+			expect(importMatch?.match(/sendErrorResponse/g)?.length).toBe(1)
+			expect(result).toContain('main().catch(sendErrorResponse)')
+		})
+
+		test('handles multiple named imports correctly', () => {
+			const input = `import { cre, Runner, Config } from '@chainlink/cre-sdk'
+
+export async function main() {
+  const runner = await Runner.newRunner()
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain('Config, sendErrorResponse')
+			expect(result).toContain('main().catch(sendErrorResponse)')
+		})
+
+		test('adds import after existing imports from other modules', () => {
+			const input = `import { something } from 'other-module'
+import { another } from 'another-module'
+
+export async function main() {
+  console.log('hello')
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain("import { sendErrorResponse } from '@chainlink/cre-sdk'")
+			// The new import should be after the existing imports
+			const lines = result.split('\n')
+			const otherModuleIndex = lines.findIndex((l) => l.includes('other-module'))
+			const creImportIndex = lines.findIndex((l) => l.includes('@chainlink/cre-sdk'))
+			expect(creImportIndex).toBeGreaterThan(otherModuleIndex)
+		})
+	})
+
+	describe('error handling detection', () => {
+		test('does not add wrapper when main().catch() already exists', () => {
+			const input = `import { Runner, sendErrorResponse } from '@chainlink/cre-sdk'
+
+export async function main() {
+  const runner = await Runner.newRunner()
+}
+
+main().catch(sendErrorResponse)`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			// Should only have one main().catch() call
+			expect(result.match(/main\(\)\.catch/g)?.length).toBe(1)
+		})
+
+		test('does not add wrapper when main().catch() with custom handler exists', () => {
+			const input = `import { Runner } from '@chainlink/cre-sdk'
+
+export async function main() {
+  const runner = await Runner.newRunner()
+}
+
+main().catch((e) => {
+  console.error('Custom error:', e)
+})`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			// Should still add sendErrorResponse import but not add another .catch()
+			expect(result).toContain('sendErrorResponse')
+			// Should only have one .catch() call
+			expect(result.match(/\.catch\(/g)?.length).toBe(1)
+		})
+
+		test('does not add wrapper when main().then().catch() exists', () => {
+			const input = `import { Runner, sendErrorResponse } from '@chainlink/cre-sdk'
+
+export async function main() {
+  const runner = await Runner.newRunner()
+}
+
+main().then(() => console.log('done')).catch(sendErrorResponse)`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			// Should only have one .catch() call
+			expect(result.match(/\.catch\(/g)?.length).toBe(1)
+		})
+
+		test('adds wrapper when main() is called without .catch()', () => {
+			const input = `import { Runner } from '@chainlink/cre-sdk'
+
+export async function main() {
+  const runner = await Runner.newRunner()
+}
+
+main()`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			// Should replace the original main() call
+			expect(result.match(/main\(\)\.catch\(sendErrorResponse\)/g)?.length).toBe(1)
+			expect(result.match(/(^|\n)\s*main\(\)\s*;?\s*$/g)?.length ?? 0).toBe(0)
+		})
+
+		test('replaces await main() with await main().catch()', () => {
+			const input = `import { Runner } from '@chainlink/cre-sdk'
+
+export async function main() {
+  const runner = await Runner.newRunner()
+}
+
+await main()`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain('await main().catch(sendErrorResponse)')
+			expect(result.match(/main\(\)\.catch\(sendErrorResponse\)/g)?.length).toBe(1)
+		})
+	})
+
+	describe('main function detection', () => {
+		test('handles exported async main function', () => {
+			const input = `export async function main() {
+  console.log('hello')
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain('main().catch(sendErrorResponse)')
+		})
+
+		test('handles exported sync main function', () => {
+			const input = `export function main() {
+  console.log('hello')
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain('main().catch(sendErrorResponse)')
+		})
+	})
+
+	describe('edge cases', () => {
+		test('handles empty file', () => {
+			const input = ''
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain("import { sendErrorResponse } from '@chainlink/cre-sdk'")
+			expect(result).toContain('main().catch(sendErrorResponse)')
+		})
+
+		test('handles file with only imports', () => {
+			const input = `import { Runner } from '@chainlink/cre-sdk'`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain('Runner, sendErrorResponse')
+			expect(result).toContain('main().catch(sendErrorResponse)')
+		})
+
+		test('ignores main() in comments', () => {
+			const input = `import { Runner } from '@chainlink/cre-sdk'
+
+// main() is called automatically
+/* main().catch(sendErrorResponse) */
+
+export async function main() {
+  console.log('hello')
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			// Should add wrapper because the main() calls in comments don't count
+			expect(result).toContain('main().catch(sendErrorResponse)')
+		})
+
+		test('ignores main() in string literals', () => {
+			const input = `import { Runner } from '@chainlink/cre-sdk'
+
+export async function main() {
+  const code = "main().catch(handler)"
+  console.log(code)
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			// Should add wrapper because the main() in string doesn't count
+			expect(result).toContain('main().catch(sendErrorResponse)')
+		})
+
+		test('preserves original code structure', () => {
+			const input = `import { Runner } from '@chainlink/cre-sdk'
+
+const config = {
+  name: 'test'
+}
+
+export async function main() {
+  const runner = await Runner.newRunner()
+  await runner.run()
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain('const config = {')
+			expect(result).toContain("name: 'test'")
+			expect(result).toContain('export async function main()')
+		})
+
+		test('handles Windows-style line endings', () => {
+			const input =
+				"import { Runner } from '@chainlink/cre-sdk'\r\n\r\nexport async function main() {\r\n  console.log('hello')\r\n}"
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain('sendErrorResponse')
+			expect(result).toContain('main().catch(sendErrorResponse)')
+		})
+
+		test('handles file ending without newline', () => {
+			const input = `import { Runner } from '@chainlink/cre-sdk'
+
+export async function main() {
+  console.log('hello')
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain('main().catch(sendErrorResponse)')
+			expect(result.endsWith('\n')).toBe(true)
+		})
+	})
+
+	describe('real-world workflow examples', () => {
+		test('wraps typical hello-world workflow', () => {
+			const input = `import { cre, Runner, type Config } from '@chainlink/cre-sdk'
+
+interface WorkflowConfig extends Config {
+  message: string
+}
+
+async function initWorkflow(runtime: cre.Runtime<WorkflowConfig>) {
+  const config = runtime.getConfig()
+  console.log(config.message)
+}
+
+export async function main() {
+  const runner = await Runner.newRunner<WorkflowConfig>()
+  await runner.run(initWorkflow)
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain('cre, Runner, type Config, sendErrorResponse')
+			expect(result).toContain('main().catch(sendErrorResponse)')
+			// Original code should be preserved
+			expect(result).toContain('interface WorkflowConfig extends Config')
+			expect(result).toContain('async function initWorkflow')
+		})
+
+		test('wraps workflow with http capability', () => {
+			const input = `import { cre, Runner, type Config } from '@chainlink/cre-sdk'
+import { http } from '@chainlink/cre-sdk/capabilities'
+
+interface WorkflowConfig extends Config {
+  apiUrl: string
+}
+
+async function initWorkflow(runtime: cre.Runtime<WorkflowConfig>) {
+  const config = runtime.getConfig()
+  const response = await http.fetch(runtime, { url: config.apiUrl })
+  console.log(response)
+}
+
+export async function main() {
+  const runner = await Runner.newRunner<WorkflowConfig>()
+  await runner.run(initWorkflow)
+}`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			expect(result).toContain('sendErrorResponse')
+			expect(result).toContain('main().catch(sendErrorResponse)')
+			// Should preserve the http import
+			expect(result).toContain("import { http } from '@chainlink/cre-sdk/capabilities'")
+		})
+
+		test('does not modify workflow that already has proper error handling', () => {
+			const input = `import { cre, Runner, sendErrorResponse, type Config } from '@chainlink/cre-sdk'
+
+interface WorkflowConfig extends Config {
+  message: string
+}
+
+async function initWorkflow(runtime: cre.Runtime<WorkflowConfig>) {
+  const config = runtime.getConfig()
+  console.log(config.message)
+}
+
+export async function main() {
+  const runner = await Runner.newRunner<WorkflowConfig>()
+  await runner.run(initWorkflow)
+}
+
+main().catch(sendErrorResponse)`
+			const result = wrapWorkflowCode(input, 'test.ts')
+
+			// Should only have one main().catch() call
+			expect(result.match(/main\(\)\.catch\(sendErrorResponse\)/g)?.length).toBe(1)
+			// Should only have one sendErrorResponse in imports
+			const importLine = result.split('\n').find((l) => l.includes('@chainlink/cre-sdk'))
+			expect(importLine?.match(/sendErrorResponse/g)?.length).toBe(1)
+		})
+	})
+})

package/scripts/src/workflow-wrapper.ts

@@ -0,0 +1,198 @@
+import * as ts from 'typescript'
+
+/**
+ * Wraps workflow code with automatic error boundary.
+ * This function:
+ * 1. Detects if `sendErrorResponse` import from `@chainlink/cre-sdk` exists in the workflow code.
+ * 2. Detects if `main()` function is exported.
+ * 3. Detects if there's already a top-level `main()` call with `.catch()` handler.
+ * 4. Adds `sendErrorResponse` to imports if missing.
+ * 5. Replaces top-level `main()` or `await main()` with `main().catch(sendErrorResponse)`.
+ * 6. Appends `main().catch(sendErrorResponse)` only if no error handling exists and no call exists.
+ *
+ * @param sourceCode - The TypeScript source code to wrap
+ * @param filePath - The file path (used for source file creation)
+ * @returns The wrapped source code
+ */
+export function wrapWorkflowCode(sourceCode: string, filePath: string): string {
+	const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true)
+
+	// Analysis state
+	let hasMainExport = false
+	let hasExistingErrorHandling = false
+	const mainCallStatements: { start: number; end: number; useAwait: boolean }[] = []
+
+	// Helper to check if a node is a main() call expression
+	const isMainCall = (node: ts.Node): boolean => {
+		return (
+			ts.isCallExpression(node) &&
+			ts.isIdentifier(node.expression) &&
+			node.expression.text === 'main'
+		)
+	}
+
+	// Helper to check if a call expression is wrapped with .catch()
+	const isWrappedWithCatch = (node: ts.Node): boolean => {
+		if (ts.isCallExpression(node)) {
+			const expr = node.expression
+			if (ts.isPropertyAccessExpression(expr) && expr.name.text === 'catch') {
+				// Check if the object being called with .catch is main()
+				return isMainCall(expr.expression)
+			}
+		}
+		return false
+	}
+
+	const getMainCallFromExpression = (expr: ts.Expression): { useAwait: boolean } | null => {
+		if (isMainCall(expr)) {
+			return { useAwait: false }
+		}
+		if (ts.isAwaitExpression(expr) && isMainCall(expr.expression)) {
+			return { useAwait: true }
+		}
+		return null
+	}
+
+	// First pass: analyze AST
+	for (const statement of sourceFile.statements) {
+		// Check for main() export
+		if (ts.isFunctionDeclaration(statement) && statement.name?.text === 'main') {
+			if (statement.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword)) {
+				hasMainExport = true
+			}
+		}
+
+		// Check for top-level main() call with error handling
+		if (ts.isExpressionStatement(statement)) {
+			const expr = statement.expression
+			const exprToCheck = ts.isAwaitExpression(expr) ? expr.expression : expr
+
+			// Check for main().catch(...)
+			if (isWrappedWithCatch(exprToCheck)) {
+				hasExistingErrorHandling = true
+			}
+
+			// Also check for: main().then(...).catch(...) or other chained patterns
+			if (ts.isCallExpression(exprToCheck)) {
+				// Walk the chain to find if there's a .catch anywhere
+				let current: ts.Expression = exprToCheck
+				while (ts.isCallExpression(current)) {
+					const propAccess = current.expression
+					if (ts.isPropertyAccessExpression(propAccess)) {
+						if (propAccess.name.text === 'catch') {
+							// Find if main() is somewhere in this chain
+							let innerCurrent: ts.Expression = propAccess.expression
+							while (ts.isCallExpression(innerCurrent)) {
+								if (isMainCall(innerCurrent)) {
+									hasExistingErrorHandling = true
+									break
+								}
+								if (ts.isPropertyAccessExpression(innerCurrent.expression)) {
+									innerCurrent = innerCurrent.expression.expression
+								} else {
+									break
+								}
+							}
+						}
+						current = propAccess.expression
+					} else {
+						break
+					}
+				}
+			}
+
+			if (!hasExistingErrorHandling) {
+				const mainCall = getMainCallFromExpression(expr)
+				if (mainCall) {
+					mainCallStatements.push({
+						start: statement.getStart(sourceFile),
+						end: statement.end,
+						useAwait: mainCall.useAwait,
+					})
+				}
+			}
+		}
+	}
+
+	// Build the transformed code
+	let result = sourceCode
+
+	if (!hasExistingErrorHandling && mainCallStatements.length > 0) {
+		for (const statement of [...mainCallStatements].sort((a, b) => b.start - a.start)) {
+			const replacement = `${statement.useAwait ? 'await ' : ''}main().catch(sendErrorResponse)`
+			result = result.slice(0, statement.start) + replacement + result.slice(statement.end)
+		}
+	}
+
+	// If we need to add sendErrorResponse import
+	const nextSourceFile = ts.createSourceFile(filePath, result, ts.ScriptTarget.Latest, true)
+	let hasSendErrorResponseImport = false
+	let creSdkImportDeclaration: ts.ImportDeclaration | null = null
+
+	for (const statement of nextSourceFile.statements) {
+		// Check for @chainlink/cre-sdk import
+		if (ts.isImportDeclaration(statement)) {
+			const moduleSpecifier = statement.moduleSpecifier
+			if (ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === '@chainlink/cre-sdk') {
+				creSdkImportDeclaration = statement
+				if (
+					statement.importClause?.namedBindings &&
+					ts.isNamedImports(statement.importClause.namedBindings)
+				) {
+					hasSendErrorResponseImport = statement.importClause.namedBindings.elements.some(
+						(element) => element.name.text === 'sendErrorResponse',
+					)
+				}
+			}
+		}
+	}
+
+	if (!hasSendErrorResponseImport) {
+		if (creSdkImportDeclaration) {
+			// Add to existing import
+			const importClause = creSdkImportDeclaration.importClause
+			if (importClause?.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
+				const elements = importClause.namedBindings.elements
+				const lastElement = elements[elements.length - 1]
+				const lastElementEnd = lastElement.end
+
+				// Insert sendErrorResponse after the last import element
+				result =
+					result.slice(0, lastElementEnd) + ', sendErrorResponse' + result.slice(lastElementEnd)
+			}
+		} else {
+			// Add new import at the beginning or after existing imports
+			const importLine = "import { sendErrorResponse } from '@chainlink/cre-sdk'\n"
+
+			// Find the last import declaration to insert after it
+			let lastImportEnd = 0
+			for (const statement of nextSourceFile.statements) {
+				if (ts.isImportDeclaration(statement)) {
+					lastImportEnd = statement.end
+				}
+			}
+
+			if (lastImportEnd > 0) {
+				// Insert after the last import, handling newlines
+				const afterImport = result.slice(lastImportEnd)
+				const leadingNewlines = afterImport.match(/^[\r\n]*/)?.[0] || ''
+				result =
+					result.slice(0, lastImportEnd) +
+					leadingNewlines +
+					importLine +
+					afterImport.slice(leadingNewlines.length)
+			} else {
+				// No imports exist, add at the beginning
+				result = importLine + result
+			}
+		}
+	}
+
+	// Append main().catch(sendErrorResponse) if no error handling exists
+	if (!hasExistingErrorHandling && mainCallStatements.length === 0) {
+		const trimmedResult = result.trimEnd()
+		result = trimmedResult + '\n\nmain().catch(sendErrorResponse)\n'
+	}
+
+	return result
+}