@mutagent/sdk 0.2.118 → 0.2.120

package/src/funcs/workspaces-list-workspaces.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v4-mini";
 import { MutagentCore } from "../core.js";
 import { encodeFormQuery } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
@@ -140,7 +141,8 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["401", "4XX", "5XX"],
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });

package/src/funcs/workspaces-set-default-workspace.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v4-mini";
 import { MutagentCore } from "../core.js";
 import { encodeSimple } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
@@ -138,7 +139,8 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["401", "403", "404", "4XX", "5XX"],
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });

package/src/funcs/workspaces-update-workspace.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v4-mini";
 import { MutagentCore } from "../core.js";
 import { encodeJSON, encodeSimple } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
@@ -138,7 +139,8 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["401", "403", "404", "409", "4XX", "5XX"],
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });

package/src/lib/config.ts

@@ -65,7 +65,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "2.0.0",
-  sdkVersion: "0.2.118",
-  genVersion: "2.879.13",
-  userAgent: "speakeasy-sdk/typescript 0.2.118 2.879.13 2.0.0 @mutagent/sdk",
+  sdkVersion: "0.2.120",
+  genVersion: "2.881.0",
+  userAgent: "speakeasy-sdk/typescript 0.2.120 2.881.0 2.0.0 @mutagent/sdk",
 } as const;

package/src/lib/sdks.ts

@@ -22,7 +22,6 @@ import {
   isConnectionError,
   isTimeoutError,
   matchContentType,
-  matchStatusCode,
 } from "./http.js";
 import { Logger } from "./logger.js";
 import { retry, RetryConfig } from "./retries.js";
