@orq-ai/node 4.12.0-rc.2 → 4.12.0-rc.21

package/src/models/components/litellmmodelinfo.ts

@@ -0,0 +1,97 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type LiteLLMModelInfo = {
+  dbModel: boolean | null;
+  id: string | null;
+  inputCostPerToken?: number | undefined;
+  key: string | null;
+  litellmProvider: string | null;
+  maxInputTokens?: number | undefined;
+  maxOutputTokens?: number | undefined;
+  mode: string | null;
+  outputCostPerToken?: number | undefined;
+  supportedOpenaiParams?: Array<string> | null | undefined;
+  supportsFunctionCalling?: boolean | undefined;
+  supportsNativeStreaming?: boolean | undefined;
+  supportsReasoning?: boolean | undefined;
+  supportsResponseSchema?: boolean | undefined;
+  supportsSystemMessages?: boolean | undefined;
+  supportsToolChoice?: boolean | undefined;
+  supportsVision?: boolean | undefined;
+};
+
+/** @internal */
+export type LiteLLMModelInfo$Outbound = {
+  db_model: boolean | null;
+  id: string | null;
+  input_cost_per_token?: number | undefined;
+  key: string | null;
+  litellm_provider: string | null;
+  max_input_tokens?: number | undefined;
+  max_output_tokens?: number | undefined;
+  mode: string | null;
+  output_cost_per_token?: number | undefined;
+  supported_openai_params?: Array<string> | null | undefined;
+  supports_function_calling?: boolean | undefined;
+  supports_native_streaming?: boolean | undefined;
+  supports_reasoning?: boolean | undefined;
+  supports_response_schema?: boolean | undefined;
+  supports_system_messages?: boolean | undefined;
+  supports_tool_choice?: boolean | undefined;
+  supports_vision?: boolean | undefined;
+};
+
+/** @internal */
+export const LiteLLMModelInfo$outboundSchema: z.ZodType<
+  LiteLLMModelInfo$Outbound,
+  z.ZodTypeDef,
+  LiteLLMModelInfo
+> = z.object({
+  dbModel: z.nullable(z.boolean()),
+  id: z.nullable(z.string()),
+  inputCostPerToken: z.number().optional(),
+  key: z.nullable(z.string()),
+  litellmProvider: z.nullable(z.string()),
+  maxInputTokens: z.number().int().optional(),
+  maxOutputTokens: z.number().int().optional(),
+  mode: z.nullable(z.string()),
+  outputCostPerToken: z.number().optional(),
+  supportedOpenaiParams: z.nullable(z.array(z.string())).optional(),
+  supportsFunctionCalling: z.boolean().optional(),
+  supportsNativeStreaming: z.boolean().optional(),
+  supportsReasoning: z.boolean().optional(),
+  supportsResponseSchema: z.boolean().optional(),
+  supportsSystemMessages: z.boolean().optional(),
+  supportsToolChoice: z.boolean().optional(),
+  supportsVision: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    dbModel: "db_model",
+    inputCostPerToken: "input_cost_per_token",
+    litellmProvider: "litellm_provider",
+    maxInputTokens: "max_input_tokens",
+    maxOutputTokens: "max_output_tokens",
+    outputCostPerToken: "output_cost_per_token",
+    supportedOpenaiParams: "supported_openai_params",
+    supportsFunctionCalling: "supports_function_calling",
+    supportsNativeStreaming: "supports_native_streaming",
+    supportsReasoning: "supports_reasoning",
+    supportsResponseSchema: "supports_response_schema",
+    supportsSystemMessages: "supports_system_messages",
+    supportsToolChoice: "supports_tool_choice",
+    supportsVision: "supports_vision",
+  });
+});
+
+export function liteLLMModelInfoToJSON(
+  liteLLMModelInfo: LiteLLMModelInfo,
+): string {
+  return JSON.stringify(
+    LiteLLMModelInfo$outboundSchema.parse(liteLLMModelInfo),
+  );
+}

