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

package/src/models/components/agentthoughtstreamingevent.ts

@@ -83,7 +83,7 @@ export type AgentThoughtStreamingEventFunction = {
   arguments?: string | undefined;
 };
 
-export type AgentThoughtStreamingEventToolCalls = {
+export type ToolCalls = {
   index?: number | undefined;
   id?: string | undefined;
   type?: AgentThoughtStreamingEventDataType | undefined;
@@ -104,7 +104,7 @@ export type AgentThoughtStreamingEventDataRole = ClosedEnum<
 /**
  * If the audio output modality is requested, this object contains data about the audio response from the model.
  */
-export type AgentThoughtStreamingEventAudio = {
+export type Audio = {
   id: string;
   expiresAt: number;
   data: string;
@@ -117,7 +117,7 @@ export type AgentThoughtStreamingEventAudio = {
 export type AgentThoughtStreamingEventMessage = {
   content?: string | null | undefined;
   refusal?: string | null | undefined;
-  toolCalls?: Array<AgentThoughtStreamingEventToolCalls> | undefined;
+  toolCalls?: Array<ToolCalls> | undefined;
   role?: AgentThoughtStreamingEventDataRole | undefined;
   /**
    * Internal thought process of the model
@@ -134,7 +134,7 @@ export type AgentThoughtStreamingEventMessage = {
   /**
    * If the audio output modality is requested, this object contains data about the audio response from the model.
    */
-  audio?: AgentThoughtStreamingEventAudio | null | undefined;
+  audio?: Audio | null | undefined;
 };
 
 export type TopLogprobs = {
@@ -152,7 +152,7 @@ export type TopLogprobs = {
   bytes: Array<number> | null;
 };
 
-export type AgentThoughtStreamingEventContent = {
+export type Content = {
   /**
    * The token.
    */
@@ -212,7 +212,7 @@ export type Logprobs = {
   /**
    * A list of message content tokens with log probability information.
    */
-  content: Array<AgentThoughtStreamingEventContent> | null;
+  content: Array<Content> | null;
   /**
    * A list of message refusal tokens with log probability information.
    */
@@ -411,8 +411,8 @@ export function agentThoughtStreamingEventFunctionFromJSON(
 }
 
 /** @internal */
-export const AgentThoughtStreamingEventToolCalls$inboundSchema: z.ZodType<
-  AgentThoughtStreamingEventToolCalls,
+export const ToolCalls$inboundSchema: z.ZodType<
+  ToolCalls,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -428,14 +428,13 @@ export const AgentThoughtStreamingEventToolCalls$inboundSchema: z.ZodType<
   });
 });
 
-export function agentThoughtStreamingEventToolCallsFromJSON(
+export function toolCallsFromJSON(
   jsonString: string,
-): SafeParseResult<AgentThoughtStreamingEventToolCalls, SDKValidationError> {
+): SafeParseResult<ToolCalls, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) =>
-      AgentThoughtStreamingEventToolCalls$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AgentThoughtStreamingEventToolCalls' from JSON`,
+    (x) => ToolCalls$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolCalls' from JSON`,
   );
 }
 
@@ -445,28 +444,25 @@ export const AgentThoughtStreamingEventDataRole$inboundSchema: z.ZodNativeEnum<
 > = z.nativeEnum(AgentThoughtStreamingEventDataRole);
 
 /** @internal */
-export const AgentThoughtStreamingEventAudio$inboundSchema: z.ZodType<
-  AgentThoughtStreamingEventAudio,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-  expires_at: z.number().int(),
-  data: z.string(),
-  transcript: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "expires_at": "expiresAt",
+export const Audio$inboundSchema: z.ZodType<Audio, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    expires_at: z.number().int(),
+    data: z.string(),
+    transcript: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      "expires_at": "expiresAt",
+    });
   });
-});
 
-export function agentThoughtStreamingEventAudioFromJSON(
+export function audioFromJSON(
   jsonString: string,
-): SafeParseResult<AgentThoughtStreamingEventAudio, SDKValidationError> {
+): SafeParseResult<Audio, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AgentThoughtStreamingEventAudio$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AgentThoughtStreamingEventAudio' from JSON`,
+    (x) => Audio$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Audio' from JSON`,
   );
 }
 
