Harness

import { init } from '@cascadeflow/core';

const report = init({
  mode: 'observe',
  verbose: false,
});

console.log(report.mode);
console.log(report.instrumented);
console.log(report.detectedButNotInstrumented);

import { init, run } from '@cascadeflow/core';

init({ mode: 'enforce' });

const value = await run({
  budget: 0.50,
  maxToolCalls: 8,
  maxLatencyMs: 5000,
  maxEnergy: 100,
  kpiWeights: { quality: 0.6, cost: 0.3, latency: 0.1 },
  compliance: 'regulated',
}, async (session) => {
  const result = await existingAgentWork();
  console.log(session.summary());
  return result;
});

type HarnessRunOptions = {
  budget?: number;
  maxToolCalls?: number;
  maxLatencyMs?: number;
  maxEnergy?: number;
  kpiTargets?: Record<string, number>;
  kpiWeights?: Record<string, number>;
  compliance?: string;
};

await run({ budget: 0.50 }, async (session) => {
  await existingAgentWork();

  const summary = session.summary();
  console.log(summary.cost);
  console.log(summary.stepCount);
  console.log(summary.budgetRemaining);

  for (const record of session.trace()) {
    console.log(record.action, record.reason, record.applied);
  }
});

import { harnessAgent } from '@cascadeflow/core';

const analyzedAgent = harnessAgent({
  budget: 0.20,
  compliance: 'regulated',
})(async (query: string) => existingAgent(query));

import {
  BudgetExceededError,
  HarnessStopError,
  resetHarness,
  run,
} from '@cascadeflow/core';

try {
  await run({ budget: 0 }, async () => existingAgentWork());
} catch (error) {
  if (error instanceof BudgetExceededError) {
    console.error(error.remaining);
  } else if (error instanceof HarnessStopError) {
    console.error(error.reason);
  }
}

resetHarness();