@tangle-network/agent-runtime 0.18.0 → 0.19.0

package/dist/agent.d.ts

@@ -1,6 +1,6 @@
 import * as _tangle_network_agent_eval from '@tangle-network/agent-eval';
 import { FindingSubject, TraceAnalystKindSpec, AnalystFinding } from '@tangle-network/agent-eval';
-import { R as RuntimeStreamEvent } from './types-ByIhNRFk.js';
+import { R as RuntimeStreamEvent } from './types-DlyPgeI0.js';
 import { I as ImprovementAdapter, K as KnowledgeAdapter, a as RunAnalystLoopResult } from './types-D_MXrmJP.js';
 
 /**

package/dist/chunk-RZAOYKCO.js

@@ -0,0 +1,51 @@
+// src/errors.ts
+import { AgentEvalError } from "@tangle-network/agent-eval";
+import {
+  AgentEvalError as AgentEvalError2,
+  CaptureIntegrityError,
+  ConfigError,
+  JudgeError,
+  NotFoundError,
+  ReplayError,
+  ValidationError,
+  VerificationError
+} from "@tangle-network/agent-eval";
+var SessionMismatchError = class extends AgentEvalError {
+  sessionBackend;
+  requestedBackend;
+  constructor(sessionBackend, requestedBackend, options) {
+    super(
+      "validation",
+      `Cannot resume ${sessionBackend} session with ${requestedBackend} backend`,
+      options
+    );
+    this.sessionBackend = sessionBackend;
+    this.requestedBackend = requestedBackend;
+  }
+};
+var BackendTransportError = class extends AgentEvalError {
+  backend;
+  status;
+  constructor(backend, message, options) {
+    super("config", message, options);
+    this.backend = backend;
+    this.status = options?.status;
+  }
+};
+var RuntimeRunStateError = class extends AgentEvalError {
+  constructor(message, options) {
+    super("validation", message, options);
+  }
+};
+
+export {
+  SessionMismatchError,
+  BackendTransportError,
+  RuntimeRunStateError,
+  AgentEvalError2 as AgentEvalError,
+  ConfigError,
+  JudgeError,
+  NotFoundError,
+  ValidationError
+};
+//# sourceMappingURL=chunk-RZAOYKCO.js.map

package/dist/chunk-RZAOYKCO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts"],"sourcesContent":["/**\n * @stable\n *\n * Error taxonomy for `@tangle-network/agent-runtime`.\n *\n * Public contract: every error this package throws as part of its consumer-\n * facing API either extends `AgentEvalError` (re-exported here for ergonomic\n * `instanceof` checks at the runtime boundary) or extends one of the\n * runtime-specific subclasses below.\n *\n * Internal invariant guards (`throw new Error('this should never happen')`)\n * remain plain `Error` — they are programmer-mistake assertions, not\n * consumer-catchable contract failures.\n *\n * Subclassing strategy: where a runtime-specific failure maps cleanly to an\n * agent-eval code (validation, config, not_found), we re-use the agent-eval\n * subclass. Runtime-only failure modes (session resume against the wrong\n * backend, backend transport errors) get fresh subclasses that still carry an\n * `AgentEvalErrorCode` so cross-package handlers can pattern-match without\n * importing the runtime.\n */\n\nimport { AgentEvalError } from '@tangle-network/agent-eval'\n\nexport {\n  AgentEvalError,\n  type AgentEvalErrorCode,\n  CaptureIntegrityError,\n  ConfigError,\n  JudgeError,\n  NotFoundError,\n  ReplayError,\n  ValidationError,\n  VerificationError,\n} from '@tangle-network/agent-eval'\n\n/**\n * @stable\n *\n * Caller asked to resume a session against a backend whose `kind` does not\n * match the session's recorded backend. This is a routing bug — the same\n * session id was reused across two different backend implementations — and\n * is not retryable without picking the right backend.\n */\nexport class SessionMismatchError extends AgentEvalError {\n  readonly sessionBackend: string\n  readonly requestedBackend: string\n\n  constructor(sessionBackend: string, requestedBackend: string, options?: { cause?: unknown }) {\n    super(\n      'validation',\n      `Cannot resume ${sessionBackend} session with ${requestedBackend} backend`,\n      options,\n    )\n    this.sessionBackend = sessionBackend\n    this.requestedBackend = requestedBackend\n  }\n}\n\n/**\n * @stable\n *\n * A backend transport call (HTTP, gRPC, sidecar IPC) failed with a non-success\n * status. Distinct from `JudgeError` (which is structural / unrecoverable)\n * because backend failures are sometimes retryable and consumers may want to\n * branch on the upstream status code.\n */\nexport class BackendTransportError extends AgentEvalError {\n  readonly backend: string\n  readonly status?: number\n\n  constructor(backend: string, message: string, options?: { cause?: unknown; status?: number }) {\n    super('config', message, options)\n    this.backend = backend\n    this.status = options?.status\n  }\n}\n\n/**\n * @stable\n *\n * A runtime-run lifecycle method was called in an order the state machine does\n * not allow: `persist()` before `complete()`, `complete()` twice, etc.\n */\nexport class RuntimeRunStateError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('validation', message, options)\n  }\n}\n"],"mappings":";AAsBA,SAAS,sBAAsB;AAE/B;AAAA,EACE,kBAAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAUA,IAAM,uBAAN,cAAmC,eAAe;AAAA,EAC9C;AAAA,EACA;AAAA,EAET,YAAY,gBAAwB,kBAA0B,SAA+B;AAC3F;AAAA,MACE;AAAA,MACA,iBAAiB,cAAc,iBAAiB,gBAAgB;AAAA,MAChE;AAAA,IACF;AACA,SAAK,iBAAiB;AACtB,SAAK,mBAAmB;AAAA,EAC1B;AACF;AAUO,IAAM,wBAAN,cAAoC,eAAe;AAAA,EAC/C;AAAA,EACA;AAAA,EAET,YAAY,SAAiB,SAAiB,SAAgD;AAC5F,UAAM,UAAU,SAAS,OAAO;AAChC,SAAK,UAAU;AACf,SAAK,SAAS,SAAS;AAAA,EACzB;AACF;AAQO,IAAM,uBAAN,cAAmC,eAAe;AAAA,EACvD,YAAY,SAAiB,SAA+B;AAC1D,UAAM,cAAc,SAAS,OAAO;AAAA,EACtC;AACF;","names":["AgentEvalError"]}