@@ -233,7 +232,7 @@ export class ClientSDK {
     request: Request,
     options: {
       context: HookContext;
-      errorCodes: number | string | (number | string)[];
+      isErrorStatusCode: (statusCode: number) => boolean;
       retryConfig: RetryConfig;
       retryCodes: string[];
     },
@@ -246,7 +245,7 @@ export class ClientSDK {
       | UnexpectedClientError
     >
   > {
-    const { context, errorCodes } = options;
+    const { context, isErrorStatusCode } = options;
 
     return retry(
       async () => {
@@ -258,7 +257,7 @@ export class ClientSDK {
         let response = await this.#httpClient.request(req);
 
         try {
-          if (matchStatusCode(response, errorCodes)) {
+          if (isErrorStatusCode(response.status)) {
             const result = await this.#hooks.afterError(
               context,
               response,

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

@@ -27,6 +27,18 @@ export type DatasetIdEvaluationIdConfigConfig = {
    * Model for evaluation scoring
    */
   evaluationModel?: string | undefined;
+  /**
+   * Provider config ID for the execution slot (provider-id-first routing)
+   */
+  executionProviderId?: string | undefined;
+  /**
+   * Provider config ID for the evaluation slot (provider-id-first routing)
+   */
+  evaluationProviderId?: string | undefined;
+  /**
+   * Provider config ID for the optimization slot (provider-id-first routing)
+   */
+  optimizationProviderId?: string | undefined;
   tuningParams?: TuningParams | undefined;
 };
 
@@ -66,6 +78,9 @@ export type DatasetIdEvaluationIdConfigConfig$Outbound = {
   executionModel?: string | undefined;
   optimizationModel?: string | undefined;
   evaluationModel?: string | undefined;
+  executionProviderId?: string | undefined;
+  evaluationProviderId?: string | undefined;
+  optimizationProviderId?: string | undefined;
   tuningParams?: TuningParams$Outbound | undefined;
 };
 
@@ -82,6 +97,9 @@ export const DatasetIdEvaluationIdConfigConfig$outboundSchema: z.ZodMiniType<
   executionModel: z.optional(z.string()),
   optimizationModel: z.optional(z.string()),
   evaluationModel: z.optional(z.string()),
+  executionProviderId: z.optional(z.string()),
+  evaluationProviderId: z.optional(z.string()),
+  optimizationProviderId: z.optional(z.string()),
   tuningParams: z.optional(z.lazy(() => TuningParams$outboundSchema)),
 });
 

package/src/models/index.ts

@@ -50,6 +50,7 @@ export * from "./new-version-changes.js";
 export * from "./optimization-job-list.js";
 export * from "./optimization-job-status.js";
 export * from "./optimization-job.js";
+export * from "./optimization-results.js";
 export * from "./optimization-score-progression.js";
 export * from "./optimization-states.js";
 export * from "./org-member-count-or-error-union.js";

package/src/models/operations/get-optimization-results.ts

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type GetOptimizationResultsRequest = {
+  id: string;
+};
+
+/** @internal */
+export type GetOptimizationResultsRequest$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const GetOptimizationResultsRequest$outboundSchema: z.ZodMiniType<
+  GetOptimizationResultsRequest$Outbound,
+  GetOptimizationResultsRequest
+> = z.object({
+  id: z.string(),
+});
+
+export function getOptimizationResultsRequestToJSON(
+  getOptimizationResultsRequest: GetOptimizationResultsRequest,
+): string {
+  return JSON.stringify(
+    GetOptimizationResultsRequest$outboundSchema.parse(
+      getOptimizationResultsRequest,
+    ),
+  );
+}

package/src/models/operations/index.ts

@@ -46,6 +46,7 @@ export * from "./get-evaluation.js";
 export * from "./get-experiment.js";
 export * from "./get-invitation.js";
 export * from "./get-optimization-progress.js";
+export * from "./get-optimization-results.js";
 export * from "./get-optimization-states.js";
 export * from "./get-optimization.js";
 export * from "./get-organization-by-slug.js";

package/src/models/optimization-results.ts

@@ -0,0 +1,220 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.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 Scores = {
+  bestScore: number | null;
+  currentScore: number | null;
+  targetScore: number | null;
+};
+
+export type OptimizationResultsCriterion = {
+  name: string;
+  scoreAvg: number;
+  passRate: number;
+};
+
+export type Costs = {
+  iterationUsd: number;
+  cumulativeUsd: number;
+};
+
+export type StageBreakdown = {};
+
+export type Durations = {
+  iterationMs: number | null;
+  stageBreakdown: StageBreakdown;
+};
+
+export enum NextAction {
+  Continue = "continue",
+  StopConverged = "stop-converged",
+  StopBudget = "stop-budget",
+  StopStagnation = "stop-stagnation",
+  StopMaxIter = "stop-max-iter",
+}
+export type NextActionOpen = OpenEnum<typeof NextAction>;
+
+export type OptimizationResultsData = {
+  jobId: string;
+  iteration: number;
+  totalIterations: number | null;
+  timestamp: string;
+  stage: string | null;
+  scores: Scores;
+  criteria: Array<OptimizationResultsCriterion>;
+  costs: Costs;
+  durations: Durations;
+  nextAction: NextActionOpen;
+};
+
+export type Scorecard = {
+  rendered: string;
+  data: Array<OptimizationResultsData>;
+};
+
+export type OptimizationResults = {
+  jobId: string;
+  scorecard: Scorecard;
+};
+
+/** @internal */
+export const Scores$inboundSchema: z.ZodMiniType<Scores, unknown> = z.object({
+  bestScore: types.nullable(types.number()),
+  currentScore: types.nullable(types.number()),
+  targetScore: types.nullable(types.number()),
+});
+
+export function scoresFromJSON(
+  jsonString: string,
+): SafeParseResult<Scores, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Scores$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Scores' from JSON`,
+  );
+}
+
+/** @internal */
+export const OptimizationResultsCriterion$inboundSchema: z.ZodMiniType<
+  OptimizationResultsCriterion,
+  unknown
+> = z.object({
+  name: types.string(),
+  scoreAvg: types.number(),
+  passRate: types.number(),
+});
+
+export function optimizationResultsCriterionFromJSON(
+  jsonString: string,
+): SafeParseResult<OptimizationResultsCriterion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OptimizationResultsCriterion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OptimizationResultsCriterion' from JSON`,
+  );
+}
+
+/** @internal */
+export const Costs$inboundSchema: z.ZodMiniType<Costs, unknown> = z.object({
+  iterationUsd: types.number(),
+  cumulativeUsd: types.number(),
+});
+
+export function costsFromJSON(
+  jsonString: string,
+): SafeParseResult<Costs, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Costs$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Costs' from JSON`,
+  );
+}
+
+/** @internal */
+export const StageBreakdown$inboundSchema: z.ZodMiniType<
+  StageBreakdown,
+  unknown
+> = z.object({});
+
+export function stageBreakdownFromJSON(
+  jsonString: string,
+): SafeParseResult<StageBreakdown, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StageBreakdown$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StageBreakdown' from JSON`,
+  );
+}
+
+/** @internal */
+export const Durations$inboundSchema: z.ZodMiniType<Durations, unknown> = z
+  .object({
+    iterationMs: types.nullable(types.number()),
+    stageBreakdown: z.lazy(() => StageBreakdown$inboundSchema),
+  });
+
+export function durationsFromJSON(
+  jsonString: string,
+): SafeParseResult<Durations, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Durations$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Durations' from JSON`,
+  );
+}
+
+/** @internal */
+export const NextAction$inboundSchema: z.ZodMiniType<NextActionOpen, unknown> =
+  openEnums.inboundSchema(NextAction);
+
+/** @internal */
+export const OptimizationResultsData$inboundSchema: z.ZodMiniType<
+  OptimizationResultsData,
+  unknown
+> = z.object({
+  jobId: types.string(),
+  iteration: types.number(),
+  totalIterations: types.nullable(types.number()),
+  timestamp: types.string(),
+  stage: types.nullable(types.string()),
+  scores: z.lazy(() => Scores$inboundSchema),
+  criteria: z.array(z.lazy(() => OptimizationResultsCriterion$inboundSchema)),
+  costs: z.lazy(() => Costs$inboundSchema),
+  durations: z.lazy(() => Durations$inboundSchema),
+  nextAction: z._default(NextAction$inboundSchema, NextAction.Continue),
+});
+
+export function optimizationResultsDataFromJSON(
+  jsonString: string,
+): SafeParseResult<OptimizationResultsData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OptimizationResultsData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OptimizationResultsData' from JSON`,
+  );
+}
+
+/** @internal */
+export const Scorecard$inboundSchema: z.ZodMiniType<Scorecard, unknown> = z
+  .object({
+    rendered: types.string(),
+    data: z.array(z.lazy(() => OptimizationResultsData$inboundSchema)),
+  });
+
+export function scorecardFromJSON(
+  jsonString: string,
+): SafeParseResult<Scorecard, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Scorecard$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Scorecard' from JSON`,
+  );
+}
+
+/** @internal */
+export const OptimizationResults$inboundSchema: z.ZodMiniType<
+  OptimizationResults,
+  unknown
+> = z.object({
+  jobId: types.string(),
+  scorecard: z.lazy(() => Scorecard$inboundSchema),
+});
+
+export function optimizationResultsFromJSON(
+  jsonString: string,
+): SafeParseResult<OptimizationResults, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OptimizationResults$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OptimizationResults' from JSON`,
+  );
+}

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

