HarnessMiddleware

HarnessMiddleware<Context, Result> = (context, next) => Promise<Result> | Result

​

runMiddleware()

runMiddleware<Context, Result>(context, middleware, core): Promise<Result>

​

HarnessTurnMiddlewareContext

readonly config: HarnessRuntimeConfig<LanguageModel, TOOLS, OutputDefinition>

readonly input: string

readonly phase: "turn"

readonly signal: AbortSignal | undefined

​

HarnessModelStepMiddlewareContext

readonly config: HarnessRuntimeConfig<LanguageModel, TOOLS>

readonly phase: "modelStep"

readonly signal: AbortSignal | undefined

readonly stepNumber: number

​

HarnessToolMiddlewareContext

readonly config: HarnessRuntimeConfig<LanguageModel, TOOLS>

readonly phase: "tool"

readonly signal: AbortSignal | undefined

readonly toolCallId: string | undefined

readonly toolName: string

​

HarnessMiddlewareError

new HarnessMiddlewareError(): HarnessMiddlewareError

optional cause?: unknown

readonly code: "HARNESS_MIDDLEWARE_NEXT"

message: string

name: string

optional stack?: string

static stackTraceLimit: number

static captureStackTrace(targetObject, constructorOpt?): void

const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Similar to `new Error().stack`

function a() {
  b();
}

function b() {
  c();
}

function c() {
  // Create an error without stack trace to avoid calculating the stack trace twice.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;

  // Capture the stack trace above function b
  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
  throw error;
}

a();

static prepareStackTrace(err, stackTraces): any