@orq-ai/node 4.3.1-rc.0 → 4.3.2

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

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * The review decision
+ */
+export const ReviewOutcome = {
+  Approved: "approved",
+  Rejected: "rejected",
+} as const;
+/**
+ * The review decision
+ */
+export type ReviewOutcome = ClosedEnum<typeof ReviewOutcome>;
+
+/** @internal */
+export const ReviewOutcome$inboundSchema: z.ZodNativeEnum<
+  typeof ReviewOutcome
+> = z.nativeEnum(ReviewOutcome);

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

@@ -0,0 +1,32 @@
+/*
+ * 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 Security = {
+  apiKey?: string | undefined;
+};
+
+/** @internal */
+export type Security$Outbound = {
+  ApiKey?: string | undefined;
+};
+
+/** @internal */
+export const Security$outboundSchema: z.ZodType<
+  Security$Outbound,
+  z.ZodTypeDef,
+  Security
+> = z.object({
+  apiKey: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    apiKey: "ApiKey",
+  });
+});
+
+export function securityToJSON(security: Security): string {
+  return JSON.stringify(Security$outboundSchema.parse(security));
+}

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

@@ -0,0 +1,207 @@
+/*
+ * 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 type of the content part.
+ */
+export const Type = {
+  Text: "text",
+} as const;
+/**
+ * The type of the content part.
+ */
+export type Type = ClosedEnum<typeof Type>;
+
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export const TextContentPartSchemaType = {
+  Ephemeral: "ephemeral",
+} as const;
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export type TextContentPartSchemaType = ClosedEnum<
+  typeof TextContentPartSchemaType
+>;
+
+/**
+ * The time-to-live for the cache control breakpoint. This may be one of the following values:
+ *
+ * @remarks
+ *
+ * - `5m`: 5 minutes
+ * - `1h`: 1 hour
+ *
+ * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+ */
+export const Ttl = {
+  Fivem: "5m",
+  Oneh: "1h",
+} as const;
+/**
+ * The time-to-live for the cache control breakpoint. This may be one of the following values:
+ *
+ * @remarks
+ *
+ * - `5m`: 5 minutes
+ * - `1h`: 1 hour
+ *
+ * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+ */
+export type Ttl = ClosedEnum<typeof Ttl>;
+
+export type CacheControl = {
+  /**
+   * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+   */
+  type: TextContentPartSchemaType;
+  /**
+   * The time-to-live for the cache control breakpoint. This may be one of the following values:
+   *
+   * @remarks
+   *
+   * - `5m`: 5 minutes
+   * - `1h`: 1 hour
+   *
+   * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+   */
+  ttl?: Ttl | undefined;
+};
+
+/**
+ * The type of the content part.
+ */
+export type TextContentPartSchema = {
+  /**
+   * The type of the content part.
+   */
+  type: Type;
+  /**
+   * The text content.
+   */
+  text: string;
+  cacheControl?: CacheControl | undefined;
+};
+
+/** @internal */
+export const Type$inboundSchema: z.ZodNativeEnum<typeof Type> = z.nativeEnum(
+  Type,
+);
+/** @internal */
+export const Type$outboundSchema: z.ZodNativeEnum<typeof Type> =
+  Type$inboundSchema;
+
+/** @internal */
+export const TextContentPartSchemaType$inboundSchema: z.ZodNativeEnum<
+  typeof TextContentPartSchemaType
+> = z.nativeEnum(TextContentPartSchemaType);
+/** @internal */
+export const TextContentPartSchemaType$outboundSchema: z.ZodNativeEnum<
+  typeof TextContentPartSchemaType
+> = TextContentPartSchemaType$inboundSchema;
+
+/** @internal */
+export const Ttl$inboundSchema: z.ZodNativeEnum<typeof Ttl> = z.nativeEnum(Ttl);
+/** @internal */
+export const Ttl$outboundSchema: z.ZodNativeEnum<typeof Ttl> =
+  Ttl$inboundSchema;
+
+/** @internal */
+export const CacheControl$inboundSchema: z.ZodType<
+  CacheControl,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: TextContentPartSchemaType$inboundSchema,
+  ttl: Ttl$inboundSchema.default("5m"),
+});
+/** @internal */
+export type CacheControl$Outbound = {
+  type: string;
+  ttl: string;
+};
+
+/** @internal */
+export const CacheControl$outboundSchema: z.ZodType<
+  CacheControl$Outbound,
+  z.ZodTypeDef,
+  CacheControl
+> = z.object({
+  type: TextContentPartSchemaType$outboundSchema,
+  ttl: Ttl$outboundSchema.default("5m"),
+});
+
+export function cacheControlToJSON(cacheControl: CacheControl): string {
+  return JSON.stringify(CacheControl$outboundSchema.parse(cacheControl));
+}
+export function cacheControlFromJSON(
+  jsonString: string,
+): SafeParseResult<CacheControl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CacheControl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CacheControl' from JSON`,
+  );
+}
+
+/** @internal */
+export const TextContentPartSchema$inboundSchema: z.ZodType<
+  TextContentPartSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: Type$inboundSchema,
+  text: z.string(),
+  cache_control: z.lazy(() => CacheControl$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "cache_control": "cacheControl",
+  });
+});
+/** @internal */
+export type TextContentPartSchema$Outbound = {
+  type: string;
+  text: string;
+  cache_control?: CacheControl$Outbound | undefined;
+};
+
+/** @internal */
+export const TextContentPartSchema$outboundSchema: z.ZodType<
+  TextContentPartSchema$Outbound,
+  z.ZodTypeDef,
+  TextContentPartSchema
+> = z.object({
+  type: Type$outboundSchema,
+  text: z.string(),
+  cacheControl: z.lazy(() => CacheControl$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    cacheControl: "cache_control",
+  });
+});
+
+export function textContentPartSchemaToJSON(
+  textContentPartSchema: TextContentPartSchema,
+): string {
+  return JSON.stringify(
+    TextContentPartSchema$outboundSchema.parse(textContentPartSchema),
+  );
+}
+export function textContentPartSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<TextContentPartSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TextContentPartSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TextContentPartSchema' from JSON`,
+  );
+}

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

