@orq-ai/node 4.0.13 → 4.0.16

package/src/models/components/agenterroredstreamingevent.ts

@@ -0,0 +1,142 @@
+/*
+ * 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 AgentErroredStreamingEventType = {
+  EventAgentsErrored: "event.agents.errored",
+} as const;
+export type AgentErroredStreamingEventType = ClosedEnum<
+  typeof AgentErroredStreamingEventType
+>;
+
+export type AgentErroredStreamingEventData = {
+  error: string;
+  code: number;
+  /**
+   * ID of the response tracking this execution
+   */
+  responseId?: string | undefined;
+  workflowRunId: string;
+};
+
+/**
+ * Emitted when an error occurs during agent execution. Contains the error message and HTTP status code indicating the failure type.
+ */
+export type AgentErroredStreamingEvent = {
+  type: AgentErroredStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: AgentErroredStreamingEventData;
+};
+
+/** @internal */
+export const AgentErroredStreamingEventType$inboundSchema: z.ZodNativeEnum<
+  typeof AgentErroredStreamingEventType
+> = z.nativeEnum(AgentErroredStreamingEventType);
+/** @internal */
+export const AgentErroredStreamingEventType$outboundSchema: z.ZodNativeEnum<
+  typeof AgentErroredStreamingEventType
+> = AgentErroredStreamingEventType$inboundSchema;
+
+/** @internal */
+export const AgentErroredStreamingEventData$inboundSchema: z.ZodType<
+  AgentErroredStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.string(),
+  code: z.number(),
+  responseId: z.string().optional(),
+  workflowRunId: z.string(),
+});
+/** @internal */
+export type AgentErroredStreamingEventData$Outbound = {
+  error: string;
+  code: number;
+  responseId?: string | undefined;
+  workflowRunId: string;
+};
+
+/** @internal */
+export const AgentErroredStreamingEventData$outboundSchema: z.ZodType<
+  AgentErroredStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  AgentErroredStreamingEventData
+> = z.object({
+  error: z.string(),
+  code: z.number(),
+  responseId: z.string().optional(),
+  workflowRunId: z.string(),
+});
+
+export function agentErroredStreamingEventDataToJSON(
+  agentErroredStreamingEventData: AgentErroredStreamingEventData,
+): string {
+  return JSON.stringify(
+    AgentErroredStreamingEventData$outboundSchema.parse(
+      agentErroredStreamingEventData,
+    ),
+  );
+}
+export function agentErroredStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentErroredStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentErroredStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentErroredStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const AgentErroredStreamingEvent$inboundSchema: z.ZodType<
+  AgentErroredStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: AgentErroredStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => AgentErroredStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type AgentErroredStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: AgentErroredStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const AgentErroredStreamingEvent$outboundSchema: z.ZodType<
+  AgentErroredStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  AgentErroredStreamingEvent
+> = z.object({
+  type: AgentErroredStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => AgentErroredStreamingEventData$outboundSchema),
+});
+
+export function agentErroredStreamingEventToJSON(
+  agentErroredStreamingEvent: AgentErroredStreamingEvent,
+): string {
+  return JSON.stringify(
+    AgentErroredStreamingEvent$outboundSchema.parse(agentErroredStreamingEvent),
+  );
+}
+export function agentErroredStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentErroredStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentErroredStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentErroredStreamingEvent' from JSON`,
+  );
+}

package/src/models/components/agentexecutionstartedstreamingevent.ts

