@orq-ai/node 4.4.12 → 4.4.14

package/packages/orq-rc/src/models/operations/listdatasetdatapoints.ts

@@ -1270,7 +1270,7 @@ export const ListDatasetDatapointsEvaluations3$inboundSchema: z.ZodType<
   ),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-03-03T10:05:08.133Z",
+    "2026-03-05T14:31:21.894Z",
   ).transform(v => new Date(v)),
   type: z.literal("string_array"),
   values: z.array(z.string()),
@@ -1320,7 +1320,7 @@ export const ListDatasetDatapointsEvaluations2$inboundSchema: z.ZodType<
   source: ListDatasetDatapointsEvaluationsSource$inboundSchema.default("orq"),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-03-03T10:05:08.132Z",
+    "2026-03-05T14:31:21.893Z",
   ).transform(v => new Date(v)),
   type: z.literal("number"),
   value: z.number(),
@@ -1369,7 +1369,7 @@ export const ListDatasetDatapointsEvaluations1$inboundSchema: z.ZodType<
     .default("orq"),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-03-03T10:05:08.131Z",
+    "2026-03-05T14:31:21.892Z",
   ).transform(v => new Date(v)),
   type: z.literal("string"),
   value: z.string(),
@@ -1448,7 +1448,7 @@ export const ListDatasetDatapointsData$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2026-03-03T10:04:52.010Z",
+    "2026-03-05T14:31:06.324Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {

package/packages/orq-rc/src/models/operations/listdatasets.ts

@@ -156,7 +156,7 @@ export const ListDatasetsData$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2026-03-03T10:04:52.010Z",
+    "2026-03-05T14:31:06.324Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {

package/packages/orq-rc/src/models/operations/listdatasources.ts

@@ -176,7 +176,7 @@ export const ListDatasourcesData$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("01KJSJH629GMSQBF89M3XCMWKT"),
+  _id: z.string().default("01KJZ6J3E0GKAJ2PQD1ZCXG8E4"),
   display_name: z.string(),
   description: z.string().optional(),
   status: ListDatasourcesStatus$inboundSchema,

package/packages/orq-rc/src/models/operations/listidentities.ts