package/dist/chunk-XLWPTPRP.js

@@ -0,0 +1,52 @@
+import {
+  ValidationError
+} from "./chunk-RZAOYKCO.js";
+
+// src/loops/drivers/fanout-vote.ts
+function createFanoutVoteDriver(options) {
+  if (!Number.isFinite(options.n) || options.n < 1) {
+    throw new ValidationError(`createFanoutVoteDriver: n must be >= 1, got ${options.n}`);
+  }
+  const selector = options.selector ?? defaultSelector;
+  return {
+    name: options.name ?? "fanout-vote",
+    async plan(task, history) {
+      if (history.length === 0) return Array.from({ length: options.n }, () => task);
+      return [];
+    },
+    decide(history) {
+      const scored = scoreIterations(history);
+      return selector(scored) ? "pick-winner" : "fail";
+    }
+  };
+}
+function defaultSelector(scored) {
+  const valid = scored.filter((entry) => entry.verdict?.valid === true);
+  if (valid.length === 0) return void 0;
+  return [...valid].sort(
+    (a, b) => (b.verdict?.score ?? 0) - (a.verdict?.score ?? 0) || a.iterationIndex - b.iterationIndex
+  )[0];
+}
+function scoreIterations(iterations) {
+  const out = [];
+  for (const iter of iterations) {
+    if (iter.output === void 0 || iter.error) continue;
+    out.push({
+      task: iter.task,
+      output: iter.output,
+      verdict: iter.verdict,
+      iterationIndex: iter.index,
+      agentRunName: iter.agentRunName
+    });
+  }
+  return out;
+}
+function scoreFanoutVoteIterations(iterations) {
+  return scoreIterations(iterations);
+}
+
+export {
+  createFanoutVoteDriver,
+  scoreFanoutVoteIterations
+};
+//# sourceMappingURL=chunk-XLWPTPRP.js.map

