@orq-ai/node 4.1.0-rc.4 → 4.1.0-rc.7

package/src/models/components/actionreviewedstreamingevent.ts

@@ -0,0 +1,189 @@
+/*
+ * 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 ActionReviewedStreamingEventType = {
+  EventAgentsActionReviewed: "event.agents.action_reviewed",
+} as const;
+export type ActionReviewedStreamingEventType = ClosedEnum<
+  typeof ActionReviewedStreamingEventType
+>;
+
+export const Review = {
+  Approved: "approved",
+  Rejected: "rejected",
+} as const;
+export type Review = ClosedEnum<typeof Review>;
+
+export type ActionReviewedStreamingEventData = {
+  agentId: string;
+  actionId: string;
+  agentToolCallId: string;
+  review: Review;
+  mockOutput?: { [k: string]: any } | undefined;
+  reviewSource?: string | undefined;
+  reviewedById?: string | undefined;
+  workflowRunId: string;
+};
+
+/**
+ * Emitted after a tool action has been reviewed. Contains the review decision (approved/rejected), optional mock output for rejected actions, and reviewer information.
+ */
+export type ActionReviewedStreamingEvent = {
+  type: ActionReviewedStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ActionReviewedStreamingEventData;
+};
+
+/** @internal */
+export const ActionReviewedStreamingEventType$inboundSchema: z.ZodNativeEnum<
+  typeof ActionReviewedStreamingEventType
+> = z.nativeEnum(ActionReviewedStreamingEventType);
+/** @internal */
+export const ActionReviewedStreamingEventType$outboundSchema: z.ZodNativeEnum<
+  typeof ActionReviewedStreamingEventType
+> = ActionReviewedStreamingEventType$inboundSchema;
+
+/** @internal */
+export const Review$inboundSchema: z.ZodNativeEnum<typeof Review> = z
+  .nativeEnum(Review);
+/** @internal */
+export const Review$outboundSchema: z.ZodNativeEnum<typeof Review> =
+  Review$inboundSchema;
+
+/** @internal */
+export const ActionReviewedStreamingEventData$inboundSchema: z.ZodType<
+  ActionReviewedStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  agent_id: z.string(),
+  action_id: z.string(),
+  agent_tool_call_id: z.string(),
+  review: Review$inboundSchema,
+  mock_output: z.record(z.any()).optional(),
+  review_source: z.string().optional(),
+  reviewed_by_id: z.string().optional(),
+  workflowRunId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "agent_id": "agentId",
+    "action_id": "actionId",
+    "agent_tool_call_id": "agentToolCallId",
+    "mock_output": "mockOutput",
+    "review_source": "reviewSource",
+    "reviewed_by_id": "reviewedById",
+  });
+});
+/** @internal */
+export type ActionReviewedStreamingEventData$Outbound = {
+  agent_id: string;
+  action_id: string;
+  agent_tool_call_id: string;
+  review: string;
+  mock_output?: { [k: string]: any } | undefined;
+  review_source?: string | undefined;
+  reviewed_by_id?: string | undefined;
+  workflowRunId: string;
+};
+
+/** @internal */
+export const ActionReviewedStreamingEventData$outboundSchema: z.ZodType<
+  ActionReviewedStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  ActionReviewedStreamingEventData
+> = z.object({
+  agentId: z.string(),
+  actionId: z.string(),
+  agentToolCallId: z.string(),
+  review: Review$outboundSchema,
+  mockOutput: z.record(z.any()).optional(),
+  reviewSource: z.string().optional(),
+  reviewedById: z.string().optional(),
+  workflowRunId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    agentId: "agent_id",
+    actionId: "action_id",
+    agentToolCallId: "agent_tool_call_id",
+    mockOutput: "mock_output",
+    reviewSource: "review_source",
+    reviewedById: "reviewed_by_id",
+  });
+});
+
+export function actionReviewedStreamingEventDataToJSON(
+  actionReviewedStreamingEventData: ActionReviewedStreamingEventData,
+): string {
+  return JSON.stringify(
+    ActionReviewedStreamingEventData$outboundSchema.parse(
+      actionReviewedStreamingEventData,
+    ),
+  );
+}
+export function actionReviewedStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ActionReviewedStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ActionReviewedStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ActionReviewedStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ActionReviewedStreamingEvent$inboundSchema: z.ZodType<
+  ActionReviewedStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ActionReviewedStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ActionReviewedStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ActionReviewedStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ActionReviewedStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ActionReviewedStreamingEvent$outboundSchema: z.ZodType<
+  ActionReviewedStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ActionReviewedStreamingEvent
+> = z.object({
+  type: ActionReviewedStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ActionReviewedStreamingEventData$outboundSchema),
+});
+
+export function actionReviewedStreamingEventToJSON(
+  actionReviewedStreamingEvent: ActionReviewedStreamingEvent,
+): string {
+  return JSON.stringify(
+    ActionReviewedStreamingEvent$outboundSchema.parse(
+      actionReviewedStreamingEvent,
+    ),
+  );
+}
+export function actionReviewedStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ActionReviewedStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ActionReviewedStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ActionReviewedStreamingEvent' from JSON`,
+  );
+}