@@ -0,0 +1,54 @@
+/*
+ * 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";
+
+/**
+ * Text content part. Use this to send text messages to the agent.
+ */
+export type TextPart = {
+  kind: "text";
+  text: string;
+};
+
+/** @internal */
+export const TextPart$inboundSchema: z.ZodType<
+  TextPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: z.literal("text"),
+  text: z.string(),
+});
+/** @internal */
+export type TextPart$Outbound = {
+  kind: "text";
+  text: string;
+};
+
+/** @internal */
+export const TextPart$outboundSchema: z.ZodType<
+  TextPart$Outbound,
+  z.ZodTypeDef,
+  TextPart
+> = z.object({
+  kind: z.literal("text"),
+  text: z.string(),
+});
+
+export function textPartToJSON(textPart: TextPart): string {
+  return JSON.stringify(TextPart$outboundSchema.parse(textPart));
+}
+export function textPartFromJSON(
+  jsonString: string,
+): SafeParseResult<TextPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TextPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TextPart' from JSON`,
+  );
+}

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

@@ -0,0 +1,59 @@
+/*
+ * 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";
+
+/**
+ * Disables the thinking mode capability
+ */
+export type ThinkingConfigDisabledSchema = {
+  /**
+   * Disables the thinking mode capability
+   */
+  type: "disabled";
+};
+
+/** @internal */
+export const ThinkingConfigDisabledSchema$inboundSchema: z.ZodType<
+  ThinkingConfigDisabledSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("disabled"),
+});
+/** @internal */
+export type ThinkingConfigDisabledSchema$Outbound = {
+  type: "disabled";
+};
+
+/** @internal */
+export const ThinkingConfigDisabledSchema$outboundSchema: z.ZodType<
+  ThinkingConfigDisabledSchema$Outbound,
+  z.ZodTypeDef,
+  ThinkingConfigDisabledSchema
+> = z.object({
+  type: z.literal("disabled"),
+});
+
+export function thinkingConfigDisabledSchemaToJSON(
+  thinkingConfigDisabledSchema: ThinkingConfigDisabledSchema,
+): string {
+  return JSON.stringify(
+    ThinkingConfigDisabledSchema$outboundSchema.parse(
+      thinkingConfigDisabledSchema,
+    ),
+  );
+}
+export function thinkingConfigDisabledSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<ThinkingConfigDisabledSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ThinkingConfigDisabledSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ThinkingConfigDisabledSchema' from JSON`,
+  );
+}

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

