How to capture and use the exception error on a Runnable With Retry Chain?

[mauriciocirelli]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

N/A

Description

Dear community,

Suppose I have a Runnable step in my chain that may throw an error.
RunnableRetry would retry that step up to stopAfterAttempt attempts, which is fine.
But how can I capture that exception message to feed it back to the retry loop in a way that the next iteration would be aware of that error and try to fix it?

A use case would be a SQL query run that throws an error. We could capture that error and ask the chain to rewrite that sql query fixing the error before retrying.

Any sample code of how to do this would be much appreciated.

System Info

[email protected] | MIT | deps: 17 | versions: 264

[dosubot[bot]]

To handle exceptions in a Runnable step within a Retry Chain and adapt the retry logic based on the error, you can use the handleChainError method. This method allows you to capture exceptions, analyze them, and modify the inputs or retry parameters before retrying the operation. Here's a simplified approach to implementing such logic:

async handleChainError(
  error: unknown,
  runId: string,
  _parentRunId?: string,
  _tags?: string[],
  kwargs?: { inputs?: Record<string, unknown> }
): Promise<Run> {
  const run = this.runMap.get(runId);
  if (!run) {
    throw new Error("No chain run to end.");
  }
  run.end_time = Date.now();
  run.error = this.stringifyError(error);
  run.events.push({
    name: "error",
    time: new Date(run.end_time).toISOString(),
  });

  // Implement your error analysis and decide if and how to retry
  if (shouldRetryBasedOnError(error)) {
    const modifiedInputs = modifyInputsBasedOnError(run.inputs, error);
    // Adjust retry parameters if needed and retry the operation
    retryChainRunWithNewParameters(runId, modifiedInputs);
  }

  await this.onChainError?.(run);
  await this._endTrace(run);
  return run;
}

In this code, shouldRetryBasedOnError and modifyInputsBasedOnError are functions you need to define based on your error handling strategy. retryChainRunWithNewParameters is a conceptual function to illustrate retrying the operation with new parameters. This approach ensures that your retry logic can dynamically adapt based on the errors encountered during execution.

Sources

• langchain-core/src/tracers/base.ts

About Dosu

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[mauriciocirelli]

Hi!

Thank you for the answer, although it is still not very clear to me how to write that code properly.

Can you help me completing the following snippet?

RunnablePassthrough.assign({
    results: async (input: any) => function_that_throws_error(input)
})
.withRetry({
  onFailedAttempt: (error: any) => {
	// How can I change the input object before it retries?
        // We could receive the input object as an argument of this function...
  },
  stopAfterAttempt: 3,
}),

Thank you!