package/src/models/components/actionreviewrequestedstreamingevent.ts

@@ -0,0 +1,326 @@
+/*
+ * 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 ActionReviewRequestedStreamingEventType = {
+  EventAgentsActionReviewRequested: "event.agents.action_review_requested",
+} as const;
+export type ActionReviewRequestedStreamingEventType = ClosedEnum<
+  typeof ActionReviewRequestedStreamingEventType
+>;
+
+export type Conditions = {
+  /**
+   * The argument of the tool call to evaluate
+   */
+  condition: string;
+  /**
+   * The operator to use
+   */
+  operator: string;
+  /**
+   * The value to compare against
+   */
+  value: string;
+};
+
+export type Tool = {
+  /**
+   * The id of the resource
+   */
+  id: string;
+  /**
+   * Optional tool key for custom tools
+   */
+  key?: string | undefined;
+  actionType: string;
+  displayName?: string | undefined;
+  /**
+   * Optional tool description
+   */
+  description?: string | undefined;
+  requiresApproval?: boolean | undefined;
+  /**
+   * Nested tool ID for MCP tools (identifies specific tool within MCP server)
+   */
+  toolId?: string | undefined;
+  conditions?: Array<Conditions> | undefined;
+  /**
+   * Tool execution timeout in seconds (default: 2 minutes, max: 10 minutes)
+   */
+  timeout?: number | undefined;
+};
+
+export type ActionReviewRequestedStreamingEventData = {
+  agentId: string;
+  actionId: string;
+  requiresApproval: boolean;
+  tool: Tool;
+  input: { [k: string]: any };
+  agentToolCallId: string;
+  responseId?: string | undefined;
+};
+
+/**
+ * Emitted when a tool action requires approval before execution. Contains the tool details, input arguments, and whether approval is mandatory.
+ */
+export type ActionReviewRequestedStreamingEvent = {
+  type: ActionReviewRequestedStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ActionReviewRequestedStreamingEventData;
+};
+
+/** @internal */
+export const ActionReviewRequestedStreamingEventType$inboundSchema:
+  z.ZodNativeEnum<typeof ActionReviewRequestedStreamingEventType> = z
+    .nativeEnum(ActionReviewRequestedStreamingEventType);
+/** @internal */
+export const ActionReviewRequestedStreamingEventType$outboundSchema:
+  z.ZodNativeEnum<typeof ActionReviewRequestedStreamingEventType> =
+    ActionReviewRequestedStreamingEventType$inboundSchema;
+
+/** @internal */
+export const Conditions$inboundSchema: z.ZodType<
+  Conditions,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  condition: z.string(),
+  operator: z.string(),
+  value: z.string(),
+});
+/** @internal */
+export type Conditions$Outbound = {
+  condition: string;
+  operator: string;
+  value: string;
+};
+
+/** @internal */
+export const Conditions$outboundSchema: z.ZodType<
+  Conditions$Outbound,
+  z.ZodTypeDef,
+  Conditions
+> = z.object({
+  condition: z.string(),
+  operator: z.string(),
+  value: z.string(),
+});
+
+export function conditionsToJSON(conditions: Conditions): string {
+  return JSON.stringify(Conditions$outboundSchema.parse(conditions));
+}
+export function conditionsFromJSON(
+  jsonString: string,
+): SafeParseResult<Conditions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Conditions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Conditions' from JSON`,
+  );
+}
+
+/** @internal */
+export const Tool$inboundSchema: z.ZodType<Tool, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    key: z.string().optional(),
+    action_type: z.string(),
+    display_name: z.string().optional(),
+    description: z.string().optional(),
+    requires_approval: z.boolean().default(false),
+    tool_id: z.string().optional(),
+    conditions: z.array(z.lazy(() => Conditions$inboundSchema)).optional(),
+    timeout: z.number().default(120),
+  }).transform((v) => {
+    return remap$(v, {
+      "action_type": "actionType",
+      "display_name": "displayName",
+      "requires_approval": "requiresApproval",
+      "tool_id": "toolId",
+    });
+  });
+/** @internal */
+export type Tool$Outbound = {
+  id: string;
+  key?: string | undefined;
+  action_type: string;
+  display_name?: string | undefined;
+  description?: string | undefined;
+  requires_approval: boolean;
+  tool_id?: string | undefined;
+  conditions?: Array<Conditions$Outbound> | undefined;
+  timeout: number;
+};
+
+/** @internal */
+export const Tool$outboundSchema: z.ZodType<Tool$Outbound, z.ZodTypeDef, Tool> =
+  z.object({
+    id: z.string(),
+    key: z.string().optional(),
+    actionType: z.string(),
+    displayName: z.string().optional(),
+    description: z.string().optional(),
+    requiresApproval: z.boolean().default(false),
+    toolId: z.string().optional(),
+    conditions: z.array(z.lazy(() => Conditions$outboundSchema)).optional(),
+    timeout: z.number().default(120),
+  }).transform((v) => {
+    return remap$(v, {
+      actionType: "action_type",
+      displayName: "display_name",
+      requiresApproval: "requires_approval",
+      toolId: "tool_id",
+    });
+  });
+
+export function toolToJSON(tool: Tool): string {
+  return JSON.stringify(Tool$outboundSchema.parse(tool));
+}
+export function toolFromJSON(
+  jsonString: string,
+): SafeParseResult<Tool, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Tool$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Tool' from JSON`,
+  );
+}
+
+/** @internal */
+export const ActionReviewRequestedStreamingEventData$inboundSchema: z.ZodType<
+  ActionReviewRequestedStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  agent_id: z.string(),
+  action_id: z.string(),
+  requires_approval: z.boolean(),
+  tool: z.lazy(() => Tool$inboundSchema),
+  input: z.record(z.any()),
+  agent_tool_call_id: z.string(),
+  responseId: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "agent_id": "agentId",
+    "action_id": "actionId",
+    "requires_approval": "requiresApproval",
+    "agent_tool_call_id": "agentToolCallId",
+  });
+});
+/** @internal */
+export type ActionReviewRequestedStreamingEventData$Outbound = {
+  agent_id: string;
+  action_id: string;
+  requires_approval: boolean;
+  tool: Tool$Outbound;
+  input: { [k: string]: any };
+  agent_tool_call_id: string;
+  responseId?: string | undefined;
+};
+
+/** @internal */
+export const ActionReviewRequestedStreamingEventData$outboundSchema: z.ZodType<
+  ActionReviewRequestedStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  ActionReviewRequestedStreamingEventData
+> = z.object({
+  agentId: z.string(),
+  actionId: z.string(),
+  requiresApproval: z.boolean(),
+  tool: z.lazy(() => Tool$outboundSchema),
+  input: z.record(z.any()),
+  agentToolCallId: z.string(),
+  responseId: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    agentId: "agent_id",
+    actionId: "action_id",
+    requiresApproval: "requires_approval",
+    agentToolCallId: "agent_tool_call_id",
+  });
+});
+
+export function actionReviewRequestedStreamingEventDataToJSON(
+  actionReviewRequestedStreamingEventData:
+    ActionReviewRequestedStreamingEventData,
+): string {
+  return JSON.stringify(
+    ActionReviewRequestedStreamingEventData$outboundSchema.parse(
+      actionReviewRequestedStreamingEventData,
+    ),
+  );
+}
+export function actionReviewRequestedStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ActionReviewRequestedStreamingEventData,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ActionReviewRequestedStreamingEventData$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ActionReviewRequestedStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ActionReviewRequestedStreamingEvent$inboundSchema: z.ZodType<
+  ActionReviewRequestedStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ActionReviewRequestedStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ActionReviewRequestedStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ActionReviewRequestedStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ActionReviewRequestedStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ActionReviewRequestedStreamingEvent$outboundSchema: z.ZodType<
+  ActionReviewRequestedStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ActionReviewRequestedStreamingEvent
+> = z.object({
+  type: ActionReviewRequestedStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ActionReviewRequestedStreamingEventData$outboundSchema),
+});
+
+export function actionReviewRequestedStreamingEventToJSON(
+  actionReviewRequestedStreamingEvent: ActionReviewRequestedStreamingEvent,
+): string {
+  return JSON.stringify(
+    ActionReviewRequestedStreamingEvent$outboundSchema.parse(
+      actionReviewRequestedStreamingEvent,
+    ),
+  );
+}
+export function actionReviewRequestedStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ActionReviewRequestedStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ActionReviewRequestedStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ActionReviewRequestedStreamingEvent' from JSON`,
+  );
+}

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`,
+  );
+}