@mutagent/sdk 0.2.57 → 0.2.59

package/src/lib/encodings.ts

@@ -479,6 +479,23 @@ export const encodeSpaceDelimitedQuery = queryEncoder(encodeSpaceDelimited);
 export const encodePipeDelimitedQuery = queryEncoder(encodePipeDelimited);
 export const encodeDeepObjectQuery = queryEncoder(encodeDeepObject);
 
+function isBlobLike(val: unknown): val is Blob {
+  if (val instanceof Blob) {
+    return true;
+  }
+
+  if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+    return false;
+  }
+
+  const tag = val[Symbol.toStringTag];
+  if (tag !== "Blob" && tag !== "File") {
+    return false;
+  }
+
+  return "stream" in val && typeof val.stream === "function";
+}
+
 export function appendForm(
   fd: FormData,
   key: string,
@@ -487,10 +504,12 @@ export function appendForm(
 ): void {
   if (value == null) {
     return;
-  } else if (value instanceof Blob && fileName) {
-    fd.append(key, value, fileName);
-  } else if (value instanceof Blob) {
-    fd.append(key, value);
+  } else if (isBlobLike(value)) {
+    if (fileName) {
+      fd.append(key, value as Blob, fileName);
+    } else {
+      fd.append(key, value as Blob);
+    }
   } else if (Array.isArray(value)) {
     value.forEach((v) => {
       appendForm(fd, key, v);

package/src/lib/files.ts

@@ -80,3 +80,25 @@ export function getContentTypeFromFileName(fileName: string): string | null {
 
   return mimeTypes[ext] || null;
 }
+
+/**
+ * Creates a Blob from file content with the given MIME type.
+ *
+ * Node.js Buffers are Uint8Array subclasses that may share a pooled
+ * ArrayBuffer (byteOffset > 0, byteLength < buffer.byteLength). Passing
+ * such a Buffer directly to `new Blob([buf])` can include the entire
+ * underlying pool on some runtimes, producing a Blob with extra bytes
+ * that corrupts multipart uploads.
+ *
+ * Copying into a standalone Uint8Array ensures the Blob receives only the
+ * intended bytes regardless of runtime behaviour.
+ */
+export function bytesToBlob(
+  content: Uint8Array<ArrayBufferLike> | ArrayBuffer | Blob | string,
+  contentType: string,
+): Blob {
+  if (content instanceof Uint8Array) {
+    return new Blob([new Uint8Array(content)], { type: contentType });
+  }
+  return new Blob([content as BlobPart], { type: contentType });
+}

package/src/lib/matchers.ts

@@ -248,8 +248,9 @@ export function match<T, E>(
         raw = body;
         break;
       default:
-        encoding satisfies never;
-        throw new Error(`Unsupported response type: ${encoding}`);
+        throw new Error(
+          `Unsupported response type: ${encoding satisfies never}`,
+        );
     }
 
     if (matcher.enc === "fail") {

package/src/lib/sdks.ts

@@ -127,13 +127,15 @@ export class ClientSDK {
     if (!base) {
       return ERR(new InvalidRequestError("No base URL provided for operation"));
     }
-    const reqURL = new URL(base);
-    const inputURL = new URL(path, reqURL);
-
+    const baseURL = new URL(base);
+    let reqURL: URL;
     if (path) {
-      reqURL.pathname += reqURL.pathname.endsWith("/") ? "" : "/";
-      reqURL.pathname += inputURL.pathname.replace(/^\/+/, "");
+      baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
+      reqURL = new URL(path, baseURL);
+    } else {
+      reqURL = baseURL;
     }
+    reqURL.hash = "";
 
     let finalQuery = query || "";
 

package/src/lib/security.ts

@@ -198,8 +198,7 @@ export function resolveSecurity(
         applyBearer(state, spec);
         break;
       default:
-        spec satisfies never;
-        throw SecurityError.unrecognizedType(type);
+        throw SecurityError.unrecognizedType((spec satisfies never, type));
     }
   });
 

package/src/lib/url.ts

@@ -13,21 +13,23 @@ export function pathToFunc(
   const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
 
   return function buildURLPath(params: Record<string, unknown> = {}): string {
-    return pathPattern.replace(paramRE, function (_, placeholder) {
-      if (!hasOwn.call(params, placeholder)) {
-        throw new Error(`Parameter '${placeholder}' is required`);
-      }
+    return pathPattern
+      .replace(paramRE, function (_, placeholder) {
+        if (!hasOwn.call(params, placeholder)) {
+          throw new Error(`Parameter '${placeholder}' is required`);
+        }
 
-      const value = params[placeholder];
-      if (typeof value !== "string" && typeof value !== "number") {
-        throw new Error(
-          `Parameter '${placeholder}' must be a string or number`,
-        );
-      }
+        const value = params[placeholder];
+        if (typeof value !== "string" && typeof value !== "number") {
+          throw new Error(
+            `Parameter '${placeholder}' must be a string or number`,
+          );
+        }
 
-      return options?.charEncoding === "percent"
-        ? encodeURIComponent(`${value}`)
-        : `${value}`;
-    });
+        return options?.charEncoding === "percent"
+          ? encodeURIComponent(`${value}`)
+          : `${value}`;
+      })
+      .replace(/^\/+/, "");
   };
 }

package/src/models/array-of-id-prompt-id-workspace-id.ts

@@ -0,0 +1,117 @@
+/*
+ * 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";
+
+/**
+ * Prompt execution result
+ */
+export type ArrayOfIdPromptIdWorkspaceId = {
+  /**
+   * Execution result ID
+   */
+  id: number;
+  /**
+   * Prompt ID (null if prompt deleted)
+   */
+  promptId: number | null;
+  /**
+   * Workspace ID
+   */
+  workspaceId: string;
+  /**
+   * Input variables used
+   */
+  inputs: any;
+  /**
+   * Model used
+   */
+  model: string;
+  /**
+   * Generated output
+   */
+  actualOutput: string;
+  /**
+   * Execution status
+   */
+  executionStatus: string;
+  /**
+   * Latency in ms
+   */
+  executionTime: number | null;
+  /**
+   * Error message
+   */
+  executionError: string | null;
+  /**
+   * Temperature used
+   */
+  temperature: number | null;
+  /**
+   * Max tokens used
+   */
+  maxTokens: number | null;
+  /**
+   * Token usage breakdown
+   */
+  tokenUsage: any | null;
+  /**
+   * Estimated cost in USD
+   */
+  cost: number | null;
+  /**
+   * Multi-model run group UUID
+   */
+  runGroupId: string | null;
+  /**
+   * Evaluation score
+   */
+  score: number | null;
+  /**
+   * Evaluation success
+   */
+  success: boolean | null;
+  /**
+   * Creation timestamp (ISO 8601)
+   */
+  createdAt: string;
+};
+
+/** @internal */
+export const ArrayOfIdPromptIdWorkspaceId$inboundSchema: z.ZodMiniType<
+  ArrayOfIdPromptIdWorkspaceId,
+  unknown
+> = z.object({
+  id: types.number(),
+  promptId: types.nullable(types.number()),
+  workspaceId: types.string(),
+  inputs: z.any(),
+  model: types.string(),
+  actualOutput: types.string(),
+  executionStatus: types.string(),
+  executionTime: types.nullable(types.number()),
+  executionError: types.nullable(types.string()),
+  temperature: types.nullable(types.number()),
+  maxTokens: types.nullable(types.number()),
+  tokenUsage: types.nullable(z.any()),
+  cost: types.nullable(types.number()),
+  runGroupId: types.nullable(types.string()),
+  score: types.nullable(types.number()),
+  success: types.nullable(types.boolean()),
+  createdAt: types.string(),
+});
+
+export function arrayOfIdPromptIdWorkspaceIdFromJSON(
+  jsonString: string,
+): SafeParseResult<ArrayOfIdPromptIdWorkspaceId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ArrayOfIdPromptIdWorkspaceId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ArrayOfIdPromptIdWorkspaceId' from JSON`,
+  );
+}

package/src/models/array-of-role-content.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type ArrayOfRoleContent = {
+  /**
+   * Message role (system, user, assistant)
+   */
+  role: string;
+  /**
+   * Message content
+   */
+  content: string;
+};
+
+/** @internal */
+export type ArrayOfRoleContent$Outbound = {
+  role: string;
+  content: string;
+};
+
+/** @internal */
+export const ArrayOfRoleContent$outboundSchema: z.ZodMiniType<
+  ArrayOfRoleContent$Outbound,
+  ArrayOfRoleContent
+> = z.object({
+  role: z.string(),
+  content: z.string(),
+});
+
+export function arrayOfRoleContentToJSON(
+  arrayOfRoleContent: ArrayOfRoleContent,
+): string {
+  return JSON.stringify(
+    ArrayOfRoleContent$outboundSchema.parse(arrayOfRoleContent),
+  );
+}

package/src/models/dataset-item-id-dataset-item-index-model-column-id.ts

@@ -0,0 +1,151 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import {
+  SchemaanyOf,
+  SchemaanyOf$Outbound,
+  SchemaanyOf$outboundSchema,
+} from "./schemaany-of.js";
+import {
+  SchemaanyOf2,
+  SchemaanyOf2$Outbound,
+  SchemaanyOf2$outboundSchema,
+} from "./schemaany-of2.js";
+
+export type EvalCriterion = {
+  /**
+   * Criterion name
+   */
+  name: string;
+  /**
+   * Criterion score (0-1)
+   */
+  score: number;
+  /**
+   * Whether criterion passed
+   */
+  passed: boolean;
+  /**
+   * Criterion description
+   */
+  description?: string | undefined;
+  /**
+   * Evaluation reasoning
+   */
+  reason?: string | undefined;
+};
+
+export type DatasetItemIdDatasetItemIndexModelColumnId = {
+  /**
+   * ID of the dataset item this result is for
+   */
+  datasetItemId: SchemaanyOf;
+  /**
+   * Position of dataset item at run time
+   */
+  datasetItemIndex: SchemaanyOf2;
+  /**
+   * Model column ID matching config.models[].id
+   */
+  modelColumnId: string;
+  /**
+   * LLM response text
+   */
+  output: string;
+  /**
+   * Evaluation score (0-1)
+   */
+  evalScore?: number | null | undefined;
+  /**
+   * Whether evaluation passed
+   */
+  evalPassed?: boolean | null | undefined;
+  /**
+   * Execution time in milliseconds
+   */
+  latencyMs?: SchemaanyOf2 | undefined;
+  /**
+   * Error message if execution failed
+   */
+  error?: string | undefined;
+  /**
+   * Trace ID for linking to tracing system
+   */
+  traceId?: string | undefined;
+  /**
+   * Per-criterion evaluation breakdown
+   */
+  evalCriteria?: Array<EvalCriterion> | null | undefined;
+};
+
+/** @internal */
+export type EvalCriterion$Outbound = {
+  name: string;
+  score: number;
+  passed: boolean;
+  description?: string | undefined;
+  reason?: string | undefined;
+};
+
+/** @internal */
+export const EvalCriterion$outboundSchema: z.ZodMiniType<
+  EvalCriterion$Outbound,
+  EvalCriterion
+> = z.object({
+  name: z.string(),
+  score: z.number(),
+  passed: z.boolean(),
+  description: z.optional(z.string()),
+  reason: z.optional(z.string()),
+});
+
+export function evalCriterionToJSON(evalCriterion: EvalCriterion): string {
+  return JSON.stringify(EvalCriterion$outboundSchema.parse(evalCriterion));
+}
+
+/** @internal */
+export type DatasetItemIdDatasetItemIndexModelColumnId$Outbound = {
+  datasetItemId: SchemaanyOf$Outbound;
+  datasetItemIndex: SchemaanyOf2$Outbound;
+  modelColumnId: string;
+  output: string;
+  evalScore?: number | null | undefined;
+  evalPassed?: boolean | null | undefined;
+  latencyMs?: SchemaanyOf2$Outbound | undefined;
+  error?: string | undefined;
+  traceId?: string | undefined;
+  evalCriteria?: Array<EvalCriterion$Outbound> | null | undefined;
+};
+
+/** @internal */
+export const DatasetItemIdDatasetItemIndexModelColumnId$outboundSchema:
+  z.ZodMiniType<
+    DatasetItemIdDatasetItemIndexModelColumnId$Outbound,
+    DatasetItemIdDatasetItemIndexModelColumnId
+  > = z.object({
+    datasetItemId: SchemaanyOf$outboundSchema,
+    datasetItemIndex: SchemaanyOf2$outboundSchema,
+    modelColumnId: z.string(),
+    output: z.string(),
+    evalScore: z.optional(z.nullable(z.number())),
+    evalPassed: z.optional(z.nullable(z.boolean())),
+    latencyMs: z.optional(SchemaanyOf2$outboundSchema),
+    error: z.optional(z.string()),
+    traceId: z.optional(z.string()),
+    evalCriteria: z.optional(
+      z.nullable(z.array(z.lazy(() => EvalCriterion$outboundSchema))),
+    ),
+  });
+
+export function datasetItemIdDatasetItemIndexModelColumnIdToJSON(
+  datasetItemIdDatasetItemIndexModelColumnId:
+    DatasetItemIdDatasetItemIndexModelColumnId,
+): string {
+  return JSON.stringify(
+    DatasetItemIdDatasetItemIndexModelColumnId$outboundSchema.parse(
+      datasetItemIdDatasetItemIndexModelColumnId,
+    ),
+  );
+}

package/src/models/evaluation-aggregation-results.ts

@@ -0,0 +1,82 @@
+/*
+ * 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";
+
+/**
+ * Aggregated evaluation results for a specific prompt version and date. Used for the Version Timeline Chart.
+ */
+export type EvaluationAggregationResultsData = {
+  /**
+   * Prompt version string (e.g., "3.1.0")
+   */
+  version: string;
+  /**
+   * ISO date string (e.g., "2026-02-10")
+   */
+  date: string;
+  /**
+   * Average accuracy percentage 0-100
+   */
+  averageAccuracy: number;
+  /**
+   * Number of evaluation results in this group
+   */
+  count: number;
+};
+
+/**
+ * Paginated aggregation results response
+ */
+export type EvaluationAggregationResults = {
+  data: Array<EvaluationAggregationResultsData>;
+  /**
+   * Total number of aggregated results
+   */
+  total: number;
+};
+
+/** @internal */
+export const EvaluationAggregationResultsData$inboundSchema: z.ZodMiniType<
+  EvaluationAggregationResultsData,
+  unknown
+> = z.object({
+  version: types.string(),
+  date: types.string(),
+  averageAccuracy: types.number(),
+  count: types.number(),
+});
+
+export function evaluationAggregationResultsDataFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluationAggregationResultsData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvaluationAggregationResultsData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluationAggregationResultsData' from JSON`,
+  );
+}
+
+/** @internal */
+export const EvaluationAggregationResults$inboundSchema: z.ZodMiniType<
+  EvaluationAggregationResults,
+  unknown
+> = z.object({
+  data: z.array(z.lazy(() => EvaluationAggregationResultsData$inboundSchema)),
+  total: types.number(),
+});
+
+export function evaluationAggregationResultsFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluationAggregationResults, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvaluationAggregationResults$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluationAggregationResults' from JSON`,
+  );
+}

