@arizeai/phoenix-client 7.4.0 → 7.6.0

package/src/client.ts

@@ -158,9 +158,10 @@ export const createClient = (
         const headers = mergedOptions.headers
           ? { ...(mergedOptions.headers as Record<string, string>) }
           : {};
-        const resp = await fetch(`${baseUrl}/arize_phoenix_version`, {
-          headers,
-        });
+        const fetchImpl = mergedOptions.fetch ?? globalThis.fetch;
+        const resp = await fetchImpl(
+          new Request(`${baseUrl}/arize_phoenix_version`, { headers })
+        );
         if (resp.ok) {
           const text = await resp.text();
           const parsed = parseSemanticVersion(text);

package/src/constants/serverRequirements.ts

@@ -138,6 +138,13 @@ export const ADD_SESSION_NOTE_IDENTIFIER: ParameterRequirement = {
   minServerVersion: [15, 5, 0],
 };
 
+export const DELETE_PROMPT: RouteRequirement = {
+  kind: "route",
+  method: "DELETE",
+  path: "/v1/prompts/{prompt_identifier}",
+  minServerVersion: [13, 20, 0],
+};
+
 export const PATCH_PROMPT: RouteRequirement = {
   kind: "route",
   method: "PATCH",
@@ -145,6 +152,62 @@ export const PATCH_PROMPT: RouteRequirement = {
   minServerVersion: [19, 18, 0],
 };
 
+export const AGENT_SESSION_CREATE: RouteRequirement = {
+  kind: "route",
+  method: "POST",
+  path: "/v1/agent_sessions",
+  minServerVersion: [20, 0, 0],
+};
+
+export const AGENT_SESSION_LIST: RouteRequirement = {
+  kind: "route",
+  method: "GET",
+  path: "/v1/agent_sessions",
+  minServerVersion: [20, 0, 0],
+};
+
+export const AGENT_SESSION_GET: RouteRequirement = {
+  kind: "route",
+  method: "GET",
+  path: "/v1/agent_sessions/{session_id}",
+  minServerVersion: [20, 0, 0],
+};
+
+export const AGENT_SESSION_PATCH: RouteRequirement = {
+  kind: "route",
+  method: "PATCH",
+  path: "/v1/agent_sessions/{session_id}",
+  minServerVersion: [20, 0, 0],
+};
+
+export const AGENT_SESSION_COMPACT: RouteRequirement = {
+  kind: "route",
+  method: "POST",
+  path: "/v1/agent_sessions/{session_id}/compact",
+  minServerVersion: [20, 0, 0],
+};
+
+export const AGENT_SESSION_TOOL_OUTPUTS: RouteRequirement = {
+  kind: "route",
+  method: "POST",
+  path: "/v1/agent_sessions/{session_id}/tool_outputs",
+  minServerVersion: [20, 0, 0],
+};
+
+export const AGENT_SESSION_CHAT: RouteRequirement = {
+  kind: "route",
+  method: "POST",
+  path: "/v1/agent_sessions/{session_id}/chat",
+  minServerVersion: [20, 0, 0],
+};
+
+export const AGENT_SESSION_MESSAGES: RouteRequirement = {
+  kind: "route",
+  method: "GET",
+  path: "/v1/agent_sessions/{session_id}/messages",
+  minServerVersion: [20, 0, 0],
+};
+
 /**
  * Aggregate list of every known capability requirement.
  *
@@ -168,5 +231,14 @@ export const ALL_REQUIREMENTS: readonly CapabilityRequirement[] = [
   ADD_TRACE_NOTE_IDENTIFIER,
   ADD_SPAN_NOTE_IDENTIFIER,
   ADD_SESSION_NOTE_IDENTIFIER,
+  DELETE_PROMPT,
   PATCH_PROMPT,
+  AGENT_SESSION_CREATE,
+  AGENT_SESSION_LIST,
+  AGENT_SESSION_GET,
+  AGENT_SESSION_PATCH,
+  AGENT_SESSION_COMPACT,
+  AGENT_SESSION_TOOL_OUTPUTS,
+  AGENT_SESSION_CHAT,
+  AGENT_SESSION_MESSAGES,
 ] as const;

package/src/index.ts

@@ -1,3 +1,29 @@
 export * from "./client";
 export * from "./authFetch";
 export * from "./errors";
+export {
+  AGENT_SESSION_CHAT,
+  AGENT_SESSION_COMPACT,
+  AGENT_SESSION_CREATE,
+  AGENT_SESSION_GET,
+  AGENT_SESSION_LIST,
+  AGENT_SESSION_MESSAGES,
+  AGENT_SESSION_PATCH,
+  AGENT_SESSION_TOOL_OUTPUTS,
+} from "./constants/serverRequirements";
+export { formatApiError } from "./utils/apiErrorUtils";
+export {
+  formatVersion,
+  parseSemanticVersion,
+  satisfiesMinVersion,
+} from "./utils/semverUtils";
+export {
+  capabilityLabel,
+  ensureServerCapability,
+} from "./utils/serverVersionUtils";
+export type { SemanticVersion } from "./types/semver";
+export type {
+  CapabilityRequirement,
+  ParameterRequirement,
+  RouteRequirement,
+} from "./types/serverRequirements";

package/src/prompts/deletePrompt.ts

@@ -0,0 +1,70 @@
+import { createClient } from "../client";
+import { DELETE_PROMPT } from "../constants/serverRequirements";
+import { HttpError } from "../errors";
+import type { ClientFn } from "../types/core";
+import type { PromptIdentifier } from "../types/prompts";
+import { resolvePromptIdentifier } from "../utils/resolvePromptIdentifier";
+import { ensureServerCapability } from "../utils/serverVersionUtils";
+
+/**
+ * Parameters for deleting a prompt.
+ */
+export interface DeletePromptParams extends ClientFn {
+  /**
+   * The prompt to delete. Selected either by `name` or by `promptId` — the same
+   * selector style {@link getPrompt} takes, minus the version-level selectors,
+   * which do not identify a prompt.
+   */
+  prompt: PromptIdentifier;
+}
+
+/**
+ * Delete a prompt via `DELETE /v1/prompts/{prompt_identifier}`.
+ *
+ * Deletion cascades: every version of the prompt, along with its version tags
+ * and labels, is removed with it. This cannot be undone.
+ *
+ * @param params - The parameters to delete the prompt.
+ * @param params.prompt - The prompt to delete, selected by `name` or `promptId`.
+ * @returns A promise that resolves once the prompt is deleted.
+ * @throws An error if the prompt does not exist, or if the deletion fails.
+ *
+ * @requires Phoenix server >= 13.20.0
+ *
+ * @example
+ * ```ts
+ * import { deletePrompt } from "@arizeai/phoenix-client/prompts";
+ *
+ * // Delete by name
+ * await deletePrompt({ prompt: { name: "my-prompt" } });
+ *
+ * // Delete by prompt id
+ * await deletePrompt({ prompt: { promptId: "UHJvbXB0OjE=" } });
+ * ```
+ */
+export async function deletePrompt({
+  client: _client,
+  prompt,
+}: DeletePromptParams): Promise<void> {
+  const promptIdentifier = resolvePromptIdentifier(prompt);
+
+  const client = _client ?? createClient();
+  await ensureServerCapability({ client, requirement: DELETE_PROMPT });
+
+  try {
+    await client.DELETE("/v1/prompts/{prompt_identifier}", {
+      params: {
+        path: {
+          prompt_identifier: promptIdentifier,
+        },
+      },
+    });
+  } catch (error) {
+    if (error instanceof HttpError && error.status === 404) {
+      throw new Error(`Prompt not found: ${promptIdentifier}`, {
+        cause: error,
+      });
+    }
+    throw error;
+  }
+}

package/src/prompts/index.ts

@@ -1,5 +1,6 @@
 export * from "./getPrompt";
 export * from "./createPrompt";
+export * from "./deletePrompt";
 export * from "./listPrompts";
 export * from "./updatePrompt";
 export * from "./sdks";

package/src/testing/reporter-format.ts

@@ -322,7 +322,8 @@ interface AcceptanceBar {
  * reused as a per-run heuristic (the suite-level acceptance block still reports
  * the true aggregate verdict). `passRate` criteria decide passing with an
  * arbitrary `passFn` predicate — there is no static numeric bar to highlight
- * against — so their rows fall back to the default miss heuristic.
+ * against — so those annotations are ignored for per-run misses when any
+ * `average` bar exists.
  */
 function buildAcceptanceBars(suite: SuiteSummary): Map<string, AcceptanceBar> {
   const bars = new Map<string, AcceptanceBar>();
@@ -339,13 +340,22 @@ function buildAcceptanceBars(suite: SuiteSummary): Map<string, AcceptanceBar> {
 /**
  * Whether a passing test's evaluator scores fall short. When maximizing, a
  * boolean `false` or a numeric score below its bar is a miss; when minimizing,
- * a boolean `true` or a score above its bar is a miss. With no criterion for an
- * annotation, only a non-positive score counts (keeps zero-config suites quiet).
+ * a boolean `true` or a score above its bar is a miss.
+ *
+ * When the suite has `average` acceptance criteria, only those gated
+ * annotations decide per-run misses. That way a minimize metric whose desired
+ * value is 0 (e.g. `no_pii_detected`) is not listed as a miss on a correctly
+ * classified row. With no average criterion, a non-positive score still counts
+ * (keeps zero-config suites quiet).
  */
 function isMiss(result: TestResult, bars: Map<string, AcceptanceBar>): boolean {
+  const hasAverageBars = bars.size > 0;
   for (const ann of result.annotations) {
     if (ann.name === "pass") continue;
     const acceptanceBar = bars.get(ann.name);
+    if (hasAverageBars && acceptanceBar === undefined) {
+      continue;
+    }
     const minimizing = acceptanceBar?.direction === "minimize";
     if (typeof ann.score === "boolean") {
       if (minimizing ? ann.score : !ann.score) return true;

package/src/types/prompts.ts

@@ -75,6 +75,16 @@ export type PromptSelector =
   | GetPromptByVersionSelector
   | GetPromptByTagSelector;
 
+/**
+ * A selector for a prompt as a whole, rather than for one of its versions.
+ *
+ * Narrower than {@link PromptSelector}: a version id or a name + tag picks out a
+ * single version, which is not what operations on the prompt itself act on. Use
+ * this wherever the API needs the `{prompt_identifier}` path segment — the name
+ * and the prompt id are the two things the Phoenix REST API accepts there.
+ */
+export type PromptIdentifier = GetPromptByIdSelector | GetPromptByNameSelector;
+
 /**
  * The prompt data needed to create a prompt.
  */

package/src/utils/resolvePromptIdentifier.ts

@@ -0,0 +1,41 @@
+import type { PromptIdentifier } from "../types/prompts";
+
+/**
+ * Resolve a prompt-level selector to the `{prompt_identifier}` path segment the
+ * Phoenix REST API expects.
+ *
+ * Version-level selectors are rejected rather than silently widened: structural
+ * typing lets a `{ name, tag }` or `{ versionId }` value reach a
+ * {@link PromptIdentifier} parameter, and quietly dropping the version would
+ * point the caller at the whole prompt instead of the version they named.
+ *
+ * @param prompt - the prompt, selected by `name` or by `promptId`
+ * @returns The identifier to interpolate into the request path.
+ * @throws An error if the selector is empty, or selects a version rather than a
+ * prompt.
+ */
+export function resolvePromptIdentifier(prompt: PromptIdentifier): string {
+  if ("versionId" in prompt) {
+    throw new Error(
+      "A prompt version id selects a single version, not a prompt. Select the prompt by name or promptId."
+    );
+  }
+  if ("tag" in prompt) {
+    throw new Error(
+      "A tag selects a single version, not a prompt. Select the prompt by name or promptId."
+    );
+  }
+  if ("promptId" in prompt) {
+    if (!prompt.promptId) {
+      throw new Error("promptId must be a non-empty prompt id.");
+    }
+    return prompt.promptId;
+  }
+  if ("name" in prompt) {
+    if (!prompt.name) {
+      throw new Error("name must be a non-empty prompt name.");
+    }
+    return prompt.name;
+  }
+  throw new Error("A prompt must be selected by either name or promptId.");
+}