package/dist/chunk-XLWPTPRP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/loops/drivers/fanout-vote.ts"],"sourcesContent":["/**\n * @experimental\n *\n * FanoutVote driver — N parallel attempts in iteration 0, pick the highest-\n * scoring valid output. No second iteration: the topology is \"spawn N, score,\n * pick winner\". The kernel handles heterogeneous fanout via the\n * `agentRuns: AgentRunSpec[]` form on `runLoop`.\n */\n\nimport { ValidationError } from '../../errors'\nimport type { DefaultVerdict, Driver, Iteration } from '../types'\n\nexport type FanoutVoteDecision = 'pick-winner' | 'fail'\n\n/** @experimental */\nexport interface FanoutVoteScored<Task, Output> {\n  task: Task\n  output: Output\n  verdict?: DefaultVerdict\n  iterationIndex: number\n  agentRunName: string\n}\n\n/** @experimental */\nexport interface CreateFanoutVoteDriverOptions<Task, Output> {\n  /** Number of parallel attempts. Must be >= 1. */\n  n: number\n  /**\n   * Pick the winner from the scored set. Default: highest `verdict.score`\n   * among valid outputs (ties broken by smallest iteration index). When\n   * no valid outputs exist, returns `undefined` and `decide()` resolves\n   * to `'fail'`. The kernel still records winners structurally — this\n   * selector only feeds `decide()`'s pass/fail signal.\n   */\n  selector?: (\n    scored: FanoutVoteScored<Task, Output>[],\n  ) => FanoutVoteScored<Task, Output> | undefined\n  /** Stable identifier surfaced in trace events. Default `'fanout-vote'`. */\n  name?: string\n}\n\n/** @experimental */\nexport function createFanoutVoteDriver<Task, Output>(\n  options: CreateFanoutVoteDriverOptions<Task, Output>,\n): Driver<Task, Output, FanoutVoteDecision> {\n  if (!Number.isFinite(options.n) || options.n < 1) {\n    throw new ValidationError(`createFanoutVoteDriver: n must be >= 1, got ${options.n}`)\n  }\n  const selector = options.selector ?? defaultSelector\n  return {\n    name: options.name ?? 'fanout-vote',\n    async plan(task, history) {\n      if (history.length === 0) return Array.from({ length: options.n }, () => task)\n      return []\n    },\n    decide(history) {\n      const scored = scoreIterations(history)\n      return selector(scored) ? 'pick-winner' : 'fail'\n    },\n  }\n}\n\nfunction defaultSelector<Task, Output>(\n  scored: FanoutVoteScored<Task, Output>[],\n): FanoutVoteScored<Task, Output> | undefined {\n  const valid = scored.filter((entry) => entry.verdict?.valid === true)\n  if (valid.length === 0) return undefined\n  return [...valid].sort(\n    (a, b) =>\n      (b.verdict?.score ?? 0) - (a.verdict?.score ?? 0) || a.iterationIndex - b.iterationIndex,\n  )[0]\n}\n\nfunction scoreIterations<Task, Output>(\n  iterations: ReadonlyArray<Iteration<Task, Output>>,\n): FanoutVoteScored<Task, Output>[] {\n  const out: FanoutVoteScored<Task, Output>[] = []\n  for (const iter of iterations) {\n    if (iter.output === undefined || iter.error) continue\n    out.push({\n      task: iter.task,\n      output: iter.output,\n      verdict: iter.verdict,\n      iterationIndex: iter.index,\n      agentRunName: iter.agentRunName,\n    })\n  }\n  return out\n}\n\n/**\n * Test helper: surface the per-iteration scored view a custom `selector`\n * would receive. Exposed so consumers writing a custom selector can test it\n * standalone without driving the full kernel.\n *\n * @experimental\n */\nexport function scoreFanoutVoteIterations<Task, Output>(\n  iterations: ReadonlyArray<Iteration<Task, Output>>,\n): FanoutVoteScored<Task, Output>[] {\n  return scoreIterations(iterations)\n}\n"],"mappings":";;;;;AA0CO,SAAS,uBACd,SAC0C;AAC1C,MAAI,CAAC,OAAO,SAAS,QAAQ,CAAC,KAAK,QAAQ,IAAI,GAAG;AAChD,UAAM,IAAI,gBAAgB,+CAA+C,QAAQ,CAAC,EAAE;AAAA,EACtF;AACA,QAAM,WAAW,QAAQ,YAAY;AACrC,SAAO;AAAA,IACL,MAAM,QAAQ,QAAQ;AAAA,IACtB,MAAM,KAAK,MAAM,SAAS;AACxB,UAAI,QAAQ,WAAW,EAAG,QAAO,MAAM,KAAK,EAAE,QAAQ,QAAQ,EAAE,GAAG,MAAM,IAAI;AAC7E,aAAO,CAAC;AAAA,IACV;AAAA,IACA,OAAO,SAAS;AACd,YAAM,SAAS,gBAAgB,OAAO;AACtC,aAAO,SAAS,MAAM,IAAI,gBAAgB;AAAA,IAC5C;AAAA,EACF;AACF;AAEA,SAAS,gBACP,QAC4C;AAC5C,QAAM,QAAQ,OAAO,OAAO,CAAC,UAAU,MAAM,SAAS,UAAU,IAAI;AACpE,MAAI,MAAM,WAAW,EAAG,QAAO;AAC/B,SAAO,CAAC,GAAG,KAAK,EAAE;AAAA,IAChB,CAAC,GAAG,OACD,EAAE,SAAS,SAAS,MAAM,EAAE,SAAS,SAAS,MAAM,EAAE,iBAAiB,EAAE;AAAA,EAC9E,EAAE,CAAC;AACL;AAEA,SAAS,gBACP,YACkC;AAClC,QAAM,MAAwC,CAAC;AAC/C,aAAW,QAAQ,YAAY;AAC7B,QAAI,KAAK,WAAW,UAAa,KAAK,MAAO;AAC7C,QAAI,KAAK;AAAA,MACP,MAAM,KAAK;AAAA,MACX,QAAQ,KAAK;AAAA,MACb,SAAS,KAAK;AAAA,MACd,gBAAgB,KAAK;AAAA,MACrB,cAAc,KAAK;AAAA,IACrB,CAAC;AAAA,EACH;AACA,SAAO;AACT;AASO,SAAS,0BACd,YACkC;AAClC,SAAO,gBAAgB,UAAU;AACnC;","names":[]}

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { AgentEvalError, KnowledgeReadinessReport, ControlEvalResult, KnowledgeRequirement } from '@tangle-network/agent-eval';
 export { AgentEvalError, AgentEvalErrorCode, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, RunRecord, ValidationError } from '@tangle-network/agent-eval';