package/src/models/components/litellmparams.ts

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type LiteLLMParams = {
+  mergeReasoningContentInChoices: boolean;
+  model: string;
+  useInPassThrough: boolean;
+  useLitellmProxy: boolean;
+};
+
+/** @internal */
+export type LiteLLMParams$Outbound = {
+  merge_reasoning_content_in_choices: boolean;
+  model: string;
+  use_in_pass_through: boolean;
+  use_litellm_proxy: boolean;
+};
+
+/** @internal */
+export const LiteLLMParams$outboundSchema: z.ZodType<
+  LiteLLMParams$Outbound,
+  z.ZodTypeDef,
+  LiteLLMParams
+> = z.object({
+  mergeReasoningContentInChoices: z.boolean(),
+  model: z.string(),
+  useInPassThrough: z.boolean(),
+  useLitellmProxy: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    mergeReasoningContentInChoices: "merge_reasoning_content_in_choices",
+    useInPassThrough: "use_in_pass_through",
+    useLitellmProxy: "use_litellm_proxy",
+  });
+});
+
+export function liteLLMParamsToJSON(liteLLMParams: LiteLLMParams): string {
+  return JSON.stringify(LiteLLMParams$outboundSchema.parse(liteLLMParams));
+}

package/src/models/components/modeldocument.ts

@@ -0,0 +1,115 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { Config, Config$inboundSchema } from "./config.js";
+import {
+  ModelConfigurationResponse,
+  ModelConfigurationResponse$inboundSchema,
+} from "./modelconfigurationresponse.js";
+import { ModelMetadata, ModelMetadata$inboundSchema } from "./modelmetadata.js";
+import {
+  ModelParameterDocument,
+  ModelParameterDocument$inboundSchema,
+} from "./modelparameterdocument.js";
+
+export type ModelDocument = {
+  configuration: ModelConfigurationResponse;
+  created: Date;
+  description: string | null;
+  displayName: string;
+  docsUrl: string | null;
+  enabled: boolean;
+  enabledForEndpoints: boolean;
+  enabledForPlayground: boolean;
+  hasCpuPricing: boolean;
+  hasFunctions: boolean;
+  id: string;
+  inputCost: number | null;
+  inputCurrency: string;
+  isActive: boolean;
+  metadata: ModelMetadata;
+  modelDeveloper?: string | undefined;
+  modelFamily?: string | undefined;
+  modelId: string;
+  modelType: string;
+  outputCost: number | null;
+  outputCurrency: string;
+  owner: string;
+  parameters: Array<ModelParameterDocument> | null;
+  pricingUrl: string | null;
+  provider: string;
+  refId: string;
+  sharing?: Config | undefined;
+  updated: Date;
+};
+
+/** @internal */
+export const ModelDocument$inboundSchema: z.ZodType<
+  ModelDocument,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  configuration: ModelConfigurationResponse$inboundSchema,
+  created: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  description: z.nullable(z.string()),
+  display_name: z.string(),
+  docs_url: z.nullable(z.string()),
+  enabled: z.boolean(),
+  enabled_for_endpoints: z.boolean(),
+  enabled_for_playground: z.boolean(),
+  has_cpu_pricing: z.boolean(),
+  has_functions: z.boolean(),
+  id: z.string(),
+  input_cost: z.nullable(z.number()),
+  input_currency: z.string(),
+  is_active: z.boolean(),
+  metadata: ModelMetadata$inboundSchema,
+  model_developer: z.string().optional(),
+  model_family: z.string().optional(),
+  model_id: z.string(),
+  model_type: z.string(),
+  output_cost: z.nullable(z.number()),
+  output_currency: z.string(),
+  owner: z.string(),
+  parameters: z.nullable(z.array(ModelParameterDocument$inboundSchema)),
+  pricing_url: z.nullable(z.string()),
+  provider: z.string(),
+  refId: z.string(),
+  sharing: Config$inboundSchema.optional(),
+  updated: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+}).transform((v) => {
+  return remap$(v, {
+    "display_name": "displayName",
+    "docs_url": "docsUrl",
+    "enabled_for_endpoints": "enabledForEndpoints",
+    "enabled_for_playground": "enabledForPlayground",
+    "has_cpu_pricing": "hasCpuPricing",
+    "has_functions": "hasFunctions",
+    "input_cost": "inputCost",
+    "input_currency": "inputCurrency",
+    "is_active": "isActive",
+    "model_developer": "modelDeveloper",
+    "model_family": "modelFamily",
+    "model_id": "modelId",
+    "model_type": "modelType",
+    "output_cost": "outputCost",
+    "output_currency": "outputCurrency",
+    "pricing_url": "pricingUrl",
+  });
+});
+
+export function modelDocumentFromJSON(
+  jsonString: string,
+): SafeParseResult<ModelDocument, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ModelDocument$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ModelDocument' from JSON`,
+  );
+}

