@mutagent/sdk 0.2.111 → 0.2.116

package/src/models/analytics-summary.ts

@@ -0,0 +1,379 @@
+/*
+ * 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 Kpis = {
+  totalRequests: number;
+  successRate: number;
+  avgLatencyMs: number;
+  totalCostUsd: number;
+};
+
+export type CostByModel = {
+  model: string;
+  cost: number;
+  percentage: number;
+};
+
+export type Models = {};
+
+export type TokensOverTime = {
+  timestamp: string;
+  models: Models;
+  total: number;
+};
+
+export type LatencyPercentile = {
+  timestamp: string;
+  p50: number;
+  p90: number;
+  p99: number;
+};
+
+export type ErrorRate = {
+  timestamp: string;
+  errorRate: number;
+  totalRequests: number;
+  errors: number;
+};
+
+export type CostEfficiency = {
+  model: string;
+  totalRequests: number;
+  successRate: number;
+  avgLatencyMs: number;
+  totalTokens: number;
+  totalCost: number;
+  costPer1kTokens: number;
+  efficiencyScore: number;
+};
+
+export type BudgetBurndown = {
+  timestamp: string;
+  dailyCost: number;
+  cumulativeCost: number;
+  remainingBudget: number;
+};
+
+export type PreviousPeriodKpis = {
+  totalRequests: number;
+  successRate: number;
+  avgLatencyMs: number;
+  totalCostUsd: number;
+};
+
+export type KpiSparklines = {
+  totalRequests: Array<number>;
+  successRate: Array<number>;
+  avgLatencyMs: Array<number>;
+  totalCostUsd: Array<number>;
+};
+
+export type ErrorBreakdown = {
+  timestamp: string;
+  timeout: number;
+  connectionError: number;
+  rateLimit: number;
+  other: number;
+};
+
+export type ModelComparison = {
+  model: string;
+  avgLatencyMs: number;
+  totalCost: number;
+  successRate: number;
+  totalTokens: number;
+};
+
+export type AnalyticsSummary = {
+  kpis: Kpis;
+  costByModel: Array<CostByModel>;
+  tokensOverTime: Array<TokensOverTime>;
+  latencyPercentiles: Array<LatencyPercentile>;
+  errorRate: Array<ErrorRate>;
+  costEfficiency: Array<CostEfficiency>;
+  budgetBurndown: Array<BudgetBurndown>;
+  previousPeriodKpis: PreviousPeriodKpis | null;
+  kpiSparklines: KpiSparklines;
+  errorBreakdown: Array<ErrorBreakdown>;
+  modelComparison: Array<ModelComparison>;
+};
+
+/** @internal */
+export const Kpis$inboundSchema: z.ZodMiniType<Kpis, unknown> = z.object({
+  totalRequests: types.number(),
+  successRate: types.number(),
+  avgLatencyMs: types.number(),
+  totalCostUsd: types.number(),
+});
+
+export function kpisFromJSON(
+  jsonString: string,
+): SafeParseResult<Kpis, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Kpis$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Kpis' from JSON`,
+  );
+}
+
+/** @internal */
+export const CostByModel$inboundSchema: z.ZodMiniType<CostByModel, unknown> = z
+  .object({
+    model: types.string(),
+    cost: types.number(),
+    percentage: types.number(),
+  });
+
+export function costByModelFromJSON(
+  jsonString: string,
+): SafeParseResult<CostByModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CostByModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CostByModel' from JSON`,
+  );
+}
+
+/** @internal */
+export const Models$inboundSchema: z.ZodMiniType<Models, unknown> = z.object(
+  {},
+);
+
+export function modelsFromJSON(
+  jsonString: string,
+): SafeParseResult<Models, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Models$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Models' from JSON`,
+  );
+}
+
+/** @internal */
+export const TokensOverTime$inboundSchema: z.ZodMiniType<
+  TokensOverTime,
+  unknown
+> = z.object({
+  timestamp: types.string(),
+  models: z.lazy(() => Models$inboundSchema),
+  total: types.number(),
+});
+
+export function tokensOverTimeFromJSON(
+  jsonString: string,
+): SafeParseResult<TokensOverTime, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TokensOverTime$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TokensOverTime' from JSON`,
+  );
+}
+
+/** @internal */
+export const LatencyPercentile$inboundSchema: z.ZodMiniType<
+  LatencyPercentile,
+  unknown
+> = z.object({
+  timestamp: types.string(),
+  p50: types.number(),
+  p90: types.number(),
+  p99: types.number(),
+});
+
+export function latencyPercentileFromJSON(
+  jsonString: string,
+): SafeParseResult<LatencyPercentile, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LatencyPercentile$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LatencyPercentile' from JSON`,
+  );
+}
+
+/** @internal */
+export const ErrorRate$inboundSchema: z.ZodMiniType<ErrorRate, unknown> = z
+  .object({
+    timestamp: types.string(),
+    errorRate: types.number(),
+    totalRequests: types.number(),
+    errors: types.number(),
+  });
+
+export function errorRateFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorRate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorRate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorRate' from JSON`,
+  );
+}
+
+/** @internal */
+export const CostEfficiency$inboundSchema: z.ZodMiniType<
+  CostEfficiency,
+  unknown
+> = z.object({
+  model: types.string(),
+  totalRequests: types.number(),
+  successRate: types.number(),
+  avgLatencyMs: types.number(),
+  totalTokens: types.number(),
+  totalCost: types.number(),
+  costPer1kTokens: types.number(),
+  efficiencyScore: types.number(),
+});
+
+export function costEfficiencyFromJSON(
+  jsonString: string,
+): SafeParseResult<CostEfficiency, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CostEfficiency$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CostEfficiency' from JSON`,
+  );
+}
+
+/** @internal */
+export const BudgetBurndown$inboundSchema: z.ZodMiniType<
+  BudgetBurndown,
+  unknown
+> = z.object({
+  timestamp: types.string(),
+  dailyCost: types.number(),
+  cumulativeCost: types.number(),
+  remainingBudget: types.number(),
+});
+
+export function budgetBurndownFromJSON(
+  jsonString: string,
+): SafeParseResult<BudgetBurndown, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BudgetBurndown$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BudgetBurndown' from JSON`,
+  );
+}
+
+/** @internal */
+export const PreviousPeriodKpis$inboundSchema: z.ZodMiniType<
+  PreviousPeriodKpis,
+  unknown
+> = z.object({
+  totalRequests: types.number(),
+  successRate: types.number(),
+  avgLatencyMs: types.number(),
+  totalCostUsd: types.number(),
+});
+
+export function previousPeriodKpisFromJSON(
+  jsonString: string,
+): SafeParseResult<PreviousPeriodKpis, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PreviousPeriodKpis$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PreviousPeriodKpis' from JSON`,
+  );
+}
+
+/** @internal */
+export const KpiSparklines$inboundSchema: z.ZodMiniType<
+  KpiSparklines,
+  unknown
+> = z.object({
+  totalRequests: z.array(types.number()),
+  successRate: z.array(types.number()),
+  avgLatencyMs: z.array(types.number()),
+  totalCostUsd: z.array(types.number()),
+});
+
+export function kpiSparklinesFromJSON(
+  jsonString: string,
+): SafeParseResult<KpiSparklines, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => KpiSparklines$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KpiSparklines' from JSON`,
+  );
+}
+
+/** @internal */
+export const ErrorBreakdown$inboundSchema: z.ZodMiniType<
+  ErrorBreakdown,
+  unknown
+> = z.object({
+  timestamp: types.string(),
+  timeout: types.number(),
+  connectionError: types.number(),
+  rateLimit: types.number(),
+  other: types.number(),
+});
+
+export function errorBreakdownFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorBreakdown, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorBreakdown$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorBreakdown' from JSON`,
+  );
+}
+
+/** @internal */
+export const ModelComparison$inboundSchema: z.ZodMiniType<
+  ModelComparison,
+  unknown
+> = z.object({
+  model: types.string(),
+  avgLatencyMs: types.number(),
+  totalCost: types.number(),
+  successRate: types.number(),
+  totalTokens: types.number(),
+});
+
+export function modelComparisonFromJSON(
+  jsonString: string,
+): SafeParseResult<ModelComparison, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ModelComparison$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ModelComparison' from JSON`,
+  );
+}
+
+/** @internal */
+export const AnalyticsSummary$inboundSchema: z.ZodMiniType<
+  AnalyticsSummary,
+  unknown
+> = z.object({
+  kpis: z.lazy(() => Kpis$inboundSchema),
+  costByModel: z.array(z.lazy(() => CostByModel$inboundSchema)),
+  tokensOverTime: z.array(z.lazy(() => TokensOverTime$inboundSchema)),
+  latencyPercentiles: z.array(z.lazy(() => LatencyPercentile$inboundSchema)),
+  errorRate: z.array(z.lazy(() => ErrorRate$inboundSchema)),
+  costEfficiency: z.array(z.lazy(() => CostEfficiency$inboundSchema)),
+  budgetBurndown: z.array(z.lazy(() => BudgetBurndown$inboundSchema)),
+  previousPeriodKpis: types.nullable(
+    z.lazy(() => PreviousPeriodKpis$inboundSchema),
+  ),
+  kpiSparklines: z.lazy(() => KpiSparklines$inboundSchema),
+  errorBreakdown: z.array(z.lazy(() => ErrorBreakdown$inboundSchema)),
+  modelComparison: z.array(z.lazy(() => ModelComparison$inboundSchema)),
+});
+
+export function analyticsSummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsSummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsSummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsSummary' from JSON`,
+  );
+}