-import { A as AgentBackendInput, a as AgentExecutionBackend, b as AgentBackendContext, R as RuntimeStreamEvent, K as KnowledgeReadinessDecision, c as RunAgentTaskOptions, d as AgentTaskRunResult, e as RunAgentTaskStreamOptions, f as AgentTaskSpec, g as AgentRuntimeEvent, h as AgentTaskStatus, i as RuntimeSessionStore, j as RuntimeSession } from './types-ByIhNRFk.js';
-export { k as AgentAdapter, l as AgentKnowledgeProvider, m as AgentRuntimeEventSink, n as AgentTaskContext } from './types-ByIhNRFk.js';
+import { A as AgentBackendInput, a as AgentExecutionBackend, b as AgentBackendContext, R as RuntimeStreamEvent, K as KnowledgeReadinessDecision, c as RunAgentTaskOptions, d as AgentTaskRunResult, e as RunAgentTaskStreamOptions, f as AgentRuntimeEvent, g as AgentTaskStatus, h as RuntimeSessionStore, i as RuntimeSession } from './types-DlyPgeI0.js';
+export { j as AgentAdapter, k as AgentKnowledgeProvider, l as AgentRuntimeEventSink, m as AgentTaskContext, n as AgentTaskSpec } from './types-DlyPgeI0.js';
+export { R as RuntimeRunHandle, a as RuntimeRunPersistenceAdapter, b as RuntimeRunRow, s as startRuntimeRun } from './runtime-run-4pbY3Jq5.js';
 
 /**
  * @stable
@@ -355,140 +356,6 @@ declare function runAgentTask<TState, TAction, TActionResult, TEval extends Cont
 /** @stable */
 declare function runAgentTaskStream<TInput extends AgentBackendInput = AgentBackendInput>(options: RunAgentTaskStreamOptions<TInput>): AsyncIterable<RuntimeStreamEvent>;
 