@@ -227,7 +227,7 @@ export const ListIdentitiesData$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2026-03-03T10:04:52.010Z",
+    "2026-03-05T14:31:06.324Z",
   ).transform(v => new Date(v)),
   metrics: z.lazy(() => ListIdentitiesMetrics$inboundSchema),
 }).transform((v) => {

package/packages/orq-rc/src/models/operations/listknowledgebases.ts

@@ -99,7 +99,7 @@ export type DataExternalConfig = {
   apiUrl: string;
 };
 
-export type Data2 = {
+export type ListKnowledgeBasesData2 = {
   /**
    * The unique identifier of the knowledge base.
    */
@@ -218,7 +218,7 @@ export type ListKnowledgeBasesDataRetrievalSettings = {
   agenticRagConfig?: ListKnowledgeBasesDataAgenticRagConfig | null | undefined;
 };
 
-export type Data1 = {
+export type ListKnowledgeBasesData1 = {
   /**
    * The unique identifier of the knowledge base.
    */
@@ -266,14 +266,16 @@ export type Data1 = {
   model: string;
 };
 
-export type ListKnowledgeBasesData = Data1 | Data2;
+export type ListKnowledgeBasesData =
+  | ListKnowledgeBasesData1
+  | ListKnowledgeBasesData2;
 
 /**
  * Knowledge bases retrieved
  */
 export type ListKnowledgeBasesResponseBody = {
   object: ListKnowledgeBasesObject;
-  data: Array<Data1 | Data2>;
+  data: Array<ListKnowledgeBasesData1 | ListKnowledgeBasesData2>;
   hasMore: boolean;
 };
 
@@ -420,39 +422,42 @@ export function dataExternalConfigFromJSON(
 }
 
 /** @internal */
-export const Data2$inboundSchema: z.ZodType<Data2, z.ZodTypeDef, unknown> = z
-  .object({
-    _id: z.string(),
-    created: z.string(),
-    description: z.string().optional(),
-    key: z.string(),
-    domain_id: z.string(),
-    path: z.string().optional(),
-    created_by_id: z.nullable(z.string()).optional(),
-    updated_by_id: z.nullable(z.string()).optional(),
-    updated: z.string(),
-    type: ListKnowledgeBasesDataKnowledgeType$inboundSchema.default("external"),
-    retrieval_settings: z.lazy(() => DataRetrievalSettings$inboundSchema)
-      .optional(),
-    external_config: z.lazy(() => DataExternalConfig$inboundSchema),
-  }).transform((v) => {
-    return remap$(v, {
-      "_id": "id",
-      "domain_id": "domainId",
-      "created_by_id": "createdById",
-      "updated_by_id": "updatedById",
-      "retrieval_settings": "retrievalSettings",
-      "external_config": "externalConfig",
-    });
+export const ListKnowledgeBasesData2$inboundSchema: z.ZodType<
+  ListKnowledgeBasesData2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  created: z.string(),
+  description: z.string().optional(),
+  key: z.string(),
+  domain_id: z.string(),
+  path: z.string().optional(),
+  created_by_id: z.nullable(z.string()).optional(),
+  updated_by_id: z.nullable(z.string()).optional(),
+  updated: z.string(),
+  type: ListKnowledgeBasesDataKnowledgeType$inboundSchema.default("external"),
+  retrieval_settings: z.lazy(() => DataRetrievalSettings$inboundSchema)
+    .optional(),
+  external_config: z.lazy(() => DataExternalConfig$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "domain_id": "domainId",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
+    "retrieval_settings": "retrievalSettings",
+    "external_config": "externalConfig",
   });
+});
 
-export function data2FromJSON(
+export function listKnowledgeBasesData2FromJSON(
   jsonString: string,
-): SafeParseResult<Data2, SDKValidationError> {
+): SafeParseResult<ListKnowledgeBasesData2, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Data2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Data2' from JSON`,
+    (x) => ListKnowledgeBasesData2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListKnowledgeBasesData2' from JSON`,
   );
 }
 
@@ -555,39 +560,42 @@ export function listKnowledgeBasesDataRetrievalSettingsFromJSON(
 }
 
 /** @internal */
-export const Data1$inboundSchema: z.ZodType<Data1, z.ZodTypeDef, unknown> = z
-  .object({
-    _id: z.string(),
-    created: z.string(),
-    description: z.string().optional(),
-    key: z.string(),
-    domain_id: z.string(),
-    path: z.string().optional(),
-    created_by_id: z.nullable(z.string()).optional(),
-    updated_by_id: z.nullable(z.string()).optional(),
-    updated: z.string(),
-    type: ListKnowledgeBasesDataType$inboundSchema.default("internal"),
-    retrieval_settings: z.lazy(() =>
-      ListKnowledgeBasesDataRetrievalSettings$inboundSchema
-    ).optional(),
-    model: z.string(),
-  }).transform((v) => {
-    return remap$(v, {
-      "_id": "id",
-      "domain_id": "domainId",
-      "created_by_id": "createdById",
-      "updated_by_id": "updatedById",
-      "retrieval_settings": "retrievalSettings",
-    });
+export const ListKnowledgeBasesData1$inboundSchema: z.ZodType<
+  ListKnowledgeBasesData1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  created: z.string(),
+  description: z.string().optional(),
+  key: z.string(),
+  domain_id: z.string(),
+  path: z.string().optional(),
+  created_by_id: z.nullable(z.string()).optional(),
+  updated_by_id: z.nullable(z.string()).optional(),
+  updated: z.string(),
+  type: ListKnowledgeBasesDataType$inboundSchema.default("internal"),
+  retrieval_settings: z.lazy(() =>
+    ListKnowledgeBasesDataRetrievalSettings$inboundSchema
+  ).optional(),
+  model: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "domain_id": "domainId",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
+    "retrieval_settings": "retrievalSettings",
   });
+});
 
-export function data1FromJSON(
+export function listKnowledgeBasesData1FromJSON(
   jsonString: string,
-): SafeParseResult<Data1, SDKValidationError> {
+): SafeParseResult<ListKnowledgeBasesData1, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Data1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Data1' from JSON`,
+    (x) => ListKnowledgeBasesData1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListKnowledgeBasesData1' from JSON`,
   );
 }
 
@@ -597,8 +605,8 @@ export const ListKnowledgeBasesData$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => Data1$inboundSchema),
-  z.lazy(() => Data2$inboundSchema),
+  z.lazy(() => ListKnowledgeBasesData1$inboundSchema),
+  z.lazy(() => ListKnowledgeBasesData2$inboundSchema),
 ]);
 
 export function listKnowledgeBasesDataFromJSON(
@@ -620,8 +628,8 @@ export const ListKnowledgeBasesResponseBody$inboundSchema: z.ZodType<
   object: ListKnowledgeBasesObject$inboundSchema,
   data: z.array(
     z.union([
-      z.lazy(() => Data1$inboundSchema),
-      z.lazy(() => Data2$inboundSchema),
+      z.lazy(() => ListKnowledgeBasesData1$inboundSchema),
+      z.lazy(() => ListKnowledgeBasesData2$inboundSchema),
     ]),
   ),
   has_more: z.boolean(),

package/packages/orq-rc/src/models/operations/postv2agentsa2a.ts

@@ -0,0 +1,252 @@
+/*
+ * 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 type Headers = {
+  /**
+   * Header value. **Update behavior**: Provide empty string ("") to preserve existing encrypted value without re-entering credentials. Provide new value to rotate. Omit header entirely to remove.
+   */
+  value: string;
+  encrypted?: boolean | undefined;
+};
+
+export type PostV2AgentsA2aRequestBody = {
+  /**
+   * Unique identifier for the agent
+   */
+  key: string;
+  /**
+   * Display name for the agent
+   */
+  displayName: string;
+  /**
+   * Description of the agent
+   */
+  description: string;
+  /**
+   * Project path for organizing the agent
+   */
+  path: string;
+  /**
+   * The A2A agent endpoint URL
+   */
+  agentUrl: string;
+  /**
+   * Optional explicit agent card URL (must be different from agent_url)
+   */
+  cardUrl?: string | undefined;
+  /**
+   * Authentication headers for the A2A agent
+   */
+  headers?: { [k: string]: Headers } | undefined;
+};
+
+export const PostV2AgentsA2aType = {
+  A2a: "a2a",
+  Internal: "internal",
+} as const;
+export type PostV2AgentsA2aType = ClosedEnum<typeof PostV2AgentsA2aType>;
+
+export type Metrics = {
+  totalCost: number;
+};
+
+export type A2a = {
+  agentUrl: string;
+  cardUrl?: string | undefined;
+  headers: { [k: string]: any };
+  cachedCard?: any | undefined;
+};
+
+/**
+ * A2A agent registered successfully
+ */
+export type PostV2AgentsA2aResponseBody = {
+  id: string;
+  type: PostV2AgentsA2aType;
+  key: string;
+  displayName: string;
+  description: string;
+  workspaceId: string;
+  projectId: string;
+  createdById?: string | null | undefined;
+  updatedById?: string | null | undefined;
+  role?: string | undefined;
+  instructions?: string | undefined;
+  status: string;
+  versionHash?: string | undefined;
+  path: string;
+  metrics: Metrics;
+  memoryStores: Array<string>;
+  teamOfAgents: Array<any>;
+  created?: string | undefined;
+  updated?: string | undefined;
+  a2a?: A2a | undefined;
+};
+
+/** @internal */
+export type Headers$Outbound = {
+  value: string;
+  encrypted: boolean;
+};
+
+/** @internal */
+export const Headers$outboundSchema: z.ZodType<
+  Headers$Outbound,
+  z.ZodTypeDef,
+  Headers
+> = z.object({
+  value: z.string(),
+  encrypted: z.boolean().default(false),
+});
+
+export function headersToJSON(headers: Headers): string {
+  return JSON.stringify(Headers$outboundSchema.parse(headers));
+}
+
+/** @internal */
+export type PostV2AgentsA2aRequestBody$Outbound = {
+  key: string;
+  display_name: string;
+  description: string;
+  path: string;
+  agent_url: string;
+  card_url?: string | undefined;
+  headers?: { [k: string]: Headers$Outbound } | undefined;
+};
+
+/** @internal */
+export const PostV2AgentsA2aRequestBody$outboundSchema: z.ZodType<
+  PostV2AgentsA2aRequestBody$Outbound,
+  z.ZodTypeDef,
+  PostV2AgentsA2aRequestBody
+> = z.object({
+  key: z.string(),
+  displayName: z.string(),
+  description: z.string(),
+  path: z.string(),
+  agentUrl: z.string(),
+  cardUrl: z.string().optional(),
+  headers: z.record(z.lazy(() => Headers$outboundSchema)).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    displayName: "display_name",
+    agentUrl: "agent_url",
+    cardUrl: "card_url",
+  });
+});
+
+export function postV2AgentsA2aRequestBodyToJSON(
+  postV2AgentsA2aRequestBody: PostV2AgentsA2aRequestBody,
+): string {
+  return JSON.stringify(
+    PostV2AgentsA2aRequestBody$outboundSchema.parse(postV2AgentsA2aRequestBody),
+  );
+}
+
+/** @internal */
+export const PostV2AgentsA2aType$inboundSchema: z.ZodNativeEnum<
+  typeof PostV2AgentsA2aType
+> = z.nativeEnum(PostV2AgentsA2aType);
+
+/** @internal */
+export const Metrics$inboundSchema: z.ZodType<Metrics, z.ZodTypeDef, unknown> =
+  z.object({
+    total_cost: z.number(),
+  }).transform((v) => {
+    return remap$(v, {
+      "total_cost": "totalCost",
+    });
+  });
+
+export function metricsFromJSON(
+  jsonString: string,
+): SafeParseResult<Metrics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Metrics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Metrics' from JSON`,
+  );
+}
+
+/** @internal */
+export const A2a$inboundSchema: z.ZodType<A2a, z.ZodTypeDef, unknown> = z
+  .object({
+    agent_url: z.string(),
+    card_url: z.string().optional(),
+    headers: z.record(z.any()),
+    cached_card: z.any().optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "agent_url": "agentUrl",
+      "card_url": "cardUrl",
+      "cached_card": "cachedCard",
+    });
+  });
+
+export function a2aFromJSON(
+  jsonString: string,
+): SafeParseResult<A2a, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => A2a$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'A2a' from JSON`,
+  );
+}
+
+/** @internal */
+export const PostV2AgentsA2aResponseBody$inboundSchema: z.ZodType<
+  PostV2AgentsA2aResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  type: PostV2AgentsA2aType$inboundSchema,
+  key: z.string(),
+  display_name: z.string(),
+  description: z.string(),
+  workspace_id: z.string(),
+  project_id: z.string(),
+  created_by_id: z.nullable(z.string()).optional(),
+  updated_by_id: z.nullable(z.string()).optional(),
+  role: z.string().optional(),
+  instructions: z.string().optional(),
+  status: z.string(),
+  version_hash: z.string().optional(),
+  path: z.string(),
+  metrics: z.lazy(() => Metrics$inboundSchema),
+  memory_stores: z.array(z.string()),
+  team_of_agents: z.array(z.any()),
+  created: z.string().optional(),
+  updated: z.string().optional(),
+  a2a: z.lazy(() => A2a$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "display_name": "displayName",
+    "workspace_id": "workspaceId",
+    "project_id": "projectId",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
+    "version_hash": "versionHash",
+    "memory_stores": "memoryStores",
+    "team_of_agents": "teamOfAgents",
+  });
+});
+
+export function postV2AgentsA2aResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PostV2AgentsA2aResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostV2AgentsA2aResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostV2AgentsA2aResponseBody' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/operations/postv2agentskeycardrefresh.ts

@@ -0,0 +1,100 @@
+/*
+ * 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 PostV2AgentsKeyCardRefreshRequestBody = {};
+
+export type PostV2AgentsKeyCardRefreshRequest = {
+  /**
+   * The unique key identifier of the agent
+   */
+  key: string;
+  requestBody?: PostV2AgentsKeyCardRefreshRequestBody | undefined;
+};
+
+/**
+ * Agent card refreshed successfully
+ */
+export type PostV2AgentsKeyCardRefreshResponseBody = {
+  message: string;
+  card?: any | undefined;
+};
+
+/** @internal */
+export type PostV2AgentsKeyCardRefreshRequestBody$Outbound = {};
+
+/** @internal */
+export const PostV2AgentsKeyCardRefreshRequestBody$outboundSchema: z.ZodType<
+  PostV2AgentsKeyCardRefreshRequestBody$Outbound,
+  z.ZodTypeDef,
+  PostV2AgentsKeyCardRefreshRequestBody
+> = z.object({});
+
+export function postV2AgentsKeyCardRefreshRequestBodyToJSON(
+  postV2AgentsKeyCardRefreshRequestBody: PostV2AgentsKeyCardRefreshRequestBody,
+): string {
+  return JSON.stringify(
+    PostV2AgentsKeyCardRefreshRequestBody$outboundSchema.parse(
+      postV2AgentsKeyCardRefreshRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type PostV2AgentsKeyCardRefreshRequest$Outbound = {
+  key: string;
+  RequestBody?: PostV2AgentsKeyCardRefreshRequestBody$Outbound | undefined;
+};
+
+/** @internal */
+export const PostV2AgentsKeyCardRefreshRequest$outboundSchema: z.ZodType<
+  PostV2AgentsKeyCardRefreshRequest$Outbound,
+  z.ZodTypeDef,
+  PostV2AgentsKeyCardRefreshRequest
+> = z.object({
+  key: z.string(),
+  requestBody: z.lazy(() =>
+    PostV2AgentsKeyCardRefreshRequestBody$outboundSchema
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function postV2AgentsKeyCardRefreshRequestToJSON(
+  postV2AgentsKeyCardRefreshRequest: PostV2AgentsKeyCardRefreshRequest,
+): string {
+  return JSON.stringify(
+    PostV2AgentsKeyCardRefreshRequest$outboundSchema.parse(
+      postV2AgentsKeyCardRefreshRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const PostV2AgentsKeyCardRefreshResponseBody$inboundSchema: z.ZodType<
+  PostV2AgentsKeyCardRefreshResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+  card: z.any().optional(),
+});
+
+export function postV2AgentsKeyCardRefreshResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PostV2AgentsKeyCardRefreshResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PostV2AgentsKeyCardRefreshResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostV2AgentsKeyCardRefreshResponseBody' from JSON`,
+  );
+}