@orq-ai/node 4.8.0-rc.9 → 4.8.3

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

@@ -0,0 +1,136 @@
+/*
+ * 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 format of the encoded audio data. Currently supports `wav` and `mp3`.
+ */
+export const Format = {
+  Mp3: "mp3",
+  Wav: "wav",
+} as const;
+/**
+ * The format of the encoded audio data. Currently supports `wav` and `mp3`.
+ */
+export type Format = ClosedEnum<typeof Format>;
+
+export type InputAudio = {
+  /**
+   * Base64 encoded audio data.
+   */
+  data: string;
+  /**
+   * The format of the encoded audio data. Currently supports `wav` and `mp3`.
+   */
+  format: Format;
+};
+
+/**
+ * An audio content part
+ */
+export type AudioContentPartSchema = {
+  type: "input_audio";
+  inputAudio: InputAudio;
+};
+
+/** @internal */
+export const Format$inboundSchema: z.ZodNativeEnum<typeof Format> = z
+  .nativeEnum(Format);
+/** @internal */
+export const Format$outboundSchema: z.ZodNativeEnum<typeof Format> =
+  Format$inboundSchema;
+
+/** @internal */
+export const InputAudio$inboundSchema: z.ZodType<
+  InputAudio,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.string(),
+  format: Format$inboundSchema,
+});
+/** @internal */
+export type InputAudio$Outbound = {
+  data: string;
+  format: string;
+};
+
+/** @internal */
+export const InputAudio$outboundSchema: z.ZodType<
+  InputAudio$Outbound,
+  z.ZodTypeDef,
+  InputAudio
+> = z.object({
+  data: z.string(),
+  format: Format$outboundSchema,
+});
+
+export function inputAudioToJSON(inputAudio: InputAudio): string {
+  return JSON.stringify(InputAudio$outboundSchema.parse(inputAudio));
+}
+export function inputAudioFromJSON(
+  jsonString: string,
+): SafeParseResult<InputAudio, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InputAudio$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InputAudio' from JSON`,
+  );
+}
+
+/** @internal */
+export const AudioContentPartSchema$inboundSchema: z.ZodType<
+  AudioContentPartSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("input_audio"),
+  input_audio: z.lazy(() => InputAudio$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "input_audio": "inputAudio",
+  });
+});
+/** @internal */
+export type AudioContentPartSchema$Outbound = {
+  type: "input_audio";
+  input_audio: InputAudio$Outbound;
+};
+
+/** @internal */
+export const AudioContentPartSchema$outboundSchema: z.ZodType<
+  AudioContentPartSchema$Outbound,
+  z.ZodTypeDef,
+  AudioContentPartSchema
+> = z.object({
+  type: z.literal("input_audio"),
+  inputAudio: z.lazy(() => InputAudio$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    inputAudio: "input_audio",
+  });
+});
+
+export function audioContentPartSchemaToJSON(
+  audioContentPartSchema: AudioContentPartSchema,
+): string {
+  return JSON.stringify(
+    AudioContentPartSchema$outboundSchema.parse(audioContentPartSchema),
+  );
+}
+export function audioContentPartSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<AudioContentPartSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AudioContentPartSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AudioContentPartSchema' from JSON`,
+  );
+}

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

@@ -0,0 +1,83 @@
+/*
+ * 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 Currency = {
+  Usd: "usd",
+} as const;
+export type Currency = ClosedEnum<typeof Currency>;
+
+export const Period = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month",
+} as const;
+export type Period = ClosedEnum<typeof Period>;
+
+export type BudgetLimit = {
+  amount: number;
+  currency: Currency;
+  period: Period;
+};
+
+/** @internal */
+export const Currency$inboundSchema: z.ZodNativeEnum<typeof Currency> = z
+  .nativeEnum(Currency);
+/** @internal */
+export const Currency$outboundSchema: z.ZodNativeEnum<typeof Currency> =
+  Currency$inboundSchema;
+
+/** @internal */
+export const Period$inboundSchema: z.ZodNativeEnum<typeof Period> = z
+  .nativeEnum(Period);
+/** @internal */
+export const Period$outboundSchema: z.ZodNativeEnum<typeof Period> =
+  Period$inboundSchema;
+
+/** @internal */
+export const BudgetLimit$inboundSchema: z.ZodType<
+  BudgetLimit,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  amount: z.number(),
+  currency: Currency$inboundSchema,
+  period: Period$inboundSchema,
+});
+/** @internal */
+export type BudgetLimit$Outbound = {
+  amount: number;
+  currency: string;
+  period: string;
+};
+
+/** @internal */
+export const BudgetLimit$outboundSchema: z.ZodType<
+  BudgetLimit$Outbound,
+  z.ZodTypeDef,
+  BudgetLimit
+> = z.object({
+  amount: z.number(),
+  currency: Currency$outboundSchema,
+  period: Period$outboundSchema,
+});
+
+export function budgetLimitToJSON(budgetLimit: BudgetLimit): string {
+  return JSON.stringify(BudgetLimit$outboundSchema.parse(budgetLimit));
+}
+export function budgetLimitFromJSON(
+  jsonString: string,
+): SafeParseResult<BudgetLimit, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BudgetLimit$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BudgetLimit' from JSON`,
+  );
+}

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

