@mutagent/sdk 0.2.111 → 0.2.115

package/src/models/paginated-trace-list.ts

@@ -21,7 +21,6 @@ export enum PaginatedTraceListSource {
   Openai = "openai",
   Otel = "otel",
   Manual = "manual",
-  ClaudeCode = "claude-code",
 }
 /**
  * Source integration that produced this trace
@@ -47,92 +46,6 @@ export type PaginatedTraceListEnvironmentOpen = OpenEnum<
 
 export type PaginatedTraceListMetadata = {};
 
-/**
- * Kind of span operation (OTel Gen AI aligned)
- */
-export enum PaginatedTraceListKind {
-  LlmChat = "llm.chat",
-  LlmCompletion = "llm.completion",
-  LlmEmbedding = "llm.embedding",
-  Chain = "chain",
-  Agent = "agent",
-  Graph = "graph",
-  Node = "node",
-  Edge = "edge",
-  Workflow = "workflow",
-  Middleware = "middleware",
-  Retrieval = "retrieval",
-  Rerank = "rerank",
-  Tool = "tool",
-  Guardrail = "guardrail",
-  Custom = "custom",
-}
-/**
- * Kind of span operation (OTel Gen AI aligned)
- */
-export type PaginatedTraceListKindOpen = OpenEnum<
-  typeof PaginatedTraceListKind
->;
-
-export type PaginatedTraceListAttributes = {};
-
-/**
- * Event attributes
- */
-export type PaginatedTraceListEventAttributes = {};
-
-/**
- * Lifecycle event within a span
- */
-export type PaginatedTraceListEvent = {
-  /**
-   * Event name
-   */
-  name: string;
-  /**
-   * Event timestamp (ISO 8601)
-   */
-  timestamp: Date;
-  /**
-   * Event attributes
-   */
-  attributes?: PaginatedTraceListEventAttributes | undefined;
-};
-
-export type PaginatedTraceListSpanMetadata = {};
-
-export type PaginatedTraceListSpan = {
-  id: string;
-  traceId: string;
-  parentSpanId: string | null;
-  name: string;
-  /**
-   * Kind of span operation (OTel Gen AI aligned)
-   */
-  kind: PaginatedTraceListKindOpen;
-  input: any | null;
-  output: any | null;
-  startTime: Date;
-  endTime: Date | null;
-  durationMs: number | null;
-  inputTokens: number | null;
-  outputTokens: number | null;
-  totalTokens: number | null;
-  model: string | null;
-  provider: string | null;
-  costUsd: string | null;
-  latencyMs: number | null;
-  ttftMs: number | null;
-  status: string;
-  statusMessage: string | null;
-  error: string | null;
-  attributes: PaginatedTraceListAttributes | null;
-  events: Array<PaginatedTraceListEvent> | null;
-  metadata: PaginatedTraceListSpanMetadata | null;
-  createdAt: Date;
-  updatedAt: Date;
-};
-
 export type PaginatedTraceListData = {
   id: string;
   workspaceId: string;
@@ -159,7 +72,10 @@ export type PaginatedTraceListData = {
   error: string | null;
   createdAt: Date;
   updatedAt: Date;
-  spans: Array<PaginatedTraceListSpan>;
+  /**
+   * Root span kind (parent_span_id IS NULL). Null if no spans exist.
+   */
+  traceKind: string | null;
 };
 
 export type PaginatedTraceList = {
@@ -206,134 +122,6 @@ export function paginatedTraceListMetadataFromJSON(
   );
 }
 
-/** @internal */
-export const PaginatedTraceListKind$inboundSchema: z.ZodMiniType<
-  PaginatedTraceListKindOpen,
-  unknown
-> = openEnums.inboundSchema(PaginatedTraceListKind);
-
-/** @internal */
-export const PaginatedTraceListAttributes$inboundSchema: z.ZodMiniType<
-  PaginatedTraceListAttributes,
-  unknown
-> = z.object({});
-
-export function paginatedTraceListAttributesFromJSON(
-  jsonString: string,
-): SafeParseResult<PaginatedTraceListAttributes, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => PaginatedTraceListAttributes$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PaginatedTraceListAttributes' from JSON`,
-  );
-}
-
-/** @internal */
-export const PaginatedTraceListEventAttributes$inboundSchema: z.ZodMiniType<
-  PaginatedTraceListEventAttributes,
-  unknown
-> = z.object({});
-
-export function paginatedTraceListEventAttributesFromJSON(
-  jsonString: string,
-): SafeParseResult<PaginatedTraceListEventAttributes, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => PaginatedTraceListEventAttributes$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PaginatedTraceListEventAttributes' from JSON`,
-  );
-}
-
-/** @internal */
-export const PaginatedTraceListEvent$inboundSchema: z.ZodMiniType<
-  PaginatedTraceListEvent,
-  unknown
-> = z.object({
-  name: types.string(),
-  timestamp: types.date(),
-  attributes: types.optional(
-    z.lazy(() => PaginatedTraceListEventAttributes$inboundSchema),
-  ),
-});
-
-export function paginatedTraceListEventFromJSON(
-  jsonString: string,
-): SafeParseResult<PaginatedTraceListEvent, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => PaginatedTraceListEvent$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PaginatedTraceListEvent' from JSON`,
-  );
-}
-
-/** @internal */
-export const PaginatedTraceListSpanMetadata$inboundSchema: z.ZodMiniType<
-  PaginatedTraceListSpanMetadata,
-  unknown
-> = z.object({});
-
-export function paginatedTraceListSpanMetadataFromJSON(
-  jsonString: string,
-): SafeParseResult<PaginatedTraceListSpanMetadata, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => PaginatedTraceListSpanMetadata$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PaginatedTraceListSpanMetadata' from JSON`,
-  );
-}
-
-/** @internal */
-export const PaginatedTraceListSpan$inboundSchema: z.ZodMiniType<
-  PaginatedTraceListSpan,
-  unknown
-> = z.object({
-  id: types.string(),
-  traceId: types.string(),
-  parentSpanId: types.nullable(types.string()),
-  name: types.string(),
-  kind: z._default(
-    PaginatedTraceListKind$inboundSchema,
-    PaginatedTraceListKind.LlmChat,
-  ),
-  input: types.nullable(z.any()),
-  output: types.nullable(z.any()),
-  startTime: types.date(),
-  endTime: types.nullable(types.date()),
-  durationMs: types.nullable(types.number()),
-  inputTokens: types.nullable(types.number()),
-  outputTokens: types.nullable(types.number()),
-  totalTokens: types.nullable(types.number()),
-  model: types.nullable(types.string()),
-  provider: types.nullable(types.string()),
-  costUsd: types.nullable(types.string()),
-  latencyMs: types.nullable(types.number()),
-  ttftMs: types.nullable(types.number()),
-  status: types.string(),
-  statusMessage: types.nullable(types.string()),
-  error: types.nullable(types.string()),
-  attributes: types.nullable(
-    z.lazy(() => PaginatedTraceListAttributes$inboundSchema),
-  ),
-  events: types.nullable(
-    z.array(z.lazy(() => PaginatedTraceListEvent$inboundSchema)),
-  ),
-  metadata: types.nullable(
-    z.lazy(() => PaginatedTraceListSpanMetadata$inboundSchema),
-  ),
-  createdAt: types.date(),
-  updatedAt: types.date(),
-});
-
-export function paginatedTraceListSpanFromJSON(
-  jsonString: string,
-): SafeParseResult<PaginatedTraceListSpan, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => PaginatedTraceListSpan$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PaginatedTraceListSpan' from JSON`,
-  );
-}
-
 /** @internal */
 export const PaginatedTraceListData$inboundSchema: z.ZodMiniType<
   PaginatedTraceListData,
