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

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

@@ -0,0 +1,66 @@
+/*
+ * 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";
+
+/**
+ * A message part containing reasoning or chain-of-thought content
+ */
+export type RedactedReasoningPartSchema = {
+  /**
+   * The type of the content part. Always `reasoning`.
+   */
+  type: "redacted_reasoning";
+  /**
+   * The encrypted reasoning or thought process behind the response. Used for chain-of-thought or extended thinking.
+   */
+  data: string;
+};
+
+/** @internal */
+export const RedactedReasoningPartSchema$inboundSchema: z.ZodType<
+  RedactedReasoningPartSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("redacted_reasoning"),
+  data: z.string(),
+});
+/** @internal */
+export type RedactedReasoningPartSchema$Outbound = {
+  type: "redacted_reasoning";
+  data: string;
+};
+
+/** @internal */
+export const RedactedReasoningPartSchema$outboundSchema: z.ZodType<
+  RedactedReasoningPartSchema$Outbound,
+  z.ZodTypeDef,
+  RedactedReasoningPartSchema
+> = z.object({
+  type: z.literal("redacted_reasoning"),
+  data: z.string(),
+});
+
+export function redactedReasoningPartSchemaToJSON(
+  redactedReasoningPartSchema: RedactedReasoningPartSchema,
+): string {
+  return JSON.stringify(
+    RedactedReasoningPartSchema$outboundSchema.parse(
+      redactedReasoningPartSchema,
+    ),
+  );
+}
+export function redactedReasoningPartSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<RedactedReasoningPartSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RedactedReasoningPartSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RedactedReasoningPartSchema' from JSON`,
+  );
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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";
+
+/**
+ * A message part containing a refusal message.
+ */
+export type RefusalPartSchema = {
+  /**
+   * The type of the content part. Always `refusal`.
+   */
+  type: "refusal";
+  /**
+   * The refusal message generated by the model.
+   */
+  refusal?: string | undefined;
+};
+
+/** @internal */
+export const RefusalPartSchema$inboundSchema: z.ZodType<
+  RefusalPartSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("refusal"),
+  refusal: z.string().optional(),
+});
+/** @internal */
+export type RefusalPartSchema$Outbound = {
+  type: "refusal";
+  refusal?: string | undefined;
+};
+
+/** @internal */
+export const RefusalPartSchema$outboundSchema: z.ZodType<
+  RefusalPartSchema$Outbound,
+  z.ZodTypeDef,
+  RefusalPartSchema
+> = z.object({
+  type: z.literal("refusal"),
+  refusal: z.string().optional(),
+});
+
+export function refusalPartSchemaToJSON(
+  refusalPartSchema: RefusalPartSchema,
+): string {
+  return JSON.stringify(
+    RefusalPartSchema$outboundSchema.parse(refusalPartSchema),
+  );
+}
+export function refusalPartSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<RefusalPartSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RefusalPartSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RefusalPartSchema' from JSON`,
+  );
+}

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