package/src/models/criteria-threshold-model.ts

@@ -0,0 +1,83 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type CriteriaThresholdModelCriterion = {
+  id?: string | undefined;
+  /**
+   * Rubric text describing how to score this criterion
+   */
+  criteria: string;
+  /**
+   * Schema field this criterion scores against
+   */
+  evaluationParameter: string;
+  evaluationSteps?: Array<string> | undefined;
+  name?: string | undefined;
+};
+
+export type CriteriaThresholdModel = {
+  criteria?: Array<CriteriaThresholdModelCriterion> | undefined;
+  threshold?: number | undefined;
+  model?: string | undefined;
+};
+
+/** @internal */
+export type CriteriaThresholdModelCriterion$Outbound = {
+  id?: string | undefined;
+  criteria: string;
+  evaluationParameter: string;
+  evaluationSteps?: Array<string> | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const CriteriaThresholdModelCriterion$outboundSchema: z.ZodMiniType<
+  CriteriaThresholdModelCriterion$Outbound,
+  CriteriaThresholdModelCriterion
+> = z.object({
+  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 criteriaThresholdModelCriterionToJSON(
+  criteriaThresholdModelCriterion: CriteriaThresholdModelCriterion,
+): string {
+  return JSON.stringify(
+    CriteriaThresholdModelCriterion$outboundSchema.parse(
+      criteriaThresholdModelCriterion,
+    ),
+  );
+}
+
+/** @internal */
+export type CriteriaThresholdModel$Outbound = {
+  criteria?: Array<CriteriaThresholdModelCriterion$Outbound> | undefined;
+  threshold?: number | undefined;
+  model?: string | undefined;
+};
+
+/** @internal */
+export const CriteriaThresholdModel$outboundSchema: z.ZodMiniType<
+  CriteriaThresholdModel$Outbound,
+  CriteriaThresholdModel
+> = z.object({
+  criteria: z.optional(
+    z.array(z.lazy(() => CriteriaThresholdModelCriterion$outboundSchema)),
+  ),
+  threshold: z.optional(z.number()),
+  model: z.optional(z.string()),
+});
+
+export function criteriaThresholdModelToJSON(
+  criteriaThresholdModel: CriteriaThresholdModel,
+): string {
+  return JSON.stringify(
+    CriteriaThresholdModel$outboundSchema.parse(criteriaThresholdModel),
+  );
+}

package/src/models/dataset-id-evaluation-id-config.ts

@@ -11,7 +11,22 @@ export type DatasetIdEvaluationIdConfigConfig = {
   targetScore?: number | undefined;
   patience?: number | undefined;
   dryRun?: boolean | undefined;
+  /**
+   * Deprecated: use optimizationModel instead. Alias for optimizationModel.
+   */
   model?: string | undefined;
+  /**
+   * Model for running the prompt (execution stage)
+   */
+  executionModel?: string | undefined;
+  /**
+   * Model for MetaTuner optimization stages (mutation, analysis)
+   */
+  optimizationModel?: string | undefined;
+  /**
+   * Model for evaluation scoring
+   */
+  evaluationModel?: string | undefined;
   tuningParams?: TuningParams | undefined;
 };
 
@@ -48,6 +63,9 @@ export type DatasetIdEvaluationIdConfigConfig$Outbound = {
   patience?: number | undefined;
   dryRun?: boolean | undefined;
   model?: string | undefined;
+  executionModel?: string | undefined;
+  optimizationModel?: string | undefined;
+  evaluationModel?: string | undefined;
   tuningParams?: TuningParams$Outbound | undefined;
 };
 
@@ -61,6 +79,9 @@ export const DatasetIdEvaluationIdConfigConfig$outboundSchema: z.ZodMiniType<
   patience: z.optional(z.number()),
   dryRun: z.optional(z.boolean()),
   model: z.optional(z.string()),
+  executionModel: z.optional(z.string()),
+  optimizationModel: z.optional(z.string()),
+  evaluationModel: z.optional(z.string()),
   tuningParams: z.optional(z.lazy(() => TuningParams$outboundSchema)),
 });
 

package/src/models/errors/index.ts

@@ -8,7 +8,10 @@ export * from "./error-response.js";
 export * from "./http-client-errors.js";
 export * from "./mutagent-error.js";
 export * from "./optimization-error.js";
+export * from "./provider-error.js";
 export * from "./response-validation-error.js";
 export * from "./sdk-error.js";
 export * from "./sdk-validation-error.js";
 export * from "./test-connection-result-error.js";
+export * from "./trace-error.js";
+export * from "./ws-error.js";

package/src/models/errors/optimization-error.ts

@@ -8,10 +8,12 @@ import { MutagentError } from "./mutagent-error.js";
 
 export type OptimizationErrorData = {
   error: string;
+  code?: string | undefined;
 };
 
 export class OptimizationError extends MutagentError {
   error: string;
+  code?: string | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: OptimizationErrorData;
@@ -26,6 +28,7 @@ export class OptimizationError extends MutagentError {
     super(message, httpMeta);
     this.data$ = err;
     this.error = err.error;
+    if (err.code != null) this.code = err.code;
 
     this.name = "OptimizationError";
   }
@@ -38,6 +41,7 @@ export const OptimizationError$inboundSchema: z.ZodMiniType<
 > = z.pipe(
   z.object({
     error: types.string(),
+    code: types.optional(types.string()),
     request$: z.custom<Request>(x => x instanceof Request),
     response$: z.custom<Response>(x => x instanceof Response),
     body$: z.string(),

package/src/models/errors/provider-error.ts

@@ -0,0 +1,72 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as types from "../../types/primitives.js";
+import { MutagentError } from "./mutagent-error.js";
+
+/**
+ * Standard error response
+ */
+export type ProviderErrorData = {
+  /**
+   * Error type or code
+   */
+  error: string;
+  /**
+   * Human-readable error message
+   */
+  message: string;
+  /**
+   * HTTP status code
+   */
+  statusCode?: number | undefined;
+};
+
+/**
+ * Standard error response
+ */
+export class ProviderError extends MutagentError {
+  /**
+   * Error type or code
+   */
+  error: string;
+
+  /** The original data that was passed to this error instance. */
+  data$: ProviderErrorData;
+
+  constructor(
+    err: ProviderErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "ProviderError";
+  }
+}
+
+/** @internal */
+export const ProviderError$inboundSchema: z.ZodMiniType<
+  ProviderError,
+  unknown
+> = z.pipe(
+  z.object({
+    error: types.string(),
+    message: types.string(),
+    statusCode: types.optional(types.number()),
+    request$: z.custom<Request>(x => x instanceof Request),
+    response$: z.custom<Response>(x => x instanceof Response),
+    body$: z.string(),
+  }),
+  z.transform((v) => {
+    return new ProviderError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  }),
+);

package/src/models/errors/trace-error.ts

@@ -0,0 +1,65 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as types from "../../types/primitives.js";
+import { MutagentError } from "./mutagent-error.js";
+
+/**
+ * Error response
+ */
+export type TraceErrorData = {
+  /**
+   * Error type
+   */
+  error: string;
+  /**
+   * Error message
+   */
+  message: string;
+};
+
+/**
+ * Error response
+ */
+export class TraceError extends MutagentError {
+  /**
+   * Error type
+   */
+  error: string;
+
+  /** The original data that was passed to this error instance. */
+  data$: TraceErrorData;
+
+  constructor(
+    err: TraceErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "TraceError";
+  }
+}
+
+/** @internal */
+export const TraceError$inboundSchema: z.ZodMiniType<TraceError, unknown> = z
+  .pipe(
+    z.object({
+      error: types.string(),
+      message: types.string(),
+      request$: z.custom<Request>(x => x instanceof Request),
+      response$: z.custom<Response>(x => x instanceof Response),
+      body$: z.string(),
+    }),
+    z.transform((v) => {
+      return new TraceError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
+    }),
+  );