@@ -0,0 +1,145 @@
+/*
+ * 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 Type = {
+  AgentsExecutionStarted: "agents.execution_started",
+} as const;
+export type Type = ClosedEnum<typeof Type>;
+
+export type Data = {
+  /**
+   * Agent execution task ID (ULID)
+   */
+  agentTaskId: string;
+  /**
+   * Workspace ID
+   */
+  workspaceId: string;
+  /**
+   * Trace ID for the workflow run
+   */
+  traceId: string;
+};
+
+/**
+ * Initial event emitted when an agent stream begins. Contains the task ID for tracking, workspace context, and trace ID for observability.
+ */
+export type AgentExecutionStartedStreamingEvent = {
+  type: Type;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: Data;
+};
+
+/** @internal */
+export const Type$inboundSchema: z.ZodNativeEnum<typeof Type> = z.nativeEnum(
+  Type,
+);
+/** @internal */
+export const Type$outboundSchema: z.ZodNativeEnum<typeof Type> =
+  Type$inboundSchema;
+
+/** @internal */
+export const Data$inboundSchema: z.ZodType<Data, z.ZodTypeDef, unknown> = z
+  .object({
+    agent_task_id: z.string(),
+    workspace_id: z.string(),
+    trace_id: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      "agent_task_id": "agentTaskId",
+      "workspace_id": "workspaceId",
+      "trace_id": "traceId",
+    });
+  });
+/** @internal */
+export type Data$Outbound = {
+  agent_task_id: string;
+  workspace_id: string;
+  trace_id: string;
+};
+
+/** @internal */
+export const Data$outboundSchema: z.ZodType<Data$Outbound, z.ZodTypeDef, Data> =
+  z.object({
+    agentTaskId: z.string(),
+    workspaceId: z.string(),
+    traceId: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      agentTaskId: "agent_task_id",
+      workspaceId: "workspace_id",
+      traceId: "trace_id",
+    });
+  });
+
+export function dataToJSON(data: Data): string {
+  return JSON.stringify(Data$outboundSchema.parse(data));
+}
+export function dataFromJSON(
+  jsonString: string,
+): SafeParseResult<Data, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Data$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Data' from JSON`,
+  );
+}
+
+/** @internal */
+export const AgentExecutionStartedStreamingEvent$inboundSchema: z.ZodType<
+  AgentExecutionStartedStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: Type$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => Data$inboundSchema),
+});
+/** @internal */
+export type AgentExecutionStartedStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: Data$Outbound;
+};
+
+/** @internal */
+export const AgentExecutionStartedStreamingEvent$outboundSchema: z.ZodType<
+  AgentExecutionStartedStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  AgentExecutionStartedStreamingEvent
+> = z.object({
+  type: Type$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => Data$outboundSchema),
+});
+
+export function agentExecutionStartedStreamingEventToJSON(
+  agentExecutionStartedStreamingEvent: AgentExecutionStartedStreamingEvent,
+): string {
+  return JSON.stringify(
+    AgentExecutionStartedStreamingEvent$outboundSchema.parse(
+      agentExecutionStartedStreamingEvent,
+    ),
+  );
+}
+export function agentExecutionStartedStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentExecutionStartedStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      AgentExecutionStartedStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentExecutionStartedStreamingEvent' from JSON`,
+  );
+}

package/src/models/components/agenthandedoffstreamingevent.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 AgentHandedOffStreamingEventType = {
+  EventAgentsHandedOff: "event.agents.handed_off",
+} as const;
+export type AgentHandedOffStreamingEventType = ClosedEnum<
+  typeof AgentHandedOffStreamingEventType
+>;
+
+export type AgentHandedOffStreamingEventData = {
+  agentId: string;
+  input: string;
+};
+
+/**
+ * Emitted when control is transferred to a sub-agent. Contains the target agent ID and the input message for the handoff.
+ */
+export type AgentHandedOffStreamingEvent = {
+  type: AgentHandedOffStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: AgentHandedOffStreamingEventData;
+};
+
+/** @internal */
+export const AgentHandedOffStreamingEventType$inboundSchema: z.ZodNativeEnum<
+  typeof AgentHandedOffStreamingEventType
+> = z.nativeEnum(AgentHandedOffStreamingEventType);
+/** @internal */
+export const AgentHandedOffStreamingEventType$outboundSchema: z.ZodNativeEnum<
+  typeof AgentHandedOffStreamingEventType
+> = AgentHandedOffStreamingEventType$inboundSchema;
+
+/** @internal */
+export const AgentHandedOffStreamingEventData$inboundSchema: z.ZodType<
+  AgentHandedOffStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  agent_id: z.string(),
+  input: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "agent_id": "agentId",
+  });
+});
+/** @internal */
+export type AgentHandedOffStreamingEventData$Outbound = {
+  agent_id: string;
+  input: string;
+};
+
+/** @internal */
+export const AgentHandedOffStreamingEventData$outboundSchema: z.ZodType<
+  AgentHandedOffStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  AgentHandedOffStreamingEventData
+> = z.object({
+  agentId: z.string(),
+  input: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    agentId: "agent_id",
+  });
+});
+
+export function agentHandedOffStreamingEventDataToJSON(
+  agentHandedOffStreamingEventData: AgentHandedOffStreamingEventData,
+): string {
+  return JSON.stringify(
+    AgentHandedOffStreamingEventData$outboundSchema.parse(
+      agentHandedOffStreamingEventData,
+    ),
+  );
+}
+export function agentHandedOffStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentHandedOffStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentHandedOffStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentHandedOffStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const AgentHandedOffStreamingEvent$inboundSchema: z.ZodType<
+  AgentHandedOffStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: AgentHandedOffStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => AgentHandedOffStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type AgentHandedOffStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: AgentHandedOffStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const AgentHandedOffStreamingEvent$outboundSchema: z.ZodType<
+  AgentHandedOffStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  AgentHandedOffStreamingEvent
+> = z.object({
+  type: AgentHandedOffStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => AgentHandedOffStreamingEventData$outboundSchema),
+});
+
+export function agentHandedOffStreamingEventToJSON(
+  agentHandedOffStreamingEvent: AgentHandedOffStreamingEvent,
+): string {
+  return JSON.stringify(
+    AgentHandedOffStreamingEvent$outboundSchema.parse(
+      agentHandedOffStreamingEvent,
+    ),
+  );
+}
+export function agentHandedOffStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentHandedOffStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentHandedOffStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentHandedOffStreamingEvent' from JSON`,
+  );
+}