@tangle-network/agent-eval 0.207.4 → 0.208.2

package/docs/quickstart-external.md

@@ -0,0 +1,268 @@
+# External agent quickstart
+
+Run an evaluation and an improvement loop in your own Node.js process.
+No Tangle account, sandbox, runtime, or framework migration is required.
+The first run is an offline wiring exercise; `--openai` explicitly opts into paid model calls.
+
+Use `defineAgentEval()` from the [main README](../README.md#quickstart) for the higher-level API.
+This guide exposes `dispatch`, `runCampaign()`, and `runImprovementLoop()` when you want to own the wiring.
+
+## Install
+
+With Node.js 20.19 or newer, start in an empty directory:
+
+```sh
+npm init -y
+npm install @tangle-network/agent-eval
+npm install --save-dev tsx
+```
+
+## Run a campaign and an improvement loop
+
+Save this entire block as `eval.mts`. It includes a deterministic agent, a rubric,
+a candidate proposer, and a reference adapter for the raw OpenAI-compatible chat API.
+The adapter reuses the package's maintained transport and receipt helpers rather than introducing another SDK or runtime.
+
+<!-- external-quickstart:program -->
+```ts
+import { randomUUID } from 'node:crypto'
+import { join, resolve } from 'node:path'
+import {
+  costReceiptFromLlm,
+  costReceiptFromLlmError,
+  maximumChargeForLlmRequest,
+} from '@tangle-network/agent-eval'
+import {
+  createChatClient,
+  defaultProductionGate,
+  type DispatchContext,
+  inMemoryCampaignStorage,
+  type JudgeConfig,
+  type MutableSurface,
+  type Scenario,
+  type SurfaceProposer,
+} from '@tangle-network/agent-eval/contract'
+import { runCampaign, runImprovementLoop } from '@tangle-network/agent-eval/campaign'
+import { type DeploymentOutcome, InMemoryOutcomeStore } from '@tangle-network/agent-eval/rl'
+
+interface SupportCase extends Scenario { ticket: string }
+interface SupportAnswer { text: string }
+
+// Replace this function with the SAME agent call your application uses.
+// Its input/output need not know anything about agent-eval.
+async function existingAgent(input: {
+  instructions: string
+  ticket: string
+  signal: AbortSignal
+}) {
+  input.signal.throwIfAborted()
+  return {
+    message: input.instructions.includes('cite the ticket id')
+      ? `Ticket ${input.ticket}: on it.`
+      : 'On it.',
+  }
+}
+
+function requiredEnv(name: string): string {
+  const value = process.env[name]?.trim()
+  if (!value) throw new Error(`Set ${name} before using --openai`)
+  return value
+}
+
+function tokenRate(name: string): number {
+  const value = Number(requiredEnv(name))
+  if (!Number.isFinite(value) || value < 0) throw new Error(`${name} must be a nonnegative rate`)
+  return value
+}
+
+// Reference adapter: raw OpenAI-compatible API, no Tangle execution service.
+function openAiDispatch() {
+  const model = requiredEnv('LLM_MODEL')
+  const pricing = {
+    inputUsdPerMillion: tokenRate('LLM_INPUT_USD_PER_MILLION'),
+    outputUsdPerMillion: tokenRate('LLM_OUTPUT_USD_PER_MILLION'),
+  }
+  const chat = createChatClient({
+    transport: 'openai-compatible',
+    baseUrl: requiredEnv('LLM_BASE_URL'),
+    apiKey: requiredEnv('LLM_API_KEY'),
+    defaultModel: model,
+  })
+  return async (
+    surface: MutableSurface,
+    scenario: SupportCase,
+    ctx: DispatchContext,
+  ): Promise<SupportAnswer> => {
+    const request = {
+      model,
+      messages: [
+        { role: 'system' as const, content: String(surface) },
+        { role: 'user' as const, content: `Please acknowledge ticket ${scenario.ticket}.` },
+      ],
+      maxTokens: 256,
+    }
+    const paid = await ctx.cost.runPaidCall({
+      actor: 'external-support-agent',
+      model,
+      maximumCharge: maximumChargeForLlmRequest(request, {
+        customTokenPricing: pricing,
+        maximumAttempts: chat.maximumAttempts,
+      }),
+      execute: (signal, callId) => chat.chat(request, { signal, idempotencyKey: callId }),
+      receipt: (result) => costReceiptFromLlm(result, pricing),
+      receiptFromError: (error) => costReceiptFromLlmError(error, pricing),
+    })
+    if (!paid.succeeded) throw paid.error
+    if (!paid.value.content.trim()) throw new Error('The agent returned an empty answer')
+    return { text: paid.value.content }
+  }
+}
+
+const useOpenAi = process.argv.includes('--openai')
+const dispatchWithSurface = useOpenAi
+  ? openAiDispatch()
+  : async (surface: MutableSurface, scenario: SupportCase, ctx: DispatchContext) => {
+      const result = await existingAgent({
+        instructions: String(surface),
+        ticket: scenario.ticket,
+        signal: ctx.signal,
+      })
+      return { text: result.message }
+    }
+
+// A deterministic rubric is a judge. Use llmJudge() for semantic criteria.
+const judge: JudgeConfig<SupportAnswer, SupportCase> = {
+  name: 'ticket-id',
+  judgeVersion: 'ticket-id-v1',
+  dimensions: [{ key: 'present', description: 'The answer cites the supplied ticket id' }],
+  score: ({ artifact, scenario }) => {
+    const present = artifact.text.includes(scenario.ticket) ? 1 : 0
+    return { dimensions: { present }, composite: present, notes: '' }
+  },
+}
+const scenarios: SupportCase[] = ['refund', 'shipping'].map((ticket) => ({
+  id: `train-${ticket}`, kind: 'support', ticket,
+}))
+const holdoutScenarios: SupportCase[] = ['cancel', 'billing'].map((ticket) => ({
+  id: `holdout-${ticket}`, kind: 'support', ticket,
+}))
+const baselineSurface = 'Answer politely.'
+const proposer: SurfaceProposer = {
+  kind: 'cite-ticket',
+  async propose({ currentSurface }) {
+    return [{
+      surface: `${String(currentSurface)} Always cite the ticket id.`,
+      label: 'cite-ticket',
+      rationale: 'The rubric requires the supplied ticket id in the answer.',
+    }]
+  },
+}
+const runRoot = resolve('eval-quickstart', randomUUID())
+const common = {
+  judges: [judge],
+  storage: inMemoryCampaignStorage(),
+  seed: 7,
+  reps: 1,
+  maxConcurrency: 2,
+  dispatchTimeoutMs: 30_000,
+  abortOnCellError: true,
+  expectUsage: useOpenAi ? 'assert' as const : 'off' as const,
+  // Each top-level call has its own $1 ceiling; the loop shares its ceiling
+  // across search and holdout. The script has $2 of total ledger budget at the declared rates.
+  costCeiling: useOpenAi ? 1 : undefined,
+}
+const baseline = await runCampaign({
+  ...common,
+  scenarios,
+  dispatch: async function dispatch(scenario, ctx) {
+    return dispatchWithSurface(baselineSurface, scenario, ctx)
+  },
+  dispatchRef: useOpenAi ? 'external-openai-baseline-v1' : 'external-fixture-baseline-v1',
+  runDir: join(runRoot, 'baseline'),
+})
+const improvement = await runImprovementLoop({
+  ...common,
+  scenarios,
+  holdoutScenarios,
+  baselineSurface,
+  dispatchWithSurface,
+  dispatchRef: useOpenAi ? 'external-openai-v1' : 'external-fixture-v1',
+  proposer,
+  populationSize: 1,
+  maxGenerations: 1,
+  gate: defaultProductionGate<SupportAnswer, SupportCase>({ holdoutScenarios, deltaThreshold: 0 }),
+  autoOnPromote: 'none',
+  runDir: join(runRoot, 'improvement'),
+})
+
+// Synthetic storage example, NOT a measured production outcome or judge score.
+const outcomes = new InMemoryOutcomeStore()
+const observation: DeploymentOutcome = {
+  runId: 'synthetic-deployment-run',
+  capturedAt: Date.now(),
+  metrics: { resolved: 1 },
+  source: 'quickstart-fixture',
+}
+await outcomes.append(observation)
+console.log('baseline:', baseline.aggregates.byJudge['ticket-id']?.mean)
+console.log('candidate on holdout:', improvement.winnerOnHoldout.aggregates.byJudge['ticket-id']?.mean)
+console.log('decision:', improvement.gateResult.decision)
+console.log('outcome rows:', (await outcomes.forRun(observation.runId)).length)
+```
+
+```sh
+npx tsx eval.mts
+```
+
+The offline fixture is constructed to score zero for the baseline and one for the candidate.
+It uses only two holdout cases, so a higher score is not sufficient evidence to ship.
+Inspect `improvement.gateResult`, not just the candidate's mean.
+The candidate generator makes one known edit; this demonstrates the loop, not learned optimization or general agent quality.
+`autoOnPromote: 'none'` reports the decision without changing your agent or opening a PR.
+
+## Connect a real agent
+
+Replace `existingAgent()` with your production SDK call, graph invocation, service, or local model.
+Keep the adaptation in `dispatchWithSurface`: translate the surface and scenario into the agent's input,
+forward cancellation, and return the artifact your judge scores.
+Do not pass hidden answer keys or grading instructions into the agent request.
+Keep execution failures as thrown errors rather than successful empty strings or task-score zeroes.
+
+For the included OpenAI-compatible adapter, explicitly configure your endpoint, credentials,
+a currently deployed model id, and its current per-million-token rates. For OpenAI directly,
+the base URL is `https://api.openai.com/v1`. Then opt in:
+
+```sh
+# Set LLM_BASE_URL, LLM_API_KEY, LLM_MODEL,
+# LLM_INPUT_USD_PER_MILLION and LLM_OUTPUT_USD_PER_MILLION in your shell.
+npx tsx eval.mts --openai
+```
+
+This mode makes paid calls. It does not fall back to the fixture when a provider fails.
+The maintained transport reports model identity, usage, retries, and failure receipts;
+`ctx.cost.runPaidCall()` reserves for bounded output and the declared maximum attempts before dispatch.
+Unknown usage is not invented, and `expectUsage: 'assert'` rejects missing dispatch evidence.
+Set rates for your actual endpoint; local estimates are not provider invoices. Add cache-read/write
+rates to `pricing` when applicable. Increase `maxTokens` and the explicit budget together when your model needs more output headroom.
+
+For an existing multi-call agent, meter every paid call at the point where its receipt is available.
+Do not set `expectUsage: 'off'` merely to make an uninstrumented paid agent appear to work.
+For semantic scoring, use `llmJudge()` from `/contract` with a separate `ChatClient`;
+see [judge verdicts](./verdicts.md). Judge failures must remain failures, not low task scores.
+
+## Keep the useful boundaries
+
+The same production execution function should serve your application and evaluation.
+Candidate generation may use training cases, but final comparisons need separate cases;
+real deployments also need representative data, calibrated judges, sufficient independent observations,
+and an explicit approval policy. The tiny fixture is not release evidence.
+
+`inMemoryCampaignStorage()` keeps campaign data in this process, and `InMemoryOutcomeStore` does the same
+for downstream observations. Use `fsCampaignStorage()` and `FileSystemOutcomeStore` from the public barrels
+when evidence must survive a restart. With durable campaign storage, include model, prompt, tools, and
+configuration revisions in `dispatchRef` so different execution behavior cannot reuse a stale cache.
+
+For real deployment feedback, use the actual production `RunRecord.runId` in `DeploymentOutcome.runId`
+and record independently observed metrics. Do not relabel an evaluation score as a deployment outcome.
+See [outcome validity](./outcome-validity.md), [campaign controls](./eval-surface-map.md), and
+[evaluation integrity](./evaluation-integrity.md) for the next stage.

package/docs/search-ledger.md

@@ -477,6 +477,9 @@ The finalists are the nodes decided `finalist`, in decision order; whether the b
 It returns `verified`, `mismatch` with the differences, or `unknown` for a claim another rule revision made.
 The projector checks the claim's structure (every finalist named, the Bonferroni confidence of each test, a ship's held-out units and pinned judge) but not its numbers, so a store keeps what `verifySearchClaim` derives, never the producer's claim as written.
 `runSearch` runs it on every close and on every rerun of a closed ledger, throws on `mismatch`, and returns it as `SearchRunResult.claimVerification`.