package/src/models/evaluation-history.ts

@@ -0,0 +1,112 @@
+/*
+ * 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";
+
+/**
+ * Evaluation definition object. This specifies HOW to evaluate, not the results (see PromptEvaluationResult for execution outcomes)
+ */
+export type EvaluationHistory = {
+  /**
+   * Unique evaluation identifier
+   */
+  id: number;
+  /**
+   * UUID of the prompt family being evaluated (cache this for performance)
+   */
+  promptGroupId: string;
+  /**
+   * Evaluation name
+   */
+  name: string;
+  /**
+   * Evaluation description
+   */
+  description: string | null;
+  /**
+   * Evaluation configuration with criteria array
+   */
+  evalConfig: any;
+  /**
+   * LLM execution configuration
+   */
+  llmConfig: any;
+  /**
+   * Organization tags
+   */
+  tags: Array<string> | null;
+  /**
+   * Arbitrary metadata
+   */
+  metadata: any;
+  /**
+   * Creation timestamp
+   */
+  createdAt: Date | null;
+  /**
+   * Last update timestamp
+   */
+  updatedAt: Date | null;
+  /**
+   * Creator email
+   */
+  createdBy: string | null;
+  /**
+   * UUID grouping all versions of this evaluation together
+   */
+  evaluationGroupId?: string | undefined;
+  /**
+   * Semantic version string (e.g., "1.0.0", "1.1.0")
+   */
+  version?: string | undefined;
+  /**
+   * ID of the previous version in the version chain (null for v1.0.0)
+   */
+  ancestorId?: number | null | undefined;
+  /**
+   * Whether this is the latest version in the evaluation group
+   */
+  isLatest?: boolean | undefined;
+  /**
+   * ID of the test dataset used for evaluation
+   */
+  datasetId?: number | undefined;
+};
+
+/** @internal */
+export const EvaluationHistory$inboundSchema: z.ZodMiniType<
+  EvaluationHistory,
+  unknown
+> = z.object({
+  id: types.number(),
+  promptGroupId: types.string(),
+  name: types.string(),
+  description: types.nullable(types.string()),
+  evalConfig: z.any(),
+  llmConfig: z.any(),
+  tags: types.nullable(z.array(types.string())),
+  metadata: z.any(),
+  createdAt: types.nullable(types.date()),
+  updatedAt: types.nullable(types.date()),
+  createdBy: types.nullable(types.string()),
+  evaluationGroupId: types.optional(types.string()),
+  version: types.optional(types.string()),
+  ancestorId: z.optional(z.nullable(types.number())),
+  isLatest: types.optional(types.boolean()),
+  datasetId: types.optional(types.number()),
+});
+
+export function evaluationHistoryFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluationHistory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvaluationHistory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluationHistory' from JSON`,
+  );
+}

