@orq-ai/node 4.0.13 → 4.0.14

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

@@ -1617,7 +1617,7 @@ export const RequestBodyTools$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string().default("01KAXGPT0CHYS861RMB0ZZ0JPN"),
+  id: z.string().default("01KAXXWB7G1B3PP880HBX0G4F4"),
   name: z.string(),
   description: z.string().optional(),
   schema: z.lazy(() => UpdateToolRequestBodyToolsSchema$inboundSchema),
@@ -1636,7 +1636,7 @@ export const RequestBodyTools$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   RequestBodyTools
 > = z.object({
-  id: z.string().default("01KAXGPT0CHYS861RMB0ZZ0JPN"),
+  id: z.string().default("01KAXXWB7G1B3PP880HBX0G4F4"),
   name: z.string(),
   description: z.string().optional(),
   schema: z.lazy(() => UpdateToolRequestBodyToolsSchema$outboundSchema),
@@ -2857,7 +2857,7 @@ export const UpdateToolResponseBodyCodeExecutionTool$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("tool_01KAXGPSZZ8M2YEDJQ3PCVQ581"),
+  _id: z.string().default("tool_01KAXXWB7B090PRBPDBVWKE7HB"),
   path: z.string(),
   key: z.string(),
   display_name: z.string().optional(),
@@ -2911,7 +2911,7 @@ export const UpdateToolResponseBodyCodeExecutionTool$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UpdateToolResponseBodyCodeExecutionTool
 > = z.object({
-  id: z.string().default("tool_01KAXGPSZZ8M2YEDJQ3PCVQ581"),
+  id: z.string().default("tool_01KAXXWB7B090PRBPDBVWKE7HB"),
   path: z.string(),
   key: z.string(),
   displayName: z.string().optional(),
@@ -3096,7 +3096,7 @@ export const UpdateToolResponseBodyTools$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string().default("01KAXGPSZY474ZKR0VC6XF91RZ"),
+  id: z.string().default("01KAXXWB7A603KNP6WSB41YK36"),
   name: z.string(),
   description: z.string().optional(),
   schema: z.lazy(() => UpdateToolResponseBodyToolsSchema$inboundSchema),
@@ -3115,7 +3115,7 @@ export const UpdateToolResponseBodyTools$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UpdateToolResponseBodyTools
 > = z.object({
-  id: z.string().default("01KAXGPSZY474ZKR0VC6XF91RZ"),
+  id: z.string().default("01KAXXWB7A603KNP6WSB41YK36"),
   name: z.string(),
   description: z.string().optional(),
   schema: z.lazy(() => UpdateToolResponseBodyToolsSchema$outboundSchema),
@@ -3216,7 +3216,7 @@ export const UpdateToolResponseBodyMCPTool$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("tool_01KAXGPSZXFXRMCYNSQXVMBS5G"),
+  _id: z.string().default("tool_01KAXXWB79JTEX0RWYCEQEKTVW"),
   path: z.string(),
   key: z.string(),
   display_name: z.string().optional(),
@@ -3269,7 +3269,7 @@ export const UpdateToolResponseBodyMCPTool$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UpdateToolResponseBodyMCPTool
 > = z.object({
-  id: z.string().default("tool_01KAXGPSZXFXRMCYNSQXVMBS5G"),
+  id: z.string().default("tool_01KAXXWB79JTEX0RWYCEQEKTVW"),
   path: z.string(),
   key: z.string(),
   displayName: z.string().optional(),
@@ -3646,7 +3646,7 @@ export const UpdateToolResponseBodyHTTPTool$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("tool_01KAXGPSZTGW9ZGATANNPM5E9G"),
+  _id: z.string().default("tool_01KAXXWB77ZMRQ9VVY9D3GJTE2"),
   path: z.string(),
   key: z.string(),
   display_name: z.string().optional(),
@@ -3699,7 +3699,7 @@ export const UpdateToolResponseBodyHTTPTool$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UpdateToolResponseBodyHTTPTool
 > = z.object({
-  id: z.string().default("tool_01KAXGPSZTGW9ZGATANNPM5E9G"),
+  id: z.string().default("tool_01KAXXWB77ZMRQ9VVY9D3GJTE2"),
   path: z.string(),
   key: z.string(),
   displayName: z.string().optional(),
@@ -3881,7 +3881,7 @@ export const UpdateToolResponseBodyJSONSchemaTool$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("tool_01KAXGPSZQ5WF9MTN404T964XY"),
+  _id: z.string().default("tool_01KAXXWB756WEYYDF734YPCX7J"),
   path: z.string(),
   key: z.string(),
   display_name: z.string().optional(),
@@ -3933,7 +3933,7 @@ export const UpdateToolResponseBodyJSONSchemaTool$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UpdateToolResponseBodyJSONSchemaTool
 > = z.object({
-  id: z.string().default("tool_01KAXGPSZQ5WF9MTN404T964XY"),
+  id: z.string().default("tool_01KAXXWB756WEYYDF734YPCX7J"),
   path: z.string(),
   key: z.string(),
   displayName: z.string().optional(),
@@ -4130,7 +4130,7 @@ export const UpdateToolResponseBodyFunctionTool$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("tool_01KAXGPSZN9MWCDFJV96Q8JCSC"),
+  _id: z.string().default("tool_01KAXXWB6XG4CKM5T7VQNW928H"),
   path: z.string(),
   key: z.string(),
   display_name: z.string().optional(),
@@ -4181,7 +4181,7 @@ export const UpdateToolResponseBodyFunctionTool$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UpdateToolResponseBodyFunctionTool
 > = z.object({
-  id: z.string().default("tool_01KAXGPSZN9MWCDFJV96Q8JCSC"),
+  id: z.string().default("tool_01KAXXWB6XG4CKM5T7VQNW928H"),
   path: z.string(),
   key: z.string(),
   displayName: z.string().optional(),

package/src/lib/config.ts

@@ -68,7 +68,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "2.0",
-  sdkVersion: "4.0.13",
+  sdkVersion: "4.0.14",
   genVersion: "2.762.0",
-  userAgent: "speakeasy-sdk/typescript 4.0.13 2.762.0 2.0 @orq-ai/node",
+  userAgent: "speakeasy-sdk/typescript 4.0.14 2.762.0 2.0 @orq-ai/node",
 } as const;

package/src/mcp-server/mcp-server.ts

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "4.0.13",
+    currentVersion: "4.0.14",
   },
 });
 

package/src/mcp-server/server.ts

@@ -120,7 +120,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "Orq",
-    version: "4.0.13",
+    version: "4.0.14",
   });
 
   const client = new OrqCore({

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