@@ -478,15 +474,12 @@ export const AgentThoughtStreamingEventMessage$inboundSchema: z.ZodType<
 > = z.object({
   content: z.nullable(z.string()).optional(),
   refusal: z.nullable(z.string()).optional(),
-  tool_calls: z.array(
-    z.lazy(() => AgentThoughtStreamingEventToolCalls$inboundSchema),
-  ).optional(),
+  tool_calls: z.array(z.lazy(() => ToolCalls$inboundSchema)).optional(),
   role: AgentThoughtStreamingEventDataRole$inboundSchema.optional(),
   reasoning: z.nullable(z.string()).optional(),
   reasoning_signature: z.nullable(z.string()).optional(),
   redacted_reasoning: z.string().optional(),
-  audio: z.nullable(z.lazy(() => AgentThoughtStreamingEventAudio$inboundSchema))
-    .optional(),
+  audio: z.nullable(z.lazy(() => Audio$inboundSchema)).optional(),
 }).transform((v) => {
   return remap$(v, {
     "tool_calls": "toolCalls",
@@ -527,28 +520,25 @@ export function topLogprobsFromJSON(
 }
 
 /** @internal */
-export const AgentThoughtStreamingEventContent$inboundSchema: z.ZodType<
-  AgentThoughtStreamingEventContent,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  token: z.string(),
-  logprob: z.number(),
-  bytes: z.nullable(z.array(z.number())),
-  top_logprobs: z.array(z.lazy(() => TopLogprobs$inboundSchema)),
-}).transform((v) => {
-  return remap$(v, {
-    "top_logprobs": "topLogprobs",
+export const Content$inboundSchema: z.ZodType<Content, z.ZodTypeDef, unknown> =
+  z.object({
+    token: z.string(),
+    logprob: z.number(),
+    bytes: z.nullable(z.array(z.number())),
+    top_logprobs: z.array(z.lazy(() => TopLogprobs$inboundSchema)),
+  }).transform((v) => {
+    return remap$(v, {
+      "top_logprobs": "topLogprobs",
+    });
   });
-});
 
-export function agentThoughtStreamingEventContentFromJSON(
+export function contentFromJSON(
   jsonString: string,
-): SafeParseResult<AgentThoughtStreamingEventContent, SDKValidationError> {
+): SafeParseResult<Content, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AgentThoughtStreamingEventContent$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AgentThoughtStreamingEventContent' from JSON`,
+    (x) => Content$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Content' from JSON`,
   );
 }
 
@@ -605,9 +595,7 @@ export const Logprobs$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  content: z.nullable(
-    z.array(z.lazy(() => AgentThoughtStreamingEventContent$inboundSchema)),
-  ),
+  content: z.nullable(z.array(z.lazy(() => Content$inboundSchema))),
   refusal: z.nullable(z.array(z.lazy(() => Refusal$inboundSchema))),
 });
 

package/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/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/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/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/src/models/components/auditlog.ts

@@ -0,0 +1,122 @@
+/*
+ * 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 { Value, Value$inboundSchema } from "./value.js";
+
+/**
+ * Additional event metadata. The exact shape depends on entity_type and action.
+ */
+export type AuditLogMetadata = {};
+
+/**
+ * An audit log entry for an entity event in the authenticated workspace.
+ */
+export type AuditLog = {
+  /**
+   * Unique identifier for the audit log entry.
+   */
+  auditLogId: string;
+  /**
+   * Project associated with the event, when the audited entity belongs to a project.
+   */
+  projectId?: string | undefined;
+  /**
+   * Identifier of the entity that changed.
+   */
+  entityId: string;
+  entityType: Value;
+  action: Value;
+  /**
+   * User or system actor that caused the event, when available.
+   */
+  actorId?: string | undefined;
+  /**
+   * IP address observed for the actor, when available.
+   */
+  actorIp?: string | undefined;
+  actorType?: Value | undefined;
+  /**
+   * Human readable actor name captured when the action happened.
+   */
+  actorDisplay?: string | undefined;
+  origin?: Value | undefined;
+  /**
+   * Correlates the entry with the originating request.
+   */
+  requestId?: string | undefined;
+  /**
+   * Time when the audit log entry was created.
+   */
+  createdAt: Date;
+  /**
+   * Additional event metadata. The exact shape depends on entity_type and action.
+   */
+  metadata?: AuditLogMetadata | undefined;
+};
+
+/** @internal */
+export const AuditLogMetadata$inboundSchema: z.ZodType<
+  AuditLogMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function auditLogMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<AuditLogMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AuditLogMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AuditLogMetadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const AuditLog$inboundSchema: z.ZodType<
+  AuditLog,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  audit_log_id: z.string(),
+  project_id: z.string().optional(),
+  entity_id: z.string(),
+  entity_type: Value$inboundSchema,
+  action: Value$inboundSchema,
+  actor_id: z.string().optional(),
+  actor_ip: z.string().optional(),
+  actor_type: Value$inboundSchema.optional(),
+  actor_display: z.string().optional(),
+  origin: Value$inboundSchema.optional(),
+  request_id: z.string().optional(),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  metadata: z.lazy(() => AuditLogMetadata$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "audit_log_id": "auditLogId",
+    "project_id": "projectId",
+    "entity_id": "entityId",
+    "entity_type": "entityType",
+    "actor_id": "actorId",
+    "actor_ip": "actorIp",
+    "actor_type": "actorType",
+    "actor_display": "actorDisplay",
+    "request_id": "requestId",
+    "created_at": "createdAt",
+  });
+});
+
+export function auditLogFromJSON(
+  jsonString: string,
+): SafeParseResult<AuditLog, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AuditLog$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AuditLog' from JSON`,
+  );
+}

