createHarnessStepContext()

createHarnessStepContext(ports, options): HarnessStepContext

​

On the Agent Runtime

// steps.ts
ports.sql.transactionSync(() => {
  const next = first(ports.sql.exec("SELECT COALESCE(MAX(journal_seq), 0) + 1 AS next FROM __telnyx_agent_harness_steps WHERE run_id = ?", options.runId).toArray()).next;
  ports.sql.exec("INSERT INTO __telnyx_agent_harness_steps(run_id,name,identity,input_fingerprint,version,status,output,journal_seq) VALUES (?,?,?,?,?,'prepared',NULL,?)", options.runId, name, identity, inputFingerprint, version, next);
});
// …
const output = await fn();
// …
const serialized = serializeStepOutput(output, stepOptions.external === true);
ports.sql.transactionSync(() => {
  ports.sql.exec("UPDATE __telnyx_agent_harness_steps SET status = 'completed', output = ?, output_failure = ? WHERE run_id = ? AND name = ?", serialized.output, serialized.failure, options.runId, name);
});

• ports.sql.exec() runs on the instance’s own SQLite database, this.ctx.storage.sql. The memo’s table sits beside the run ledger’s.
• ports.sql.transactionSync() is this.ctx.storage.transactionSync(). A transaction that throws is rolled back whole.

​

HarnessStepContext

readonly isContinuation: boolean

readonly runId: string

associateToolCallJournal(calls): ReadonlyMap<string, string>

isCompleted(name, options?): boolean

nextToolCallOrdinal(toolName, toolCallId): number

reconcileToolCallJournal(journalMarkers): void

step<T>(name, fn, options?): Promise<T>

​

HarnessStepContextOptions

readonly optional checkpoints?: HarnessCheckpoint

readonly input: unknown

readonly optional isContinuation?: boolean

readonly runId: string

readonly version: string

​

HarnessStepOptions

readonly optional beforeEffect?: () => void

readonly optional external?: boolean

readonly optional input?: unknown

readonly optional version?: string

​

HarnessStepOutputSerializationError

new HarnessStepOutputSerializationError(): HarnessStepOutputSerializationError

optional cause?: unknown

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

​

isToolOutputSerializationFailure()

isToolOutputSerializationFailure(value): boolean