Not able to work on callBack mechanism using AWS Lambda durable functions #1

[pjonnlagadda]

Hi Team,
I am using AWS Lambda durable functions and using this i want to achieve the below scenario in POC and i am trying this with some mock https calls

Execute api1→ callback → continue [callback signal will be from AWS CLI]

Execute api2→ callback → continue [callback signal will be from AWS CLI]

Execute api3→ callback → complete

for this i have written some sample code by referring https://docs.aws.amazon.com/lambda/latest/dg/durable-getting-started.html.

When i try to execute the function, i am getting below error message

Calling the invoke API action failed with this message: {
"errorMessage": "context.waitForSignal is not a function",
"errorType": "TypeError"
}

i have tried with all the below methods available but same error saying that function is not available

const callbackData = await context.waitForSignal(${state.name}_callback);
//const callbackData = await context.signal(${state.name}_callback);
// const callbackData = await context.waitForExternalEvent(${state.name}_callback);
Here is my lambdaFunction code which is in nodeJs in POC as i am trying[the json file the one i am reading is in the correct place and able to parse it]

import { withDurableExecution } from "@aws/durable-execution-sdk-js";
import fs from "node:fs";
import { promises as fsp } from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";
import https from "node:https";

/** Resolve __dirname in ESM */
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const mockUrls = {
rpa1: 'https://httpbin.org/post',
rpa2: 'https://httpbin.org/post',
baas1: 'https://httpbin.org/post'
};

/** @typedef {import('@aws/durable-execution-sdk-js').DurableContext} DurableContext */

export const handler = withDurableExecution(
/**

@param {{ orderId: string }} event
@param {DurableContext} context
*/
async (event, context) => {
const { orderId } = event;
// Read symphony from static file packaged with the Lambda bundle
// Using async I/O; this is deterministic as long as the file content is static.
context.logger.info("=== Read symphony from static file ===");
const symphonyPath = path.join(__dirname, "symphony.json");

let symphonyJson;
try {
  // Ensure the file exists (useful when testing locally)
  if (!fs.existsSync(symphonyPath)) {
    throw new Error(`symphony.json not found at ${symphonyPath}`);
  }
  const raw = await fsp.readFile(symphonyPath, "utf8");
  symphonyJson = JSON.parse(raw);
  context.logger.info("Loaded symphony.json", { keys: Object.keys(symphonyJson) });
} catch (err) {
  // Fail fast with a clear message; durable functions will retry your step logic,
  // but reading a static file normally shouldn't be retried, so we do it before steps.
  context.logger.error("Failed to read symphony.json", { error: String(err) });
  throw err;
}
// Execute each step with durable waiting
for (const state of symphonyJson.states) {
// Wrap HTTP call in a durable step
const result = await context.step(`http-call-${state.name}`, async (stepContext) => {
    stepContext.logger.info(`Starting ${state.name}...`);
    
    // Make HTTP call inside the step
    const httpResult = await makeHttpCall(mockUrls[state.name], state.name, state.inputVariables || []);
    
    stepContext.logger.info(`Step ${state.name} completed. HTTP status: ${httpResult.status}`);
    return httpResult;
});

// Wait for callback using durable context - can wait indefinitely
console.log(`Step ${state.name} completed. Waiting for callback...`);
// Simulate external confirmation (no compute charges during wait)
//await context.wait({ seconds: 10 });
// Wait for signal from AWS CLI - this will wait indefinitely
//const callbackData = await context.waitForSignal(`${state.name}_callback`);
//const callbackData = await context.signal(`${state.name}_callback`);
const callbackData = await context.waitForExternalEvent(`${state.name}_callback`);


console.log(`Received callback for ${state.name}:`, callbackData);
}
return {
orderId,
status: "completed",
steps: [symphonyJson.states.map(state => state.name)]
};
});

