@tangle-network/agent-eval 0.118.2 → 0.119.0

package/dist/campaign/index.d.ts

@@ -299,6 +299,174 @@ interface AgentProfileCell {
     dimensions?: Record<string, AgentProfileDimensionValue>;
 }
 
+type CostChannel = 'agent' | 'judge' | 'verifier' | 'analyst' | 'driver' | (string & {});
+interface CostUsage {
+    inputTokens: number;
+    /** Includes reasoning tokens when the provider bills them as output. */
+    outputTokens: number;
+    /** Reasoning-token subset of outputTokens, when reported. */
+    reasoningTokens?: number;
+    /** Prompt tokens served from a provider cache. */
+    cachedTokens?: number;
+    /** Prompt tokens written into a provider cache. */
+    cacheWriteTokens?: number;
+}
+interface CostCallBase {
+    callId: string;
+    channel: CostChannel;
+    phase: string;
+    actor: string;
+    model: string;
+    maximumCostUsd?: number;
+    tags?: Record<string, string>;
+    timestamp: number;
+}
+interface CostReceipt extends CostCallBase, CostUsage {
+    status: 'settled';
+    costUsd: number;
+    costUnknown: boolean;
+    usageUnknown?: boolean;
+    pricing?: {
+        inputUsdPerThousand: number;
+        outputUsdPerThousand: number;
+    };
+    actualCostUsd?: number;
+    error?: string;
+}
+interface CostReceiptInput extends CostUsage {
+    model: string;
+    actualCostUsd?: number;
+    costUnknown?: boolean;
+    usageUnknown?: boolean;
+}
+type MaximumCharge = {
+    externallyEnforcedMaximumUsd: number;
+} | ({
+    model: string;
+} & CostUsage);
+interface RunPaidCallInput<T> {
+    callId?: string;
+    channel: CostChannel;
+    phase: string;
+    actor: string;
+    /** Used before a provider receipt exists and on failures without one. */
+    model?: string;
+    tags?: Record<string, string>;
+    signal?: AbortSignal;
+    /** Provider-enforced dollar maximum, or maximum priced token usage. Required when capped. */
+    maximumCharge?: MaximumCharge;
+    /** `callId` can be forwarded as the provider's idempotency key. */
+    execute(signal: AbortSignal, callId: string): Promise<T>;
+    receipt(value: T): CostReceiptInput;
+    receiptFromError?(error: Error): CostReceiptInput | undefined;
+}
+type PaidCallResult<T> = {
+    succeeded: true;
+    callId: string;
+    value: T;
+    receipt: CostReceipt;
+} | {
+    succeeded: false;
+    callId?: string;
+    error: Error;
+    receipt?: CostReceipt;
+};
+interface ChannelRollup {
+    channel: CostChannel;
+    calls: number;
+    inputTokens: number;
+    outputTokens: number;
+    reasoningTokens?: number;
+    cachedTokens: number;
+    cacheWriteTokens?: number;
+    costUsd: number;
+    unpricedCalls: number;
+    unknownUsageCalls: number;
+}
+interface CostLedgerSummary {
+    totalCalls: number;
+    pendingCalls: number;
+    unresolvedCalls: number;
+    reservedCostUsd: number;
+    inputTokens: number;
+    outputTokens: number;
+    reasoningTokens?: number;
+    cachedTokens: number;
+    cacheWriteTokens?: number;
+    totalCostUsd: number;
+    byChannel: ChannelRollup[];
+    unpricedModels: string[];
+    fullyPriced: boolean;
+    usageComplete: boolean;
+    accountingComplete: boolean;
+    incompleteReasons: string[];
+}
+interface CostLedgerFilter {
+    channel?: CostChannel;
+    phase?: string;
+    tags?: Record<string, string>;
+}
+interface CostLedgerWaitOptions {
+    /** Maximum time to wait for active provider calls. Default 5 seconds. */
+    timeoutMs?: number;
+}
+/** Append-only storage. `append` must atomically reject stale revisions. */
+interface CostLedgerPersistence {
+    read(): {
+        revision: string;
+        events: string;
+    };
+    append(expectedRevision: string, event: string): string | undefined;
+}
+interface CostLedgerOptions {
+    costCeilingUsd?: number;
+    persistence?: CostLedgerPersistence;
+    /** Import already-settled receipts without admitting new paid work. */
+    receipts?: readonly CostReceipt[];
+}
+/** Run-wide paid-call admission, durable call state, receipts, and summaries. */
+declare class CostLedger {
+    private readonly records;
+    private readonly activeCallIds;
+    private readonly lateCallIds;
+    private readonly idleWaiters;
+    private completedTasks;
+    private revision;
+    private costLimitPersisted;
+    readonly costCeilingUsd?: number;
+    private readonly persistence?;
+    constructor(input?: number | CostLedgerOptions);
+    runPaidCall<T>(input: RunPaidCallInput<T>): Promise<PaidCallResult<T>>;
+    /** Wait until every call started by this ledger has produced a durable outcome. */
+    waitForIdle(options?: CostLedgerWaitOptions): Promise<boolean>;
+    /** Settle a call left pending by a crashed process after reconciling with the provider. */
+    reconcile(callId: string, observed: CostReceiptInput, options?: {
+        error?: string;
+    }): CostReceipt;
+    list(filter?: CostLedgerFilter): CostReceipt[];
+    summary(filter?: CostLedgerFilter): CostLedgerSummary;
+    markCompleted(count?: number): void;
+    costPerCompletedTask(): number | null;
+    private execute;
+    private captureLateOutcome;
+    private releaseActiveCall;
+    private commitOutcome;
+    private captureFailure;
+    private commitReceipt;
+    private resolveMaximum;
+    private hasIncompleteSettledCall;
+    private appendRecord;
+    private ensureCostLimitPersisted;
+    private appendEvent;
+}
+/** Public callback surface for a shared cost ledger.
+ *
+ * Declaration bundles may expose this type through multiple package subpaths.
+ * Keeping callback contracts structural lets those subpaths compose while the
+ * concrete {@link CostLedger} retains its private durable state.
+ */
+type CostLedgerHandle = Pick<CostLedger, Exclude<keyof CostLedger, 'waitForIdle'>> & Partial<Pick<CostLedger, 'waitForIdle'>>;
+
 type FailureClass = 'success' | 'reasoning_error' | 'tool_selection_error' | 'tool_argument_error' | 'tool_recovery_failure' | 'hallucination' | 'instruction_following' | 'safety_refusal_miss' | 'policy_violation' | 'budget_exceeded' | 'format_drift' | 'permission_escalation' | 'pii_leak' | 'cost_overrun' | 'timeout' | 'sandbox_failure' | 'missing_user_data' | 'missing_domain_data' | 'missing_codebase_context' | 'missing_runtime_context' | 'missing_credentials' | 'missing_integration_connection' | 'missing_integration_scope' | 'integration_approval_required' | 'integration_auth_expired' | 'integration_provider_failure' | 'bad_integration_manifest' | 'unsafe_integration_write_denied' | 'stale_external_data' | 'bad_retrieval' | 'insufficient_evidence' | 'contradictory_evidence' | 'ambiguous_user_intent' | 'knowledge_readiness_blocked' | 'unknown';
 
 /**
@@ -746,156 +914,6 @@ interface TraceAnalysisStore {
     }): Promise<SearchSpanResult>;
 }
 
-type CostChannel = 'agent' | 'judge' | 'verifier' | 'analyst' | 'driver' | (string & {});
-interface CostUsage {
-    inputTokens: number;
-    outputTokens: number;
-    cachedTokens?: number;
-}
-interface CostCallBase {
-    callId: string;
-    channel: CostChannel;
-    phase: string;
-    actor: string;
-    model: string;
-    maximumCostUsd?: number;
-    tags?: Record<string, string>;
-    timestamp: number;
-}
-interface CostReceipt extends CostCallBase, CostUsage {
-    status: 'settled';
-    costUsd: number;
-    costUnknown: boolean;
-    usageUnknown?: boolean;
-    pricing?: {
-        inputUsdPerThousand: number;
-        outputUsdPerThousand: number;
-    };
-    actualCostUsd?: number;
-    error?: string;
-}
-interface CostReceiptInput extends CostUsage {
-    model: string;
-    actualCostUsd?: number;
-    costUnknown?: boolean;
-    usageUnknown?: boolean;
-}
-type MaximumCharge = {
-    externallyEnforcedMaximumUsd: number;
-} | ({
-    model: string;
-} & CostUsage);
-interface RunPaidCallInput<T> {
-    callId?: string;
-    channel: CostChannel;
-    phase: string;
-    actor: string;
-    /** Used before a provider receipt exists and on failures without one. */
-    model?: string;
-    tags?: Record<string, string>;
-    signal?: AbortSignal;
-    /** Provider-enforced dollar maximum, or maximum priced token usage. Required when capped. */
-    maximumCharge?: MaximumCharge;
-    /** `callId` can be forwarded as the provider's idempotency key. */
-    execute(signal: AbortSignal, callId: string): Promise<T>;
-    receipt(value: T): CostReceiptInput;
-    receiptFromError?(error: Error): CostReceiptInput | undefined;
-}
-type PaidCallResult<T> = {
-    succeeded: true;
-    callId: string;
-    value: T;
-    receipt: CostReceipt;
-} | {
-    succeeded: false;
-    callId?: string;
-    error: Error;
-    receipt?: CostReceipt;
-};
-interface ChannelRollup {
-    channel: CostChannel;
-    calls: number;
-    inputTokens: number;
-    outputTokens: number;
-    cachedTokens: number;
-    costUsd: number;
-    unpricedCalls: number;
-    unknownUsageCalls: number;
-}
-interface CostLedgerSummary {
-    totalCalls: number;
-    pendingCalls: number;
-    unresolvedCalls: number;
-    reservedCostUsd: number;
-    inputTokens: number;
-    outputTokens: number;
-    cachedTokens: number;
-    totalCostUsd: number;
-    byChannel: ChannelRollup[];
-    unpricedModels: string[];
-    fullyPriced: boolean;
-    usageComplete: boolean;
-    accountingComplete: boolean;
-    incompleteReasons: string[];
-}
-interface CostLedgerFilter {
-    channel?: CostChannel;
-    phase?: string;
-    tags?: Record<string, string>;
-}
-/** Append-only storage. `append` must atomically reject stale revisions. */
-interface CostLedgerPersistence {
-    read(): {
-        revision: string;
-        events: string;
-    };
-    append(expectedRevision: string, event: string): string | undefined;
-}
-interface CostLedgerOptions {
-    costCeilingUsd?: number;
-    persistence?: CostLedgerPersistence;
-    /** Import already-settled receipts without admitting new paid work. */
-    receipts?: readonly CostReceipt[];
-}
-/** Run-wide paid-call admission, durable call state, receipts, and summaries. */
-declare class CostLedger {
-    private readonly records;
-    private readonly activeCallIds;
-    private readonly lateCallIds;
-    private completedTasks;
-    private revision;
-    private costLimitPersisted;
-    readonly costCeilingUsd?: number;
-    private readonly persistence?;
-    constructor(input?: number | CostLedgerOptions);
-    runPaidCall<T>(input: RunPaidCallInput<T>): Promise<PaidCallResult<T>>;
-    /** Settle a call left pending by a crashed process after reconciling with the provider. */
-    reconcile(callId: string, observed: CostReceiptInput, options?: {
-        error?: string;
-    }): CostReceipt;
-    list(filter?: CostLedgerFilter): CostReceipt[];
-    summary(filter?: CostLedgerFilter): CostLedgerSummary;
-    markCompleted(count?: number): void;
-    costPerCompletedTask(): number | null;
-    private execute;
-    private captureLateOutcome;
-    private commitOutcome;
-    private captureFailure;
-    private commitReceipt;
-    private resolveMaximum;
-    private hasIncompleteSettledCall;
-    private appendRecord;
-    private ensureCostLimitPersisted;
-    private appendEvent;
-}
-/** Public callback surface for a shared cost ledger.
- *
- * Declaration bundles may expose this type through multiple package subpaths.
- * Keeping callback contracts structural lets those subpaths compose while the
- * concrete {@link CostLedger} retains its private durable state.
- */
-type CostLedgerHandle = Pick<CostLedger, keyof CostLedger>;
-
 /**
  * RawProviderSink — first-class persistence for the actual HTTP-level
  * request/response bodies of every LLM provider call.
@@ -1270,6 +1288,10 @@ interface AnalystContext {
     deadlineMs?: number;
     /** Per-analyst USD budget. Analysts MAY check before issuing LLM calls. */
     budgetUsd?: number;
