@orq-ai/node 4.11.0-rc.53 → 4.11.0-rc.54

package/src/models/components/evaluatorresponsellm.ts

@@ -0,0 +1,442 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const Operator = {
+  Eq: "eq",
+  Ne: "ne",
+  Gt: "gt",
+  Gte: "gte",
+  Lt: "lt",
+  Lte: "lte",
+} as const;
+export type Operator = ClosedEnum<typeof Operator>;
+
+export type NumberT = {
+  enabled: boolean;
+  alertOnFailure: boolean;
+  type: "number";
+  value: number;
+  operator: Operator;
+};
+
+export type Categorical = {
+  enabled: boolean;
+  alertOnFailure: boolean;
+  type: "categorical";
+  values: Array<string>;
+};
+
+export type Boolean = {
+  enabled: boolean;
+  alertOnFailure: boolean;
+  type: "boolean";
+  value: boolean;
+};
+
+export type GuardrailConfig = Boolean | Categorical | NumberT;
+
+export type CategoricalLabels = {
+  value: string;
+  description?: string | undefined;
+};
+
+export const Mode = {
+  Single: "single",
+  Jury: "jury",
+} as const;
+export type Mode = ClosedEnum<typeof Mode>;
+
+export type Retry = {
+  count: number;
+  onCodes?: Array<number> | undefined;
+};
+
+export type Fallbacks = {
+  model: string;
+};
+
+export type Judges = {
+  model: string;
+  retry?: Retry | undefined;
+  fallbacks?: Array<Fallbacks> | undefined;
+};
+
+export type EvaluatorResponseLlmRetry = {
+  count: number;
+  onCodes?: Array<number> | undefined;
+};
+
+export type EvaluatorResponseLlmFallbacks = {
+  model: string;
+};
+
+export type ReplacementJudges = {
+  model: string;
+  retry?: EvaluatorResponseLlmRetry | undefined;
+  fallbacks?: Array<EvaluatorResponseLlmFallbacks> | undefined;
+};
+
+export const TieValue = {
+  Tie: "Tie",
+} as const;
+export type TieValue = ClosedEnum<typeof TieValue>;
+
+export type Jury = {
+  judges: Array<Judges>;
+  replacementJudges?: Array<ReplacementJudges> | undefined;
+  minSuccessfulJudges: number;
+  tieValue: TieValue;
+};
+
+export type EvaluatorResponseLlm = {
+  id: string;
+  description: string;
+  created: string;
+  updated: string;
+  updatedById?: string | null | undefined;
+  guardrailConfig?: Boolean | Categorical | NumberT | null | undefined;
+  type: "llm_eval";
+  repetitions?: number | null | undefined;
+  prompt: string;
+  categories?: Array<string> | null | undefined;
+  categoricalLabels?: Array<CategoricalLabels> | null | undefined;
+  datasetId?: string | undefined;
+  key: string;
+  mode: Mode;
+  model?: string | undefined;
+  jury?: Jury | undefined;
+};
+
+/** @internal */
+export const Operator$inboundSchema: z.ZodNativeEnum<typeof Operator> = z
+  .nativeEnum(Operator);
+
+/** @internal */
+export const NumberT$inboundSchema: z.ZodType<NumberT, z.ZodTypeDef, unknown> =
+  z.object({
+    enabled: z.boolean().default(true),
+    alert_on_failure: z.boolean().default(false),
+    type: z.literal("number"),
+    value: z.number(),
+    operator: Operator$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "alert_on_failure": "alertOnFailure",
+    });
+  });
+
+export function numberFromJSON(
+  jsonString: string,
+): SafeParseResult<NumberT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => NumberT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NumberT' from JSON`,
+  );
+}
+
+/** @internal */
+export const Categorical$inboundSchema: z.ZodType<
+  Categorical,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean().default(true),
+  alert_on_failure: z.boolean().default(false),
+  type: z.literal("categorical"),
+  values: z.array(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "alert_on_failure": "alertOnFailure",
+  });
+});
+
+export function categoricalFromJSON(
+  jsonString: string,
+): SafeParseResult<Categorical, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Categorical$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Categorical' from JSON`,
+  );
+}
+
+/** @internal */
+export const Boolean$inboundSchema: z.ZodType<Boolean, z.ZodTypeDef, unknown> =
+  z.object({
+    enabled: z.boolean().default(true),
+    alert_on_failure: z.boolean().default(false),
+    type: z.literal("boolean"),
+    value: z.boolean(),
+  }).transform((v) => {
+    return remap$(v, {
+      "alert_on_failure": "alertOnFailure",
+    });
+  });
+
+export function booleanFromJSON(
+  jsonString: string,
+): SafeParseResult<Boolean, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Boolean$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Boolean' from JSON`,
+  );
+}
+
+/** @internal */
+export const GuardrailConfig$inboundSchema: z.ZodType<
+  GuardrailConfig,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => Boolean$inboundSchema),
+  z.lazy(() => Categorical$inboundSchema),
+  z.lazy(() => NumberT$inboundSchema),
+]);
+
+export function guardrailConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<GuardrailConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GuardrailConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GuardrailConfig' from JSON`,
+  );
+}
+
+/** @internal */
+export const CategoricalLabels$inboundSchema: z.ZodType<
+  CategoricalLabels,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  value: z.string(),
+  description: z.string().optional(),
+});
+
+export function categoricalLabelsFromJSON(
+  jsonString: string,
+): SafeParseResult<CategoricalLabels, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CategoricalLabels$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CategoricalLabels' from JSON`,
+  );
+}
+
+/** @internal */
+export const Mode$inboundSchema: z.ZodNativeEnum<typeof Mode> = z.nativeEnum(
+  Mode,
+);
+
+/** @internal */
+export const Retry$inboundSchema: z.ZodType<Retry, z.ZodTypeDef, unknown> = z
+  .object({
+    count: z.number().int().default(2),
+    on_codes: z.array(z.number().int()).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "on_codes": "onCodes",
+    });
+  });
+
+export function retryFromJSON(
+  jsonString: string,
+): SafeParseResult<Retry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Retry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Retry' from JSON`,
+  );
+}
+
+/** @internal */
+export const Fallbacks$inboundSchema: z.ZodType<
+  Fallbacks,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.string(),
+});
+
+export function fallbacksFromJSON(
+  jsonString: string,
+): SafeParseResult<Fallbacks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Fallbacks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Fallbacks' from JSON`,
+  );
+}
+
+/** @internal */
+export const Judges$inboundSchema: z.ZodType<Judges, z.ZodTypeDef, unknown> = z
+  .object({
+    model: z.string(),
+    retry: z.lazy(() => Retry$inboundSchema).optional(),
+    fallbacks: z.array(z.lazy(() => Fallbacks$inboundSchema)).optional(),
+  });
+
+export function judgesFromJSON(
+  jsonString: string,
+): SafeParseResult<Judges, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Judges$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Judges' from JSON`,
+  );
+}
+
+/** @internal */
+export const EvaluatorResponseLlmRetry$inboundSchema: z.ZodType<
+  EvaluatorResponseLlmRetry,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  count: z.number().int().default(2),
+  on_codes: z.array(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "on_codes": "onCodes",
+  });
+});
+
+export function evaluatorResponseLlmRetryFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluatorResponseLlmRetry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvaluatorResponseLlmRetry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluatorResponseLlmRetry' from JSON`,
+  );
+}
+
+/** @internal */
+export const EvaluatorResponseLlmFallbacks$inboundSchema: z.ZodType<
+  EvaluatorResponseLlmFallbacks,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.string(),
+});
+
+export function evaluatorResponseLlmFallbacksFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluatorResponseLlmFallbacks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvaluatorResponseLlmFallbacks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluatorResponseLlmFallbacks' from JSON`,
+  );
+}
+
+/** @internal */
+export const ReplacementJudges$inboundSchema: z.ZodType<
+  ReplacementJudges,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.string(),
+  retry: z.lazy(() => EvaluatorResponseLlmRetry$inboundSchema).optional(),
+  fallbacks: z.array(z.lazy(() => EvaluatorResponseLlmFallbacks$inboundSchema))
+    .optional(),
+});
+
+export function replacementJudgesFromJSON(
+  jsonString: string,
+): SafeParseResult<ReplacementJudges, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReplacementJudges$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReplacementJudges' from JSON`,
+  );
+}
+
+/** @internal */
+export const TieValue$inboundSchema: z.ZodNativeEnum<typeof TieValue> = z
+  .nativeEnum(TieValue);
+
+/** @internal */
+export const Jury$inboundSchema: z.ZodType<Jury, z.ZodTypeDef, unknown> = z
+  .object({
+    judges: z.array(z.lazy(() => Judges$inboundSchema)),
+    replacement_judges: z.array(z.lazy(() => ReplacementJudges$inboundSchema))
+      .optional(),
+    min_successful_judges: z.number().int().default(2),
+    tie_value: TieValue$inboundSchema.default("Tie"),
+  }).transform((v) => {
+    return remap$(v, {
+      "replacement_judges": "replacementJudges",
+      "min_successful_judges": "minSuccessfulJudges",
+      "tie_value": "tieValue",
+    });
+  });
+
+export function juryFromJSON(
+  jsonString: string,
+): SafeParseResult<Jury, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Jury$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Jury' from JSON`,
+  );
+}
+
+/** @internal */
+export const EvaluatorResponseLlm$inboundSchema: z.ZodType<
+  EvaluatorResponseLlm,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  description: z.string(),
+  created: z.string().default("2026-06-29T09:12:37.464Z"),
+  updated: z.string().default("2026-06-29T09:12:37.464Z"),
+  updated_by_id: z.nullable(z.string()).optional(),
+  guardrail_config: z.nullable(
+    z.union([
+      z.lazy(() => Boolean$inboundSchema),
+      z.lazy(() => Categorical$inboundSchema),
+      z.lazy(() => NumberT$inboundSchema),
+    ]),
+  ).optional(),
+  type: z.literal("llm_eval"),
+  repetitions: z.nullable(z.number().int()).optional(),
+  prompt: z.string(),
+  categories: z.nullable(z.array(z.string())).optional(),
+  categorical_labels: z.nullable(
+    z.array(z.lazy(() => CategoricalLabels$inboundSchema)),
+  ).optional(),
+  dataset_id: z.string().optional(),
+  key: z.string(),
+  mode: Mode$inboundSchema,
+  model: z.string().optional(),
+  jury: z.lazy(() => Jury$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "updated_by_id": "updatedById",
+    "guardrail_config": "guardrailConfig",
+    "categorical_labels": "categoricalLabels",
+    "dataset_id": "datasetId",
+  });
+});
+
+export function evaluatorResponseLlmFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluatorResponseLlm, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvaluatorResponseLlm$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluatorResponseLlm' from JSON`,
+  );
+}

