@orq-ai/node 4.1.0-rc.1 → 4.1.0-rc.11

package/src/models/components/datapart.ts

@@ -0,0 +1,71 @@
+/*
+ * 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 DataPartKind = {
+  Data: "data",
+} as const;
+export type DataPartKind = ClosedEnum<typeof DataPartKind>;
+
+/**
+ * A structured data part containing JSON-serializable key-value pairs. Used for passing structured information between agents and tools.
+ */
+export type DataPart = {
+  kind: DataPartKind;
+  data: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const DataPartKind$inboundSchema: z.ZodNativeEnum<typeof DataPartKind> =
+  z.nativeEnum(DataPartKind);
+/** @internal */
+export const DataPartKind$outboundSchema: z.ZodNativeEnum<typeof DataPartKind> =
+  DataPartKind$inboundSchema;
+
+/** @internal */
+export const DataPart$inboundSchema: z.ZodType<
+  DataPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: DataPartKind$inboundSchema,
+  data: z.record(z.any()),
+  metadata: z.record(z.any()).optional(),
+});
+/** @internal */
+export type DataPart$Outbound = {
+  kind: string;
+  data: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const DataPart$outboundSchema: z.ZodType<
+  DataPart$Outbound,
+  z.ZodTypeDef,
+  DataPart
+> = z.object({
+  kind: DataPartKind$outboundSchema,
+  data: z.record(z.any()),
+  metadata: z.record(z.any()).optional(),
+});
+
+export function dataPartToJSON(dataPart: DataPart): string {
+  return JSON.stringify(DataPart$outboundSchema.parse(dataPart));
+}
+export function dataPartFromJSON(
+  jsonString: string,
+): SafeParseResult<DataPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DataPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DataPart' from JSON`,
+  );
+}

package/src/models/components/errorstreamingevent.ts

@@ -0,0 +1,129 @@
+/*
+ * 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 ErrorStreamingEventType = {
+  AgentsError: "agents.error",
+} as const;
+export type ErrorStreamingEventType = ClosedEnum<
+  typeof ErrorStreamingEventType
+>;
+
+export type ErrorStreamingEventData = {
+  error: string;
+  code: string;
+};
+
+/**
+ * Emitted when a streaming error occurs outside of normal agent execution. Contains the error message and error code for debugging.
+ */
+export type ErrorStreamingEvent = {
+  type: ErrorStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ErrorStreamingEventData;
+};
+
+/** @internal */
+export const ErrorStreamingEventType$inboundSchema: z.ZodNativeEnum<
+  typeof ErrorStreamingEventType
+> = z.nativeEnum(ErrorStreamingEventType);
+/** @internal */
+export const ErrorStreamingEventType$outboundSchema: z.ZodNativeEnum<
+  typeof ErrorStreamingEventType
+> = ErrorStreamingEventType$inboundSchema;
+
+/** @internal */
+export const ErrorStreamingEventData$inboundSchema: z.ZodType<
+  ErrorStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.string(),
+  code: z.string(),
+});
+/** @internal */
+export type ErrorStreamingEventData$Outbound = {
+  error: string;
+  code: string;
+};
+
+/** @internal */
+export const ErrorStreamingEventData$outboundSchema: z.ZodType<
+  ErrorStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  ErrorStreamingEventData
+> = z.object({
+  error: z.string(),
+  code: z.string(),
+});
+
+export function errorStreamingEventDataToJSON(
+  errorStreamingEventData: ErrorStreamingEventData,
+): string {
+  return JSON.stringify(
+    ErrorStreamingEventData$outboundSchema.parse(errorStreamingEventData),
+  );
+}
+export function errorStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ErrorStreamingEvent$inboundSchema: z.ZodType<
+  ErrorStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ErrorStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ErrorStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ErrorStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ErrorStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ErrorStreamingEvent$outboundSchema: z.ZodType<
+  ErrorStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ErrorStreamingEvent
+> = z.object({
+  type: ErrorStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ErrorStreamingEventData$outboundSchema),
+});
+
+export function errorStreamingEventToJSON(
+  errorStreamingEvent: ErrorStreamingEvent,
+): string {
+  return JSON.stringify(
+    ErrorStreamingEvent$outboundSchema.parse(errorStreamingEvent),
+  );
+}
+export function errorStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorStreamingEvent' from JSON`,
+  );
+}

package/src/models/components/executionnamedstreamingevent.ts