@@ -0,0 +1,106 @@
+/*
+ * 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 level of reasoning the model should use. This setting is supported only by `gemini-3` models. If budget_tokens is specified and `thinking_level` is available, `budget_tokens` will be ignored.
+ */
+export const ThinkingLevel = {
+  Low: "low",
+  High: "high",
+} as const;
+/**
+ * The level of reasoning the model should use. This setting is supported only by `gemini-3` models. If budget_tokens is specified and `thinking_level` is available, `budget_tokens` will be ignored.
+ */
+export type ThinkingLevel = ClosedEnum<typeof ThinkingLevel>;
+
+/**
+ * Enables the thinking mode capability
+ */
+export type ThinkingConfigEnabledSchema = {
+  /**
+   * Enables or disables the thinking mode capability
+   */
+  type: "enabled";
+  /**
+   * Determines how many tokens the model can use for its internal reasoning process. Larger budgets can enable more thorough analysis for complex problems, improving response quality. Must be ≥1024 and less than `max_tokens`.
+   */
+  budgetTokens: number;
+  /**
+   * The level of reasoning the model should use. This setting is supported only by `gemini-3` models. If budget_tokens is specified and `thinking_level` is available, `budget_tokens` will be ignored.
+   */
+  thinkingLevel?: ThinkingLevel | undefined;
+};
+
+/** @internal */
+export const ThinkingLevel$inboundSchema: z.ZodNativeEnum<
+  typeof ThinkingLevel
+> = z.nativeEnum(ThinkingLevel);
+/** @internal */
+export const ThinkingLevel$outboundSchema: z.ZodNativeEnum<
+  typeof ThinkingLevel
+> = ThinkingLevel$inboundSchema;
+
+/** @internal */
+export const ThinkingConfigEnabledSchema$inboundSchema: z.ZodType<
+  ThinkingConfigEnabledSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("enabled"),
+  budget_tokens: z.number(),
+  thinking_level: ThinkingLevel$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "budget_tokens": "budgetTokens",
+    "thinking_level": "thinkingLevel",
+  });
+});
+/** @internal */
+export type ThinkingConfigEnabledSchema$Outbound = {
+  type: "enabled";
+  budget_tokens: number;
+  thinking_level?: string | undefined;
+};
+
+/** @internal */
+export const ThinkingConfigEnabledSchema$outboundSchema: z.ZodType<
+  ThinkingConfigEnabledSchema$Outbound,
+  z.ZodTypeDef,
+  ThinkingConfigEnabledSchema
+> = z.object({
+  type: z.literal("enabled"),
+  budgetTokens: z.number(),
+  thinkingLevel: ThinkingLevel$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    budgetTokens: "budget_tokens",
+    thinkingLevel: "thinking_level",
+  });
+});
+
+export function thinkingConfigEnabledSchemaToJSON(
+  thinkingConfigEnabledSchema: ThinkingConfigEnabledSchema,
+): string {
+  return JSON.stringify(
+    ThinkingConfigEnabledSchema$outboundSchema.parse(
+      thinkingConfigEnabledSchema,
+    ),
+  );
+}
+export function thinkingConfigEnabledSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<ThinkingConfigEnabledSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ThinkingConfigEnabledSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ThinkingConfigEnabledSchema' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/timeoutstreamingevent.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";
+
+export type TimeoutStreamingEventData = {
+  message: string;
+};
+
+/**
+ * Emitted when the agent stream exceeds the configured timeout duration. Contains a message describing the timeout condition.
+ */
+export type TimeoutStreamingEvent = {
+  type: "agents.timeout";
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: TimeoutStreamingEventData;
+};
+
+/** @internal */
+export const TimeoutStreamingEventData$inboundSchema: z.ZodType<
+  TimeoutStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+});
+
+export function timeoutStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<TimeoutStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TimeoutStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TimeoutStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const TimeoutStreamingEvent$inboundSchema: z.ZodType<
+  TimeoutStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("agents.timeout"),
+  timestamp: z.string(),
+  data: z.lazy(() => TimeoutStreamingEventData$inboundSchema),
+});
+
+export function timeoutStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<TimeoutStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TimeoutStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TimeoutStreamingEvent' from JSON`,
+  );
+}

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

@@ -0,0 +1,51 @@
+/*
+ * 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";
+
+/**
+ * A tool invocation request from an agent. Contains the tool name, unique call ID, and arguments for the tool execution.
+ */
+export type ToolCallPart = {
+  kind: "tool_call";
+  toolName: string;
+  toolCallId: string;
+  arguments: { [k: string]: any };
+  thoughtSignature?: string | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ToolCallPart$inboundSchema: z.ZodType<
+  ToolCallPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: z.literal("tool_call"),
+  tool_name: z.string(),
+  tool_call_id: z.string(),
+  arguments: z.record(z.any()),
+  thought_signature: z.string().optional(),
+  metadata: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_name": "toolName",
+    "tool_call_id": "toolCallId",
+    "thought_signature": "thoughtSignature",
+  });
+});
+
+export function toolCallPartFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolCallPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolCallPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolCallPart' from JSON`,
+  );
+}

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

@@ -0,0 +1,77 @@
+/*
+ * 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 ToolDoneEventData = {
+  /**
+   * Unique identifier for the tool in the tool registry
+   */
+  toolId: string;
+  /**
+   * Unique identifier matching the tool call that was executed
+   */
+  toolCallId: string;
+  /**
+   * The result returned by the tool
+   */
+  result?: any | undefined;
+};
+
+/**
+ * Emitted when a tool completes execution successfully. Contains the tool result.
+ */
+export type ToolDoneEvent = {
+  type: "tool.done";
+  /**
+   * ISO timestamp of when the event occurred
+   */
+  timestamp: string;
+  data: ToolDoneEventData;
+};
+
+/** @internal */
+export const ToolDoneEventData$inboundSchema: z.ZodType<
+  ToolDoneEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  toolId: z.string(),
+  toolCallId: z.string(),
+  result: z.any().optional(),
+});
+
+export function toolDoneEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolDoneEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolDoneEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolDoneEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolDoneEvent$inboundSchema: z.ZodType<
+  ToolDoneEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("tool.done"),
+  timestamp: z.string(),
+  data: z.lazy(() => ToolDoneEventData$inboundSchema),
+});
+
+export function toolDoneEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolDoneEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolDoneEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolDoneEvent' from JSON`,
+  );
+}