-/**
- * @stable
- *
- * 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 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-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`.
- */
-
-/** @stable */
-type RuntimeRunStatus = 'running' | 'completed' | 'failed' | 'cancelled';
-/** @stable */
-interface RuntimeRunCost {
-    /** Cumulative input tokens across every observed `llm_call` event. */
-    tokensIn: number;
-    /** Cumulative output tokens across every observed `llm_call` event. */
-    tokensOut: number;
-    /** Sum of `costUsd` from every observed `llm_call` event. */
-    costUsd: number;
-    /** Wall time from `startRuntimeRun()` to `complete()` (or `now()` if not yet completed). */
-    wallMs: number;
-    /** Count of `llm_call` events observed during the run. */
-    llmCalls: number;
-}
-/** @stable */
-interface RuntimeRunCompleteInput {
-    status: Exclude<RuntimeRunStatus, 'running'>;
-    resultSummary?: string;
-    /** Optional explicit cost override; if omitted, the accumulated ledger is used. */
-    cost?: Partial<RuntimeRunCost>;
-    /** Stable error message when `status === 'failed'`. */
-    error?: string;
-    /** Additional adapter-specific fields merged into the persisted row. */
-    metadata?: Record<string, unknown>;
-}
-/** @stable */
-interface RuntimeRunRow {
-    /** Stable runtime-side identifier. Adapters may translate to their own primary key. */
-    id: string;
-    workspaceId: string;
-    sessionId?: string;
-    agentId?: string;
-    domain?: string;
-    taskId: string;
-    scenarioId?: string;
-    status: RuntimeRunStatus;
-    resultSummary?: string;
-    error?: string;
-    cost: RuntimeRunCost;
-    startedAt: string;
-    completedAt?: string;
-    metadata?: Record<string, unknown>;
-}
-/** @stable */
-interface RuntimeRunPersistenceAdapter {
-    /**
-     * Called once when `handle.persist()` runs. Implementations write `row` to
-     * their durable store (D1, postgres, KV) and return whatever the consumer
-     * wants the caller to see (often the storage-side row id). Errors thrown
-     * here propagate out of `persist()` so the caller can decide whether to
-     * retry or log-and-continue.
-     */
-    upsert(row: RuntimeRunRow): Promise<void> | void;
-}
-/** @stable */
-interface RuntimeRunOptions {
-    workspaceId: string;
-    sessionId?: string;
-    agentId?: string;
-    taskSpec: AgentTaskSpec;
-    scenarioId?: string;
-    /** Optional persistence adapter; if omitted, `persist()` is a no-op. */
-    adapter?: RuntimeRunPersistenceAdapter;
-    /** Override the row id; default = `${taskSpec.id}:${random suffix}`. */
-    id?: string;
-    /** Override the clock; default = `Date.now()`. Useful for deterministic tests. */
-    now?: () => number;
-}
-/** @stable */
-interface RuntimeRunHandle {
-    /** Stable id assigned at start. */
-    readonly id: string;
-    readonly workspaceId: string;
-    readonly sessionId: string | undefined;
-    readonly taskSpec: AgentTaskSpec;
-    readonly status: RuntimeRunStatus;
-    /**
-     * Observe a single `RuntimeStreamEvent`. The handle ignores non-cost events
-     * (text deltas, tool calls) silently so consumers can pipe the whole stream
-     * through `handle.observe`. `llm_call` events update the ledger.
-     */
-    observe(event: RuntimeStreamEvent): void;
-    /** Snapshot of the current cost ledger. Safe to call at any time. */
-    cost(): RuntimeRunCost;
-    /**
-     * Transition to a terminal state. Idempotent for the same status; throws
-     * `RuntimeRunStateError` for a different terminal status (state machines
-     * don't time-travel).
-     */
-    complete(input: RuntimeRunCompleteInput): void;
-    /** Build the current row without writing it. Useful for tests + dry runs. */
-    toRow(metadata?: Record<string, unknown>): RuntimeRunRow;
-    /**
-     * Persist the current row via the configured adapter. Must be called after
-     * `complete()`. Idempotent for the same terminal state (the adapter sees
-     * the same row on retry).
-     */
-    persist(metadata?: Record<string, unknown>): Promise<void>;
-}
-/**
- * @stable
- *
- * Construct a runtime-run handle. The returned handle is mutable across its
- * lifetime; consumers should not share it across requests.
- */
-declare function startRuntimeRun(options: RuntimeRunOptions): RuntimeRunHandle;
-
 /**
  * @stable
  *
@@ -637,4 +504,4 @@ declare function readinessServerSentEvent(report: KnowledgeReadinessReport, opti
 /** @stable */
 declare function runtimeStreamServerSentEvent(event: RuntimeStreamEvent, options?: RuntimeTelemetryOptions & ServerSentEventOptions): string;
 