const makeHttpCall = (url, stepName, inputVariables) => {
return new Promise((resolve, reject) => {
const postData = JSON.stringify({ stepName, inputVariables });

    const options = {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Content-Length': Buffer.byteLength(postData)
        }
    };
    console.log('==========> Step Name:====>', stepName);
    console.log('==========> Input Variables:====>', inputVariables);
    const req = https.request(url, options, (res) => {
        let data = '';
        res.on('data', chunk => data += chunk);
        res.on('end', () => {
            // Don't parse the response, just return status
            resolve({ 
                status: res.statusCode,
                // Remove this line: response: JSON.parse(data)
            });
        });
    });
    
    req.on('error', err => reject(err));
    req.write(postData);
    req.end();
});
};

Thanks in advance,
Praveen

[anthonyting]

context.waitForSignal is not valid, the correct method for callback handling is context.waitForCallback. See here: https://github.com/aws/aws-durable-execution-sdk-js/blob/main/packages/aws-durable-execution-sdk-js/README.md#external-callbacks

[pjonnlagadda]

We are designing a multi-step workflow using AWS Lambda Durable Functions where each step calls an external service and waits for a callback. We need architectural guidance on the recommended pattern to prevent duplicate HTTP calls during function replay while using AWS-generated callback IDs.

REQUIREMENT:
We are building a multi-step workflow using AWS Lambda Durable Functions where each step calls an external service via HTTP POST, sends a callback ID to the external service, waits for the external service to complete processing, and then the external service calls back using AWS CLI with the callback ID to resume our Lambda function.

CURRENT ISSUE:
To send the AWS-generated callback ID to the external service, we must make the HTTP call inside the waitForCallback function. However, due to the replay mechanism in Durable Functions, this HTTP call executes multiple times when subsequent activities start.

Example with 3 activities:

• Activity 1 external service receives 3 HTTP calls (should be 1)
• Activity 2 external service receives 2 HTTP calls (should be 1)
• Activity 3 external service receives 1 HTTP call (correct)

WHY WE CAN'T USE context.step():

1. Cannot use context.step() inside waitForCallback - AWS throws error: "Context usage error in step"
2. Cannot use context.step() before waitForCallback because we don't have the AWS callback ID yet
3. AWS ignores custom callback IDs specified in waitForCallback options and generates its own

WHAT WE NEED:
A way to prevent duplicate HTTP calls to external services while still sending the AWS-generated callback ID to those services.

IMPACT:
External services (not in our control) receive duplicate requests, blocking production deployment.

I have described the detail requirement in attachment, Please look into it and try to resolve my issue?
AWS_SUPPORT_TICKET.md

[pjonnlagadda]

Any update on my recent comment which is about AWS Lambda Durable Functions where each step calls an external service and waits for a callback.

[anthonyting]

I'm not sure if I understand the issue. Why can't you use the submitter in waitForCallback to submit your callback? Why do you need to pass a custom callback ID?

Documentation here:

• https://github.com/aws/aws-durable-execution-sdk-js/tree/main/packages/aws-durable-execution-sdk-js#external-callbacks
• https://docs.aws.amazon.com/lambda/latest/dg/durable-examples.html#durable-examples-long-running

[pjonnlagadda]

we have multiple steps/activates to execute on each step we will make an api call and need to send the contextId to external service, and based on the same contextId, when they give callback(through AWS CLI command), the durable lambda function need to resumed.

When i make api call inside the waitForCallbac(), the completed activities are making duplicate api calls again and again on each step

REQUIREMENT:
We are building a multi-step workflow using AWS Lambda Durable Functions where each step calls an external service via HTTP POST, sends a callback ID to the external service, waits for the external service to complete processing, and then the external service calls back using AWS CLI with the callback ID to resume our Lambda function.

CURRENT ISSUE:
To send the AWS-generated callback ID to the external service, we must make the HTTP call inside the waitForCallback function. However, due to the replay mechanism in Durable Functions, this HTTP call executes multiple times when subsequent activities start.

Example with 3 activities:

Activity 1 external service receives 3 HTTP calls (should be 1)
Activity 2 external service receives 2 HTTP calls (should be 1)
Activity 3 external service receives 1 HTTP call (correct)

WHY WE CAN'T USE context.step():

Cannot use context.step() inside waitForCallback - AWS throws error: "Context usage error in step"
Cannot use context.step() before waitForCallback because we don't have the AWS callback ID yet
AWS ignores custom callback IDs specified in waitForCallback options and generates its own