@orq-ai/node 4.8.0-rc.4 → 4.8.0-rc.40

package/src/funcs/toolsDelete.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { OrqCore } 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";
@@ -134,7 +135,8 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["4XX", "5XX"],
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });

package/src/funcs/toolsGetV2ToolsToolIdVersions.ts

@@ -4,6 +4,7 @@
 
 import { OrqCore } from "../core.js";
 import { encodeFormQuery, 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";
@@ -144,7 +145,8 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["404", "4XX", "5XX"],
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });

package/src/funcs/toolsGetV2ToolsToolIdVersionsVersionId.ts

@@ -4,6 +4,7 @@
 
 import { OrqCore } 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";
@@ -145,7 +146,8 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["404", "4XX", "5XX"],
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });

package/src/funcs/toolsList.ts

@@ -4,6 +4,7 @@
 
 import { OrqCore } 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";
@@ -138,7 +139,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/toolsRetrieve.ts

@@ -4,6 +4,7 @@
 
 import { OrqCore } 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";
@@ -133,7 +134,8 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["4XX", "5XX"],
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });

package/src/funcs/toolsUpdate.ts

@@ -4,6 +4,7 @@
 
 import { OrqCore } 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";
@@ -137,7 +138,8 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["404", "4XX", "5XX"],
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });

package/src/lib/config.ts

@@ -68,7 +68,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "2.0",
-  sdkVersion: "4.8.0-rc.4",
-  genVersion: "2.879.10",
-  userAgent: "speakeasy-sdk/typescript 4.8.0-rc.4 2.879.10 2.0 @orq-ai/node",
+  sdkVersion: "4.8.0-rc.40",
+  genVersion: "2.881.4",
+  userAgent: "speakeasy-sdk/typescript 4.8.0-rc.40 2.881.4 2.0 @orq-ai/node",
 } 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";
@@ -234,7 +233,7 @@ export class ClientSDK {
     request: Request,
     options: {
       context: HookContext;
-      errorCodes: number | string | (number | string)[];
+      isErrorStatusCode: (statusCode: number) => boolean;
       retryConfig: RetryConfig;
       retryCodes: string[];
     },
@@ -247,7 +246,7 @@ export class ClientSDK {
       | UnexpectedClientError
     >
   > {
-    const { context, errorCodes } = options;
+    const { context, isErrorStatusCode } = options;
 
     return retry(
       async () => {
@@ -259,7 +258,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,
@@ -383,8 +382,6 @@ async function logResponse(
       break;
     case matchContentType(res, "application/jsonl")
       || jsonlLikeContentTypeRE.test(ct):
-      logger.log(await res.clone().text());
-      break;
     case matchContentType(res, "text/event-stream"):
       logger.log(`<${contentType}>`);
       break;

package/src/models/components/agentstartedstreamingevent.ts

@@ -112,14 +112,16 @@ export type Tools = {
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export const ExecuteOn = {
+export const AgentStartedStreamingEventDataExecuteOn = {
   Input: "input",
   Output: "output",
 } as const;
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export type ExecuteOn = ClosedEnum<typeof ExecuteOn>;
+export type AgentStartedStreamingEventDataExecuteOn = ClosedEnum<
+  typeof AgentStartedStreamingEventDataExecuteOn
+>;
 
 export type Evaluators = {
   /**
@@ -133,7 +135,7 @@ export type Evaluators = {
   /**
    * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
    */
-  executeOn: ExecuteOn;
+  executeOn: AgentStartedStreamingEventDataExecuteOn;
 };
 
 /**
@@ -352,8 +354,9 @@ export function toolsFromJSON(
 }
 
 /** @internal */
-export const ExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ExecuteOn> = z
-  .nativeEnum(ExecuteOn);
+export const AgentStartedStreamingEventDataExecuteOn$inboundSchema:
+  z.ZodNativeEnum<typeof AgentStartedStreamingEventDataExecuteOn> = z
+    .nativeEnum(AgentStartedStreamingEventDataExecuteOn);
 
 /** @internal */
 export const Evaluators$inboundSchema: z.ZodType<
@@ -363,7 +366,7 @@ export const Evaluators$inboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   sample_rate: z.number().default(50),
-  execute_on: ExecuteOn$inboundSchema,
+  execute_on: AgentStartedStreamingEventDataExecuteOn$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "sample_rate": "sampleRate",

package/src/models/components/budgetlimit.ts

@@ -0,0 +1,83 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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 Currency = {
+  Usd: "usd",
+} as const;
+export type Currency = ClosedEnum<typeof Currency>;
+
+export const Period = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month",
+} as const;
+export type Period = ClosedEnum<typeof Period>;
+
+export type BudgetLimit = {
+  amount: number;
+  currency: Currency;
+  period: Period;
+};
+
+/** @internal */
+export const Currency$inboundSchema: z.ZodNativeEnum<typeof Currency> = z
+  .nativeEnum(Currency);
+/** @internal */
+export const Currency$outboundSchema: z.ZodNativeEnum<typeof Currency> =
+  Currency$inboundSchema;
+
+/** @internal */
+export const Period$inboundSchema: z.ZodNativeEnum<typeof Period> = z
+  .nativeEnum(Period);
+/** @internal */
+export const Period$outboundSchema: z.ZodNativeEnum<typeof Period> =
+  Period$inboundSchema;
+
+/** @internal */
+export const BudgetLimit$inboundSchema: z.ZodType<
+  BudgetLimit,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  amount: z.number(),
+  currency: Currency$inboundSchema,
+  period: Period$inboundSchema,
+});
+/** @internal */
+export type BudgetLimit$Outbound = {
+  amount: number;
+  currency: string;
+  period: string;
+};
+
+/** @internal */
+export const BudgetLimit$outboundSchema: z.ZodType<
+  BudgetLimit$Outbound,
+  z.ZodTypeDef,
+  BudgetLimit
+> = z.object({
+  amount: z.number(),
+  currency: Currency$outboundSchema,
+  period: Period$outboundSchema,
+});
+
+export function budgetLimitToJSON(budgetLimit: BudgetLimit): string {
+  return JSON.stringify(BudgetLimit$outboundSchema.parse(budgetLimit));
+}
+export function budgetLimitFromJSON(
+  jsonString: string,
+): SafeParseResult<BudgetLimit, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BudgetLimit$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BudgetLimit' from JSON`,
+  );
+}

package/src/models/components/conversationparam.ts

@@ -0,0 +1,51 @@
+/*
+ * 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 ConversationParam = {
+  id: string;
+};
+
+/** @internal */
+export const ConversationParam$inboundSchema: z.ZodType<
+  ConversationParam,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+});
+/** @internal */
+export type ConversationParam$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const ConversationParam$outboundSchema: z.ZodType<
+  ConversationParam$Outbound,
+  z.ZodTypeDef,
+  ConversationParam
+> = z.object({
+  id: z.string(),
+});
+
+export function conversationParamToJSON(
+  conversationParam: ConversationParam,
+): string {
+  return JSON.stringify(
+    ConversationParam$outboundSchema.parse(conversationParam),
+  );
+}
+export function conversationParamFromJSON(
+  jsonString: string,
+): SafeParseResult<ConversationParam, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConversationParam$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConversationParam' from JSON`,
+  );
+}