@@ -55,9 +55,6 @@ export type PaginatedTraceListData = {
    * Source integration that produced this trace
    */
   source: PaginatedTraceListSourceOpen;
-  /**
-   * Environment where the trace was captured
-   */
   environment: PaginatedTraceListEnvironmentOpen | null;
   tags: Array<string> | null;
   metadata: PaginatedTraceListMetadata | null;

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

@@ -137,9 +137,6 @@ export type TraceWithSpans = {
    * Source integration that produced this trace
    */
   source: TraceWithSpansSourceOpen;
-  /**
-   * Environment where the trace was captured
-   */
   environment: TraceWithSpansEnvironmentOpen | null;
   tags: Array<string> | null;
   metadata: TraceWithSpansMetadata | null;

package/src/sdk/optimization.ts

@@ -4,6 +4,7 @@
 
 import { optimizationCancelOptimization } from "../funcs/optimization-cancel-optimization.js";
 import { optimizationGetOptimizationProgress } from "../funcs/optimization-get-optimization-progress.js";
+import { optimizationGetOptimizationResults } from "../funcs/optimization-get-optimization-results.js";
 import { optimizationGetOptimizationStates } from "../funcs/optimization-get-optimization-states.js";
 import { optimizationGetOptimization } from "../funcs/optimization-get-optimization.js";
 import { optimizationListOptimizations } from "../funcs/optimization-list-optimizations.js";
@@ -104,6 +105,23 @@ export class Optimization extends ClientSDK {
     ));
   }
 
+  /**
+   * Get optimization results with scorecard digest
+   *
+   * @remarks
+   * Get the full per-iteration scorecard digest for an optimization job. Returns rendered text and structured ScorecardData for each iteration. Requires x-workspace-id header.
+   */
+  async getOptimizationResults(
+    request: operations.GetOptimizationResultsRequest,
+    options?: RequestOptions,
+  ): Promise<models.OptimizationResults> {
+    return unwrapAsync(optimizationGetOptimizationResults(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Pause job
    *