package/src/models/components/modelsconfig.ts

@@ -16,6 +16,7 @@ import {
 
 export const ModelsConfigMode = {
   Fallback: "fallback",
+  LatencyBased: "latency_based",
   Weighted: "weighted",
   RoundRobin: "round_robin",
 } as const;

package/src/models/components/querytelemetrymeta.ts

@@ -0,0 +1,38 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type QueryTelemetryMeta = {
+  effectiveGrain?: string | undefined;
+  warnings?: Array<string> | undefined;
+};
+
+/** @internal */
+export const QueryTelemetryMeta$inboundSchema: z.ZodType<
+  QueryTelemetryMeta,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  effective_grain: z.string().optional(),
+  warnings: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "effective_grain": "effectiveGrain",
+  });
+});
+
+export function queryTelemetryMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<QueryTelemetryMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QueryTelemetryMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QueryTelemetryMeta' from JSON`,
+  );
+}

package/src/models/components/querytelemetryrequest.ts

@@ -0,0 +1,85 @@
+/*
+ * 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 {
+  TraceCompute,
+  TraceCompute$Outbound,
+  TraceCompute$outboundSchema,
+} from "./tracecompute.js";
+import {
+  TraceFilter,
+  TraceFilter$Outbound,
+  TraceFilter$outboundSchema,
+} from "./tracefilter.js";
+
+export type QueryTelemetryRequest = {
+  source?: number | undefined;
+  from?: Date | undefined;
+  to?: Date | undefined;
+  compute?: Array<TraceCompute> | undefined;
+  /**
+   * Empty string and "none" are equivalent: a single row per group instead
+   *
+   * @remarks
+   *  of a time series.
+   */
+  grain?: string | undefined;
+  groupBy?: Array<string> | undefined;
+  filters?: Array<TraceFilter> | undefined;
+  filterOperator?: string | undefined;
+  limit?: number | undefined;
+  timeZone?: string | undefined;
+  includeTotals?: boolean | undefined;
+};
+
+/** @internal */
+export type QueryTelemetryRequest$Outbound = {
+  source?: number | undefined;
+  from?: string | undefined;
+  to?: string | undefined;
+  compute?: Array<TraceCompute$Outbound> | undefined;
+  grain?: string | undefined;
+  group_by?: Array<string> | undefined;
+  filters?: Array<TraceFilter$Outbound> | undefined;
+  filter_operator?: string | undefined;
+  limit?: number | undefined;
+  time_zone?: string | undefined;
+  include_totals?: boolean | undefined;
+};
+
+/** @internal */
+export const QueryTelemetryRequest$outboundSchema: z.ZodType<
+  QueryTelemetryRequest$Outbound,
+  z.ZodTypeDef,
+  QueryTelemetryRequest
+> = z.object({
+  source: z.number().int().optional(),
+  from: z.date().transform(v => v.toISOString()).optional(),
+  to: z.date().transform(v => v.toISOString()).optional(),
+  compute: z.array(TraceCompute$outboundSchema).optional(),
+  grain: z.string().optional(),
+  groupBy: z.array(z.string()).optional(),
+  filters: z.array(TraceFilter$outboundSchema).optional(),
+  filterOperator: z.string().optional(),
+  limit: z.number().int().optional(),
+  timeZone: z.string().optional(),
+  includeTotals: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    groupBy: "group_by",
+    filterOperator: "filter_operator",
+    timeZone: "time_zone",
+    includeTotals: "include_totals",
+  });
+});
+
+export function queryTelemetryRequestToJSON(
+  queryTelemetryRequest: QueryTelemetryRequest,
+): string {
+  return JSON.stringify(
+    QueryTelemetryRequest$outboundSchema.parse(queryTelemetryRequest),
+  );
+}