@@ -0,0 +1,318 @@
+/*
+ * 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";
+
+/**
+ * The reason why the agent stopped generating
+ */
+export const ResponseDoneEventFinishReason = {
+  Stop: "stop",
+  Length: "length",
+  ToolCalls: "tool_calls",
+  ContentFilter: "content_filter",
+  FunctionCall: "function_call",
+  MaxIterations: "max_iterations",
+  MaxTime: "max_time",
+} as const;
+/**
+ * The reason why the agent stopped generating
+ */
+export type ResponseDoneEventFinishReason = ClosedEnum<
+  typeof ResponseDoneEventFinishReason
+>;
+
+export type ResponseDoneEventPromptTokensDetails = {
+  cachedTokens?: number | null | undefined;
+  cacheCreationTokens?: number | null | undefined;
+  /**
+   * The number of audio input tokens consumed by the request.
+   */
+  audioTokens?: number | null | undefined;
+};
+
+export type ResponseDoneEventCompletionTokensDetails = {
+  reasoningTokens?: number | null | undefined;
+  acceptedPredictionTokens?: number | null | undefined;
+  rejectedPredictionTokens?: number | null | undefined;
+  /**
+   * The number of audio output tokens produced by the response.
+   */
+  audioTokens?: number | null | undefined;
+};
+
+/**
+ * Token usage statistics for the complete response
+ */
+export type ResponseDoneEventUsage = {
+  /**
+   * Number of tokens in the generated completion.
+   */
+  completionTokens?: number | undefined;
+  /**
+   * Number of tokens in the prompt.
+   */
+  promptTokens?: number | undefined;
+  /**
+   * Total number of tokens used in the request (prompt + completion).
+   */
+  totalTokens?: number | undefined;
+  promptTokensDetails?: ResponseDoneEventPromptTokensDetails | null | undefined;
+  completionTokensDetails?:
+    | ResponseDoneEventCompletionTokensDetails
+    | null
+    | undefined;
+};
+
+export const ResponseDoneEventDataType = {
+  Function: "function",
+} as const;
+export type ResponseDoneEventDataType = ClosedEnum<
+  typeof ResponseDoneEventDataType
+>;
+
+export type ResponseDoneEventFunction = {
+  /**
+   * The name of the function to call
+   */
+  name?: string | undefined;
+  /**
+   * The arguments to pass to the function as JSON string
+   */
+  arguments?: string | undefined;
+};
+
+export type ResponseDoneEventPendingToolCalls = {
+  /**
+   * Unique identifier for the tool call
+   */
+  id: string;
+  type: ResponseDoneEventDataType;
+  function: ResponseDoneEventFunction;
+};
+
+export type ResponseDoneEventData = {
+  /**
+   * The reason why the agent stopped generating
+   */
+  finishReason: ResponseDoneEventFinishReason;
+  /**
+   * Token usage statistics for the complete response
+   */
+  usage?: ResponseDoneEventUsage | undefined;
+  /**
+   * Tool calls awaiting user response (when finishReason is function_call)
+   */
+  pendingToolCalls?: Array<ResponseDoneEventPendingToolCalls> | undefined;
+};
+
+/**
+ * Emitted when the agent completes processing. Contains the finish reason and usage statistics.
+ */
+export type ResponseDoneEvent = {
+  type: "response.done";
+  /**
+   * ISO timestamp of when the event occurred
+   */
+  timestamp: string;
+  data: ResponseDoneEventData;
+};
+
+/** @internal */
+export const ResponseDoneEventFinishReason$inboundSchema: z.ZodNativeEnum<
+  typeof ResponseDoneEventFinishReason
+> = z.nativeEnum(ResponseDoneEventFinishReason);
+
+/** @internal */
+export const ResponseDoneEventPromptTokensDetails$inboundSchema: z.ZodType<
+  ResponseDoneEventPromptTokensDetails,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  cached_tokens: z.nullable(z.number().int()).optional(),
+  cache_creation_tokens: z.nullable(z.number().int()).optional(),
+  audio_tokens: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "cached_tokens": "cachedTokens",
+    "cache_creation_tokens": "cacheCreationTokens",
+    "audio_tokens": "audioTokens",
+  });
+});
+
+export function responseDoneEventPromptTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseDoneEventPromptTokensDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ResponseDoneEventPromptTokensDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseDoneEventPromptTokensDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseDoneEventCompletionTokensDetails$inboundSchema: z.ZodType<
+  ResponseDoneEventCompletionTokensDetails,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  reasoning_tokens: z.nullable(z.number()).optional(),
+  accepted_prediction_tokens: z.nullable(z.number()).optional(),
+  rejected_prediction_tokens: z.nullable(z.number()).optional(),
+  audio_tokens: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "reasoning_tokens": "reasoningTokens",
+    "accepted_prediction_tokens": "acceptedPredictionTokens",
+    "rejected_prediction_tokens": "rejectedPredictionTokens",
+    "audio_tokens": "audioTokens",
+  });
+});
+
+export function responseDoneEventCompletionTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ResponseDoneEventCompletionTokensDetails,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ResponseDoneEventCompletionTokensDetails$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ResponseDoneEventCompletionTokensDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseDoneEventUsage$inboundSchema: z.ZodType<
+  ResponseDoneEventUsage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  completion_tokens: z.number().optional(),
+  prompt_tokens: z.number().optional(),
+  total_tokens: z.number().optional(),
+  prompt_tokens_details: z.nullable(
+    z.lazy(() => ResponseDoneEventPromptTokensDetails$inboundSchema),
+  ).optional(),
+  completion_tokens_details: z.nullable(
+    z.lazy(() => ResponseDoneEventCompletionTokensDetails$inboundSchema),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "completion_tokens": "completionTokens",
+    "prompt_tokens": "promptTokens",
+    "total_tokens": "totalTokens",
+    "prompt_tokens_details": "promptTokensDetails",
+    "completion_tokens_details": "completionTokensDetails",
+  });
+});
+
+export function responseDoneEventUsageFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseDoneEventUsage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseDoneEventUsage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseDoneEventUsage' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseDoneEventDataType$inboundSchema: z.ZodNativeEnum<
+  typeof ResponseDoneEventDataType
+> = z.nativeEnum(ResponseDoneEventDataType);
+
+/** @internal */
+export const ResponseDoneEventFunction$inboundSchema: z.ZodType<
+  ResponseDoneEventFunction,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  arguments: z.string().optional(),
+});
+
+export function responseDoneEventFunctionFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseDoneEventFunction, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseDoneEventFunction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseDoneEventFunction' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseDoneEventPendingToolCalls$inboundSchema: z.ZodType<
+  ResponseDoneEventPendingToolCalls,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  type: ResponseDoneEventDataType$inboundSchema,
+  function: z.lazy(() => ResponseDoneEventFunction$inboundSchema),
+});
+
+export function responseDoneEventPendingToolCallsFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseDoneEventPendingToolCalls, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseDoneEventPendingToolCalls$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseDoneEventPendingToolCalls' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseDoneEventData$inboundSchema: z.ZodType<
+  ResponseDoneEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  finishReason: ResponseDoneEventFinishReason$inboundSchema,
+  usage: z.lazy(() => ResponseDoneEventUsage$inboundSchema).optional(),
+  pendingToolCalls: z.array(
+    z.lazy(() => ResponseDoneEventPendingToolCalls$inboundSchema),
+  ).optional(),
+});
+
+export function responseDoneEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseDoneEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseDoneEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseDoneEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseDoneEvent$inboundSchema: z.ZodType<
+  ResponseDoneEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("response.done"),
+  timestamp: z.string(),
+  data: z.lazy(() => ResponseDoneEventData$inboundSchema),
+});
+
+export function responseDoneEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseDoneEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseDoneEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseDoneEvent' from JSON`,
+  );
+}

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