package/src/models/evaluation-list.ts

@@ -56,6 +56,26 @@ export type EvaluationListData = {
    * Creator email
    */
   createdBy: string | null;
+  /**
+   * UUID grouping all versions of this evaluation together
+   */
+  evaluationGroupId?: string | undefined;
+  /**
+   * Semantic version string (e.g., "1.0.0", "1.1.0")
+   */
+  version?: string | undefined;
+  /**
+   * ID of the previous version in the version chain (null for v1.0.0)
+   */
+  ancestorId?: number | null | undefined;
+  /**
+   * Whether this is the latest version in the evaluation group
+   */
+  isLatest?: boolean | undefined;
+  /**
+   * ID of the test dataset used for evaluation
+   */
+  datasetId?: number | undefined;
 };
 
 /**
@@ -104,6 +124,11 @@ export const EvaluationListData$inboundSchema: z.ZodMiniType<
   createdAt: types.nullable(types.date()),
   updatedAt: types.nullable(types.date()),
   createdBy: types.nullable(types.string()),
+  evaluationGroupId: types.optional(types.string()),
+  version: types.optional(types.string()),
+  ancestorId: z.optional(z.nullable(types.number())),
+  isLatest: types.optional(types.boolean()),
+  datasetId: types.optional(types.number()),
 });
 
 export function evaluationListDataFromJSON(