package/src/models/components/evaluatorresponsepython.ts

@@ -0,0 +1,234 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const EvaluatorResponsePythonGuardrailConfigOperator = {
+  Eq: "eq",
+  Ne: "ne",
+  Gt: "gt",
+  Gte: "gte",
+  Lt: "lt",
+  Lte: "lte",
+} as const;
+export type EvaluatorResponsePythonGuardrailConfigOperator = ClosedEnum<
+  typeof EvaluatorResponsePythonGuardrailConfigOperator
+>;
+
+export type EvaluatorResponsePythonGuardrailConfigNumber = {
+  enabled: boolean;
+  alertOnFailure: boolean;
+  type: "number";
+  value: number;
+  operator: EvaluatorResponsePythonGuardrailConfigOperator;
+};
+
+export type EvaluatorResponsePythonGuardrailConfigCategorical = {
+  enabled: boolean;
+  alertOnFailure: boolean;
+  type: "categorical";
+  values: Array<string>;
+};
+
+export type EvaluatorResponsePythonGuardrailConfigBoolean = {
+  enabled: boolean;
+  alertOnFailure: boolean;
+  type: "boolean";
+  value: boolean;
+};
+
+export type EvaluatorResponsePythonGuardrailConfig =
+  | EvaluatorResponsePythonGuardrailConfigBoolean
+  | EvaluatorResponsePythonGuardrailConfigCategorical
+  | EvaluatorResponsePythonGuardrailConfigNumber;
+
+export type EvaluatorResponsePython = {
+  id: string;
+  description: string;
+  created: string;
+  updated: string;
+  updatedById?: string | null | undefined;
+  guardrailConfig?:
+    | EvaluatorResponsePythonGuardrailConfigBoolean
+    | EvaluatorResponsePythonGuardrailConfigCategorical
+    | EvaluatorResponsePythonGuardrailConfigNumber
+    | null
+    | undefined;
+  code: string;
+  type: "python_eval";
+  key: string;
+};
+
+/** @internal */
+export const EvaluatorResponsePythonGuardrailConfigOperator$inboundSchema:
+  z.ZodNativeEnum<typeof EvaluatorResponsePythonGuardrailConfigOperator> = z
+    .nativeEnum(EvaluatorResponsePythonGuardrailConfigOperator);
+
+/** @internal */
+export const EvaluatorResponsePythonGuardrailConfigNumber$inboundSchema:
+  z.ZodType<
+    EvaluatorResponsePythonGuardrailConfigNumber,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    enabled: z.boolean().default(true),
+    alert_on_failure: z.boolean().default(false),
+    type: z.literal("number"),
+    value: z.number(),
+    operator: EvaluatorResponsePythonGuardrailConfigOperator$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "alert_on_failure": "alertOnFailure",
+    });
+  });
+
+export function evaluatorResponsePythonGuardrailConfigNumberFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  EvaluatorResponsePythonGuardrailConfigNumber,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EvaluatorResponsePythonGuardrailConfigNumber$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'EvaluatorResponsePythonGuardrailConfigNumber' from JSON`,
+  );
+}
+
+/** @internal */
+export const EvaluatorResponsePythonGuardrailConfigCategorical$inboundSchema:
+  z.ZodType<
+    EvaluatorResponsePythonGuardrailConfigCategorical,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    enabled: z.boolean().default(true),
+    alert_on_failure: z.boolean().default(false),
+    type: z.literal("categorical"),
+    values: z.array(z.string()),
+  }).transform((v) => {
+    return remap$(v, {
+      "alert_on_failure": "alertOnFailure",
+    });
+  });
+
+export function evaluatorResponsePythonGuardrailConfigCategoricalFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  EvaluatorResponsePythonGuardrailConfigCategorical,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EvaluatorResponsePythonGuardrailConfigCategorical$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'EvaluatorResponsePythonGuardrailConfigCategorical' from JSON`,
+  );
+}
+
+/** @internal */
+export const EvaluatorResponsePythonGuardrailConfigBoolean$inboundSchema:
+  z.ZodType<
+    EvaluatorResponsePythonGuardrailConfigBoolean,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    enabled: z.boolean().default(true),
+    alert_on_failure: z.boolean().default(false),
+    type: z.literal("boolean"),
+    value: z.boolean(),
+  }).transform((v) => {
+    return remap$(v, {
+      "alert_on_failure": "alertOnFailure",
+    });
+  });
+
+export function evaluatorResponsePythonGuardrailConfigBooleanFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  EvaluatorResponsePythonGuardrailConfigBoolean,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EvaluatorResponsePythonGuardrailConfigBoolean$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'EvaluatorResponsePythonGuardrailConfigBoolean' from JSON`,
+  );
+}
+
+/** @internal */
+export const EvaluatorResponsePythonGuardrailConfig$inboundSchema: z.ZodType<
+  EvaluatorResponsePythonGuardrailConfig,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => EvaluatorResponsePythonGuardrailConfigBoolean$inboundSchema),
+  z.lazy(() => EvaluatorResponsePythonGuardrailConfigCategorical$inboundSchema),
+  z.lazy(() => EvaluatorResponsePythonGuardrailConfigNumber$inboundSchema),
+]);
+
+export function evaluatorResponsePythonGuardrailConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluatorResponsePythonGuardrailConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EvaluatorResponsePythonGuardrailConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluatorResponsePythonGuardrailConfig' from JSON`,
+  );
+}
+
+/** @internal */
+export const EvaluatorResponsePython$inboundSchema: z.ZodType<
+  EvaluatorResponsePython,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  description: z.string(),
+  created: z.string().default("2026-06-29T09:12:37.464Z"),
+  updated: z.string().default("2026-06-29T09:12:37.464Z"),
+  updated_by_id: z.nullable(z.string()).optional(),
+  guardrail_config: z.nullable(
+    z.union([
+      z.lazy(() => EvaluatorResponsePythonGuardrailConfigBoolean$inboundSchema),
+      z.lazy(() =>
+        EvaluatorResponsePythonGuardrailConfigCategorical$inboundSchema
+      ),
+      z.lazy(() => EvaluatorResponsePythonGuardrailConfigNumber$inboundSchema),
+    ]),
+  ).optional(),
+  code: z.string(),
+  type: z.literal("python_eval"),
+  key: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "updated_by_id": "updatedById",
+    "guardrail_config": "guardrailConfig",
+  });
+});
+
+export function evaluatorResponsePythonFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluatorResponsePython, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvaluatorResponsePython$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluatorResponsePython' from JSON`,
+  );
+}