@orq-ai/node 4.10.0-rc.88 → 4.10.0

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

@@ -0,0 +1,48 @@
+/*
+ * 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";
+
+/**
+ * Telemetry information for correlating the response with traces
+ */
+export type Telemetry = {
+  /**
+   * The root trace ID for the agent execution
+   */
+  traceId: string;
+  /**
+   * The span ID of the agent execution within the trace
+   */
+  spanId: string;
+};
+
+/** @internal */
+export const Telemetry$inboundSchema: z.ZodType<
+  Telemetry,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  trace_id: z.string(),
+  span_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "trace_id": "traceId",
+    "span_id": "spanId",
+  });
+});
+
+export function telemetryFromJSON(
+  jsonString: string,
+): SafeParseResult<Telemetry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Telemetry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Telemetry' from JSON`,
+  );
+}

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/thinkingconfigadaptiveschema.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";
+
+/**
+ * Enables adaptive thinking mode where the model dynamically determines thinking depth
+ */
+export type ThinkingConfigAdaptiveSchema = {
+  /**
+   * Lets the model dynamically determine when and how much to use extended thinking based on the complexity of each request. Supported on Claude Opus 4.6 and Sonnet 4.6.
+   */
+  type: "adaptive";
+};
+
+/** @internal */
+export const ThinkingConfigAdaptiveSchema$inboundSchema: z.ZodType<
+  ThinkingConfigAdaptiveSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("adaptive"),
+});
+/** @internal */
+export type ThinkingConfigAdaptiveSchema$Outbound = {
+  type: "adaptive";
+};
+
+/** @internal */
+export const ThinkingConfigAdaptiveSchema$outboundSchema: z.ZodType<
+  ThinkingConfigAdaptiveSchema$Outbound,
+  z.ZodTypeDef,
+  ThinkingConfigAdaptiveSchema
+> = z.object({
+  type: z.literal("adaptive"),
+});
+
+export function thinkingConfigAdaptiveSchemaToJSON(
+  thinkingConfigAdaptiveSchema: ThinkingConfigAdaptiveSchema,
+): string {
+  return JSON.stringify(
+    ThinkingConfigAdaptiveSchema$outboundSchema.parse(
+      thinkingConfigAdaptiveSchema,
+    ),
+  );
+}
+export function thinkingConfigAdaptiveSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<ThinkingConfigAdaptiveSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ThinkingConfigAdaptiveSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ThinkingConfigAdaptiveSchema' 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,107 @@
+/*
+ * 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",
+  Medium: "medium",
+  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/tokenlimit.ts

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