package/src/models/components/evaluatorref.ts

@@ -0,0 +1,89 @@
+/*
+ * 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 EvaluatorRefExecuteOn = {
+  Input: "input",
+  Output: "output",
+  Both: "both",
+} as const;
+export type EvaluatorRefExecuteOn = ClosedEnum<typeof EvaluatorRefExecuteOn>;
+
+export type EvaluatorRef = {
+  executeOn: EvaluatorRefExecuteOn;
+  id: string;
+  isGuardrail?: boolean | undefined;
+  sampleRate?: number | undefined;
+};
+
+/** @internal */
+export const EvaluatorRefExecuteOn$inboundSchema: z.ZodNativeEnum<
+  typeof EvaluatorRefExecuteOn
+> = z.nativeEnum(EvaluatorRefExecuteOn);
+/** @internal */
+export const EvaluatorRefExecuteOn$outboundSchema: z.ZodNativeEnum<
+  typeof EvaluatorRefExecuteOn
+> = EvaluatorRefExecuteOn$inboundSchema;
+
+/** @internal */
+export const EvaluatorRef$inboundSchema: z.ZodType<
+  EvaluatorRef,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  execute_on: EvaluatorRefExecuteOn$inboundSchema,
+  id: z.string(),
+  is_guardrail: z.boolean().optional(),
+  sample_rate: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "execute_on": "executeOn",
+    "is_guardrail": "isGuardrail",
+    "sample_rate": "sampleRate",
+  });
+});
+/** @internal */
+export type EvaluatorRef$Outbound = {
+  execute_on: string;
+  id: string;
+  is_guardrail?: boolean | undefined;
+  sample_rate?: number | undefined;
+};
+
+/** @internal */
+export const EvaluatorRef$outboundSchema: z.ZodType<
+  EvaluatorRef$Outbound,
+  z.ZodTypeDef,
+  EvaluatorRef
+> = z.object({
+  executeOn: EvaluatorRefExecuteOn$outboundSchema,
+  id: z.string(),
+  isGuardrail: z.boolean().optional(),
+  sampleRate: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    executeOn: "execute_on",
+    isGuardrail: "is_guardrail",
+    sampleRate: "sample_rate",
+  });
+});
+
+export function evaluatorRefToJSON(evaluatorRef: EvaluatorRef): string {
+  return JSON.stringify(EvaluatorRef$outboundSchema.parse(evaluatorRef));
+}
+export function evaluatorRefFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluatorRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvaluatorRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluatorRef' from JSON`,
+  );
+}

package/src/models/components/expression.ts