@@ -0,0 +1,142 @@
+/*
+ * 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 ExecutionNamedStreamingEventType = {
+  EventAgentsExecutionNamed: "event.agents.execution_named",
+} as const;
+export type ExecutionNamedStreamingEventType = ClosedEnum<
+  typeof ExecutionNamedStreamingEventType
+>;
+
+export type ExecutionNamedStreamingEventData = {
+  name: string;
+  agentManifestId: string;
+};
+
+/**
+ * Emitted when the agent execution is assigned a human-readable name, typically generated based on the conversation content.
+ */
+export type ExecutionNamedStreamingEvent = {
+  type: ExecutionNamedStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ExecutionNamedStreamingEventData;
+};
+
+/** @internal */
+export const ExecutionNamedStreamingEventType$inboundSchema: z.ZodNativeEnum<
+  typeof ExecutionNamedStreamingEventType
+> = z.nativeEnum(ExecutionNamedStreamingEventType);
+/** @internal */
+export const ExecutionNamedStreamingEventType$outboundSchema: z.ZodNativeEnum<
+  typeof ExecutionNamedStreamingEventType
+> = ExecutionNamedStreamingEventType$inboundSchema;
+
+/** @internal */
+export const ExecutionNamedStreamingEventData$inboundSchema: z.ZodType<
+  ExecutionNamedStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+  agent_manifest_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "agent_manifest_id": "agentManifestId",
+  });
+});
+/** @internal */
+export type ExecutionNamedStreamingEventData$Outbound = {
+  name: string;
+  agent_manifest_id: string;
+};
+
+/** @internal */
+export const ExecutionNamedStreamingEventData$outboundSchema: z.ZodType<
+  ExecutionNamedStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  ExecutionNamedStreamingEventData
+> = z.object({
+  name: z.string(),
+  agentManifestId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    agentManifestId: "agent_manifest_id",
+  });
+});
+
+export function executionNamedStreamingEventDataToJSON(
+  executionNamedStreamingEventData: ExecutionNamedStreamingEventData,
+): string {
+  return JSON.stringify(
+    ExecutionNamedStreamingEventData$outboundSchema.parse(
+      executionNamedStreamingEventData,
+    ),
+  );
+}
+export function executionNamedStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionNamedStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExecutionNamedStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionNamedStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExecutionNamedStreamingEvent$inboundSchema: z.ZodType<
+  ExecutionNamedStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ExecutionNamedStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionNamedStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ExecutionNamedStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ExecutionNamedStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ExecutionNamedStreamingEvent$outboundSchema: z.ZodType<
+  ExecutionNamedStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ExecutionNamedStreamingEvent
+> = z.object({
+  type: ExecutionNamedStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionNamedStreamingEventData$outboundSchema),
+});
+
+export function executionNamedStreamingEventToJSON(
+  executionNamedStreamingEvent: ExecutionNamedStreamingEvent,
+): string {
+  return JSON.stringify(
+    ExecutionNamedStreamingEvent$outboundSchema.parse(
+      executionNamedStreamingEvent,
+    ),
+  );
+}
+export function executionNamedStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionNamedStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExecutionNamedStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionNamedStreamingEvent' from JSON`,
+  );
+}

package/src/models/components/executionreviewedstreamingevent.ts

@@ -0,0 +1,122 @@
+/*
+ * 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 ExecutionReviewedStreamingEventType = {
+  EventAgentsExecutionReviewed: "event.agents.execution_reviewed",
+} as const;
+export type ExecutionReviewedStreamingEventType = ClosedEnum<
+  typeof ExecutionReviewedStreamingEventType
+>;
+
+export type ExecutionReviewedStreamingEventData = {};
+
+/**
+ * Emitted after the agent execution has been reviewed. The execution will resume processing after this event.
+ */
+export type ExecutionReviewedStreamingEvent = {
+  type: ExecutionReviewedStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ExecutionReviewedStreamingEventData;
+};
+
+/** @internal */
+export const ExecutionReviewedStreamingEventType$inboundSchema: z.ZodNativeEnum<
+  typeof ExecutionReviewedStreamingEventType
+> = z.nativeEnum(ExecutionReviewedStreamingEventType);
+/** @internal */
+export const ExecutionReviewedStreamingEventType$outboundSchema:
+  z.ZodNativeEnum<typeof ExecutionReviewedStreamingEventType> =
+    ExecutionReviewedStreamingEventType$inboundSchema;
+
+/** @internal */
+export const ExecutionReviewedStreamingEventData$inboundSchema: z.ZodType<
+  ExecutionReviewedStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type ExecutionReviewedStreamingEventData$Outbound = {};
+
+/** @internal */
+export const ExecutionReviewedStreamingEventData$outboundSchema: z.ZodType<
+  ExecutionReviewedStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  ExecutionReviewedStreamingEventData
+> = z.object({});
+
+export function executionReviewedStreamingEventDataToJSON(
+  executionReviewedStreamingEventData: ExecutionReviewedStreamingEventData,
+): string {
+  return JSON.stringify(
+    ExecutionReviewedStreamingEventData$outboundSchema.parse(
+      executionReviewedStreamingEventData,
+    ),
+  );
+}
+export function executionReviewedStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionReviewedStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ExecutionReviewedStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionReviewedStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExecutionReviewedStreamingEvent$inboundSchema: z.ZodType<
+  ExecutionReviewedStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ExecutionReviewedStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionReviewedStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ExecutionReviewedStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ExecutionReviewedStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ExecutionReviewedStreamingEvent$outboundSchema: z.ZodType<
+  ExecutionReviewedStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ExecutionReviewedStreamingEvent
+> = z.object({
+  type: ExecutionReviewedStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionReviewedStreamingEventData$outboundSchema),
+});
+
+export function executionReviewedStreamingEventToJSON(
+  executionReviewedStreamingEvent: ExecutionReviewedStreamingEvent,
+): string {
+  return JSON.stringify(
+    ExecutionReviewedStreamingEvent$outboundSchema.parse(
+      executionReviewedStreamingEvent,
+    ),
+  );
+}
+export function executionReviewedStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionReviewedStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExecutionReviewedStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionReviewedStreamingEvent' from JSON`,
+  );
+}

