@launchdarkly/server-sdk-ai 0.16.8 → 0.17.1

package/dist/index.d.cts

@@ -49,26 +49,23 @@ interface StructuredResponse {
     metrics: LDAIMetrics;
 }
 /**
- * Score and reasoning for a single evaluation metric.
+ * Result from a judge evaluation containing score, reasoning, and metadata.
  */
-interface EvalScore {
-    /** Score between 0.0 and 1.0 indicating the evaluation result for this metric */
-    score: number;
-    /** Reasoning behind the provided score for this metric */
-    reasoning: string;
-}
-/**
- * Response from a judge evaluation containing scores and reasoning for multiple metrics.
- */
-interface JudgeResponse {
-    /** The key of the judge configuration that was used to generate this response */
+interface LDJudgeResult {
+    /** The key of the judge configuration that was used to generate this result */
     judgeConfigKey?: string;
-    /** Dictionary where keys are metric names and values contain score and reasoning */
-    evals: Record<string, EvalScore>;
     /** Whether the evaluation completed successfully */
     success: boolean;
     /** Error message if evaluation failed */
-    error?: string;
+    errorMessage?: string;
+    /** Whether this evaluation was sampled (i.e. actually run). False when skipped by sampling. */
+    sampled: boolean;
+    /** The metric key for this evaluation */
+    metricKey?: string;
+    /** Score between 0.0 and 1.0 indicating the evaluation result */
+    score?: number;
+    /** Reasoning behind the provided score */
+    reasoning?: string;
 }
 
 declare function createBedrockTokenUsage(data: {
@@ -140,15 +137,28 @@ interface LDAIConfigTracker {
      * Get the data for tracking.
      */
     getTrackData(): {
-        variationKey: string;
+        runId: string;
         configKey: string;
+        variationKey: string;
         version: number;
         modelName: string;
         providerName: string;
+        graphKey?: string;
     };
+    /**
+     * A URL-safe Base64-encoded token that encodes the tracker's runId, configKey,
+     * variationKey, and version. Pass this to AIClient.createTracker() to reconstruct
+     * the tracker across process boundaries (e.g. for associating deferred feedback
+     * with the original invocation).
+     */
+    readonly resumptionToken: string;
     /**
      * Track the duration of generation.
      *
+     * At-most-once per execution: subsequent calls on the same tracker are dropped
+     * with a warning. Use createTracker() on the config result to obtain a fresh
+     * tracker for a new execution.
+     *
      * Ideally this would not include overhead time such as network communication.
      *
      * @param durationMs The duration in milliseconds.
@@ -157,20 +167,32 @@ interface LDAIConfigTracker {
     /**
      * Track information about token usage.
      *
+     * At-most-once per execution: subsequent calls on the same tracker are dropped
+     * with a warning.
+     *
      * @param tokens Token usage information.
      */
     trackTokens(tokens: LDTokenUsage): void;
     /**
      * Generation was successful.
+     *
+     * At-most-once per execution: subsequent calls (including trackError) on the
+     * same tracker are dropped with a warning.
      */
     trackSuccess(): void;
     /**
      * An error was encountered during generation.
+     *
+     * At-most-once per execution: subsequent calls (including trackSuccess) on the
+     * same tracker are dropped with a warning.
      */
     trackError(): void;
     /**
      * Track sentiment about the generation.
      *
+     * At-most-once per execution: subsequent calls on the same tracker are dropped
+     * with a warning.
+     *
      * @param feedback Feedback about the generation.
      */
     trackFeedback(feedback: {
@@ -179,21 +201,32 @@ interface LDAIConfigTracker {
     /**
      * Track the time to first token for this generation.
      *
+     * At-most-once per execution: subsequent calls on the same tracker are dropped
+     * with a warning.
+     *
      * @param timeToFirstTokenMs The duration in milliseconds.
      */
     trackTimeToFirstToken(timeToFirstTokenMs: number): void;
     /**
-     * Track evaluation scores for multiple metrics.
+     * Track a judge evaluation result.
+     *
+     * No event is emitted when the result was not sampled (result.sampled is false).
+     *
+     * @param result Judge result containing score, reasoning, and metadata
+     */
+    trackJudgeResult(result: LDJudgeResult): void;
+    /**
+     * Track a single tool invocation.
      *
-     * @param scores Record mapping metric keys to their evaluation scores
+     * @param toolKey The identifier of the tool that was invoked.
      */
-    trackEvalScores(scores: Record<string, EvalScore>): void;
+    trackToolCall(toolKey: string): void;
     /**
-     * Track a judge response containing evaluation scores and judge configuration key.
+     * Track multiple tool invocations.
      *
-     * @param response Judge response containing evaluation scores and judge configuration key
+     * @param toolKeys The identifiers of the tools that were invoked.
      */
-    trackJudgeResponse(response: JudgeResponse): void;
+    trackToolCalls(toolKeys: string[]): void;
     /**
      * Track the duration of execution of the provided function.
      *
@@ -396,10 +429,11 @@ interface LDAIConfig extends Omit<LDAIConfigDefault, 'enabled'> {
      */
     enabled: boolean;
     /**
-     * A tracker which can be used to generate analytics.
-     * Undefined for disabled configs.
+     * Creates a new tracker for this AI Config invocation. Each call returns a
+     * new tracker with a fresh runId. Use createTracker() at the start of each
+     * execution to obtain a tracker, then use it to record metrics for that run.
      */
-    tracker?: LDAIConfigTracker;
+    createTracker?: () => LDAIConfigTracker;
 }
 /**
  * Default Agent-specific AI Config with instructions.
@@ -543,7 +577,7 @@ interface ChatResponse {
      * Promise that resolves to judge evaluation results.
      * Only present when judges are configured for evaluation.
      */
-    evaluations?: Promise<Array<JudgeResponse | undefined>>;
+    evaluations?: Promise<LDJudgeResult[]>;
 }
 
 /**
@@ -602,11 +636,9 @@ declare abstract class AIProvider {
  */
 declare class Judge {
     private readonly _aiConfig;
-    private readonly _aiConfigTracker;
     private readonly _aiProvider;
     private readonly _logger?;
-    private readonly _evaluationResponseStructure;
-    constructor(_aiConfig: LDAIJudgeConfig, _aiConfigTracker: LDAIConfigTracker, _aiProvider: AIProvider, logger?: LDLogger$1);
+    constructor(_aiConfig: LDAIJudgeConfig, _aiProvider: AIProvider, logger?: LDLogger$1);
     /**
      * Gets the evaluation metric key, prioritizing evaluationMetricKey over evaluationMetricKeys.
      * Falls back to the first valid (non-empty, non-whitespace) value in evaluationMetricKeys if evaluationMetricKey is not provided.
@@ -620,26 +652,22 @@ declare class Judge {
      * @param input The input prompt or question that was provided to the AI
      * @param output The AI-generated response to be evaluated
      * @param samplingRate Sampling rate (0-1) to determine if evaluation should be processed (defaults to 1)
-     * @returns Promise that resolves to evaluation results or undefined if not sampled
+     * @returns Promise that resolves to evaluation results
      */
-    evaluate(input: string, output: string, samplingRate?: number): Promise<JudgeResponse | undefined>;
+    evaluate(input: string, output: string, samplingRate?: number): Promise<LDJudgeResult>;
     /**
      * Evaluates an AI response from chat messages and response.
      *
      * @param messages Array of messages representing the conversation history
      * @param response The AI response to be evaluated
      * @param samplingRatio Sampling ratio (0-1) to determine if evaluation should be processed (defaults to 1)
-     * @returns Promise that resolves to evaluation results or undefined if not sampled
+     * @returns Promise that resolves to evaluation results
      */
-    evaluateMessages(messages: LDMessage[], response: ChatResponse, samplingRatio?: number): Promise<JudgeResponse | undefined>;
+    evaluateMessages(messages: LDMessage[], response: ChatResponse, samplingRatio?: number): Promise<LDJudgeResult>;
     /**
      * Returns the AI Config used by this judge.
      */
     getAIConfig(): LDAIJudgeConfig;
-    /**
-     * Returns the tracker associated with this judge.
-     */
-    getTracker(): LDAIConfigTracker;
     /**
      * Returns the AI provider used by this judge.
      */
@@ -653,7 +681,8 @@ declare class Judge {
      */
     private _interpolateMessage;
     /**
-     * Parses the structured evaluation response from the AI provider.
+     * Parses the structured evaluation response. Expects top-level {score, reasoning}.
+     * Returns score and reasoning, or undefined if parsing fails.
      */
     private _parseEvaluationResponse;
 }
@@ -666,12 +695,11 @@ declare class Judge {
  */
 declare class TrackedChat {
     protected readonly aiConfig: LDAICompletionConfig;
-    protected readonly tracker: LDAIConfigTracker;
     protected readonly provider: AIProvider;
     protected readonly judges: Record<string, Judge>;
     private readonly _logger?;
     protected messages: LDMessage[];
-    constructor(aiConfig: LDAICompletionConfig, tracker: LDAIConfigTracker, provider: AIProvider, judges?: Record<string, Judge>, _logger?: LDLogger$1 | undefined);
+    constructor(aiConfig: LDAICompletionConfig, provider: AIProvider, judges?: Record<string, Judge>, _logger?: LDLogger$1 | undefined);
     /**
      * Invoke the chat model with a prompt string.
      * This method handles conversation management and tracking, delegating to the provider's invokeModel method.
@@ -690,10 +718,6 @@ declare class TrackedChat {
      * Get the underlying AI configuration used to initialize this TrackedChat.
      */
     getConfig(): LDAICompletionConfig;
-    /**
-     * Get the underlying AI configuration tracker used to initialize this TrackedChat.
-     */
-    getTracker(): LDAIConfigTracker;
     /**
      * Get the underlying AI provider instance.
      * This provides direct access to the provider for advanced use cases.
@@ -724,6 +748,322 @@ declare class TrackedChat {
     getMessages(includeConfigMessages?: boolean): LDMessage[];
 }
 
+/**
+ * Represents a directed edge in an agent graph, connecting a source node to a target node.
+ */
+interface LDGraphEdge {
+    /**
+     * The key of the target AIAgentConfig node.
+     */
+    key: string;
+    /**
+     * Optional handoff options that customize how data flows between nodes.
+     */
+    handoff?: Record<string, unknown>;
+}
+/**
+ * Raw flag value for an agent graph configuration as returned by LaunchDarkly.
+ * This represents the data structure delivered by LaunchDarkly for graph configurations.
+ */
+interface LDAgentGraphFlagValue {
+    _ldMeta?: {
+        variationKey?: string;
+        version?: number;
+        enabled?: boolean;
+    };
+    /**
+     * The key of the root AIAgentConfig in the graph.
+     */
+    root: string;
+    /**
+     * Object mapping source agent config keys to arrays of target edges.
+     */
+    edges?: Record<string, LDGraphEdge[]>;
+}
+/**
+ * Accumulated graph-level metrics collected by an LDGraphTracker.
+ */
+interface LDGraphMetricSummary {
+    /**
+     * Whether the graph invocation succeeded. Absent if not yet tracked.
+     */
+    success?: boolean;
+    /**
+     * Total graph execution duration in milliseconds. Absent if not yet tracked.
+     */
+    durationMs?: number;
+    /**
+     * Aggregate token usage across the entire graph invocation. Absent if not yet tracked.
+     */
+    tokens?: LDTokenUsage;
+    /**
+     * Execution path through the graph as an array of config keys. Absent if not yet tracked.
+     */
+    path?: string[];
+}
+/**
+ * Tracking metadata returned by {@link LDGraphTracker.getTrackData}.
+ */
+interface LDGraphTrackData {
+    /**
+     * UUID v4 uniquely identifying this tracker and all events it emits.
+     */
+    runId: string;
+    /**
+     * The graph configuration key.
+     */
+    graphKey: string;
+    /**
+     * The variation key. Absent when a default config was used rather than a real flag evaluation.
+     */
+    variationKey?: string;
+    /**
+     * The version of the flag variation.
+     */
+    version: number;
+}
+
+/**
+ * Tracks graph-level and edge-level metrics for an agent graph invocation.
+ *
+ * Graph-level methods enforce at-most-once semantics: calling the same method
+ * twice on a tracker instance drops the second call and emits a warning.
+ * Edge-level methods (trackRedirect, trackHandoffSuccess, trackHandoffFailure)
+ * are multi-fire and are not subject to this constraint.
+ *
+ * @example
+ * ```typescript
+ * const tracker = graphDefinition.createTracker();
+ * try {
+ *   // ... execute graph ...
+ *   tracker.trackInvocationSuccess();
+ *   tracker.trackDuration(durationMs);
+ * } catch {
+ *   tracker.trackInvocationFailure();
+ * }
+ * ```
+ */
+interface LDGraphTracker {
+    /**
+     * Returns tracking metadata to be included in every LDClient.track call.
+     */
+    getTrackData(): LDGraphTrackData;
+    /**
+     * Returns a snapshot of all graph-level metrics tracked so far.
+     */
+    getSummary(): LDGraphMetricSummary;
+    /**
+     * A URL-safe Base64-encoded (RFC 4648, no padding) token encoding the tracker's
+     * identity. Pass this token to {@link LDGraphTrackerImpl.fromResumptionToken} to
+     * reconstruct the tracker across process boundaries, preserving the original runId.
+     *
+     * **Security note:** The token contains the flag variation key and version. If passed
+     * to an untrusted client (e.g., a browser) this could expose feature-flag targeting
+     * details. Keep the token server-side and use an opaque reference in client-facing APIs.
+     */
+    readonly resumptionToken: string;
+    /**
+     * Tracks a successful graph invocation.
+     * Emits event `$ld:ai:graph:invocation_success` with metric value `1`.
+     * At-most-once: subsequent calls are dropped with a warning.
+     */
+    trackInvocationSuccess(): void;
+    /**
+     * Tracks an unsuccessful graph invocation.
+     * Emits event `$ld:ai:graph:invocation_failure` with metric value `1`.
+     * At-most-once: subsequent calls are dropped with a warning.
+     */
+    trackInvocationFailure(): void;
+    /**
+     * Tracks the total duration of the graph execution in milliseconds.
+     * Emits event `$ld:ai:graph:duration:total` with the duration as the metric value.
+     * At-most-once: subsequent calls are dropped with a warning.
+     *
+     * @param durationMs Duration in milliseconds.
+     */
+    trackDuration(durationMs: number): void;
+    /**
+     * Tracks aggregate token usage across the entire graph invocation.
+     * Emits event `$ld:ai:graph:total_tokens` with the total token count as the metric value.
+     * At-most-once: subsequent calls are dropped with a warning.
+     *
+     * @param tokens Token usage information.
+     */
+    trackTotalTokens(tokens: LDTokenUsage): void;
+    /**
+     * Tracks the execution path through the graph.
+     * Emits event `$ld:ai:graph:path` with metric value `1`.
+     * The data payload includes the path array in addition to standard track data.
+     * At-most-once: subsequent calls are dropped with a warning.
+     *
+     * @param path An ordered array of agent config keys representing the execution path.
+     */
+    trackPath(path: string[]): void;
+    /**
+     * Tracks when a node redirects to a different target than originally specified.
+     * Emits event `$ld:ai:graph:redirect` with metric value `1`.
+     *
+     * @param sourceKey Config key of the source node.
+     * @param redirectedTarget Config key of the actual target node.
+     */
+    trackRedirect(sourceKey: string, redirectedTarget: string): void;
+    /**
+     * Tracks a successful handoff between two nodes.
+     * Emits event `$ld:ai:graph:handoff_success` with metric value `1`.
+     *
+     * @param sourceKey Config key of the source node.
+     * @param targetKey Config key of the target node.
+     */
+    trackHandoffSuccess(sourceKey: string, targetKey: string): void;
+    /**
+     * Tracks a failed handoff between two nodes.
+     * Emits event `$ld:ai:graph:handoff_failure` with metric value `1`.
+     *
+     * @param sourceKey Config key of the source node.
+     * @param targetKey Config key of the target node.
+     */
+    trackHandoffFailure(sourceKey: string, targetKey: string): void;
+}
+
+/**
+ * Represents a single node within an agent graph.
+ *
+ * Each node wraps an {@link LDAIAgentConfig} and carries the outgoing edges
+ * to its children. Use the node's tracker (via `getConfig().tracker`) to record
+ * node-level metrics against the underlying agent config.
+ */
+declare class AgentGraphNode {
+    private readonly _key;
+    private readonly _config;
+    private readonly _edges;
+    constructor(_key: string, _config: LDAIAgentConfig, _edges: LDGraphEdge[]);
+    /**
+     * Returns the agent config key that identifies this node in the graph.
+     */
+    getKey(): string;
+    /**
+     * Returns the underlying AIAgentConfig for this node.
+     * Use `getConfig().tracker` to record node-level metrics.
+     */
+    getConfig(): LDAIAgentConfig;
+    /**
+     * Returns the outgoing edges from this node to its children.
+     */
+    getEdges(): LDGraphEdge[];
+    /**
+     * Returns `true` if this node has no outgoing edges (i.e., it is a terminal/leaf node).
+     */
+    isTerminal(): boolean;
+}
+
+/**
+ * Callback function signature for graph traversal methods.
+ */
+type TraversalFn = (node: AgentGraphNode, executionContext: Record<string, unknown>) => unknown;
+/**
+ * Encapsulates an agent graph configuration and its pre-built node collection.
+ *
+ * Provides graph-level orchestration including relationship queries (parent/child),
+ * breadth-first traversal in both forward and reverse directions, and graph tracker creation.
+ *
+ * Obtain an instance via {@link LDAIClient.agentGraph}. When the graph is disabled
+ * or invalid, the returned instance has {@link enabled} set to `false` and an
+ * empty node collection.
+ */
+declare class AgentGraphDefinition {
+    private readonly _agentGraph;
+    private readonly _nodes;
+    readonly enabled: boolean;
+    private readonly _createTracker;
+    constructor(_agentGraph: LDAgentGraphFlagValue, _nodes: Record<string, AgentGraphNode>, enabled: boolean, _createTracker: () => LDGraphTracker);
+    /**
+     * Builds a node map from a raw agent graph flag value and a map of pre-fetched agent configs.
+     *
+     * @param graph Raw graph flag value from LaunchDarkly.
+     * @param agentConfigs Map of agent config key to resolved LDAIAgentConfig.
+     * @returns Record mapping agent config keys to AgentGraphNode instances.
+     */
+    static buildNodes(graph: LDAgentGraphFlagValue, agentConfigs: Record<string, LDAIAgentConfig>): Record<string, AgentGraphNode>;
+    /**
+     * Returns the children of the node identified by `nodeKey`.
+     *
+     * @param nodeKey The agent config key of the parent node.
+     */
+    getChildNodes(nodeKey: string): AgentGraphNode[];
+    /**
+     * Returns all nodes that have a direct edge to the node identified by `nodeKey`.
+     *
+     * @param nodeKey The agent config key of the child node.
+     */
+    getParentNodes(nodeKey: string): AgentGraphNode[];
+    /**
+     * Returns all terminal nodes (nodes with no outgoing edges).
+     */
+    terminalNodes(): AgentGraphNode[];
+    /**
+     * Returns the root node of the graph.
+     */
+    rootNode(): AgentGraphNode;
+    /**
+     * Returns the node with the given key, or `null` if not found.
+     *
+     * @param nodeKey The agent config key to look up.
+     */
+    getNode(nodeKey: string): AgentGraphNode | null;
+    /**
+     * Returns the underlying raw graph configuration from LaunchDarkly.
+     */
+    getConfig(): LDAgentGraphFlagValue;
+    /**
+     * Returns a new {@link LDGraphTracker} for this graph invocation.
+     *
+     * Call this once per invocation. Each call produces a tracker with a fresh `runId`
+     * that groups all events for that invocation.
+     */
+    createTracker(): LDGraphTracker;
+    /**
+     * Traverses the graph breadth-first from the root to all terminal nodes.
+     *
+     * Nodes at the same depth are processed before advancing to the next depth.
+     * The value returned by `fn` is stored in the mutable `executionContext` under
+     * the node's key, making upstream results available to downstream nodes.
+     *
+     * Cyclic graphs are handled safely — each node is visited at most once.
+     *
+     * @param fn Callback invoked for each node. Its return value is added to
+     *   `executionContext` keyed by the node's config key.
+     * @param initialExecutionContext Optional initial context to seed the traversal.
+     */
+    traverse(fn: TraversalFn, initialExecutionContext?: Record<string, unknown>): void;
+    /**
+     * Traverses the graph from terminal nodes up to the root.
+     *
+     * Uses BFS upward via parent edges so that each node is processed only after
+     * all of its reachable descendants have been processed. The root is always
+     * visited last. Cyclic graphs are handled safely — each node is visited at
+     * most once; if the graph has no terminal nodes, this method returns without
+     * invoking `fn`.
+     *
+     * **Ordering note:** Within a single BFS level (nodes at the same depth from a
+     * terminal) the visit order is not strictly guaranteed. The guarantee is only
+     * that a node is visited before any of its ancestors — not that siblings at the
+     * same depth are visited in a specific order relative to each other.
+     *
+     * The value returned by `fn` is stored in the mutable `executionContext` under
+     * the node's key.
+     *
+     * @param fn Callback invoked for each node. Its return value is added to
+     *   `executionContext` keyed by the node's config key.
+     * @param initialExecutionContext Optional initial context to seed the traversal.
+     */
+    reverseTraverse(fn: TraversalFn, initialExecutionContext?: Record<string, unknown>): void;
+    /**
+     * Collects every unique node key referenced in the graph (root + all edge sources
+     * and targets).
+     */
+    static collectAllKeys(graph: LDAgentGraphFlagValue): Set<string>;
+}
+
 /**
  * List of supported AI providers.
  */
@@ -1010,6 +1350,61 @@ interface LDAIClient {
      * ```
      */
     createJudge(key: string, context: LDContext, defaultValue?: LDAIJudgeConfigDefault, variables?: Record<string, unknown>, defaultAiProvider?: SupportedAIProvider): Promise<Judge | undefined>;
+    /**
+     * Reconstructs an AIConfigTracker from a resumption token string previously
+     * obtained from a tracker's `resumptionToken` property. Use this to associate
+     * deferred events (such as user feedback) with the original invocation's runId.
+     *
+     * @param token A URL-safe Base64-encoded resumption token string.
+     * @param context The evaluation context to use for subsequent track calls.
+     * @returns A reconstructed AIConfigTracker with the original runId preserved.
+     */
+    createTracker(token: string, context: LDContext): LDAIConfigTracker;
+    /**
+     * Fetches an agent graph configuration from LaunchDarkly and returns an
+     * {@link AgentGraphDefinition}.
+     *
+     * When the graph is enabled the method validates that:
+     * - The graph flag can be evaluated.
+     * - A single root node is present.
+     * - All nodes in the graph are reachable from the root (no disconnected nodes).
+     * - Every referenced agent config can be fetched and is enabled.
+     *
+     * If any validation check fails, the returned definition has
+     * {@link AgentGraphDefinition.enabled | enabled} set to `false` with an empty
+     * node collection. When the logger level is DEBUG, a message describing the
+     * failure is emitted.
+     *
+     * @param graphKey The LaunchDarkly flag key for the agent graph configuration.
+     * @param context The LaunchDarkly context used for flag evaluation and tracking.
+     * @param variables Optional key-value pairs used for Mustache template interpolation
+     *   in each node's agent config instructions. Applied uniformly to all nodes.
+     *
+     * @returns A promise that resolves to an {@link AgentGraphDefinition}. Check
+     *   {@link AgentGraphDefinition.enabled | enabled} before traversing.
+     *
+     * @example
+     * ```typescript
+     * const graph = await aiClient.agentGraph('my-agent-graph', context, { userName: 'Sandy' });
+     * if (graph.enabled) {
+     *   graph.traverse((node, ctx) => {
+     *     // build your provider-specific node here
+     *   });
+     * }
+     * ```
+     */
+    agentGraph(graphKey: string, context: LDContext, variables?: Record<string, unknown>): Promise<AgentGraphDefinition>;
+    /**
+     * Reconstructs an {@link LDGraphTracker} from a resumption token, preserving
+     * the original `runId` so events from a resumed session are correlated correctly.
+     *
+     * **Security note:** The token encodes the flag variation key and version.
+     * Keep it server-side; do not expose it to untrusted clients.
+     *
+     * @param token URL-safe Base64-encoded token from {@link LDGraphTracker.resumptionToken}.
+     * @param context LDContext to associate with the reconstructed tracker.
+     */
+    createGraphTracker(token: string, context: LDContext): LDGraphTracker;
 }
 
 /**
@@ -1022,6 +1417,46 @@ interface LDClientMin {
     readonly logger?: LDLogger$1;
 }
 
+/**
+ * Concrete implementation of {@link LDGraphTracker}.
+ *
+ * Construct directly or reconstruct from a resumption token via
+ * {@link LDGraphTrackerImpl.fromResumptionToken}.
+ */
+declare class LDGraphTrackerImpl implements LDGraphTracker {
+    private readonly _ldClient;
+    private readonly _runId;
+    private readonly _graphKey;
+    private readonly _variationKey;
+    private readonly _version;
+    private readonly _context;
+    private _summary;
+    constructor(_ldClient: LDClientMin, _runId: string, _graphKey: string, _variationKey: string | undefined, _version: number, _context: LDContext);
+    /**
+     * Reconstructs an {@link LDGraphTrackerImpl} from a resumption token, preserving
+     * the original `runId` so all events continue to be correlated under the same run.
+     *
+     * **Security note:** The token contains the flag variation key and version.
+     * Do not pass the raw token to untrusted clients.
+     *
+     * @param token URL-safe Base64-encoded token produced by {@link LDGraphTrackerImpl.resumptionToken}.
+     * @param ldClient LaunchDarkly client instance.
+     * @param context LDContext for the new tracker.
+     */
+    static fromResumptionToken(token: string, ldClient: LDClientMin, context: LDContext): LDGraphTrackerImpl;
+    getTrackData(): LDGraphTrackData;
+    getSummary(): LDGraphMetricSummary;
+    get resumptionToken(): string;
+    trackInvocationSuccess(): void;
+    trackInvocationFailure(): void;
+    trackDuration(durationMs: number): void;
+    trackTotalTokens(tokens: LDTokenUsage): void;
+    trackPath(path: string[]): void;
+    trackRedirect(sourceKey: string, redirectedTarget: string): void;
+    trackHandoffSuccess(sourceKey: string, targetKey: string): void;
+    trackHandoffFailure(sourceKey: string, targetKey: string): void;
+}
+
 /**
  * This is the API reference for the LaunchDarkly AI SDK for Server-Side JavaScript.
  *
@@ -1039,4 +1474,4 @@ interface LDClientMin {
 declare function initAi(ldClient: LDClientMin): LDAIClient;
 type LDLogger = common.LDLogger;
 
-export { AIProvider, AIProviderFactory, type ChatResponse, type EvalScore, Judge, type JudgeResponse, type LDAIAgentConfig, type LDAIAgentConfigDefault, type LDAIAgentRequestConfig, type LDAIClient, type LDAICompletionConfig, type LDAICompletionConfigDefault, type LDAIConfig, type LDAIConfigDefault, type LDAIConfigDefaultKind, type LDAIConfigKind, type LDAIConfigMode, type LDAIConfigTracker, type LDAIJudgeConfig, type LDAIJudgeConfigDefault, type LDAIMetrics, LDFeedbackKind, type LDJudge, type LDJudgeConfiguration, type LDLogger, type LDMessage, type LDModelConfig, type LDProviderConfig, type LDTokenUsage, SUPPORTED_AI_PROVIDERS, type StructuredResponse, type SupportedAIProvider, TrackedChat, createBedrockTokenUsage, createOpenAiUsage, createVercelAISDKTokenUsage, initAi };
+export { AIProvider, AIProviderFactory, AgentGraphDefinition, AgentGraphNode, type ChatResponse, Judge, type LDAIAgentConfig, type LDAIAgentConfigDefault, type LDAIAgentRequestConfig, type LDAIClient, type LDAICompletionConfig, type LDAICompletionConfigDefault, type LDAIConfig, type LDAIConfigDefault, type LDAIConfigDefaultKind, type LDAIConfigKind, type LDAIConfigMode, type LDAIConfigTracker, type LDAIJudgeConfig, type LDAIJudgeConfigDefault, type LDAIMetrics, type LDAgentGraphFlagValue, LDFeedbackKind, type LDGraphEdge, type LDGraphMetricSummary, type LDGraphTrackData, type LDGraphTracker, LDGraphTrackerImpl, type LDJudge, type LDJudgeConfiguration, type LDJudgeResult, type LDLogger, type LDMessage, type LDModelConfig, type LDProviderConfig, type LDTokenUsage, SUPPORTED_AI_PROVIDERS, type StructuredResponse, type SupportedAIProvider, TrackedChat, type TraversalFn, createBedrockTokenUsage, createOpenAiUsage, createVercelAISDKTokenUsage, initAi };