package/src/models/components/querytelemetryresponse.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  QueryTelemetryMeta,
+  QueryTelemetryMeta$inboundSchema,
+} from "./querytelemetrymeta.js";
+import { TelemetryRow, TelemetryRow$inboundSchema } from "./telemetryrow.js";
+
+export type QueryTelemetryResponse = {
+  object?: string | undefined;
+  data?: Array<TelemetryRow> | undefined;
+  totals?: TelemetryRow | undefined;
+  meta?: QueryTelemetryMeta | undefined;
+};
+
+/** @internal */
+export const QueryTelemetryResponse$inboundSchema: z.ZodType<
+  QueryTelemetryResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: z.string().optional(),
+  data: z.array(TelemetryRow$inboundSchema).optional(),
+  totals: TelemetryRow$inboundSchema.optional(),
+  meta: QueryTelemetryMeta$inboundSchema.optional(),
+});
+
+export function queryTelemetryResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<QueryTelemetryResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QueryTelemetryResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QueryTelemetryResponse' from JSON`,
+  );
+}

package/src/models/components/reasoningpart.ts

@@ -40,7 +40,7 @@ export const ReasoningPart$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("reasoning_01kwtvr4qdc17weez7q26n5a6a"),
+  _id: z.string().default("reasoning_01kxg07w48ttq0wzw6x4ewqbpm"),
   metadata: z.record(z.any()).optional(),
   kind: z.literal("reasoning"),
   reasoning: z.string(),

package/src/models/components/telemetryrow.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type TelemetryRow = {
+  /**
+   * Unset when the resolved grain is "none" — one row per group, not a
+   *
+   * @remarks
+   *  time series.
+   */
+  timestamp?: Date | undefined;
+  group?: { [k: string]: string } | undefined;
+  metrics?: { [k: string]: number } | undefined;
+};
+
+/** @internal */
+export const TelemetryRow$inboundSchema: z.ZodType<
+  TelemetryRow,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  timestamp: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  group: z.record(z.string()).optional(),
+  metrics: z.record(z.number()).optional(),
+});
+
+export function telemetryRowFromJSON(
+  jsonString: string,
+): SafeParseResult<TelemetryRow, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TelemetryRow$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TelemetryRow' from JSON`,
+  );
+}

package/src/models/components/thinkingconfigenabledschema.ts

@@ -13,6 +13,7 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
  * The level of reasoning the model should use. This setting is supported only by `gemini-3` models. If budget_tokens is specified and `thinking_level` is available, `budget_tokens` will be ignored.
  */
 export const ThinkingLevel = {
+  Minimal: "minimal",
   Low: "low",
   Medium: "medium",
   High: "high",

package/src/models/components/updatebudgetrequest.ts

@@ -4,6 +4,11 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
+import {
+  BudgetAlert,
+  BudgetAlert$Outbound,
+  BudgetAlert$outboundSchema,
+} from "./budgetalert.js";
 import {
   BudgetLimits,
   BudgetLimits$Outbound,
@@ -52,6 +57,17 @@ export type UpdateBudgetRequest = {
    *  its derived expression is too. Validated via CEL parse.
    */
   match?: BudgetMatch | undefined;
+  /**
+   * Replaces the alert list wholesale. Omit to keep the current alerts.
+   *
+   * @remarks
+   *  An entry with a known `id` is edited in place; one with no id is minted.
+   */
+  alerts?: Array<BudgetAlert> | undefined;
+  /**
+   * Force-clear every alert. Mutually exclusive with a non-empty `alerts`.
+   */
+  clearAlerts?: boolean | undefined;
 };
 
 /** @internal */
@@ -62,6 +78,8 @@ export type UpdateBudgetRequest$Outbound = {
   expires_at?: string | undefined;
   clear_expires_at?: boolean | undefined;
   match?: BudgetMatch$Outbound | undefined;
+  alerts?: Array<BudgetAlert$Outbound> | undefined;
+  clear_alerts?: boolean | undefined;
 };
 
 /** @internal */
@@ -76,12 +94,15 @@ export const UpdateBudgetRequest$outboundSchema: z.ZodType<
   expiresAt: z.date().transform(v => v.toISOString()).optional(),
   clearExpiresAt: z.boolean().optional(),
   match: BudgetMatch$outboundSchema.optional(),
+  alerts: z.array(BudgetAlert$outboundSchema).optional(),
+  clearAlerts: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
     rateLimit: "rate_limit",
     isActive: "is_active",
     expiresAt: "expires_at",
     clearExpiresAt: "clear_expires_at",
+    clearAlerts: "clear_alerts",
   });
 });