@@ -0,0 +1,51 @@
+/*
+ * 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 ConversationParam = {
+  id: string;
+};
+
+/** @internal */
+export const ConversationParam$inboundSchema: z.ZodType<
+  ConversationParam,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+});
+/** @internal */
+export type ConversationParam$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const ConversationParam$outboundSchema: z.ZodType<
+  ConversationParam$Outbound,
+  z.ZodTypeDef,
+  ConversationParam
+> = z.object({
+  id: z.string(),
+});
+
+export function conversationParamToJSON(
+  conversationParam: ConversationParam,
+): string {
+  return JSON.stringify(
+    ConversationParam$outboundSchema.parse(conversationParam),
+  );
+}
+export function conversationParamFromJSON(
+  jsonString: string,
+): SafeParseResult<ConversationParam, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConversationParam$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConversationParam' from JSON`,
+  );
+}

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

@@ -0,0 +1,305 @@
+/*
+ * 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";
+import {
+  AgentResponseMessage,
+  AgentResponseMessage$inboundSchema,
+} from "./agentresponsemessage.js";
+import { Telemetry, Telemetry$inboundSchema } from "./telemetry.js";
+
+export type PromptTokensDetails = {
+  cachedTokens?: number | null | undefined;
+  cacheCreationTokens?: number | null | undefined;
+  /**
+   * The number of audio input tokens consumed by the request.
+   */
+  audioTokens?: number | null | undefined;
+};
+
+export type CompletionTokensDetails = {
+  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 from the agent execution
+ */
+export type Usage = {
+  /**
+   * 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?: PromptTokensDetails | null | undefined;
+  completionTokensDetails?: CompletionTokensDetails | null | undefined;
+};
+
+/**
+ * The reason why the agent stopped generating
+ */
+export const FinishReason = {
+  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 FinishReason = ClosedEnum<typeof FinishReason>;
+
+export const CreateAgentResponseType = {
+  Function: "function",
+} as const;
+export type CreateAgentResponseType = ClosedEnum<
+  typeof CreateAgentResponseType
+>;
+
+export type FunctionT = {
+  name?: string | undefined;
+  arguments?: string | undefined;
+};
+
+export type PendingToolCalls = {
+  id: string;
+  type: CreateAgentResponseType;
+  function: FunctionT;
+};
+
+/**
+ * Response type from the create-response endpoint.
+ */
+export type CreateAgentResponse = {
+  /**
+   * The unique response ID
+   */
+  id: string;
+  /**
+   * The agent execution task ID
+   */
+  taskId: string;
+  /**
+   * Array of messages from the agent execution
+   */
+  output: Array<AgentResponseMessage>;
+  /**
+   * ISO timestamp of response creation
+   */
+  createdAt: string;
+  /**
+   * Model used in provider/model format
+   */
+  model: string;
+  /**
+   * Token usage from the agent execution
+   */
+  usage?: Usage | null | undefined;
+  /**
+   * The reason why the agent stopped generating
+   */
+  finishReason?: FinishReason | undefined;
+  /**
+   * Tool calls awaiting user response (when finish_reason is function_call)
+   */
+  pendingToolCalls?: Array<PendingToolCalls> | undefined;
+  /**
+   * Telemetry information for correlating the response with traces
+   */
+  telemetry?: Telemetry | undefined;
+};
+
+/** @internal */
+export const PromptTokensDetails$inboundSchema: z.ZodType<
+  PromptTokensDetails,
+  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 promptTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<PromptTokensDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PromptTokensDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromptTokensDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const CompletionTokensDetails$inboundSchema: z.ZodType<
+  CompletionTokensDetails,
+  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 completionTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<CompletionTokensDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CompletionTokensDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CompletionTokensDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const Usage$inboundSchema: z.ZodType<Usage, 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(() => PromptTokensDetails$inboundSchema),
+    ).optional(),
+    completion_tokens_details: z.nullable(
+      z.lazy(() => CompletionTokensDetails$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 usageFromJSON(
+  jsonString: string,
+): SafeParseResult<Usage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Usage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Usage' from JSON`,
+  );
+}
+
+/** @internal */
+export const FinishReason$inboundSchema: z.ZodNativeEnum<typeof FinishReason> =
+  z.nativeEnum(FinishReason);
+
+/** @internal */
+export const CreateAgentResponseType$inboundSchema: z.ZodNativeEnum<
+  typeof CreateAgentResponseType
+> = z.nativeEnum(CreateAgentResponseType);
+
+/** @internal */
+export const FunctionT$inboundSchema: z.ZodType<
+  FunctionT,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  arguments: z.string().optional(),
+});
+
+export function functionFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionT' from JSON`,
+  );
+}
+
+/** @internal */
+export const PendingToolCalls$inboundSchema: z.ZodType<
+  PendingToolCalls,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  type: CreateAgentResponseType$inboundSchema,
+  function: z.lazy(() => FunctionT$inboundSchema),
+});
+
+export function pendingToolCallsFromJSON(
+  jsonString: string,
+): SafeParseResult<PendingToolCalls, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PendingToolCalls$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PendingToolCalls' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateAgentResponse$inboundSchema: z.ZodType<
+  CreateAgentResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  task_id: z.string(),
+  output: z.array(AgentResponseMessage$inboundSchema),
+  created_at: z.string(),
+  model: z.string(),
+  usage: z.nullable(z.lazy(() => Usage$inboundSchema)).optional(),
+  finish_reason: FinishReason$inboundSchema.optional(),
+  pending_tool_calls: z.array(z.lazy(() => PendingToolCalls$inboundSchema))
+    .optional(),
+  telemetry: Telemetry$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "task_id": "taskId",
+    "created_at": "createdAt",
+    "finish_reason": "finishReason",
+    "pending_tool_calls": "pendingToolCalls",
+  });
+});
+
+export function createAgentResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateAgentResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateAgentResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateAgentResponse' from JSON`,
+  );
+}

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

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type CreateFileRequest = {
+  filename?: string | undefined;
+  content?: string | undefined;
+  purpose?: number | undefined;
+  contentType?: string | undefined;
+};
+
+/** @internal */
+export type CreateFileRequest$Outbound = {
+  filename?: string | undefined;
+  content?: string | undefined;
+  purpose?: number | undefined;
+  content_type?: string | undefined;
+};
+
+/** @internal */
+export const CreateFileRequest$outboundSchema: z.ZodType<
+  CreateFileRequest$Outbound,
+  z.ZodTypeDef,
+  CreateFileRequest
+> = z.object({
+  filename: z.string().optional(),
+  content: z.string().optional(),
+  purpose: z.number().int().optional(),
+  contentType: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    contentType: "content_type",
+  });
+});
+
+export function createFileRequestToJSON(
+  createFileRequest: CreateFileRequest,
+): string {
+  return JSON.stringify(
+    CreateFileRequest$outboundSchema.parse(createFileRequest),
+  );
+}

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

