@tangle-network/agent-runtime 0.7.0 → 0.9.0

package/README.md

@@ -15,8 +15,8 @@ pnpm add @tangle-network/agent-runtime @tangle-network/agent-eval
 |---|---|
 | `runAgentTask` | Single-shot adapter-driven task with eval/verification |
 | `runAgentTaskStream` | Streaming product loop with session resume + backends |
-| `startRuntimeRun` | Canonical production-run row + cost ledger (NEW in 0.7.0) |
-| `createTraceBridge` | Map `RuntimeStreamEvent` → `agent-eval` `TraceEvent` (NEW in 0.7.0) |
+| `startRuntimeRun` | Canonical production-run row + cost ledger |
+| `createTraceBridge` | Map `RuntimeStreamEvent` → `agent-eval` `TraceEvent` |
 | `decideKnowledgeReadiness` | `ready` / `blocked` / `caveat` branch for routes / UI |
 | `createOpenAICompatibleBackend` | OpenAI-compatible streaming backend (TCloud / cli-bridge) |
 | `createSandboxPromptBackend` | Sandbox / sidecar `streamPrompt` clients |
@@ -50,13 +50,11 @@ const result = await runAgentTask({
 console.log(result.status, result.runRecords)
 ```
 
-## Canonical production-run lifecycle (NEW in 0.7.0)
+## Canonical production-run lifecycle
 
-`startRuntimeRun` is the ONE abstraction for "the agent did a thing on
-behalf of a customer; record what it did, what it cost, how it ended."
-Replaces bespoke `agentRuns`-row helpers (legal-agent's
-`completeProductionAgentRun` + `persistRuntimeRun` pair is the canonical
-example of what this subsumes).
+`startRuntimeRun` records what the agent did on behalf of a customer,
+what it cost, and how it ended. Replaces bespoke `agentRuns`-row helpers
+across consumer repos with a single contract.
 
 ```ts
 import { startRuntimeRun, runAgentTaskStream } from '@tangle-network/agent-runtime'
@@ -87,11 +85,11 @@ console.log(run.cost()) // { tokensIn, tokensOut, costUsd, wallMs, llmCalls }
 
 Full runnable: [`examples/runtime-run/`](./examples/runtime-run/).
 
-## agent-eval trace bridge (NEW in 0.7.0)
+## agent-eval trace bridge
 
-If you persist traces in agent-eval's `TraceStore`, map runtime stream
-events to `TraceEvent` once and stop hand-rolling the adapter in every
-domain repo:
+If you persist traces in agent-eval's `TraceStore`, the bridge maps
+runtime stream events to `TraceEvent` so consumer repos don't hand-roll
+the adapter:
 
 ```ts
 import { createTraceBridge } from '@tangle-network/agent-runtime'
@@ -146,10 +144,41 @@ details. Private diagnostics opt-in via `RuntimeTelemetryOptions`.
 | Package | Owns |
 |---|---|
 | `agent-runtime` | Lifecycle, adapters, backends, `RuntimeRunHandle`, trace bridge |
+| `agent-runtime/platform` | Server-side clients for the Tangle platform: cross-site SSO (`PlatformAuthClient`) and integrations hub (`PlatformHubClient`) |
 | `agent-eval` | Control loops, readiness scoring, traces, evals, failure classes, release evidence |
 | `agent-knowledge` | Evidence, claims, wiki pages, retrieval, knowledge bundle builders |
 | Domain packages | Domain tools, policies, credentials, UI text, rubrics |
 
+### `agent-runtime/platform` — Login with Tangle + integrations hub
+
+```ts
+import {
+  PlatformAuthClient,
+  PlatformHubClient,
+} from '@tangle-network/agent-runtime/platform'
+
+// Login with Tangle (cross-site SSO bridge).
+const auth = new PlatformAuthClient({
+  baseUrl: process.env.TANGLE_PLATFORM_URL!, // https://id.tangle.tools
+  appId: 'gtm-agent',                        // must be registered in TRUSTED_APPS
+})
+const url = auth.authorizeUrl({ state: csrfToken, redirectUri: callbackUrl })
+// …user redirected to `url`, returns to callbackUrl with ?code=…
+const { apiKey, user } = await auth.exchange(code)
+
+// Integrations hub (uses the user's apiKey from cross-site exchange).
+const hub = new PlatformHubClient({
+  baseUrl: process.env.TANGLE_PLATFORM_URL!,
+  bearer: apiKey,
+})
+const connections = await hub.listConnections()
+const { authorizationUrl } = await hub.startAuth({
+  providerId: 'google',
+  connectorId: 'gmail',
+  returnUrl: 'https://gtm.tangle.tools/integrations',
+})
+```
+
 The API uses `runAgentTask`, not `runVerticalAgentTask`. `domain` is
 metadata on the task because the runtime is reusable across many kinds of
 agents without baking taxonomy into type names.
@@ -165,4 +194,4 @@ Runnable in [`examples/`](./examples/):
 - [`sse-stream/`](./examples/sse-stream/) — Server-Sent Events for browser clients
 - [`sandbox-stream-backend/`](./examples/sandbox-stream-backend/) — `createSandboxPromptBackend`
 - [`openai-stream-backend/`](./examples/openai-stream-backend/) — `createOpenAICompatibleBackend`
-- [`runtime-run/`](./examples/runtime-run/) — `startRuntimeRun` + cost ledger + persistence adapter (NEW)
+- [`runtime-run/`](./examples/runtime-run/) — `startRuntimeRun` + cost ledger + persistence adapter

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { ControlEvalResult, KnowledgeRequirement, ControlBudget, KnowledgeReadinessReport, ControlStep, ControlDecision, UserQuestion, DataAcquisitionPlan, ControlRunResult, RunRecord, TraceStore, AgentEvalError, TraceEvent } from '@tangle-network/agent-eval';
 export { AgentEvalError, AgentEvalErrorCode, CaptureIntegrityError, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, ReplayError, RunRecord, UserQuestion, ValidationError, VerificationError } from '@tangle-network/agent-eval';
+import { AgentProfilePrompt, AgentProfileResources, AgentSubagentProfile, AgentProfile, SandboxInstance } from '@tangle-network/sandbox';
 
 /**
  * @stable
@@ -427,6 +428,105 @@ declare function createOpenAICompatibleBackend<TInput extends AgentBackendInput
     fetchImpl?: typeof fetch;
 }): AgentExecutionBackend<TInput>;
 
+/**
+ * Send an AgentProfile to a sandbox runtime for one chat turn. Composes
+ * the per-turn overlay (user message, prior history, knowledge flags)
+ * via `mergeAgentProfiles`, POSTs the full profile to the runtime's
+ * `/runtime/agents/run/stream` endpoint, and yields `RuntimeStreamEvent`s
+ * from the SSE response. The full profile — subagents, MCP servers,
+ * permissions, file mounts — reaches the sandbox by construction.
+ */
+
+/** A message in the chat turn's prior context. Provider-neutral. */
+interface ChatTurnMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    /** Optional metadata the consumer wants threaded through (timestamps, msg id, etc). */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Per-turn profile overlay. The caller's profile is the durable contract;
+ * the overlay carries volatile per-turn context (workspace facts, dynamic-
+ * advisor instructions, RAG hits) that the runtime should see but that
+ * doesn't belong in the canonical profile. Composed via `mergeAgentProfiles`.
+ */
+interface ChatTurnOverlay {
+    /** Volatile prompt additions: dynamic-advisor context, intake gate output, RAG citations. */
+    promptOverlay?: AgentProfilePrompt;
+    /** Per-turn additional file mounts (vault docs, recent uploads). */
+    resourcesOverlay?: AgentProfileResources;
+    /** Override or augment the subagent map for this turn (rare). */
+    subagentsOverlay?: Record<string, AgentSubagentProfile>;
+    /** Free-form metadata threaded into the runtime call. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Sandbox runtime contract — the subset of `SandboxInstance` `runChatTurn`
+ * actually invokes. Defined as an interface so consumers can inject a
+ * stub in tests without standing up a real sandbox.
+ */
+interface ChatTurnSandbox {
+    /** Sandbox identifier used in the runtime URL. */
+    readonly id: string;
+    /** Base URL of the sandbox runtime, e.g. `https://sandbox.tangle.tools/v1/sandboxes/&lt;id&gt;`. */
+    readonly runtimeUrl: string;
+    /** Optional bearer for the runtime call (sidecar auth). */
+    readonly authHeader?: {
+        name: string;
+        value: string;
+    };
+}
+interface RunChatTurnOptions {
+    /** Canonical agent profile — the durable contract. */
+    profile: AgentProfile;
+    /** Volatile per-turn additions. */
+    overlay?: ChatTurnOverlay;
+    /** Current user message. */
+    message: string;
+    /** Prior conversation. */
+    priorMessages: readonly ChatTurnMessage[];
+    /** Sandbox the turn should run inside. */
+    sandbox: ChatTurnSandbox;
+    /** Override model for this turn (otherwise profile.model.default is used). */
+    modelOverride?: string;
+    /** AbortSignal for cancellation (timeouts, client disconnect, etc). */
+    signal?: AbortSignal;
+    /** Override fetch (for tests). */
+    fetch?: typeof fetch;
+}
+/**
+ * Compose the per-turn profile via `mergeAgentProfiles(profile, overlay)`,
+ * POST the FULL composed profile to the sandbox's runtime streaming endpoint,
+ * and yield parsed `RuntimeStreamEvent`s. The runtime resolves prompt,
+ * subagents, MCP servers, and permissions from the profile — callers do not
+ * hand-craft a `backend.profile` shape.
+ *
+ *     for await (const event of runChatTurn({ profile, overlay, message, priorMessages, sandbox })) {
+ *       // event.type === 'message' / 'tool_call' / 'task_complete' / etc.
+ *     }
+ */
+declare function runChatTurn(options: RunChatTurnOptions): AsyncIterable<RuntimeStreamEvent>;
+/**
+ * Compose the per-turn AgentProfile. Public-and-pure so consumers can
+ * preview/log/persist the composed shape without firing a runtime call.
+ */
+declare function composeTurnProfile(base: AgentProfile, overlay: ChatTurnOverlay): AgentProfile;
+declare class ChatTurnError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+/**
+ * Convenience: build a `ChatTurnSandbox` from a full `SandboxInstance`. Most
+ * callers already have one of these from `client.create()`. The runtime URL
+ * is derived from the instance's transport configuration.
+ */
+declare function sandboxAsChatTurnTarget(instance: SandboxInstance, opts?: {
+    authHeader?: {
+        name: string;
+        value: string;
+    };
+}): ChatTurnSandbox;
+
 /**
  * @stable
  *
@@ -492,6 +592,124 @@ declare class RuntimeRunStateError extends AgentEvalError {
     });
 }
 
+/**
+ * Classify a user message against a profile's subagent map. Routes are
+ * declared on each `AgentSubagentProfile.metadata.matchers` (keywords +
+ * regex patterns); `classifyIntent` scores every subagent against the
+ * message and returns a typed result. Pure scoring — no LLM call. Caller
+ * decides whether the score is high enough to dispatch the subagent.
+ */
+
+/** Matcher shape attached to `subagent.metadata.matchers`. */
+interface SubagentMatcher {
+    /** Literal keywords (case-insensitive substring match). +1 per match unless `weight` overrides. */
+    keywords?: readonly string[];
+    /** Regex patterns (case-insensitive). +`weight` per match (default 1.5). */
+    patterns?: readonly (string | RegExp)[];
+    /** Per-rule weight override. */
+    weight?: number;
+    /** Minimum score for this subagent to be considered "matched". Default 1. */
+    minScore?: number;
+}
+interface ClassifyIntentResult {
+    /** Best-scoring subagent id; null if no subagent crossed `minScore`. */
+    id: string | null;
+    /** Best subagent's `AgentSubagentProfile`; null if no match. */
+    subagent: AgentSubagentProfile | null;
+    /** Score of the chosen subagent. */
+    score: number;
+    /** All subagent scores keyed by id — useful for telemetry / debugging. */
+    scores: Record<string, number>;
+    /** The matchers checked, for debugging "why didn't X route?" */
+    evaluated: Record<string, {
+        keywordHits: number;
+        patternHits: number;
+        minScore: number;
+    }>;
+}
+interface ClassifyIntentOptions {
+    /** Override the global default `minScore` (used when a subagent omits its own). */
+    defaultMinScore?: number;
+    /** Subagent ids to skip (e.g. scaffold-only subagents with `metadata.status === 'scaffold'`). */
+    skip?: readonly string[];
+    /** Only consider subagents whose metadata predicate returns true (e.g. `m =&gt; m.status === 'full'`). */
+    filter?: (subagent: AgentSubagentProfile, id: string) => boolean;
+}
+/**
+ * Pure intent classifier.
+ *
+ * For each subagent in `profile.subagents`: read `metadata.matchers`,
+ * score keyword + pattern hits against the user message, return the
+ * highest-scoring subagent (or null if none crossed `minScore`). No LLM
+ * call, no side effects. The runtime decides what to do with the result.
+ */
+declare function classifyIntent(profile: AgentProfile, message: string, opts?: ClassifyIntentOptions): ClassifyIntentResult;
+
+/**
+ * Validate an AgentProfile against canonical conformance rules: tool keys
+ * must map to an MCP server entry (not be shell capabilities masquerading
+ * as tools), subagents marked `metadata.status: 'scaffold'` must not be
+ * dispatchable, system prompts must be substantive. Pure — no I/O — so
+ * callers run it in a unit test or at module load to fail-fast on
+ * misconfiguration.
+ */
+
+interface ConformanceIssue {
+    severity: 'error' | 'warn';
+    /** Stable kebab-case code, useful for CI matching. */
+    code: string;
+    /** Profile path the issue is anchored to, e.g. `tools.bash` or `subagents.foo`. */
+    path: string;
+    /** Human-readable failure reason. */
+    message: string;
+}
+interface ConformanceResult {
+    valid: boolean;
+    errors: ConformanceIssue[];
+    warnings: ConformanceIssue[];
+}
+interface ConformanceOptions {
+    /**
+     * Shell-style capabilities that may appear in `permissions` but NEVER in
+     * `tools`. Declaring these as tools is decorative — the runtime doesn't
+     * dispatch them as MCP servers. Default covers the observed offenders.
+     */
+    knownShellCapabilities?: readonly string[];
+    /**
+     * If true, treat `subagents[id].metadata.status === 'scaffold'` as an
+     * error rather than a warning. Default false — scaffolds are honest
+     * stubs as long as the router skips them.
+     */
+    strictNoScaffolds?: boolean;
+    /**
+     * Names that may appear in `tools` without a corresponding MCP server or
+     * resource mount. Default empty — kills decorative-tool anti-pattern.
+     */
+    toolsAllowedWithoutMcp?: readonly string[];
+    /**
+     * Minimum length of `prompt.systemPrompt`. Profiles below this are
+     * likely incomplete. Default 800 chars (rough lower bound for the
+     * partner-tier prompts the product agents target).
+     */
+    minSystemPromptChars?: number;
+}
+/**
+ * Run all conformance checks against a profile. Designed to be called from
+ * a unit test:
+ *
+ *     it('legalAgentProfile passes conformance', () => {
+ *       const result = assertProfileConformance(legalAgentProfile, {
+ *         toolsAllowedWithoutMcp: ['agent-knowledge:query'],  // in-process function
+ *       })
+ *       expect(result.valid).toBe(true)
+ *       expect(result.errors).toEqual([])
+ *     })
+ *
+ * Issues carry `path` + `code` so tests can pinpoint failures rather than
+ * collapse to a generic "validation failed."
+ */
+declare function assertProfileConformance(profile: AgentProfile, opts?: ConformanceOptions): ConformanceResult;
+
 /**
  * @stable
  *
@@ -534,34 +752,27 @@ declare function runAgentTaskStream<TInput extends AgentBackendInput = AgentBack
 /**
  * @stable
  *
- * Canonical production-run lifecycle. ONE abstraction for "the agent did a
- * thing on behalf of a customer; record what it did, what it cost, and how it
- * ended." Consumer agents (legal, tax, gtm, creative, agent-builder) reach for
- * `startRuntimeRun` instead of inventing their own `agentRuns`-row helpers.
+ * Production-run lifecycle: record what the agent did on behalf of a customer,
+ * what it cost, and how it ended.
  *
  * Three concerns live in this module:
  *
  *  1. **Lifecycle state machine** — `running` -> `completed | failed | cancelled`,
- *     enforced by `RuntimeRunStateError`. Completion is idempotent (a second
- *     `complete()` call with the same status is a no-op so retries / cleanup
- *     paths don't double-fire side effects). A different terminal status is a
- *     state error.
+ *     enforced by `RuntimeRunStateError`. Completion is idempotent for the same
+ *     status (a second `complete()` call is a no-op so retries / cleanup paths
+ *     don't double-fire side effects). A different terminal status is a state
+ *     error.
  *
  *  2. **Cost ledger** — every `llm_call` event the handle observes contributes
  *     `tokensIn`, `tokensOut`, `costUsd`, and bumps `llmCalls`. Wall time is
  *     measured from `startRuntimeRun()` to `complete()`. Surface via
- *     `handle.cost()` for "cost per customer task" dashboards.
+ *     `handle.cost()` for cost-per-task dashboards.
  *
  *  3. **Persistence adapter** — `RuntimeRunPersistenceAdapter` is the seam
  *     consumers plug in to write a `RuntimeRunRow` to their D1 / postgres /
  *     KV store. The adapter receives a sanitized row shape; no telemetry
  *     payload bytes flow through it unless the consumer opts in via
  *     `RuntimeRunOptions.telemetryEvents`.
- *
- * The pattern replaces legal-agent's bespoke `completeProductionAgentRun` /
- * `persistRuntimeRun` pair from `eval-evidence.ts` + `api.chat.ts`. Both are
- * marked `@deprecated` in this release; consumers ditch them on their own
- * version bumps.
  */
 
 /** @stable */
@@ -770,16 +981,12 @@ declare function createRuntimeEventCollector<TState = unknown, TAction = unknown
 /**
  * @stable
  *
- * Streaming-event counterpart of `createRuntimeEventCollector`. Use this with
- * `runAgentTaskStream` — pass each yielded event through `onEvent` and read
- * the sanitized copies off `events`. The same `RuntimeTelemetryOptions`
- * redaction flags apply.
- *
- * Stream and non-stream events have different field shapes (timestamps,
- * sessions, text/tool deltas) so this is a sibling factory rather than an
- * overload of `createRuntimeEventCollector`; the unified-union alternative
- * was rejected because dispatching on `type` alone would silently misroute
- * events whose `type` literals overlap (`task_start`, `readiness_end`, etc.).
+ * Streaming-event counterpart of `createRuntimeEventCollector`. Pass each
+ * event yielded by `runAgentTaskStream` through `onEvent` and read the
+ * sanitized copies off `events`; the same `RuntimeTelemetryOptions` redaction
+ * flags apply. Kept distinct from `createRuntimeEventCollector` because the
+ * stream and non-stream event shapes overlap on `type` literals — dispatching
+ * on `type` alone would misroute events.
  */
 declare function createRuntimeStreamEventCollector(options?: RuntimeTelemetryOptions): RuntimeStreamEventCollector;
 
@@ -829,17 +1036,10 @@ declare function runtimeStreamServerSentEvent(event: RuntimeStreamEvent, options
 /**
  * @stable
  *
- * Bridge from runtime stream events to the agent-eval trace schema.
- *
- * Before this module, consumers (legal-agent's chat.ts, gtm-agent's runtime
- * route) hand-rolled an adapter from `RuntimeStreamEvent` -> `TraceEvent` per
- * repo. The mapping is mechanical and the destination schema is owned by
- * agent-eval, so the adapter belongs in runtime, not in N consumer repos.
+ * One-way bridge from `RuntimeStreamEvent` to agent-eval's `TraceEvent`.
  *
- * The bridge is intentionally one-way (runtime -> agent-eval). The reverse
- * mapping is degenerate (agent-eval events have no session / task affinity)
- * and would invite consumers to round-trip through agent-eval, defeating the
- * point of the runtime-specific shape.
+ * The reverse direction is intentionally unsupported — agent-eval events
+ * have no session / task affinity, so round-tripping would erase information.
  */
 
 /** @stable */
@@ -890,4 +1090,4 @@ declare function createTraceBridge(options: TraceBridgeOptions): TraceBridge;
  */
 declare function toAgentEvalTrace(event: RuntimeStreamEvent, options: TraceBridgeOptions): TraceEvent | undefined;
 
-export { type AgentAdapter, type AgentBackendContext, type AgentBackendInput, type AgentExecutionBackend, type AgentKnowledgeProvider, type AgentRuntimeEvent, type AgentRuntimeEventSink, type AgentTaskContext, type AgentTaskRunResult, type AgentTaskRunSummary, type AgentTaskSpec, type AgentTaskStatus, BackendTransportError, InMemoryRuntimeSessionStore, type KnowledgeReadinessDecision, type RunAgentTaskOptions, type RunAgentTaskStreamOptions, type RuntimeEventCollector, type RuntimeRunCompleteInput, type RuntimeRunCost, type RuntimeRunHandle, type RuntimeRunOptions, type RuntimeRunPersistenceAdapter, type RuntimeRunRow, RuntimeRunStateError, type RuntimeRunStatus, type RuntimeSession, type RuntimeSessionStore, type RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeStreamEventSink, type RuntimeStreamEventSummary, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SanitizedKnowledgeRequirement, type ServerSentEventOptions, SessionMismatchError, type TraceBridge, type TraceBridgeOptions, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, createTraceBridge, decideKnowledgeReadiness, encodeServerSentEvent, readinessServerSentEvent, runAgentTask, runAgentTaskStream, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, startRuntimeRun, summarizeAgentTaskRun, toAgentEvalTrace };
+export { type AgentAdapter, type AgentBackendContext, type AgentBackendInput, type AgentExecutionBackend, type AgentKnowledgeProvider, type AgentRuntimeEvent, type AgentRuntimeEventSink, type AgentTaskContext, type AgentTaskRunResult, type AgentTaskRunSummary, type AgentTaskSpec, type AgentTaskStatus, BackendTransportError, ChatTurnError, type ChatTurnMessage, type ChatTurnOverlay, type ChatTurnSandbox, type ClassifyIntentOptions, type ClassifyIntentResult, type ConformanceIssue, type ConformanceOptions, type ConformanceResult, InMemoryRuntimeSessionStore, type KnowledgeReadinessDecision, type RunAgentTaskOptions, type RunAgentTaskStreamOptions, type RunChatTurnOptions, type RuntimeEventCollector, type RuntimeRunCompleteInput, type RuntimeRunCost, type RuntimeRunHandle, type RuntimeRunOptions, type RuntimeRunPersistenceAdapter, type RuntimeRunRow, RuntimeRunStateError, type RuntimeRunStatus, type RuntimeSession, type RuntimeSessionStore, type RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeStreamEventSink, type RuntimeStreamEventSummary, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SanitizedKnowledgeRequirement, type ServerSentEventOptions, SessionMismatchError, type SubagentMatcher, type TraceBridge, type TraceBridgeOptions, assertProfileConformance, classifyIntent, composeTurnProfile, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, createTraceBridge, decideKnowledgeReadiness, encodeServerSentEvent, readinessServerSentEvent, runAgentTask, runAgentTaskStream, runChatTurn, runtimeStreamServerSentEvent, sandboxAsChatTurnTarget, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, startRuntimeRun, summarizeAgentTaskRun, toAgentEvalTrace };