@@ -0,0 +1,33 @@
+/*
+ * 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 Expression = {
+  cel: string;
+  config?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const Expression$inboundSchema: z.ZodType<
+  Expression,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  cel: z.string(),
+  config: z.record(z.any()).optional(),
+});
+
+export function expressionFromJSON(
+  jsonString: string,
+): SafeParseResult<Expression, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Expression$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Expression' from JSON`,
+  );
+}

package/src/models/components/expressioninput.ts

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type ExpressionInput = {
+  cel: string;
+};
+
+/** @internal */
+export type ExpressionInput$Outbound = {
+  cel: string;
+};
+
+/** @internal */
+export const ExpressionInput$outboundSchema: z.ZodType<
+  ExpressionInput$Outbound,
+  z.ZodTypeDef,
+  ExpressionInput
+> = z.object({
+  cel: z.string(),
+});
+
+export function expressionInputToJSON(
+  expressionInput: ExpressionInput,
+): string {
+  return JSON.stringify(ExpressionInput$outboundSchema.parse(expressionInput));
+}

package/src/models/components/fallbackconfig.ts

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type FallbackConfig = {
+  model: string;
+};
+
+/** @internal */
+export type FallbackConfig$Outbound = {
+  model: string;
+};
+
+/** @internal */
+export const FallbackConfig$outboundSchema: z.ZodType<
+  FallbackConfig$Outbound,
+  z.ZodTypeDef,
+  FallbackConfig
+> = z.object({
+  model: z.string(),
+});
+
+export function fallbackConfigToJSON(fallbackConfig: FallbackConfig): string {
+  return JSON.stringify(FallbackConfig$outboundSchema.parse(fallbackConfig));
+}

package/src/models/components/guardrailref.ts

@@ -0,0 +1,87 @@
+/*
+ * 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 ExecuteOn = {
+  Input: "input",
+  Output: "output",
+  Both: "both",
+} as const;
+export type ExecuteOn = ClosedEnum<typeof ExecuteOn>;
+
+export type GuardrailRef = {
+  executeOn: ExecuteOn;
+  id: string;
+  isGuardrail?: boolean | undefined;
+  sampleRate?: number | undefined;
+};
+
+/** @internal */
+export const ExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ExecuteOn> = z
+  .nativeEnum(ExecuteOn);
+/** @internal */
+export const ExecuteOn$outboundSchema: z.ZodNativeEnum<typeof ExecuteOn> =
+  ExecuteOn$inboundSchema;
+
+/** @internal */
+export const GuardrailRef$inboundSchema: z.ZodType<
+  GuardrailRef,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  execute_on: ExecuteOn$inboundSchema,
+  id: z.string(),
+  is_guardrail: z.boolean().optional(),
+  sample_rate: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "execute_on": "executeOn",
+    "is_guardrail": "isGuardrail",
+    "sample_rate": "sampleRate",
+  });
+});
+/** @internal */
+export type GuardrailRef$Outbound = {
+  execute_on: string;
+  id: string;
+  is_guardrail?: boolean | undefined;
+  sample_rate?: number | undefined;
+};
+
+/** @internal */
+export const GuardrailRef$outboundSchema: z.ZodType<
+  GuardrailRef$Outbound,
+  z.ZodTypeDef,
+  GuardrailRef
+> = z.object({
+  executeOn: ExecuteOn$outboundSchema,
+  id: z.string(),
+  isGuardrail: z.boolean().optional(),
+  sampleRate: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    executeOn: "execute_on",
+    isGuardrail: "is_guardrail",
+    sampleRate: "sample_rate",
+  });
+});
+
+export function guardrailRefToJSON(guardrailRef: GuardrailRef): string {
+  return JSON.stringify(GuardrailRef$outboundSchema.parse(guardrailRef));
+}
+export function guardrailRefFromJSON(
+  jsonString: string,
+): SafeParseResult<GuardrailRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GuardrailRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GuardrailRef' from JSON`,
+  );
+}

package/src/models/components/guardrailrule.ts

@@ -0,0 +1,66 @@
+/*
+ * 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 { Expression, Expression$inboundSchema } from "./expression.js";
+import { GuardrailRef, GuardrailRef$inboundSchema } from "./guardrailref.js";
+
+export type GuardrailRule = {
+  id: string;
+  createdAt: Date;
+  createdById: string;
+  description?: string | undefined;
+  displayName: string;
+  enabled: boolean;
+  expression?: Expression | undefined;
+  guardrails?: Array<GuardrailRef> | null | undefined;
+  projectId: string;
+  timeout: number;
+  updatedAt: Date;
+  updatedById: string;
+};
+
+/** @internal */
+export const GuardrailRule$inboundSchema: z.ZodType<
+  GuardrailRule,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  created_by_id: z.string(),
+  description: z.string().optional(),
+  display_name: z.string(),
+  enabled: z.boolean(),
+  expression: Expression$inboundSchema.optional(),
+  guardrails: z.nullable(z.array(GuardrailRef$inboundSchema)).optional(),
+  project_id: z.string(),
+  timeout: z.number().int(),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updated_by_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "created_at": "createdAt",
+    "created_by_id": "createdById",
+    "display_name": "displayName",
+    "project_id": "projectId",
+    "updated_at": "updatedAt",
+    "updated_by_id": "updatedById",
+  });
+});
+
+export function guardrailRuleFromJSON(
+  jsonString: string,
+): SafeParseResult<GuardrailRule, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GuardrailRule$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GuardrailRule' from JSON`,
+  );
+}