@@ -368,7 +156,7 @@ export const PaginatedTraceListData$inboundSchema: z.ZodMiniType<
   error: types.nullable(types.string()),
   createdAt: types.date(),
   updatedAt: types.date(),
-  spans: z.array(z.lazy(() => PaginatedTraceListSpan$inboundSchema)),
+  traceKind: types.nullable(types.string()),
 });
 
 export function paginatedTraceListDataFromJSON(

package/src/models/prompt-dataset-export.ts

@@ -11,7 +11,7 @@ import { SDKValidationError } from "./errors/sdk-validation-error.js";
 /**
  * Test dataset object with metadata and configuration
  */
-export type PromptDatasetExportDataset = {
+export type Dataset = {
   /**
    * Unique dataset identifier
    */
@@ -49,7 +49,7 @@ export type PromptDatasetExportDataset = {
    */
   labels: Array<string> | null;
   /**
-   * Number of items in this dataset (included in list responses)
+   * Number of items in the dataset (included in list responses)
    */
   itemCount?: number | undefined;
 };
@@ -72,7 +72,7 @@ export type PromptGroup = {
 /**
  * Test case item with input/output data and feedback
  */
-export type PromptDatasetExportItem = {
+export type Item = {
   /**
    * Unique item identifier
    */
@@ -126,12 +126,12 @@ export type PromptDatasetExport = {
   /**
    * Test dataset object with metadata and configuration
    */
-  dataset: PromptDatasetExportDataset;
+  dataset: Dataset;
   promptGroup: PromptGroup;
   /**
    * All items in the dataset
    */
-  items: Array<PromptDatasetExportItem>;
+  items: Array<Item>;
   /**
    * Export timestamp
    */
@@ -139,10 +139,7 @@ export type PromptDatasetExport = {
 };
 
 /** @internal */
-export const PromptDatasetExportDataset$inboundSchema: z.ZodMiniType<
-  PromptDatasetExportDataset,
-  unknown
-> = z.object({
+export const Dataset$inboundSchema: z.ZodMiniType<Dataset, unknown> = z.object({
   id: types.number(),
   name: types.string(),
   description: types.nullable(types.string()),
@@ -155,13 +152,13 @@ export const PromptDatasetExportDataset$inboundSchema: z.ZodMiniType<
   itemCount: types.optional(types.number()),
 });
 
-export function promptDatasetExportDatasetFromJSON(
+export function datasetFromJSON(
   jsonString: string,
-): SafeParseResult<PromptDatasetExportDataset, SDKValidationError> {
+): SafeParseResult<Dataset, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => PromptDatasetExportDataset$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PromptDatasetExportDataset' from JSON`,
+    (x) => Dataset$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Dataset' from JSON`,
   );
 }
 
@@ -184,10 +181,7 @@ export function promptGroupFromJSON(
 }
 
 /** @internal */
-export const PromptDatasetExportItem$inboundSchema: z.ZodMiniType<
-  PromptDatasetExportItem,
-  unknown
-> = z.object({
+export const Item$inboundSchema: z.ZodMiniType<Item, unknown> = z.object({
   id: types.number(),
   datasetId: types.number(),
   name: types.nullable(types.string()),
@@ -201,13 +195,13 @@ export const PromptDatasetExportItem$inboundSchema: z.ZodMiniType<
   updatedAt: types.nullable(types.date()),
 });
 
-export function promptDatasetExportItemFromJSON(
+export function itemFromJSON(
   jsonString: string,
-): SafeParseResult<PromptDatasetExportItem, SDKValidationError> {
+): SafeParseResult<Item, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => PromptDatasetExportItem$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PromptDatasetExportItem' from JSON`,
+    (x) => Item$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Item' from JSON`,
   );
 }
 
@@ -216,9 +210,9 @@ export const PromptDatasetExport$inboundSchema: z.ZodMiniType<
   PromptDatasetExport,
   unknown
 > = z.object({
-  dataset: z.lazy(() => PromptDatasetExportDataset$inboundSchema),
+  dataset: z.lazy(() => Dataset$inboundSchema),
   promptGroup: z.lazy(() => PromptGroup$inboundSchema),
-  items: z.array(z.lazy(() => PromptDatasetExportItem$inboundSchema)),
+  items: z.array(z.lazy(() => Item$inboundSchema)),
   exportedAt: types.date(),
 });
 

package/src/models/prompt-dataset-list.ts

@@ -49,7 +49,7 @@ export type PromptDatasetListData = {
    */
   labels: Array<string> | null;
   /**
-   * Number of items in this dataset (included in list responses)
+   * Number of items in the dataset (included in list responses)
    */
   itemCount?: number | undefined;
 };

package/src/models/prompt-dataset.ts

@@ -49,7 +49,7 @@ export type PromptDataset = {
    */
   labels: Array<string> | null;
   /**
-   * Number of items in this dataset (included in list responses)
+   * Number of items in the dataset (included in list responses)
    */
   itemCount?: number | undefined;
 };

package/src/models/prompt-id-dataset-id-name.ts

@@ -4,32 +4,24 @@
 
 import * as z from "zod/v4-mini";
 
-/**
- * A single evaluation criterion specifying what to measure and on which output field
- */
-export type Criterion = {
-  /**
-   * Criterion name (e.g., "correctness", "completeness")
-   */
-  name: string;
+export type PromptIdDatasetIdNameCriterion = {
+  id?: string | undefined;
   /**
-   * What this criterion measures and how it should be scored
+   * Rubric text describing how to score this criterion
    */
-  description: string;
+  criteria: string;
   /**
-   * The output field this criterion evaluates (e.g., "Mandatory_Requirements")
+   * Schema field this criterion scores against
    */
   evaluationParameter: string;
+  evaluationSteps?: Array<string> | undefined;
+  name?: string | undefined;
 };
 
-/**
- * Evaluation configuration with structured criteria. Each criterion targets a specific output field.
- */
 export type PromptIdDatasetIdNameEvalConfig = {
-  /**
-   * List of evaluation criteria (at least one required)
-   */
-  criteria: Array<Criterion>;
+  criteria?: Array<PromptIdDatasetIdNameCriterion> | undefined;
+  threshold?: number | undefined;
+  model?: string | undefined;
 };
 
 /**
@@ -48,7 +40,7 @@ export type PromptIdDatasetIdName = {
    */
   promptId: number;
   /**
-   * ID of the test dataset to evaluate against (optional)
+   * ID of the test dataset to evaluate against (optional — can be linked later)
    */
   datasetId?: number | undefined;
   /**
@@ -59,10 +51,7 @@ export type PromptIdDatasetIdName = {
    * Detailed explanation of evaluation purpose and methodology
    */
   description?: string | undefined;
-  /**
-   * Evaluation configuration with structured criteria. Each criterion targets a specific output field.
-   */
-  evalConfig: PromptIdDatasetIdNameEvalConfig;
+  evalConfig?: PromptIdDatasetIdNameEvalConfig | undefined;
   /**
    * LLM execution config for running this evaluation (e.g., {"model": "gpt-4", "temperature": 0.7})
    */
@@ -82,29 +71,41 @@ export type PromptIdDatasetIdName = {
 };
 
 /** @internal */
-export type Criterion$Outbound = {
-  name: string;
-  description: string;
+export type PromptIdDatasetIdNameCriterion$Outbound = {
+  id?: string | undefined;
+  criteria: string;
   evaluationParameter: string;
+  evaluationSteps?: Array<string> | undefined;
+  name?: string | undefined;
 };
 
 /** @internal */
-export const Criterion$outboundSchema: z.ZodMiniType<
-  Criterion$Outbound,
-  Criterion
+export const PromptIdDatasetIdNameCriterion$outboundSchema: z.ZodMiniType<
+  PromptIdDatasetIdNameCriterion$Outbound,
+  PromptIdDatasetIdNameCriterion
 > = z.object({
-  name: z.string(),
-  description: z.string(),
+  id: z.optional(z.string()),
+  criteria: z.string(),
   evaluationParameter: z.string(),
+  evaluationSteps: z.optional(z.array(z.string())),
+  name: z.optional(z.string()),
 });
 
-export function criterionToJSON(criterion: Criterion): string {
-  return JSON.stringify(Criterion$outboundSchema.parse(criterion));
+export function promptIdDatasetIdNameCriterionToJSON(
+  promptIdDatasetIdNameCriterion: PromptIdDatasetIdNameCriterion,
+): string {
+  return JSON.stringify(
+    PromptIdDatasetIdNameCriterion$outboundSchema.parse(
+      promptIdDatasetIdNameCriterion,
+    ),
+  );
 }
 
 /** @internal */
 export type PromptIdDatasetIdNameEvalConfig$Outbound = {
-  criteria: Array<Criterion$Outbound>;
+  criteria?: Array<PromptIdDatasetIdNameCriterion$Outbound> | undefined;
+  threshold?: number | undefined;
+  model?: string | undefined;
 };
 
 /** @internal */
@@ -112,7 +113,11 @@ export const PromptIdDatasetIdNameEvalConfig$outboundSchema: z.ZodMiniType<
   PromptIdDatasetIdNameEvalConfig$Outbound,
   PromptIdDatasetIdNameEvalConfig
 > = z.object({
-  criteria: z.array(z.lazy(() => Criterion$outboundSchema)),
+  criteria: z.optional(
+    z.array(z.lazy(() => PromptIdDatasetIdNameCriterion$outboundSchema)),
+  ),
+  threshold: z.optional(z.number()),
+  model: z.optional(z.string()),
 });
 
 export function promptIdDatasetIdNameEvalConfigToJSON(
@@ -169,7 +174,7 @@ export type PromptIdDatasetIdName$Outbound = {
   datasetId?: number | undefined;
   name: string;
   description?: string | undefined;
-  evalConfig: PromptIdDatasetIdNameEvalConfig$Outbound;
+  evalConfig?: PromptIdDatasetIdNameEvalConfig$Outbound | undefined;
   llmConfig?: PromptIdDatasetIdNameLlmConfig$Outbound | undefined;
   tags?: Array<string> | undefined;
   metadata?: PromptIdDatasetIdNameMetadata$Outbound | undefined;
@@ -185,7 +190,9 @@ export const PromptIdDatasetIdName$outboundSchema: z.ZodMiniType<
   datasetId: z.optional(z.number()),
   name: z.string(),
   description: z.optional(z.string()),
-  evalConfig: z.lazy(() => PromptIdDatasetIdNameEvalConfig$outboundSchema),
+  evalConfig: z.optional(
+    z.lazy(() => PromptIdDatasetIdNameEvalConfig$outboundSchema),
+  ),
   llmConfig: z.optional(
     z.lazy(() => PromptIdDatasetIdNameLlmConfig$outboundSchema),
   ),

package/src/models/{success-response.ts → provider-success.ts}

@@ -11,7 +11,7 @@ import { SDKValidationError } from "./errors/sdk-validation-error.js";
 /**
  * Standard success response
  */
-export type SuccessResponse = {
+export type ProviderSuccess = {
   /**
    * Operation success status
    */
@@ -23,20 +23,20 @@ export type SuccessResponse = {
 };
 
 /** @internal */
-export const SuccessResponse$inboundSchema: z.ZodMiniType<
-  SuccessResponse,
+export const ProviderSuccess$inboundSchema: z.ZodMiniType<
+  ProviderSuccess,
   unknown
 > = z.object({
   success: types.boolean(),
   message: types.optional(types.string()),
 });
 
-export function successResponseFromJSON(
+export function providerSuccessFromJSON(
   jsonString: string,
-): SafeParseResult<SuccessResponse, SDKValidationError> {
+): SafeParseResult<ProviderSuccess, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => SuccessResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SuccessResponse' from JSON`,
+    (x) => ProviderSuccess$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSuccess' from JSON`,
   );
 }

package/src/models/{schemadefaul12.ts → schemadefaul11.ts}

@@ -4,7 +4,7 @@
 
 import * as z from "zod/v4-mini";
 
-export enum Schemadefaul12 {
+export enum Schemadefaul11 {
   Owner = "owner",
   Admin = "admin",
   Editor = "editor",
@@ -12,6 +12,6 @@ export enum Schemadefaul12 {
 }
 
 /** @internal */
-export const Schemadefaul12$outboundSchema: z.ZodMiniEnum<
-  typeof Schemadefaul12
-> = z.enum(Schemadefaul12);
+export const Schemadefaul11$outboundSchema: z.ZodMiniEnum<
+  typeof Schemadefaul11
+> = z.enum(Schemadefaul11);

package/src/models/{schemadefaul14.ts → schemadefaul13.ts}

@@ -4,13 +4,13 @@
 
 import * as z from "zod/v4-mini";
 
-export enum Schemadefaul14 {
+export enum Schemadefaul13 {
   Admin = "admin",
   Editor = "editor",
   Viewer = "viewer",
 }
 
 /** @internal */
-export const Schemadefaul14$outboundSchema: z.ZodMiniEnum<
-  typeof Schemadefaul14
-> = z.enum(Schemadefaul14);
+export const Schemadefaul13$outboundSchema: z.ZodMiniEnum<
+  typeof Schemadefaul13
+> = z.enum(Schemadefaul13);

package/src/models/success-message.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type SuccessMessage = {
+  success: boolean;
+  message?: string | undefined;
+};
+
+/** @internal */
+export const SuccessMessage$inboundSchema: z.ZodMiniType<
+  SuccessMessage,
+  unknown
+> = z.object({
+  success: types.boolean(),
+  message: types.optional(types.string()),
+});
+
+export function successMessageFromJSON(
+  jsonString: string,
+): SafeParseResult<SuccessMessage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SuccessMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SuccessMessage' from JSON`,
+  );
+}

package/src/models/trace-id-session-id-name.ts

@@ -15,7 +15,6 @@ export enum TraceIdSessionIdNameSource {
   Openai = "openai",
   Otel = "otel",
   Manual = "manual",
-  ClaudeCode = "claude-code",
 }
 
 /**

package/src/models/trace-with-spans.ts

@@ -21,7 +21,6 @@ export enum TraceWithSpansSource {
   Openai = "openai",
   Otel = "otel",
   Manual = "manual",
-  ClaudeCode = "claude-code",
 }
 /**
  * Source integration that produced this trace