@orq-ai/node 4.14.3 → 4.14.4

package/packages/orq-rc/src/lib/encodings.ts

@@ -12,10 +12,41 @@ export class EncodingError extends Error {
   }
 }
 
+export type CharEncoding = "percent" | "percentExceptReserved" | "none";
+
+const reservedEscapes = /%(2[346bcf]|3[abdf]|40|5[bd])/gi;
+
+function encodeKeyChars(
+  v: string,
+  charEncoding: CharEncoding | undefined,
+): string {
+  return encodeChars(
+    v,
+    charEncoding === "percentExceptReserved" ? "percent" : charEncoding,
+  );
+}
+
+function encodeChars(
+  v: string,
+  charEncoding: CharEncoding | undefined,
+): string {
+  switch (charEncoding) {
+    case "percent":
+      return encodeURIComponent(v);
+    case "percentExceptReserved":
+      return encodeURIComponent(v).replace(
+        reservedEscapes,
+        (m) => decodeURIComponent(m),
+      );
+    default:
+      return v;
+  }
+}
+
 export function encodeMatrix(
   key: string,
   value: unknown,
-  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+  options?: { explode?: boolean; charEncoding?: CharEncoding },
 ): string | undefined {
   let out = "";
   const pairs: [string, unknown][] = options?.explode
@@ -27,7 +58,7 @@ export function encodeMatrix(
   }
 
   const encodeString = (v: string) => {
-    return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    return encodeChars(v, options?.charEncoding);
   };
   const encodeValue = (v: unknown) => encodeString(serializeValue(v));
 
@@ -52,7 +83,7 @@ export function encodeMatrix(
       return;
     }
 
-    const keyPrefix = encodeString(pk);
+    const keyPrefix = encodeKeyChars(pk, options?.charEncoding);
     tmp = `${keyPrefix}=${encValue}`;
     // trim trailing '=' if value was empty
     if (tmp === `${keyPrefix}=`) {
@@ -73,7 +104,7 @@ export function encodeMatrix(
 export function encodeLabel(
   key: string,
   value: unknown,
-  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+  options?: { explode?: boolean; charEncoding?: CharEncoding },
 ): string | undefined {
   let out = "";
   const pairs: [string, unknown][] = options?.explode
@@ -85,7 +116,7 @@ export function encodeLabel(
   }
 
   const encodeString = (v: string) => {
-    return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    return encodeChars(v, options?.charEncoding);
   };
   const encodeValue = (v: unknown) => encodeString(serializeValue(v));
 
@@ -103,7 +134,7 @@ export function encodeLabel(
       encValue = mapped?.join("").slice(1);
     } else {
       const k = options?.explode && isPlainObject(value)
-        ? `${encodeString(pk)}=`
+        ? `${encodeKeyChars(pk, options?.charEncoding)}=`
         : "";
       encValue = `${k}${encodeValue(pv)}`;
     }
@@ -117,14 +148,14 @@ export function encodeLabel(
 type FormEncoder = (
   key: string,
   value: unknown,
-  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+  options?: { explode?: boolean; charEncoding?: CharEncoding },
 ) => string | undefined;
 
 function formEncoder(sep: string): FormEncoder {
   return (
     key: string,
     value: unknown,
-    options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+    options?: { explode?: boolean; charEncoding?: CharEncoding },
   ) => {
     let out = "";
     const pairs: [string, unknown][] = options?.explode
@@ -136,7 +167,7 @@ function formEncoder(sep: string): FormEncoder {
     }
 
     const encodeString = (v: string) => {
-      return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+      return encodeChars(v, options?.charEncoding);
     };
 
     const encodeValue = (v: unknown) => encodeString(serializeValue(v));
@@ -163,7 +194,7 @@ function formEncoder(sep: string): FormEncoder {
         return;
       }
 
-      tmp = `${encodeString(pk)}=${encValue}`;
+      tmp = `${encodeKeyChars(pk, options?.charEncoding)}=${encValue}`;
 
       // If we end up with the nothing then skip forward
       if (!tmp || tmp === "=") {
@@ -184,7 +215,7 @@ export const encodePipeDelimited = formEncoder("|");
 export function encodeBodyForm(
   key: string,
   value: unknown,
-  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+  options?: { explode?: boolean; charEncoding?: CharEncoding },
 ): string {
   let out = "";
   const pairs: [string, unknown][] = options?.explode
@@ -192,7 +223,7 @@ export function encodeBodyForm(
     : [[key, value]];
 
   const encodeString = (v: string) => {
-    return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    return encodeChars(v, options?.charEncoding);
   };
 
   const encodeValue = (v: unknown) => encodeString(serializeValue(v));
@@ -211,7 +242,7 @@ export function encodeBodyForm(
       encValue = `${encodeValue(pv)}`;
     }
 
-    tmp = `${encodeString(pk)}=${encValue}`;
+    tmp = `${encodeKeyChars(pk, options?.charEncoding)}=${encValue}`;
 
     // If we end up with the nothing then skip forward
     if (!tmp || tmp === "=") {
@@ -227,7 +258,7 @@ export function encodeBodyForm(
 export function encodeDeepObject(
   key: string,
   value: unknown,
-  options?: { charEncoding?: "percent" | "none" },
+  options?: { charEncoding?: CharEncoding },
 ): string | undefined {
   if (value == null) {
     return;
@@ -245,7 +276,7 @@ export function encodeDeepObject(
 export function encodeDeepObjectObject(
   key: string,
   value: unknown,
-  options?: { charEncoding?: "percent" | "none" },
+  options?: { charEncoding?: CharEncoding },
 ): string | undefined {
   if (value == null) {
     return;
@@ -254,7 +285,7 @@ export function encodeDeepObjectObject(
   let out = "";
 
   const encodeString = (v: string) => {
-    return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    return encodeChars(v, options?.charEncoding);
   };
 
   if (!isPlainObject(value)) {
@@ -278,7 +309,9 @@ export function encodeDeepObjectObject(
 
     const pairs: unknown[] = Array.isArray(cv) ? cv : [cv];
     const encoded = mapDefined(pairs, (v) => {
-      return `${encodeString(pk)}=${encodeString(serializeValue(v))}`;
+      return `${encodeKeyChars(pk, options?.charEncoding)}=${
+        encodeString(serializeValue(v))
+      }`;
     })?.join("&");
 
     out += encoded == null ? "" : `&${encoded}`;
@@ -290,25 +323,27 @@ export function encodeDeepObjectObject(
 export function encodeJSON(
   key: string,
   value: unknown,
-  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+  options?: { explode?: boolean; charEncoding?: CharEncoding },
 ): string | undefined {
   if (typeof value === "undefined") {
     return;
   }
 
   const encodeString = (v: string) => {
-    return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    return encodeChars(v, options?.charEncoding);
   };
 
   const encVal = encodeString(JSON.stringify(value, jsonReplacer));
 
-  return options?.explode ? encVal : `${encodeString(key)}=${encVal}`;
+  return options?.explode
+    ? encVal
+    : `${encodeKeyChars(key, options?.charEncoding)}=${encVal}`;
 }
 
 export const encodeSimple = (
   key: string,
   value: unknown,
-  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+  options?: { explode?: boolean; charEncoding?: CharEncoding },
 ): string | undefined => {
   let out = "";
   const pairs: [string, unknown][] = options?.explode
@@ -320,7 +355,7 @@ export const encodeSimple = (
   }
 
   const encodeString = (v: string) => {
-    return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    return encodeChars(v, options?.charEncoding);
   };
   const encodeValue = (v: unknown) => encodeString(serializeValue(v));
 
@@ -426,7 +461,7 @@ export function queryJoin(...args: (string | undefined)[]): string {
 
 type QueryEncoderOptions = {
   explode?: boolean;
-  charEncoding?: "percent" | "none";
+  charEncoding?: CharEncoding;
   allowEmptyValue?: string[];
 };
 

package/packages/orq-rc/src/models/components/addannotationqueueitemsrequest.ts

@@ -0,0 +1,41 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  AnnotationQueueItemRef,
+  AnnotationQueueItemRef$Outbound,
+  AnnotationQueueItemRef$outboundSchema,
+} from "./annotationqueueitemref.js";
+
+export type AddAnnotationQueueItemsRequest = {
+  /**
+   * The spans to add to the annotation queue.
+   */
+  items: Array<AnnotationQueueItemRef>;
+};
+
+/** @internal */
+export type AddAnnotationQueueItemsRequest$Outbound = {
+  items: Array<AnnotationQueueItemRef$Outbound>;
+};
+
+/** @internal */
+export const AddAnnotationQueueItemsRequest$outboundSchema: z.ZodType<
+  AddAnnotationQueueItemsRequest$Outbound,
+  z.ZodTypeDef,
+  AddAnnotationQueueItemsRequest
+> = z.object({
+  items: z.array(AnnotationQueueItemRef$outboundSchema),
+});
+
+export function addAnnotationQueueItemsRequestToJSON(
+  addAnnotationQueueItemsRequest: AddAnnotationQueueItemsRequest,
+): string {
+  return JSON.stringify(
+    AddAnnotationQueueItemsRequest$outboundSchema.parse(
+      addAnnotationQueueItemsRequest,
+    ),
+  );
+}

package/packages/orq-rc/src/models/components/addannotationqueueitemsresponse.ts

@@ -0,0 +1,38 @@
+/*
+ * 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 {
+  AnnotationQueueItem,
+  AnnotationQueueItem$inboundSchema,
+} from "./annotationqueueitem.js";
+
+export type AddAnnotationQueueItemsResponse = {
+  /**
+   * Items created by this call. Spans already present in the queue are omitted.
+   */
+  items: Array<AnnotationQueueItem>;
+};
+
+/** @internal */
+export const AddAnnotationQueueItemsResponse$inboundSchema: z.ZodType<
+  AddAnnotationQueueItemsResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  items: z.array(AnnotationQueueItem$inboundSchema),
+});
+
+export function addAnnotationQueueItemsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AddAnnotationQueueItemsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddAnnotationQueueItemsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddAnnotationQueueItemsResponse' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/agentresponserequest.ts

@@ -182,7 +182,7 @@ export type Engine = ClosedEnum<typeof Engine>;
 /**
  * Configuration options for the agent invocation
  */
-export type Configuration = {
+export type AgentResponseRequestConfiguration = {
   /**
    * Whether to block until the agent task completes. When true, the response will include the full task with messages. When false (default), returns immediately with task ID and status.
    */
@@ -244,7 +244,7 @@ export type AgentResponseRequest = {
   /**
    * Configuration options for the agent invocation
    */
-  configuration?: Configuration | undefined;
+  configuration?: AgentResponseRequestConfiguration | undefined;
   /**
    * If true, returns immediately without waiting for completion. If false (default), waits until the agent becomes inactive or errors.
    */
@@ -469,21 +469,27 @@ export const Engine$outboundSchema: z.ZodNativeEnum<typeof Engine> = z
   .nativeEnum(Engine);
 
 /** @internal */
-export type Configuration$Outbound = {
+export type AgentResponseRequestConfiguration$Outbound = {
   blocking: boolean;
 };
 
 /** @internal */
-export const Configuration$outboundSchema: z.ZodType<
-  Configuration$Outbound,
+export const AgentResponseRequestConfiguration$outboundSchema: z.ZodType<
+  AgentResponseRequestConfiguration$Outbound,
   z.ZodTypeDef,
-  Configuration
+  AgentResponseRequestConfiguration
 > = z.object({
   blocking: z.boolean().default(false),
 });
 
-export function configurationToJSON(configuration: Configuration): string {
-  return JSON.stringify(Configuration$outboundSchema.parse(configuration));
+export function agentResponseRequestConfigurationToJSON(
+  agentResponseRequestConfiguration: AgentResponseRequestConfiguration,
+): string {
+  return JSON.stringify(
+    AgentResponseRequestConfiguration$outboundSchema.parse(
+      agentResponseRequestConfiguration,
+    ),
+  );
 }
 
 /** @internal */
@@ -519,7 +525,7 @@ export type AgentResponseRequest$Outbound = {
   memory?: AgentResponseRequestMemory$Outbound | undefined;
   metadata?: { [k: string]: any } | undefined;
   engine?: string | undefined;
-  configuration?: Configuration$Outbound | undefined;
+  configuration?: AgentResponseRequestConfiguration$Outbound | undefined;
   background: boolean;
   stream: boolean;
   conversation?: Conversation$Outbound | undefined;
@@ -541,7 +547,8 @@ export const AgentResponseRequest$outboundSchema: z.ZodType<
   memory: z.lazy(() => AgentResponseRequestMemory$outboundSchema).optional(),
   metadata: z.record(z.any()).optional(),
   engine: Engine$outboundSchema.optional(),
-  configuration: z.lazy(() => Configuration$outboundSchema).optional(),
+  configuration: z.lazy(() => AgentResponseRequestConfiguration$outboundSchema)
+    .optional(),
   background: z.boolean().default(false),
   stream: z.boolean().default(false),
   conversation: z.lazy(() => Conversation$outboundSchema).optional(),

package/packages/orq-rc/src/models/components/annotationqueue.ts

@@ -0,0 +1,101 @@
+/*
+ * 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 {
+  AnnotationQueueMetadata,
+  AnnotationQueueMetadata$inboundSchema,
+} from "./annotationqueuemetadata.js";
+
+export type AnnotationQueue = {
+  /**
+   * Unique annotation queue identifier assigned by ORQ.
+   */
+  id: string;
+  /**
+   * The display name of the annotation queue.
+   */
+  displayName: string;
+  /**
+   * The description of the annotation queue.
+   */
+  description: string;
+  /**
+   * The unique identifier of the workspace it belongs to.
+   */
+  workspaceId: string;
+  /**
+   * The project ID. When set, human reviews are resolved from the project automatically.
+   */
+  projectId?: string | undefined;
+  /**
+   * Legacy: manually selected human review IDs. Used only when project_id is not set.
+   */
+  humanReviewIds: Array<string>;
+  /**
+   * Aggregate counters for the annotation queue.
+   */
+  metadata: AnnotationQueueMetadata;
+  /**
+   * The account that created the annotation queue. Unset when created via API key authentication.
+   */
+  createdById?: string | undefined;
+  /**
+   * The account that last updated the annotation queue. Unset when updated via API key authentication.
+   */
+  updatedById?: string | undefined;
+  /**
+   * The date and time the annotation queue was created.
+   */
+  created?: Date | undefined;
+  /**
+   * The date and time the annotation queue was last updated.
+   */
+  updated?: Date | undefined;
+};
+
+/** @internal */
+export const AnnotationQueue$inboundSchema: z.ZodType<
+  AnnotationQueue,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  display_name: z.string(),
+  description: z.string(),
+  workspace_id: z.string(),
+  project_id: z.string().optional(),
+  human_review_ids: z.array(z.string()),
+  metadata: AnnotationQueueMetadata$inboundSchema,
+  created_by_id: z.string().optional(),
+  updated_by_id: z.string().optional(),
+  created: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  updated: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "display_name": "displayName",
+    "workspace_id": "workspaceId",
+    "project_id": "projectId",
+    "human_review_ids": "humanReviewIds",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
+  });
+});
+
+export function annotationQueueFromJSON(
+  jsonString: string,
+): SafeParseResult<AnnotationQueue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnnotationQueue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnnotationQueue' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/annotationqueueitem.ts

@@ -0,0 +1,80 @@
+/*
+ * 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 AnnotationQueueItem = {
+  /**
+   * Unique annotation queue item identifier assigned by ORQ.
+   */
+  id: string;
+  /**
+   * The unique identifier of the annotation queue.
+   */
+  annotationQueueId: string;
+  /**
+   * The unique identifier of the workspace it belongs to.
+   */
+  workspaceId: string;
+  /**
+   * The unique identifiers of the human reviews that have been used to annotate the item.
+   */
+  usedHumanReviewIds?: Array<string> | undefined;
+  /**
+   * The item type. Either `span` or `datapoint`.
+   */
+  type: string;
+  /**
+   * The span this item points to. Present when `type` is `span`.
+   */
+  spanId?: string | undefined;
+  /**
+   * The trace identifier this span belongs to.
+   */
+  traceId?: string | undefined;
+  /**
+   * The datapoint this item points to. Present when `type` is `datapoint`.
+   */
+  datapointId?: string | undefined;
+};
+
+/** @internal */
+export const AnnotationQueueItem$inboundSchema: z.ZodType<
+  AnnotationQueueItem,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  annotation_queue_id: z.string(),
+  workspace_id: z.string(),
+  used_human_review_ids: z.array(z.string()).optional(),
+  type: z.string(),
+  span_id: z.string().optional(),
+  trace_id: z.string().optional(),
+  datapoint_id: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "annotation_queue_id": "annotationQueueId",
+    "workspace_id": "workspaceId",
+    "used_human_review_ids": "usedHumanReviewIds",
+    "span_id": "spanId",
+    "trace_id": "traceId",
+    "datapoint_id": "datapointId",
+  });
+});
+
+export function annotationQueueItemFromJSON(
+  jsonString: string,
+): SafeParseResult<AnnotationQueueItem, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnnotationQueueItem$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnnotationQueueItem' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/annotationqueueitemref.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";
+
+/**
+ * Span reference accepted by AddAnnotationQueueItems.
+ */
+export type AnnotationQueueItemRef = {
+  spanId: string;
+  traceId: string;
+};
+
+/** @internal */
+export type AnnotationQueueItemRef$Outbound = {
+  span_id: string;
+  trace_id: string;
+};
+
+/** @internal */
+export const AnnotationQueueItemRef$outboundSchema: z.ZodType<
+  AnnotationQueueItemRef$Outbound,
+  z.ZodTypeDef,
+  AnnotationQueueItemRef
+> = z.object({
+  spanId: z.string(),
+  traceId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    spanId: "span_id",
+    traceId: "trace_id",
+  });
+});
+
+export function annotationQueueItemRefToJSON(
+  annotationQueueItemRef: AnnotationQueueItemRef,
+): string {
+  return JSON.stringify(
+    AnnotationQueueItemRef$outboundSchema.parse(annotationQueueItemRef),
+  );
+}

package/packages/orq-rc/src/models/components/annotationqueuemetadata.ts

@@ -0,0 +1,42 @@
+/*
+ * 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";
+
+/**
+ * Aggregate counters maintained by the service as items are added and removed.
+ */
+export type AnnotationQueueMetadata = {
+  /**
+   * Number of items currently in the annotation queue.
+   */
+  itemsCount: number;
+};
+
+/** @internal */
+export const AnnotationQueueMetadata$inboundSchema: z.ZodType<
+  AnnotationQueueMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  items_count: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "items_count": "itemsCount",
+  });
+});
+
+export function annotationQueueMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<AnnotationQueueMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnnotationQueueMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnnotationQueueMetadata' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/budgetmatch.ts

@@ -12,9 +12,9 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
  *
  * @remarks
  *  applies to a request. Available variables: `model`, `provider`,
- *  `model_id`, `api_key`, `identity`, `project`, `metadata` (map),
- *  `headers` (map, lowercase keys). An empty expression always matches.
- *  Expressions are syntax-validated at write time.
+ *  `model_id`, `api_key`, `api_key_labels` (map), `factory`, `identity`,
+ *  `project`, `metadata` (map), `headers` (map, lowercase keys). An empty
+ *  expression always matches. Expressions are syntax-validated at write time.
  */
 export type BudgetMatch = {
   cel?: string | undefined;