@orq-ai/node 4.9.0-rc.8 → 4.9.0

package/packages/orq-rc/src/lib/security.ts

@@ -0,0 +1,275 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as components from "../models/components/index.js";
+import { env } from "./env.js";
+
+type OAuth2PasswordFlow = {
+  username: string;
+  password: string;
+  clientID?: string | undefined;
+  clientSecret?: string | undefined;
+  tokenURL: string;
+};
+
+export enum SecurityErrorCode {
+  Incomplete = "incomplete",
+  UnrecognisedSecurityType = "unrecognized_security_type",
+}
+
+export class SecurityError extends Error {
+  constructor(
+    public code: SecurityErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = "SecurityError";
+  }
+
+  static incomplete(): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.Incomplete,
+      "Security requirements not met in order to perform the operation",
+    );
+  }
+  static unrecognizedType(type: string): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.UnrecognisedSecurityType,
+      `Unrecognised security type: ${type}`,
+    );
+  }
+}
+
+export type SecurityState = {
+  basic: { username?: string | undefined; password?: string | undefined };
+  headers: Record<string, string>;
+  queryParams: Record<string, string>;
+  cookies: Record<string, string>;
+  oauth2: ({ type: "password" } & OAuth2PasswordFlow) | { type: "none" };
+};
+
+type SecurityInputBasic = {
+  type: "http:basic";
+  value:
+    | { username?: string | undefined; password?: string | undefined }
+    | null
+    | undefined;
+};
+
+type SecurityInputBearer = {
+  type: "http:bearer";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputAPIKey = {
+  type: "apiKey:header" | "apiKey:query" | "apiKey:cookie";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOIDC = {
+  type: "openIdConnect";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2 = {
+  type: "oauth2";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2ClientCredentials = {
+  type: "oauth2:client_credentials";
+  value:
+    | {
+      clientID?: string | undefined;
+      clientSecret?: string | undefined;
+    }
+    | null
+    | string
+    | undefined;
+  fieldName?: string;
+};
+
+type SecurityInputOAuth2PasswordCredentials = {
+  type: "oauth2:password";
+  value:
+    | string
+    | null
+    | undefined;
+  fieldName?: string;
+};
+
+type SecurityInputCustom = {
+  type: "http:custom";
+  value: any | null | undefined;
+  fieldName?: string;
+};
+
+export type SecurityInput =
+  | SecurityInputBasic
+  | SecurityInputBearer
+  | SecurityInputAPIKey
+  | SecurityInputOAuth2
+  | SecurityInputOAuth2ClientCredentials
+  | SecurityInputOAuth2PasswordCredentials
+  | SecurityInputOIDC
+  | SecurityInputCustom;
+
+export function resolveSecurity(
+  ...options: SecurityInput[][]
+): SecurityState | null {
+  const state: SecurityState = {
+    basic: {},
+    headers: {},
+    queryParams: {},
+    cookies: {},
+    oauth2: { type: "none" },
+  };
+
+  const option = options.find((opts) => {
+    return opts.every((o) => {
+      if (o.value == null) {
+        return false;
+      } else if (o.type === "http:basic") {
+        return o.value.username != null || o.value.password != null;
+      } else if (o.type === "http:custom") {
+        return null;
+      } else if (o.type === "oauth2:password") {
+        return (
+          typeof o.value === "string" && !!o.value
+        );
+      } else if (o.type === "oauth2:client_credentials") {
+        if (typeof o.value == "string") {
+          return !!o.value;
+        }
+        return o.value.clientID != null || o.value.clientSecret != null;
+      } else if (typeof o.value === "string") {
+        return !!o.value;
+      } else {
+        throw new Error(
+          `Unrecognized security type: ${o.type} (value type: ${typeof o
+            .value})`,
+        );
+      }
+    });
+  });
+  if (option == null) {
+    return null;
+  }
+
+  option.forEach((spec) => {
+    if (spec.value == null) {
+      return;
+    }
+
+    const { type } = spec;
+
+    switch (type) {
+      case "apiKey:header":
+        state.headers[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:query":
+        state.queryParams[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:cookie":
+        state.cookies[spec.fieldName] = spec.value;
+        break;
+      case "http:basic":
+        applyBasic(state, spec);
+        break;
+      case "http:custom":
+        break;
+      case "http:bearer":
+        applyBearer(state, spec);
+        break;
+      case "oauth2":
+        applyBearer(state, spec);
+        break;
+      case "oauth2:password":
+        applyBearer(state, spec);
+        break;
+      case "oauth2:client_credentials":
+        break;
+      case "openIdConnect":
+        applyBearer(state, spec);
+        break;
+      default:
+        throw SecurityError.unrecognizedType((spec satisfies never, type));
+    }
+  });
+
+  return state;
+}
+
+function applyBasic(
+  state: SecurityState,
+  spec: SecurityInputBasic,
+) {
+  if (spec.value == null) {
+    return;
+  }
+
+  state.basic = spec.value;
+}
+
+function applyBearer(
+  state: SecurityState,
+  spec:
+    | SecurityInputBearer
+    | SecurityInputOAuth2
+    | SecurityInputOIDC
+    | SecurityInputOAuth2PasswordCredentials,
+) {
+  if (typeof spec.value !== "string" || !spec.value) {
+    return;
+  }
+
+  let value = spec.value;
+  if (value.slice(0, 7).toLowerCase() !== "bearer ") {
+    value = `Bearer ${value}`;
+  }
+
+  if (spec.fieldName !== undefined) {
+    state.headers[spec.fieldName] = value;
+  }
+}
+
+export function resolveGlobalSecurity(
+  security: Partial<components.Security> | null | undefined,
+  allowedFields?: number[],
+): SecurityState | null {
+  let inputs: SecurityInput[][] = [
+    [
+      {
+        fieldName: "Authorization",
+        type: "http:bearer",
+        value: security?.apiKey ?? env().ORQ_API_KEY,
+      },
+    ],
+  ];
+
+  if (allowedFields) {
+    inputs = allowedFields.map((i) => {
+      if (i < 0 || i >= inputs.length) {
+        throw new RangeError(`invalid allowedFields index ${i}`);
+      }
+      return inputs[i]!;
+    });
+  }
+
+  return resolveSecurity(...inputs);
+}
+
+export async function extractSecurity<
+  T extends string | Record<string, unknown>,
+>(sec: T | (() => Promise<T>) | undefined): Promise<T | undefined> {
+  if (sec == null) {
+    return;
+  }
+
+  return typeof sec === "function" ? sec() : sec;
+}

package/packages/orq-rc/src/lib/url.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export type Params = Partial<Record<string, string | number>>;
+
+export function pathToFunc(
+  pathPattern: string,
+  options?: { charEncoding?: "percent" | "none" },
+): (params?: Params) => string {
+  const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
+
+  return function buildURLPath(params: Record<string, unknown> = {}): string {
+    return pathPattern
+      .replace(paramRE, function (_, placeholder) {
+        if (!hasOwn.call(params, placeholder)) {
+          throw new Error(`Parameter '${placeholder}' is required`);
+        }
+
+        const value = params[placeholder];
+        if (typeof value !== "string" && typeof value !== "number") {
+          throw new Error(
+            `Parameter '${placeholder}' must be a string or number`,
+          );
+        }
+
+        return options?.charEncoding === "percent"
+          ? encodeURIComponent(`${value}`)
+          : `${value}`;
+      })
+      .replace(/^\/+/, "");
+  };
+}

package/packages/orq-rc/src/models/components/actionreviewedstreamingevent.ts

@@ -0,0 +1,99 @@
+/*
+ * 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 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: "event.agents.action_reviewed";
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ActionReviewedStreamingEventData;
+};
+
+/** @internal */
+export const Review$inboundSchema: z.ZodNativeEnum<typeof Review> = z
+  .nativeEnum(Review);
+
+/** @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",
+  });
+});
+
+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: z.literal("event.agents.action_reviewed"),
+  timestamp: z.string(),
+  data: z.lazy(() => ActionReviewedStreamingEventData$inboundSchema),
+});
+
+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/packages/orq-rc/src/models/components/actionreviewrequestedstreamingevent.ts

@@ -0,0 +1,185 @@
+/*
+ * 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 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;
+  /**
+   * 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;
+};
+
+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: "event.agents.action_review_requested";
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ActionReviewRequestedStreamingEventData;
+};
+
+/** @internal */
+export const Conditions$inboundSchema: z.ZodType<
+  Conditions,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  condition: z.string(),
+  operator: z.string(),
+  value: z.string(),
+});
+
+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",
+    });
+  });
+
+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",
+  });
+});
+
+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: z.literal("event.agents.action_review_requested"),
+  timestamp: z.string(),
+  data: z.lazy(() => ActionReviewRequestedStreamingEventData$inboundSchema),
+});
+
+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/packages/orq-rc/src/models/components/agenterroredstreamingevent.ts

@@ -0,0 +1,73 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+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: "event.agents.errored";
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: AgentErroredStreamingEventData;
+};
+
+/** @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(),
+});
+
+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: z.literal("event.agents.errored"),
+  timestamp: z.string(),
+  data: z.lazy(() => AgentErroredStreamingEventData$inboundSchema),
+});
+
+export function agentErroredStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentErroredStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentErroredStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentErroredStreamingEvent' from JSON`,
+  );
+}