+`searchClaimDecision(state, nodeId)` returns the `PairedPromotionDecision` the claim made for one tested finalist, made again from the closed ledger: the root as control, the improvement as `delta`, at the finalist's Bonferroni confidence, with the claim's estimator, resamples and seed.
+It throws unless the result reproduces the claim's recorded test for that finalist, and returns null for a node the claim did not test.
+A consumer that promotes the selected finalist cites this decision with the claim, rather than deciding again from the same cells at another confidence or seed.
 A judge change is a changed `search-opened` header, which `SearchRecorder.open` refuses; it starts a derived search instead of mixing verdicts.
 
 `compareOptimizationMethods` keeps its own held-out comparison for black-box methods such as GEPA, which return one winner and never see the test split.
@@ -555,7 +558,7 @@ Those claims need the sealed test split, the claim's power check, and held-out e
 - `src/search/lenses/edit-credit.ts`: `editCredit` and `editCreditText`.
 - `src/campaign/search-ledger-recording.ts`: `SearchRecorder` and the surface helpers.
 - `src/campaign/search-kernel.ts`: `runSearch`, the executor, proposer and codec ports, `searchPolicyView` and `searchDivergence`.
-- `src/campaign/search-claim.ts`: `planSearchClaim`, `decideSearchClaim`, `verifySearchClaim` and `searchClaimReserveUsd`.
+- `src/campaign/search-claim.ts`: `planSearchClaim`, `decideSearchClaim`, `verifySearchClaim`, `searchClaimDecision` and `searchClaimReserveUsd`.
 - `src/search/lenses/landscape.ts`, `plateau.ts` and `skill-manifold.ts`: the geometry lenses, the plateau score and the unit extension.
 - `src/campaign/search-policy.ts`: `SearchPolicy`, `incumbent`, `incumbentWithOperatorBandit`, `crowdedFrontierParent`, `aide` and `beam`.
 - `src/campaign/allocation.ts`: `SearchAllocator`, `uniform` and `asha`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.207.4",
+  "version": "0.208.2",
   "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {

package/dist/search-kernel-CzTWtv5d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"search-kernel-CzTWtv5d.d.ts","names":[],"sources":["../src/campaign/storage.ts","../src/campaign/search-ledger.ts","../src/campaign/search-history-receipt.ts","../src/campaign/search-ledger-recording.ts","../src/search/lenses/shared.ts","../src/search/lenses/operator-yield.ts","../src/campaign/estimate-node.ts","../src/campaign/search-policy.ts","../src/campaign/allocation.ts","../src/campaign/search-claim.ts","../src/campaign/search-kernel.ts"],"mappings":"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"}