+    /** Shared paid-call account when the analyst runs inside a larger campaign. */
+    costLedger?: CostLedgerHandle;
+    /** Attribution phase used when writing to the shared paid-call account. */
+    costPhase?: string;
     /**
      * Shared chat client. Analysts that call an LLM go through this so
      * the operator picks transport (sandbox-sdk | router | cli-bridge |
@@ -1287,6 +1309,18 @@ interface AnalystContext {
      * filter. Empty / absent means no cross-run context.
      */
     priorFindings?: ReadonlyArray<AnalystFinding>;
+    /**
+     * Findings emitted by analysts that completed earlier in this registry run.
+     * This is separate from `priorFindings`: upstream findings are dependency
+     * context for the current pass, while prior findings are cross-run memory.
+     * The registry populates this only when `RegistryRunOpts.chainFindings` is on.
+     */
+    upstreamFindings?: ReadonlyArray<AnalystFinding>;
+    /**
+     * Report metered work independently of findings. This keeps an empty finding
+     * set from erasing token/cost telemetry. Multiple receipts are accumulated.
+     */
+    recordUsage?: (receipt: AnalystUsageReceipt) => void;
     /** Free-form runtime tags (env, host, op). Findings can echo these into metadata. */
     tags?: Record<string, string>;
     /** Logger callback — analysts SHOULD prefer this over console.* for testability. */