package/src/models/components/executionreviewrequiredstreamingevent.ts

@@ -0,0 +1,130 @@
+/*
+ * 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 ExecutionReviewRequiredStreamingEventType = {
+  EventAgentsExecutionReviewRequired: "event.agents.execution_review_required",
+} as const;
+export type ExecutionReviewRequiredStreamingEventType = ClosedEnum<
+  typeof ExecutionReviewRequiredStreamingEventType
+>;
+
+export type ExecutionReviewRequiredStreamingEventData = {};
+
+/**
+ * Emitted when the entire agent execution requires human review before proceeding. The execution will pause until reviewed.
+ */
+export type ExecutionReviewRequiredStreamingEvent = {
+  type: ExecutionReviewRequiredStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ExecutionReviewRequiredStreamingEventData;
+};
+
+/** @internal */
+export const ExecutionReviewRequiredStreamingEventType$inboundSchema:
+  z.ZodNativeEnum<typeof ExecutionReviewRequiredStreamingEventType> = z
+    .nativeEnum(ExecutionReviewRequiredStreamingEventType);
+/** @internal */
+export const ExecutionReviewRequiredStreamingEventType$outboundSchema:
+  z.ZodNativeEnum<typeof ExecutionReviewRequiredStreamingEventType> =
+    ExecutionReviewRequiredStreamingEventType$inboundSchema;
+
+/** @internal */
+export const ExecutionReviewRequiredStreamingEventData$inboundSchema: z.ZodType<
+  ExecutionReviewRequiredStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type ExecutionReviewRequiredStreamingEventData$Outbound = {};
+
+/** @internal */
+export const ExecutionReviewRequiredStreamingEventData$outboundSchema:
+  z.ZodType<
+    ExecutionReviewRequiredStreamingEventData$Outbound,
+    z.ZodTypeDef,
+    ExecutionReviewRequiredStreamingEventData
+  > = z.object({});
+
+export function executionReviewRequiredStreamingEventDataToJSON(
+  executionReviewRequiredStreamingEventData:
+    ExecutionReviewRequiredStreamingEventData,
+): string {
+  return JSON.stringify(
+    ExecutionReviewRequiredStreamingEventData$outboundSchema.parse(
+      executionReviewRequiredStreamingEventData,
+    ),
+  );
+}
+export function executionReviewRequiredStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ExecutionReviewRequiredStreamingEventData,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ExecutionReviewRequiredStreamingEventData$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ExecutionReviewRequiredStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExecutionReviewRequiredStreamingEvent$inboundSchema: z.ZodType<
+  ExecutionReviewRequiredStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ExecutionReviewRequiredStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionReviewRequiredStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ExecutionReviewRequiredStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ExecutionReviewRequiredStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ExecutionReviewRequiredStreamingEvent$outboundSchema: z.ZodType<
+  ExecutionReviewRequiredStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ExecutionReviewRequiredStreamingEvent
+> = z.object({
+  type: ExecutionReviewRequiredStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionReviewRequiredStreamingEventData$outboundSchema),
+});
+
+export function executionReviewRequiredStreamingEventToJSON(
+  executionReviewRequiredStreamingEvent: ExecutionReviewRequiredStreamingEvent,
+): string {
+  return JSON.stringify(
+    ExecutionReviewRequiredStreamingEvent$outboundSchema.parse(
+      executionReviewRequiredStreamingEvent,
+    ),
+  );
+}
+export function executionReviewRequiredStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionReviewRequiredStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ExecutionReviewRequiredStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionReviewRequiredStreamingEvent' from JSON`,
+  );
+}