-export { AgentBackendContext, AgentBackendInput, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskSpec, AgentTaskStatus, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, DEFAULT_ROUTER_BASE_URL, InMemoryRuntimeSessionStore, type ModelInfo, type ResolvedChatModel, type RouterEnv, type RunChatTurnInput, type RuntimeEventCollector, type RuntimeRunHandle, type RuntimeRunPersistenceAdapter, type RuntimeRunRow, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, cleanModelId, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, decideKnowledgeReadiness, deriveExecutionId, getModels, handleChatTurn, readinessServerSentEvent, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, startRuntimeRun, validateChatModelId };
+export { AgentBackendContext, AgentBackendInput, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, DEFAULT_ROUTER_BASE_URL, InMemoryRuntimeSessionStore, type ModelInfo, type ResolvedChatModel, type RouterEnv, type RunChatTurnInput, type RuntimeEventCollector, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, cleanModelId, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, decideKnowledgeReadiness, deriveExecutionId, getModels, handleChatTurn, readinessServerSentEvent, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, validateChatModelId };

package/dist/index.js

@@ -1,44 +1,14 @@
-import "./chunk-DGUM43GV.js";
-
-// src/errors.ts
-import { AgentEvalError } from "@tangle-network/agent-eval";
 import {
-  AgentEvalError as AgentEvalError2,
-  CaptureIntegrityError,
+  AgentEvalError,
+  BackendTransportError,
   ConfigError,
   JudgeError,
   NotFoundError,
-  ReplayError,
-  ValidationError,
-  VerificationError
-} from "@tangle-network/agent-eval";
-var SessionMismatchError = class extends AgentEvalError {
-  sessionBackend;
-  requestedBackend;
-  constructor(sessionBackend, requestedBackend, options) {
-    super(
-      "validation",
-      `Cannot resume ${sessionBackend} session with ${requestedBackend} backend`,
-      options
-    );
-    this.sessionBackend = sessionBackend;
-    this.requestedBackend = requestedBackend;
-  }
-};
-var BackendTransportError = class extends AgentEvalError {
-  backend;
-  status;
-  constructor(backend, message, options) {
-    super("config", message, options);
-    this.backend = backend;
-    this.status = options?.status;
-  }
-};
-var RuntimeRunStateError = class extends AgentEvalError {
-  constructor(message, options) {
-    super("validation", message, options);
-  }
-};
+  RuntimeRunStateError,
+  SessionMismatchError,
+  ValidationError
+} from "./chunk-RZAOYKCO.js";
+import "./chunk-DGUM43GV.js";
 
 // src/sessions.ts
 function newRuntimeSession(backend, requestedId, metadata) {
@@ -1540,7 +1510,7 @@ function stripNewlines(value) {
   return value.replace(/[\r\n]/g, " ");
 }
 export {
-  AgentEvalError2 as AgentEvalError,
+  AgentEvalError,
   ConfigError,
   DEFAULT_ROUTER_BASE_URL,
   InMemoryRuntimeSessionStore,