@@ -0,0 +1,72 @@
+/*
+ * 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 ResponseFailedEventData = {
+  /**
+   * Error message describing what went wrong
+   */
+  error: string;
+  /**
+   * HTTP status code indicating the error type
+   */
+  code: number;
+};
+
+/**
+ * Emitted when an error occurs during agent execution. Contains error details.
+ */
+export type ResponseFailedEvent = {
+  type: "response.failed";
+  /**
+   * ISO timestamp of when the event occurred
+   */
+  timestamp: string;
+  data: ResponseFailedEventData;
+};
+
+/** @internal */
+export const ResponseFailedEventData$inboundSchema: z.ZodType<
+  ResponseFailedEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.string(),
+  code: z.number(),
+});
+
+export function responseFailedEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseFailedEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseFailedEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseFailedEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseFailedEvent$inboundSchema: z.ZodType<
+  ResponseFailedEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("response.failed"),
+  timestamp: z.string(),
+  data: z.lazy(() => ResponseFailedEventData$inboundSchema),
+});
+
+export function responseFailedEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseFailedEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseFailedEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseFailedEvent' from JSON`,
+  );
+}

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

@@ -0,0 +1,91 @@
+/*
+ * 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 Data = {
+  /**
+   * Unique identifier for this response
+   */
+  responseId: string;
+  /**
+   * The agent execution task ID. Use responseId for tracking instead.
+   *
+   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
+  taskId: string;
+  /**
+   * The model ID being used for this response in provider/model format
+   */
+  model: string;
+  /**
+   * Trace ID for this turn of the conversation (new for each continuation)
+   */
+  workflowRunId: string;
+  /**
+   * Server-generated ID for the user message. Use this ID for frontend state consistency.
+   */
+  userMessageId?: string | undefined;
+  /**
+   * Server-generated ID for the assistant message. Use this ID for frontend state consistency.
+   */
+  assistantMessageId?: string | undefined;
+};
+
+/**
+ * Emitted when the agent begins processing. Contains identifiers for tracking the response.
+ */
+export type ResponseStartedEvent = {
+  type: "response.started";
+  /**
+   * ISO timestamp of when the event occurred
+   */
+  timestamp: string;
+  data: Data;
+};
+
+/** @internal */
+export const Data$inboundSchema: z.ZodType<Data, z.ZodTypeDef, unknown> = z
+  .object({
+    responseId: z.string(),
+    taskId: z.string(),
+    model: z.string(),
+    workflowRunId: z.string(),
+    userMessageId: z.string().optional(),
+    assistantMessageId: z.string().optional(),
+  });
+
+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 ResponseStartedEvent$inboundSchema: z.ZodType<
+  ResponseStartedEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("response.started"),
+  timestamp: z.string(),
+  data: z.lazy(() => Data$inboundSchema),
+});
+
+export function responseStartedEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseStartedEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseStartedEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseStartedEvent' from JSON`,
+  );
+}

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