package/src/models/components/auditlogfilter.ts

@@ -0,0 +1,51 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+/**
+ * A single advanced filter applied to audit logs.
+ */
+export type AuditLogFilter = {
+  /**
+   * Filter value type, such as string, date, number, boolean, or array.
+   */
+  type: string;
+  /**
+   * Audit log field path to filter on. Supported paths include created_at, entity_id, entity_type, action, actor_id, and metadata.display_name.
+   */
+  path: string;
+  /**
+   * Filter operator supported by the selected field type.
+   */
+  operator: string;
+  /**
+   * Represents a dynamically typed value which can be either null, a number, a string, a boolean, a recursive struct value, or a list of values.
+   */
+  value?: any | undefined;
+};
+
+/** @internal */
+export type AuditLogFilter$Outbound = {
+  type: string;
+  path: string;
+  operator: string;
+  value?: any | undefined;
+};
+
+/** @internal */
+export const AuditLogFilter$outboundSchema: z.ZodType<
+  AuditLogFilter$Outbound,
+  z.ZodTypeDef,
+  AuditLogFilter
+> = z.object({
+  type: z.string(),
+  path: z.string(),
+  operator: z.string(),
+  value: z.any().optional(),
+});
+
+export function auditLogFilterToJSON(auditLogFilter: AuditLogFilter): string {
+  return JSON.stringify(AuditLogFilter$outboundSchema.parse(auditLogFilter));
+}

package/src/models/components/auditlogfilterquery.ts

@@ -0,0 +1,54 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  AuditLogFilter,
+  AuditLogFilter$Outbound,
+  AuditLogFilter$outboundSchema,
+} from "./auditlogfilter.js";
+
+/**
+ * Search and advanced filters for querying audit logs.
+ */
+export type AuditLogFilterQuery = {
+  /**
+   * Optional text search applied to supported display fields.
+   */
+  search?: string | undefined;
+  /**
+   * Logical operator used to combine filters.
+   */
+  operator: string;
+  /**
+   * Advanced filters applied to the query.
+   */
+  filters: Array<AuditLogFilter>;
+};
+
+/** @internal */
+export type AuditLogFilterQuery$Outbound = {
+  search?: string | undefined;
+  operator: string;
+  filters: Array<AuditLogFilter$Outbound>;
+};
+
+/** @internal */
+export const AuditLogFilterQuery$outboundSchema: z.ZodType<
+  AuditLogFilterQuery$Outbound,
+  z.ZodTypeDef,
+  AuditLogFilterQuery
+> = z.object({
+  search: z.string().optional(),
+  operator: z.string(),
+  filters: z.array(AuditLogFilter$outboundSchema),
+});
+
+export function auditLogFilterQueryToJSON(
+  auditLogFilterQuery: AuditLogFilterQuery,
+): string {
+  return JSON.stringify(
+    AuditLogFilterQuery$outboundSchema.parse(auditLogFilterQuery),
+  );
+}