@@ -0,0 +1,32 @@
+/*
+ * 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 { FileT, FileT$inboundSchema } from "./file.js";
+
+export type CreateFileResponse = {
+  file?: FileT | undefined;
+};
+
+/** @internal */
+export const CreateFileResponse$inboundSchema: z.ZodType<
+  CreateFileResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  file: FileT$inboundSchema.optional(),
+});
+
+export function createFileResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateFileResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateFileResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateFileResponse' from JSON`,
+  );
+}

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

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type CreateSkillRequest = {
+  displayName?: string | undefined;
+  description?: string | undefined;
+  enabled?: boolean | undefined;
+  tags?: Array<string> | undefined;
+  path?: string | undefined;
+  projectId?: string | undefined;
+  instructions?: string | undefined;
+};
+
+/** @internal */
+export type CreateSkillRequest$Outbound = {
+  display_name?: string | undefined;
+  description?: string | undefined;
+  enabled?: boolean | undefined;
+  tags?: Array<string> | undefined;
+  path?: string | undefined;
+  project_id?: string | undefined;
+  instructions?: string | undefined;
+};
+
+/** @internal */
+export const CreateSkillRequest$outboundSchema: z.ZodType<
+  CreateSkillRequest$Outbound,
+  z.ZodTypeDef,
+  CreateSkillRequest
+> = z.object({
+  displayName: z.string().optional(),
+  description: z.string().optional(),
+  enabled: z.boolean().optional(),
+  tags: z.array(z.string()).optional(),
+  path: z.string().optional(),
+  projectId: z.string().optional(),
+  instructions: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    displayName: "display_name",
+    projectId: "project_id",
+  });
+});
+
+export function createSkillRequestToJSON(
+  createSkillRequest: CreateSkillRequest,
+): string {
+  return JSON.stringify(
+    CreateSkillRequest$outboundSchema.parse(createSkillRequest),
+  );
+}