@@ -1294,6 +1328,17 @@ interface AnalystContext {
     /** Optional abort signal. Analysts SHOULD pass it through to LLM calls. */
     signal?: AbortSignal;
 }
+/** Metered work performed by one analyst call. */
+interface AnalystUsageReceipt {
+    /** Number of model-usage records observed at the provider boundary. */
+    calls: number | null;
+    /** Null when the provider did not return token accounting. */
+    tokens: RunTokenUsage | null;
+    /** Observed, estimated, or explicitly uncaptured dollar cost. */
+    cost: RunCostProvenance;
+    /** Known lower bound when one or more calls have uncaptured cost. */
+    knownCostUsd?: number;
+}
 
 type PolicyEditSchemaVersion = 'policy-edit/v1';
 declare const POLICY_EDIT_AXES: readonly ["carrier", "representation", "budget", "sampling", "output_contract", "tool_contract", "routing", "memory", "agent_profile", "deployment_target"];
@@ -5819,7 +5864,10 @@ declare function assertPolicyEditAuthorContextBudget(value: unknown, maxChars: n
  * validation surface independent of which Ax version is installed.
  */
 
+/** Original public schema retained for stored rows and callback contracts. */
 declare const RawAnalystFindingSchema: z.ZodObject<{
+    evidence_uri: z.ZodString;
+    evidence_excerpt: z.ZodOptional<z.ZodString>;
     severity: z.ZodEnum<{
         low: "low";
         high: "high";
@@ -5829,13 +5877,36 @@ declare const RawAnalystFindingSchema: z.ZodObject<{
     }>;
     claim: z.ZodString;
     subject: z.ZodOptional<z.ZodString>;
-    evidence_uri: z.ZodString;
-    evidence_excerpt: z.ZodOptional<z.ZodString>;
     confidence: z.ZodNumber;
     rationale: z.ZodOptional<z.ZodString>;
     recommended_action: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 type RawAnalystFinding = z.infer<typeof RawAnalystFindingSchema>;
+/**
+ * Canonical plural-evidence contract. The preprocessor accepts the original
+ * `evidence_uri` / `evidence_excerpt` pair and normalizes it into one evidence
+ * item so persisted rows and older model fixtures remain readable. New output
+ * always receives the plural shape.
+ */
+declare const CanonicalRawAnalystFindingSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    evidence: z.ZodArray<z.ZodObject<{
+        uri: z.ZodString;
+        excerpt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    severity: z.ZodEnum<{
+        low: "low";
+        high: "high";
+        critical: "critical";
+        medium: "medium";
+        info: "info";
+    }>;
+    claim: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodNumber;
+    rationale: z.ZodOptional<z.ZodString>;
+    recommended_action: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+type CanonicalRawAnalystFinding = z.infer<typeof CanonicalRawAnalystFindingSchema>;
 
 /**
  * Analyst-kind factory — the typed way to define trace analysts.
@@ -5843,9 +5914,9 @@ type RawAnalystFinding = z.infer<typeof RawAnalystFindingSchema>;
  * A "kind" is a specialized analyst whose actor prompt, tool subset,
  * and Ax recursion config target one failure-mode lens (failure-mode
  * classification, knowledge gap discovery, knowledge poisoning, recursive
- * self-improvement, ...). Kinds emit findings in the typed `RawAnalystFinding`
- * shape via a JSON-array Ax output; the factory validates each row with
- * Zod and lifts it into `AnalystFinding[]` with no shape guessing.
+ * self-improvement, ...). Kinds emit findings in the typed
+ * `CanonicalRawAnalystFinding` shape via a JSON-array Ax output; the factory
+ * validates each row with Zod and lifts it into `AnalystFinding[]`.
  *
  * Composition rules:
  *   - Each kind owns its actor description. No generic "answer this
@@ -5891,10 +5962,14 @@ interface TraceAnalystKindSpec {
     maxTurns?: number;
     /** Runtime char cap. Default 6000. */
     maxRuntimeChars?: number;
+    /** Maximum output tokens for every actor, responder, and recursive model call. Default 4096. */
+    maxOutputTokens?: number;
     /** Cost classification surfaced in `registry.list()` and budget enforcement. */
     cost: AnalystCost;
     /** Per-finding-row hook — kinds may reject / rewrite before lifting. */
     postProcess?: (row: RawAnalystFinding, ctx: AnalystContext) => RawAnalystFinding | null;
+    /** Minimum citations per finding. Default 1; rows below it are rejected. */
+    minimumEvidenceCitations?: number;
     /** Optional optimizer hook — populated when a kind wants to fit its prompt against labeled examples. */
     goldens?: TraceAnalystGolden[];
 }
@@ -5906,7 +5981,7 @@ interface TraceAnalystKindSpec {
  */
 interface TraceAnalystGolden {
     question: string;
-    expected: ReadonlyArray<Omit<RawAnalystFinding, 'confidence'>>;
+    expected: ReadonlyArray<Omit<CanonicalRawAnalystFinding, 'confidence'>>;
 }
 
 /**

package/dist/campaign/index.js

@@ -66,7 +66,7 @@ import {
   userStoryScoreboard,
   validateSearchLedgerEvent,
   verifyCodeSurface
-} from "../chunk-GCT3DQWU.js";
+} from "../chunk-F6YUH3L4.js";
 import {
   assertCodeSurfaceIdentity,
   buildEvidenceVector,
@@ -103,7 +103,7 @@ import {
   runOptimization,
   surfaceContentHash,
   surfaceHash
-} from "../chunk-I42AAGHL.js";
+} from "../chunk-RLCJQ6VZ.js";
 import {
   SearchLedgerConflictError,
   SearchLedgerError,
@@ -115,27 +115,27 @@ import {
   resolveRunDir,
   runCampaign,
   tangleTracesRoot
-} from "../chunk-EGNRE7VA.js";
+} from "../chunk-PAHNGS65.js";
 import "../chunk-3YYRZDON.js";
 import {
   POLICY_EDIT_CANDIDATE_RECORD_SCHEMA,
   validatePolicyEditCandidateRecord
-} from "../chunk-DZBCDDIE.js";
+} from "../chunk-7A4LIMMY.js";
 import "../chunk-ARU2PZFM.js";
 import "../chunk-NJC7U437.js";
 import "../chunk-PJQFMIOX.js";
-import "../chunk-MLHRFWQK.js";
+import "../chunk-JHOJHHU7.js";
 import "../chunk-VI2UW6B6.js";
-import "../chunk-63KG3ASG.js";
+import "../chunk-FIUFRXP3.js";
 import "../chunk-GGE4NNQT.js";
-import "../chunk-BUBU3YHT.js";
+import "../chunk-6QIM2EAP.js";
 import "../chunk-PC4UYEBM.js";
 import "../chunk-S3UZOQ5Y.js";
 import "../chunk-MA6HLL3S.js";
 import "../chunk-XJYR7XFV.js";
 import "../chunk-VSMTAMNK.js";
 import "../chunk-ONWEPEDO.js";
-import "../chunk-NW4AQBXD.js";
+import "../chunk-K4DBDHLK.js";
 import "../chunk-PZ5AY32C.js";
 export {
   DEFAULT_POLICY_EDIT_HISTORY_LIMITS,

package/dist/{chunk-JTMFT5QZ.js → chunk-4I2E3LLO.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-NJC7U437.js";
 import {
   CostLedger
-} from "./chunk-MLHRFWQK.js";
+} from "./chunk-JHOJHHU7.js";
 
 // src/wire/schemas.ts
 import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
@@ -1027,4 +1027,4 @@ export {
   startServer,
   startServerAsync
 };
-//# sourceMappingURL=chunk-JTMFT5QZ.js.map
+//# sourceMappingURL=chunk-4I2E3LLO.js.map

package/dist/{chunk-BUBU3YHT.js → chunk-6QIM2EAP.js}

@@ -3,26 +3,16 @@ import {
 } from "./chunk-ONWEPEDO.js";
 import {
   INPUT_VALUE,
-  LLM_CACHED_TOKENS,
-  LLM_CACHE_WRITE_TOKENS,
-  LLM_COST_USD,
-  LLM_INPUT_TOKENS,
-  LLM_MODEL_NAME,
-  LLM_OUTPUT_TOKENS,
-  LLM_REASONING_TOKENS,
-  OPENINFERENCE_SPAN_KIND,
+  LLM_MODEL_ATTR_KEYS,
   OUTPUT_VALUE,
+  SPAN_KIND_ATTR_KEYS,
   TOOL_ARGS_CAPTURED,
   TOOL_LATENCY_MS,
-  TOOL_NAME
-} from "./chunk-NW4AQBXD.js";
+  TOOL_NAME,
+  TOOL_NAME_ATTR_KEYS
+} from "./chunk-K4DBDHLK.js";
 
 // src/trace/otlp-attributes.ts
-import {
-  GEN_AI_INPUT_TOKEN_KEYS,
-  GEN_AI_MODEL_KEYS,
-  GEN_AI_OUTPUT_TOKEN_KEYS
-} from "@tangle-network/agent-core/telemetry";
 var TOOL_SPAN_ATTRIBUTE_KEYS = [
   TOOL_NAME,
   TOOL_ARGS_CAPTURED,
@@ -30,79 +20,6 @@ var TOOL_SPAN_ATTRIBUTE_KEYS = [
   INPUT_VALUE,
   OUTPUT_VALUE
 ];
-var SPAN_KIND_ATTR_KEYS = [OPENINFERENCE_SPAN_KIND, "inference.observation_kind"];
-var LLM_MODEL_ATTR_KEYS = [
-  LLM_MODEL_NAME,
-  "inference.llm.model_name",
-  "llm.model",
-  ...GEN_AI_MODEL_KEYS,
-  "tangle.model"
-];
-var LLM_INPUT_TOKEN_ATTR_KEYS = [
-  LLM_INPUT_TOKENS,
-  "inference.llm.input_tokens",
-  "llm.input_tokens",
-  ...GEN_AI_INPUT_TOKEN_KEYS,
-  "tangle.tokens.in",
-  "tokens.in"
-];
-var LLM_OUTPUT_TOKEN_ATTR_KEYS = [
-  LLM_OUTPUT_TOKENS,
-  "inference.llm.output_tokens",
-  "llm.output_tokens",
-  ...GEN_AI_OUTPUT_TOKEN_KEYS,
-  "tangle.tokens.out",
-  "tokens.out"
-];
-var LLM_REASONING_TOKEN_ATTR_KEYS = [
-  LLM_REASONING_TOKENS,
-  "inference.llm.reasoning_tokens",
-  "llm.reasoning_tokens",
-  "gen_ai.usage.reasoning_tokens",
-  "gen_ai.usage.reasoning_output_tokens",
-  "reasoning_tokens",
-  "reasoning_output_tokens",
-  "tangle.tokens.reasoning",
-  "gen_ai.usage.output_tokens_details.reasoning_tokens",
-  "gen_ai.usage.completion_tokens_details.reasoning_tokens"
-];
-var LLM_CACHED_TOKEN_ATTR_KEYS = [
-  LLM_CACHED_TOKENS,
-  "inference.llm.cached_tokens",
-  "llm.cached_tokens",
-  "gen_ai.usage.cached_tokens",
-  "gen_ai.usage.prompt_tokens_details.cached_tokens",
-  "gen_ai.usage.input_tokens_details.cached_tokens",
-  "gen_ai.usage.cache_read_tokens",
-  "gen_ai.usage.cache_read_input_tokens",
-  "cache_read_tokens",
-  "cache_read_input_tokens",
-  "input_cache_read",
-  "tangle.tokens.cached"
-];
-var LLM_CACHE_WRITE_TOKEN_ATTR_KEYS = [
-  LLM_CACHE_WRITE_TOKENS,
-  "inference.llm.cache_write_tokens",
-  "llm.cache_write_tokens",
-  "gen_ai.usage.cache_creation_tokens",
-  "gen_ai.usage.cache_creation_input_tokens",
-  "cache_creation_tokens",
-  "cache_creation_input_tokens",
-  "input_cache_creation",
-  "tangle.tokens.cache_write"
-];
-var LLM_COST_ATTR_KEYS = [
-  LLM_COST_USD,
-  "inference.llm.cost.total",
-  "llm.cost.total",
-  "gen_ai.usage.cost",
-  "gen_ai.usage.cost_usd",
-  "tangle.cost.usd",
-  "cost.usd",
-  "cost"
-];
-var RUN_COST_ATTR_KEYS = ["tangle.cost.usd", "cost.usd"];
-var TOOL_NAME_ATTR_KEYS = [TOOL_NAME, "inference.tool.name"];
 function toolSpanOtlpAttributes(span) {
   const argsCaptured = span.argsCaptured !== false;
   const attributes = {
@@ -239,21 +156,6 @@ function stringField(raw, key) {
 function asString(v) {
   return typeof v === "string" && v.length > 0 ? v : null;
 }
-function asNumber(v) {
-  if (typeof v === "number") return Number.isFinite(v) ? v : null;
-  if (typeof v === "string" && v.length > 0) {
-    const n = Number(v);
-    return Number.isFinite(n) ? n : null;
-  }
-  return null;
-}
-function firstNumberAttr(attrs, keys) {
-  for (const k of keys) {
-    const n = asNumber(attrs[k]);
-    if (n !== null) return n;
-  }
-  return null;
-}
 function firstStringAttr(attrs, keys) {
   for (const k of keys) {
     const s = asString(attrs[k]);
@@ -1084,16 +986,6 @@ function assertStringArray(v, label) {
 }
 
 export {
-  SPAN_KIND_ATTR_KEYS,
-  LLM_MODEL_ATTR_KEYS,
-  LLM_INPUT_TOKEN_ATTR_KEYS,
-  LLM_OUTPUT_TOKEN_ATTR_KEYS,
-  LLM_REASONING_TOKEN_ATTR_KEYS,
-  LLM_CACHED_TOKEN_ATTR_KEYS,
-  LLM_CACHE_WRITE_TOKEN_ATTR_KEYS,
-  LLM_COST_ATTR_KEYS,
-  RUN_COST_ATTR_KEYS,
-  TOOL_NAME_ATTR_KEYS,
   applyToolSpanOtlpAttributes,
   traceSpanKindToOpenInferenceKind,
   projectOtlpFlatLine,
@@ -1102,8 +994,6 @@ export {
   extractOtlpAttributes,
   stringField,
   asString,
-  asNumber,
-  firstNumberAttr,
   firstStringAttr,
   spanEpochMillis,
   compareSpanTime,
@@ -1116,4 +1006,4 @@ export {
   buildTraceAnalystTools,
   traceAnalystFunctionGroup
 };
-//# sourceMappingURL=chunk-BUBU3YHT.js.map
+//# sourceMappingURL=chunk-6QIM2EAP.js.map