@arizeai/phoenix-client 7.7.0 → 7.7.1

package/docs/sessions.mdx

@@ -29,10 +29,19 @@ const sessions = await listSessions({
 });
 
 for (const session of sessions) {
-  console.log(session.sessionId);
+  console.log({
+    sessionId: session.sessionId,
+    promptTokens: session.tokenCountPrompt,
+    completionTokens: session.tokenCountCompletion,
+    totalTokens: session.tokenCountTotal,
+  });
 }
 ```
 
+Each session includes cumulative prompt, completion, and total token counts across
+all of its spans. The fields may be `undefined` when using a Phoenix server that
+does not return session token usage.
+
 ## Retrieve A Session And Its Turns
 
 ```ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arizeai/phoenix-client",
-  "version": "7.7.0",
+  "version": "7.7.1",
   "description": "A client for the Phoenix API",
   "keywords": [
     "arize",

package/src/experiments/resumeEvaluation.ts

@@ -301,6 +301,71 @@ function setupEvaluationTracer({
  * });
  * ```
  */
+function isEmptyEvaluationBatch({
+  batchLength,
+  totalProcessed,
+  logger,
+}: {
+  batchLength: number;
+  totalProcessed: number;
+  logger: Logger;
+}): boolean {
+  if (batchLength > 0) return false;
+  if (totalProcessed === 0) {
+    logger.info(`${PROGRESS_PREFIX.completed}No incomplete evaluations found.`);
+  }
+  return true;
+}
+
+function shouldContinueEvaluationFetch({
+  cursor,
+  signal,
+}: {
+  cursor: string | null;
+  signal: AbortSignal;
+}): boolean {
+  return cursor !== null && !signal.aborted;
+}
+
+function getEvaluationExecutionError({
+  rejections,
+  isAborted,
+  logger,
+}: {
+  rejections: unknown[];
+  isAborted: boolean;
+  logger: Logger;
+}): Error | null {
+  if (rejections.length === 0) return null;
+  const fetchError = rejections.find(
+    (reason) => reason instanceof EvaluationFetchError
+  );
+  if (fetchError instanceof Error) {
+    logger.error(`Critical: Failed to fetch evaluations from server`);
+    return fetchError;
+  }
+  const workerError = rejections.find(
+    (reason) =>
+      reason instanceof Error &&
+      !(reason instanceof EvaluationFetchError) &&
+      !(reason instanceof ChannelError)
+  );
+  if (workerError instanceof Error) return workerError;
+  const channelError = rejections.find(
+    (reason) => reason instanceof ChannelError
+  );
+  if (channelError instanceof Error && isAborted) {
+    return new EvaluationAbortedError(
+      "Evaluation stopped due to error in concurrent evaluator",
+      channelError
+    );
+  }
+  const reason = rejections[0];
+  const error = reason instanceof Error ? reason : new Error(String(reason));
+  logger.error(`Unexpected error during evaluation: ${error.message}`);
+  return error;
+}
+
 export async function resumeEvaluation({
   client: _client,
   experimentId,
@@ -425,12 +490,13 @@ export async function resumeEvaluation({
           const batchIncomplete = res.data?.data;
           invariant(batchIncomplete, "Failed to fetch incomplete evaluations");
 
-          if (batchIncomplete.length === 0) {
-            if (totalProcessed === 0) {
-              logger.info(
-                `${PROGRESS_PREFIX.completed}No incomplete evaluations found.`
-              );
-            }
+          if (
+            isEmptyEvaluationBatch({
+              batchLength: batchIncomplete.length,
+              totalProcessed,
+              logger,
+            })
+          ) {
             break;
           }
 
@@ -468,7 +534,7 @@ export async function resumeEvaluation({
           logger.debug(
             `${PROGRESS_PREFIX.progress}Fetched batch of ${batchCount} evaluation tasks.`
           );
-        } while (cursor !== null && !signal.aborted);
+        } while (shouldContinueEvaluationFetch({ cursor, signal }));
       } catch (error) {
         // Re-throw with context preservation
         if (error instanceof EvaluationFetchError) {
@@ -547,47 +613,11 @@ export async function resumeEvaluation({
         )
         .map((result) => result.reason);
 
-      if (rejections.length > 0) {
-        // Classify and handle errors based on their nature. When multiple tasks
-        // reject, prefer the most meaningful error over incidental fallout
-        // (e.g. a ChannelError raised in a blocked worker when the channel
-        // closes on abort).
-        const fetchError = rejections.find(
-          (reason) => reason instanceof EvaluationFetchError
-        );
-        const workerError = rejections.find(
-          (reason) =>
-            reason instanceof Error &&
-            !(reason instanceof EvaluationFetchError) &&
-            !(reason instanceof ChannelError)
-        );
-        const channelError = rejections.find(
-          (reason) => reason instanceof ChannelError
-        );
-
-        if (fetchError) {
-          // Producer failed - this is ALWAYS critical regardless of stopOnFirstError
-          logger.error(`Critical: Failed to fetch evaluations from server`);
-          executionError = fetchError;
-        } else if (workerError) {
-          // Worker error in stopOnFirstError mode - already logged by worker
-          executionError = workerError;
-        } else if (channelError && signal.aborted) {
-          // Channel closed due to intentional abort - wrap in semantic error
-          executionError = new EvaluationAbortedError(
-            "Evaluation stopped due to error in concurrent evaluator",
-            channelError
-          );
-        } else {
-          // Unexpected error (not from worker, not from producer fetch)
-          // This could be a bug in our code or infrastructure failure
-          const reason = rejections[0];
-          const err =
-            reason instanceof Error ? reason : new Error(String(reason));
-          logger.error(`Unexpected error during evaluation: ${err.message}`);
-          executionError = err;
-        }
-      }
+      executionError = getEvaluationExecutionError({
+        rejections,
+        isAborted: signal.aborted,
+        logger,
+      });
     } finally {
       // Ensure channel is closed even if there are unexpected errors
       // This is a safety net in case producer's finally block didn't execute

package/src/experiments/resumeExperiment.ts

@@ -276,6 +276,67 @@ function setupTracer({
  * });
  * ```
  */
+function getResumeEvaluators({
+  evaluators,
+  executionError,
+}: {
+  evaluators: readonly ExperimentEvaluatorLike[] | undefined;
+  executionError: Error | null;
+}): readonly ExperimentEvaluatorLike[] | null {
+  return evaluators && evaluators.length > 0 && !executionError
+    ? evaluators
+    : null;
+}
+
+function shouldWarnAboutFailedRuns({
+  totalFailed,
+  executionError,
+}: {
+  totalFailed: number;
+  executionError: Error | null;
+}): boolean {
+  return totalFailed > 0 && !executionError;
+}
+
+function getTaskExecutionError({
+  rejections,
+  isAborted,
+  logger,
+}: {
+  rejections: unknown[];
+  isAborted: boolean;
+  logger: Logger;
+}): Error | null {
+  if (rejections.length === 0) return null;
+  const fetchError = rejections.find(
+    (reason) => reason instanceof TaskFetchError
+  );
+  if (fetchError instanceof Error) {
+    logger.error(`Critical: Failed to fetch incomplete runs from server`);
+    return fetchError;
+  }
+  const taskError = rejections.find(
+    (reason) =>
+      reason instanceof Error &&
+      !(reason instanceof TaskFetchError) &&
+      !(reason instanceof ChannelError)
+  );
+  if (taskError instanceof Error) return taskError;
+  const channelError = rejections.find(
+    (reason) => reason instanceof ChannelError
+  );
+  if (channelError instanceof Error && isAborted) {
+    return new TaskAbortedError(
+      "Task execution stopped due to error in concurrent worker",
+      channelError
+    );
+  }
+  const reason = rejections[0];
+  const error = reason instanceof Error ? reason : new Error(String(reason));
+  logger.error(`Unexpected error during task execution: ${error.message}`);
+  return error;
+}
+
 export async function resumeExperiment({
   client: _client,
   experimentId,
@@ -514,49 +575,11 @@ export async function resumeExperiment({
         )
         .map((result) => result.reason);
 
-      if (rejections.length > 0) {
-        // Classify and handle errors based on their nature. When multiple tasks
-        // reject, prefer the most meaningful error over incidental fallout
-        // (e.g. a ChannelError raised in a blocked worker when the channel
-        // closes on abort).
-        const fetchError = rejections.find(
-          (reason) => reason instanceof TaskFetchError
-        );
-        const taskError = rejections.find(
-          (reason) =>
-            reason instanceof Error &&
-            !(reason instanceof TaskFetchError) &&
-            !(reason instanceof ChannelError)
-        );
-        const channelError = rejections.find(
-          (reason) => reason instanceof ChannelError
-        );
-
-        if (fetchError) {
-          // Producer failed - this is ALWAYS critical regardless of stopOnFirstError
-          logger.error(`Critical: Failed to fetch incomplete runs from server`);
-          executionError = fetchError;
-        } else if (taskError) {
-          // Worker error in stopOnFirstError mode - already logged by worker
-          executionError = taskError;
-        } else if (channelError && signal.aborted) {
-          // Channel closed due to intentional abort - wrap in semantic error
-          executionError = new TaskAbortedError(
-            "Task execution stopped due to error in concurrent worker",
-            channelError
-          );
-        } else {
-          // Unexpected error (not from worker, not from producer fetch)
-          // This could be a bug in our code or infrastructure failure
-          const reason = rejections[0];
-          const err =
-            reason instanceof Error ? reason : new Error(String(reason));
-          logger.error(
-            `Unexpected error during task execution: ${err.message}`
-          );
-          executionError = err;
-        }
-      }
+      executionError = getTaskExecutionError({
+        rejections,
+        isAborted: signal.aborted,
+        logger,
+      });
     } finally {
       // Ensure channel is closed even if there are unexpected errors
       // This is a safety net in case producer's finally block didn't execute
@@ -570,11 +593,15 @@ export async function resumeExperiment({
       logger.info(`${PROGRESS_PREFIX.completed}Task runs completed.`);
     }
 
-    if (totalFailed > 0 && !executionError) {
+    if (shouldWarnAboutFailedRuns({ totalFailed, executionError })) {
       logger.warn(`${totalFailed} out of ${totalProcessed} runs failed.`);
     }
 
-    if (evaluators && evaluators.length > 0 && !executionError) {
+    const resumeEvaluators = getResumeEvaluators({
+      evaluators,
+      executionError,
+    });
+    if (resumeEvaluators) {
       await cleanupOwnedTracerProvider({
         provider,
         globalRegistration,
@@ -585,7 +612,7 @@ export async function resumeExperiment({
       logger.info(`${PROGRESS_PREFIX.start}Running evaluators.`);
       await resumeEvaluation({
         experimentId,
-        evaluators: [...evaluators],
+        evaluators: [...resumeEvaluators],
         client,
         logger,
         concurrency,