@mutagent/sdk 0.2.57 → 0.2.58

package/src/models/{prompt-id-name-description.ts → prompt-id-dataset-id-name.ts}

@@ -25,7 +25,7 @@ export type Criterion = {
 /**
  * Evaluation configuration with structured criteria. Each criterion targets a specific output field.
  */
-export type EvalConfig = {
+export type PromptIdDatasetIdNameEvalConfig = {
   /**
    * List of evaluation criteria (at least one required)
    */
@@ -35,18 +35,22 @@ export type EvalConfig = {
 /**
  * LLM execution config for running this evaluation (e.g., {"model": "gpt-4", "temperature": 0.7})
  */
-export type PromptIdNameDescriptionLlmConfig = {};
+export type PromptIdDatasetIdNameLlmConfig = {};
 
 /**
  * Arbitrary metadata for tracking
  */
-export type PromptIdNameDescriptionMetadata = {};
+export type PromptIdDatasetIdNameMetadata = {};
 
-export type PromptIdNameDescription = {
+export type PromptIdDatasetIdName = {
   /**
    * ID of the prompt to evaluate (e.g., 123). Resolved to promptGroupId internally
    */
   promptId: number;
+  /**
+   * ID of the test dataset to evaluate against (optional)
+   */
+  datasetId?: number | undefined;
   /**
    * Human-readable evaluation name (e.g., "Customer Support Quality Eval")
    */
@@ -58,11 +62,11 @@ export type PromptIdNameDescription = {
   /**
    * Evaluation configuration with structured criteria. Each criterion targets a specific output field.
    */
-  evalConfig: EvalConfig;
+  evalConfig: PromptIdDatasetIdNameEvalConfig;
   /**
    * LLM execution config for running this evaluation (e.g., {"model": "gpt-4", "temperature": 0.7})
    */
-  llmConfig?: PromptIdNameDescriptionLlmConfig | undefined;
+  llmConfig?: PromptIdDatasetIdNameLlmConfig | undefined;
   /**
    * Organization tags (e.g., ["production", "baseline", "v2"])
    */
@@ -70,7 +74,7 @@ export type PromptIdNameDescription = {
   /**
    * Arbitrary metadata for tracking
    */
-  metadata?: PromptIdNameDescriptionMetadata | undefined;
+  metadata?: PromptIdDatasetIdNameMetadata | undefined;
   /**
    * Email of the evaluation creator
    */
@@ -99,95 +103,103 @@ export function criterionToJSON(criterion: Criterion): string {
 }
 
 /** @internal */
-export type EvalConfig$Outbound = {
+export type PromptIdDatasetIdNameEvalConfig$Outbound = {
   criteria: Array<Criterion$Outbound>;
 };
 
 /** @internal */
-export const EvalConfig$outboundSchema: z.ZodMiniType<
-  EvalConfig$Outbound,
-  EvalConfig
+export const PromptIdDatasetIdNameEvalConfig$outboundSchema: z.ZodMiniType<
+  PromptIdDatasetIdNameEvalConfig$Outbound,
+  PromptIdDatasetIdNameEvalConfig
 > = z.object({
   criteria: z.array(z.lazy(() => Criterion$outboundSchema)),
 });
 
-export function evalConfigToJSON(evalConfig: EvalConfig): string {
-  return JSON.stringify(EvalConfig$outboundSchema.parse(evalConfig));
+export function promptIdDatasetIdNameEvalConfigToJSON(
+  promptIdDatasetIdNameEvalConfig: PromptIdDatasetIdNameEvalConfig,
+): string {
+  return JSON.stringify(
+    PromptIdDatasetIdNameEvalConfig$outboundSchema.parse(
+      promptIdDatasetIdNameEvalConfig,
+    ),
+  );
 }
 
 /** @internal */
-export type PromptIdNameDescriptionLlmConfig$Outbound = {};
+export type PromptIdDatasetIdNameLlmConfig$Outbound = {};
 
 /** @internal */
-export const PromptIdNameDescriptionLlmConfig$outboundSchema: z.ZodMiniType<
-  PromptIdNameDescriptionLlmConfig$Outbound,
-  PromptIdNameDescriptionLlmConfig
+export const PromptIdDatasetIdNameLlmConfig$outboundSchema: z.ZodMiniType<
+  PromptIdDatasetIdNameLlmConfig$Outbound,
+  PromptIdDatasetIdNameLlmConfig
 > = z.object({});
 
-export function promptIdNameDescriptionLlmConfigToJSON(
-  promptIdNameDescriptionLlmConfig: PromptIdNameDescriptionLlmConfig,
+export function promptIdDatasetIdNameLlmConfigToJSON(
+  promptIdDatasetIdNameLlmConfig: PromptIdDatasetIdNameLlmConfig,
 ): string {
   return JSON.stringify(
-    PromptIdNameDescriptionLlmConfig$outboundSchema.parse(
-      promptIdNameDescriptionLlmConfig,
+    PromptIdDatasetIdNameLlmConfig$outboundSchema.parse(
+      promptIdDatasetIdNameLlmConfig,
     ),
   );
 }
 
 /** @internal */
-export type PromptIdNameDescriptionMetadata$Outbound = {};
+export type PromptIdDatasetIdNameMetadata$Outbound = {};
 
 /** @internal */
-export const PromptIdNameDescriptionMetadata$outboundSchema: z.ZodMiniType<
-  PromptIdNameDescriptionMetadata$Outbound,
-  PromptIdNameDescriptionMetadata
+export const PromptIdDatasetIdNameMetadata$outboundSchema: z.ZodMiniType<
+  PromptIdDatasetIdNameMetadata$Outbound,
+  PromptIdDatasetIdNameMetadata
 > = z.object({});
 
-export function promptIdNameDescriptionMetadataToJSON(
-  promptIdNameDescriptionMetadata: PromptIdNameDescriptionMetadata,
+export function promptIdDatasetIdNameMetadataToJSON(
+  promptIdDatasetIdNameMetadata: PromptIdDatasetIdNameMetadata,
 ): string {
   return JSON.stringify(
-    PromptIdNameDescriptionMetadata$outboundSchema.parse(
-      promptIdNameDescriptionMetadata,
+    PromptIdDatasetIdNameMetadata$outboundSchema.parse(
+      promptIdDatasetIdNameMetadata,
     ),
   );
 }
 
 /** @internal */
-export type PromptIdNameDescription$Outbound = {
+export type PromptIdDatasetIdName$Outbound = {
   promptId: number;
+  datasetId?: number | undefined;
   name: string;
   description?: string | undefined;
-  evalConfig: EvalConfig$Outbound;
-  llmConfig?: PromptIdNameDescriptionLlmConfig$Outbound | undefined;
+  evalConfig: PromptIdDatasetIdNameEvalConfig$Outbound;
+  llmConfig?: PromptIdDatasetIdNameLlmConfig$Outbound | undefined;
   tags?: Array<string> | undefined;
-  metadata?: PromptIdNameDescriptionMetadata$Outbound | undefined;
+  metadata?: PromptIdDatasetIdNameMetadata$Outbound | undefined;
   createdBy?: string | undefined;
 };
 
 /** @internal */
-export const PromptIdNameDescription$outboundSchema: z.ZodMiniType<
-  PromptIdNameDescription$Outbound,
-  PromptIdNameDescription
+export const PromptIdDatasetIdName$outboundSchema: z.ZodMiniType<
+  PromptIdDatasetIdName$Outbound,
+  PromptIdDatasetIdName
 > = z.object({
   promptId: z.number(),
+  datasetId: z.optional(z.number()),
   name: z.string(),
   description: z.optional(z.string()),
-  evalConfig: z.lazy(() => EvalConfig$outboundSchema),
+  evalConfig: z.lazy(() => PromptIdDatasetIdNameEvalConfig$outboundSchema),
   llmConfig: z.optional(
-    z.lazy(() => PromptIdNameDescriptionLlmConfig$outboundSchema),
+    z.lazy(() => PromptIdDatasetIdNameLlmConfig$outboundSchema),
   ),
   tags: z.optional(z.array(z.string())),
   metadata: z.optional(
-    z.lazy(() => PromptIdNameDescriptionMetadata$outboundSchema),
+    z.lazy(() => PromptIdDatasetIdNameMetadata$outboundSchema),
   ),
   createdBy: z.optional(z.string()),
 });
 
-export function promptIdNameDescriptionToJSON(
-  promptIdNameDescription: PromptIdNameDescription,
+export function promptIdDatasetIdNameToJSON(
+  promptIdDatasetIdName: PromptIdDatasetIdName,
 ): string {
   return JSON.stringify(
-    PromptIdNameDescription$outboundSchema.parse(promptIdNameDescription),
+    PromptIdDatasetIdName$outboundSchema.parse(promptIdDatasetIdName),
   );
 }

package/src/models/prompt-id-executions.ts

@@ -0,0 +1,124 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import {
+  InputOutputTotal,
+  InputOutputTotal$Outbound,
+  InputOutputTotal$outboundSchema,
+} from "./input-output-total.js";
+import { Schemaenum2, Schemaenum2$outboundSchema } from "./schemaenum2.js";
+
+/**
+ * Input variables for this execution
+ */
+export type PromptIdExecutionsInputs = {};
+
+export type Execution = {
+  /**
+   * Input variables for this execution
+   */
+  inputs: PromptIdExecutionsInputs;
+  /**
+   * Model used for this execution
+   */
+  model: string;
+  /**
+   * Generated LLM response
+   */
+  actualOutput: string;
+  executionStatus: Schemaenum2;
+  executionTime?: number | undefined;
+  executionError?: string | undefined;
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  tokenUsage?: InputOutputTotal | undefined;
+  cost?: number | undefined;
+};
+
+export type PromptIdExecutions = {
+  /**
+   * ID of the prompt executed across models
+   */
+  promptId: number;
+  /**
+   * Array of executions (one per model)
+   */
+  executions: Array<Execution>;
+};
+
+/** @internal */
+export type PromptIdExecutionsInputs$Outbound = {};
+
+/** @internal */
+export const PromptIdExecutionsInputs$outboundSchema: z.ZodMiniType<
+  PromptIdExecutionsInputs$Outbound,
+  PromptIdExecutionsInputs
+> = z.object({});
+
+export function promptIdExecutionsInputsToJSON(
+  promptIdExecutionsInputs: PromptIdExecutionsInputs,
+): string {
+  return JSON.stringify(
+    PromptIdExecutionsInputs$outboundSchema.parse(promptIdExecutionsInputs),
+  );
+}
+
+/** @internal */
+export type Execution$Outbound = {
+  inputs: PromptIdExecutionsInputs$Outbound;
+  model: string;
+  actualOutput: string;
+  executionStatus: string;
+  executionTime?: number | undefined;
+  executionError?: string | undefined;
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  tokenUsage?: InputOutputTotal$Outbound | undefined;
+  cost?: number | undefined;
+};
+
+/** @internal */
+export const Execution$outboundSchema: z.ZodMiniType<
+  Execution$Outbound,
+  Execution
+> = z.object({
+  inputs: z.lazy(() => PromptIdExecutionsInputs$outboundSchema),
+  model: z.string(),
+  actualOutput: z.string(),
+  executionStatus: Schemaenum2$outboundSchema,
+  executionTime: z.optional(z.number()),
+  executionError: z.optional(z.string()),
+  temperature: z.optional(z.number()),
+  maxTokens: z.optional(z.number()),
+  tokenUsage: z.optional(InputOutputTotal$outboundSchema),
+  cost: z.optional(z.number()),
+});
+
+export function executionToJSON(execution: Execution): string {
+  return JSON.stringify(Execution$outboundSchema.parse(execution));
+}
+
+/** @internal */
+export type PromptIdExecutions$Outbound = {
+  promptId: number;
+  executions: Array<Execution$Outbound>;
+};
+
+/** @internal */
+export const PromptIdExecutions$outboundSchema: z.ZodMiniType<
+  PromptIdExecutions$Outbound,
+  PromptIdExecutions
+> = z.object({
+  promptId: z.number(),
+  executions: z.array(z.lazy(() => Execution$outboundSchema)),
+});
+
+export function promptIdExecutionsToJSON(
+  promptIdExecutions: PromptIdExecutions,
+): string {
+  return JSON.stringify(
+    PromptIdExecutions$outboundSchema.parse(promptIdExecutions),
+  );
+}

package/src/models/prompt-id-inputs-model.ts

@@ -0,0 +1,163 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+/**
+ * Input variables used for the execution
+ */
+export type PromptIdInputsModelInputs = {};
+
+export enum ExecutionStatus {
+  Success = "success",
+  Failed = "failed",
+  Timeout = "timeout",
+  Error = "error",
+}
+
+/**
+ * Token usage breakdown
+ */
+export type TokenUsage = {
+  /**
+   * Input tokens used
+   */
+  input: number;
+  /**
+   * Output tokens generated
+   */
+  output: number;
+  /**
+   * Total tokens used
+   */
+  total: number;
+};
+
+export type PromptIdInputsModel = {
+  /**
+   * ID of the prompt that was executed
+   */
+  promptId: number;
+  /**
+   * Input variables used for the execution
+   */
+  inputs: PromptIdInputsModelInputs;
+  /**
+   * Model used (e.g., "gpt-5", "claude-sonnet-4-5")
+   */
+  model: string;
+  /**
+   * The generated LLM response (JSON string)
+   */
+  actualOutput: string;
+  executionStatus: ExecutionStatus;
+  /**
+   * Execution time in milliseconds
+   */
+  executionTime?: number | undefined;
+  /**
+   * Error message if execution failed
+   */
+  executionError?: string | undefined;
+  /**
+   * Model temperature (0.0-2.0)
+   */
+  temperature?: number | undefined;
+  /**
+   * Max tokens configuration
+   */
+  maxTokens?: number | undefined;
+  /**
+   * Token usage breakdown
+   */
+  tokenUsage?: TokenUsage | undefined;
+  /**
+   * Estimated cost in USD
+   */
+  cost?: number | undefined;
+};
+
+/** @internal */
+export type PromptIdInputsModelInputs$Outbound = {};
+
+/** @internal */
+export const PromptIdInputsModelInputs$outboundSchema: z.ZodMiniType<
+  PromptIdInputsModelInputs$Outbound,
+  PromptIdInputsModelInputs
+> = z.object({});
+
+export function promptIdInputsModelInputsToJSON(
+  promptIdInputsModelInputs: PromptIdInputsModelInputs,
+): string {
+  return JSON.stringify(
+    PromptIdInputsModelInputs$outboundSchema.parse(promptIdInputsModelInputs),
+  );
+}
+
+/** @internal */
+export const ExecutionStatus$outboundSchema: z.ZodMiniEnum<
+  typeof ExecutionStatus
+> = z.enum(ExecutionStatus);
+
+/** @internal */
+export type TokenUsage$Outbound = {
+  input: number;
+  output: number;
+  total: number;
+};
+
+/** @internal */
+export const TokenUsage$outboundSchema: z.ZodMiniType<
+  TokenUsage$Outbound,
+  TokenUsage
+> = z.object({
+  input: z.number(),
+  output: z.number(),
+  total: z.number(),
+});
+
+export function tokenUsageToJSON(tokenUsage: TokenUsage): string {
+  return JSON.stringify(TokenUsage$outboundSchema.parse(tokenUsage));
+}
+
+/** @internal */
+export type PromptIdInputsModel$Outbound = {
+  promptId: number;
+  inputs: PromptIdInputsModelInputs$Outbound;
+  model: string;
+  actualOutput: string;
+  executionStatus: string;
+  executionTime?: number | undefined;
+  executionError?: string | undefined;
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  tokenUsage?: TokenUsage$Outbound | undefined;
+  cost?: number | undefined;
+};
+
+/** @internal */
+export const PromptIdInputsModel$outboundSchema: z.ZodMiniType<
+  PromptIdInputsModel$Outbound,
+  PromptIdInputsModel
+> = z.object({
+  promptId: z.number(),
+  inputs: z.lazy(() => PromptIdInputsModelInputs$outboundSchema),
+  model: z.string(),
+  actualOutput: z.string(),
+  executionStatus: ExecutionStatus$outboundSchema,
+  executionTime: z.optional(z.number()),
+  executionError: z.optional(z.string()),
+  temperature: z.optional(z.number()),
+  maxTokens: z.optional(z.number()),
+  tokenUsage: z.optional(z.lazy(() => TokenUsage$outboundSchema)),
+  cost: z.optional(z.number()),
+});
+
+export function promptIdInputsModelToJSON(
+  promptIdInputsModel: PromptIdInputsModel,
+): string {
+  return JSON.stringify(
+    PromptIdInputsModel$outboundSchema.parse(promptIdInputsModel),
+  );
+}

package/src/models/prompt-id-prompt-group-id-evaluation-id.ts

@@ -0,0 +1,182 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { smartUnion } from "../types/smart-union.js";
+
+/**
+ * ID of the prompt to experiment with
+ */
+export type PromptId = string | number;
+
+/**
+ * ID of the evaluation criteria to use
+ */
+export type EvaluationId = string | number;
+
+/**
+ * ID of the dataset to use
+ */
+export type DatasetId = string | number;
+
+export type Model = {
+  /**
+   * Client-generated column ID (e.g., "col_abc123")
+   */
+  id: string;
+  /**
+   * Model identifier (e.g., "gpt-5", "claude-sonnet-4-5")
+   */
+  model: string;
+  /**
+   * Sampling temperature (0-2)
+   */
+  temperature: number;
+};
+
+/**
+ * Snapshot of dataset size at run time
+ */
+export type DatasetItemCount = string | number;
+
+export type PromptIdPromptGroupIdEvaluationId = {
+  /**
+   * ID of the prompt to experiment with
+   */
+  promptId: string | number;
+  /**
+   * Prompt group UUID for filtering experiments by prompt family
+   */
+  promptGroupId: string;
+  /**
+   * ID of the evaluation criteria to use
+   */
+  evaluationId: string | number;
+  /**
+   * ID of the dataset to use
+   */
+  datasetId: string | number;
+  /**
+   * Array of model configurations (1-4 models)
+   */
+  models: Array<Model>;
+  /**
+   * Snapshot of dataset size at run time
+   */
+  datasetItemCount?: string | number | undefined;
+  /**
+   * Experiment name (auto-generated if not provided)
+   */
+  name?: string | undefined;
+};
+
+/** @internal */
+export type PromptId$Outbound = string | number;
+
+/** @internal */
+export const PromptId$outboundSchema: z.ZodMiniType<
+  PromptId$Outbound,
+  PromptId
+> = smartUnion([z.string(), z.int()]);
+
+export function promptIdToJSON(promptId: PromptId): string {
+  return JSON.stringify(PromptId$outboundSchema.parse(promptId));
+}
+
+/** @internal */
+export type EvaluationId$Outbound = string | number;
+
+/** @internal */
+export const EvaluationId$outboundSchema: z.ZodMiniType<
+  EvaluationId$Outbound,
+  EvaluationId
+> = smartUnion([z.string(), z.int()]);
+
+export function evaluationIdToJSON(evaluationId: EvaluationId): string {
+  return JSON.stringify(EvaluationId$outboundSchema.parse(evaluationId));
+}
+
+/** @internal */
+export type DatasetId$Outbound = string | number;
+
+/** @internal */
+export const DatasetId$outboundSchema: z.ZodMiniType<
+  DatasetId$Outbound,
+  DatasetId
+> = smartUnion([z.string(), z.int()]);
+
+export function datasetIdToJSON(datasetId: DatasetId): string {
+  return JSON.stringify(DatasetId$outboundSchema.parse(datasetId));
+}
+
+/** @internal */
+export type Model$Outbound = {
+  id: string;
+  model: string;
+  temperature: number;
+};
+
+/** @internal */
+export const Model$outboundSchema: z.ZodMiniType<Model$Outbound, Model> = z
+  .object({
+    id: z.string(),
+    model: z.string(),
+    temperature: z.number(),
+  });
+
+export function modelToJSON(model: Model): string {
+  return JSON.stringify(Model$outboundSchema.parse(model));
+}
+
+/** @internal */
+export type DatasetItemCount$Outbound = string | number;
+
+/** @internal */
+export const DatasetItemCount$outboundSchema: z.ZodMiniType<
+  DatasetItemCount$Outbound,
+  DatasetItemCount
+> = smartUnion([z.string(), z.int()]);
+
+export function datasetItemCountToJSON(
+  datasetItemCount: DatasetItemCount,
+): string {
+  return JSON.stringify(
+    DatasetItemCount$outboundSchema.parse(datasetItemCount),
+  );
+}
+
+/** @internal */
+export type PromptIdPromptGroupIdEvaluationId$Outbound = {
+  promptId: string | number;
+  promptGroupId: string;
+  evaluationId: string | number;
+  datasetId: string | number;
+  models: Array<Model$Outbound>;
+  datasetItemCount?: string | number | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const PromptIdPromptGroupIdEvaluationId$outboundSchema: z.ZodMiniType<
+  PromptIdPromptGroupIdEvaluationId$Outbound,
+  PromptIdPromptGroupIdEvaluationId
+> = z.object({
+  promptId: smartUnion([z.string(), z.int()]),
+  promptGroupId: z.string(),
+  evaluationId: smartUnion([z.string(), z.int()]),
+  datasetId: smartUnion([z.string(), z.int()]),
+  models: z.array(z.lazy(() => Model$outboundSchema)),
+  datasetItemCount: z.optional(smartUnion([z.string(), z.int()])),
+  name: z.optional(z.string()),
+});
+
+export function promptIdPromptGroupIdEvaluationIdToJSON(
+  promptIdPromptGroupIdEvaluationId: PromptIdPromptGroupIdEvaluationId,
+): string {
+  return JSON.stringify(
+    PromptIdPromptGroupIdEvaluationId$outboundSchema.parse(
+      promptIdPromptGroupIdEvaluationId,
+    ),
+  );
+}