@@ -0,0 +1,85 @@
+/*
+ * 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";
+import {
+  PartDeltaEvent,
+  PartDeltaEvent$inboundSchema,
+} from "./partdeltaevent.js";
+import { PartDoneEvent, PartDoneEvent$inboundSchema } from "./partdoneevent.js";
+import {
+  ResponseDoneEvent,
+  ResponseDoneEvent$inboundSchema,
+} from "./responsedoneevent.js";
+import {
+  ResponseFailedEvent,
+  ResponseFailedEvent$inboundSchema,
+} from "./responsefailedevent.js";
+import {
+  ResponseStartedEvent,
+  ResponseStartedEvent$inboundSchema,
+} from "./responsestartedevent.js";
+import { ToolDoneEvent, ToolDoneEvent$inboundSchema } from "./tooldoneevent.js";
+import {
+  ToolFailedEvent,
+  ToolFailedEvent$inboundSchema,
+} from "./toolfailedevent.js";
+import {
+  ToolReviewDoneEvent,
+  ToolReviewDoneEvent$inboundSchema,
+} from "./toolreviewdoneevent.js";
+import {
+  ToolReviewRequestedEvent,
+  ToolReviewRequestedEvent$inboundSchema,
+} from "./toolreviewrequestedevent.js";
+import {
+  ToolStartedEvent,
+  ToolStartedEvent$inboundSchema,
+} from "./toolstartedevent.js";
+
+/**
+ * Union of all possible streaming events. Each event has a type field for discrimination.
+ */
+export type ResponseStreamingEvent =
+  | ResponseStartedEvent
+  | ResponseDoneEvent
+  | ResponseFailedEvent
+  | ToolStartedEvent
+  | ToolDoneEvent
+  | ToolFailedEvent
+  | ToolReviewRequestedEvent
+  | ToolReviewDoneEvent
+  | PartDeltaEvent
+  | PartDoneEvent;
+
+/** @internal */
+export const ResponseStreamingEvent$inboundSchema: z.ZodType<
+  ResponseStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  ResponseStartedEvent$inboundSchema,
+  ResponseDoneEvent$inboundSchema,
+  ResponseFailedEvent$inboundSchema,
+  ToolStartedEvent$inboundSchema,
+  ToolDoneEvent$inboundSchema,
+  ToolFailedEvent$inboundSchema,
+  ToolReviewRequestedEvent$inboundSchema,
+  ToolReviewDoneEvent$inboundSchema,
+  PartDeltaEvent$inboundSchema,
+  PartDoneEvent$inboundSchema,
+]);
+
+export function responseStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseStreamingEvent' from JSON`,
+  );
+}