@orq-ai/node 4.15.0-rc.21 → 4.15.0-rc.23

package/src/models/components/publicplugin.ts

@@ -19,18 +19,6 @@ export const PublicPluginId = {
  */
 export type PublicPluginId = ClosedEnum<typeof PublicPluginId>;
 
-/**
- * pii_redaction only. Detector language. Defaults to en.
- */
-export const PublicPluginLanguage = {
-  En: "en",
-  Nl: "nl",
-} as const;
-/**
- * pii_redaction only. Detector language. Defaults to en.
- */
-export type PublicPluginLanguage = ClosedEnum<typeof PublicPluginLanguage>;
-
 export const PublicPluginMask = {
   All: "all",
   System: "system",
@@ -55,17 +43,21 @@ export type PublicPluginOnFailure = ClosedEnum<typeof PublicPluginOnFailure>;
 
 export type PublicPlugin = {
   /**
-   * pii_redaction only. Entity types to redact (e.g. EMAIL_ADDRESS, BSN). Omit to redact every type detected for the language.
+   * pii_redaction only. Entity types to redact (e.g. EMAIL_ADDRESS, BSN). Omit to redact every type detected for the language and regions. Cannot be combined with regions.
    */
   entities?: Array<string> | null | undefined;
+  /**
+   * pii_redaction only. Per-entity confidence cutoff overrides in [0,1], keyed by entity type. An override replaces threshold for that type and may sit above or below it. Every key must also appear in entities.
+   */
+  entityThresholds?: { [k: string]: number } | undefined;
   /**
    * Plugin discriminator. pii_redaction redacts PII, response_healing repairs malformed JSON, and trace_scrubbing removes selected sensitive fields from exported traces.
    */
   id: PublicPluginId;
   /**
-   * pii_redaction only. Detector language. Defaults to en.
+   * pii_redaction only. Detector language, or "auto" to detect it per request. Defaults to en. The accepted values are whatever GET /v2/pii/capabilities lists, so they are not enumerated here: a fixed enum would reject a language the detector has since added.
    */
-  language?: PublicPluginLanguage | undefined;
+  language?: string | undefined;
   /**
    * trace_scrubbing only. Trace surfaces to scrub. At least one value required.
    */
@@ -74,6 +66,10 @@ export type PublicPlugin = {
    * pii_redaction only. Behavior when redaction is unavailable. block (default) fails the request; passthrough sends the original text.
    */
   onFailure?: PublicPluginOnFailure | undefined;
+  /**
+   * pii_redaction only. Region codes gating regional recognizers (e.g. nl, gb). ["all"] is exclusive. Omit for base entities only. Cannot be combined with entities.
+   */
+  regions?: Array<string> | null | undefined;
   /**
    * pii_redaction only. Detector confidence cutoff in [0,1].
    */
@@ -85,11 +81,6 @@ export const PublicPluginId$outboundSchema: z.ZodNativeEnum<
   typeof PublicPluginId
 > = z.nativeEnum(PublicPluginId);
 
-/** @internal */
-export const PublicPluginLanguage$outboundSchema: z.ZodNativeEnum<
-  typeof PublicPluginLanguage
-> = z.nativeEnum(PublicPluginLanguage);
-
 /** @internal */
 export const PublicPluginMask$outboundSchema: z.ZodNativeEnum<
   typeof PublicPluginMask
@@ -103,10 +94,12 @@ export const PublicPluginOnFailure$outboundSchema: z.ZodNativeEnum<
 /** @internal */
 export type PublicPlugin$Outbound = {
   entities?: Array<string> | null | undefined;
+  entity_thresholds?: { [k: string]: number } | undefined;
   id: string;
   language?: string | undefined;
   mask?: Array<string> | null | undefined;
   on_failure?: string | undefined;
+  regions?: Array<string> | null | undefined;
   threshold?: number | undefined;
 };
 
@@ -117,13 +110,16 @@ export const PublicPlugin$outboundSchema: z.ZodType<
   PublicPlugin
 > = z.object({
   entities: z.nullable(z.array(z.string())).optional(),
+  entityThresholds: z.record(z.number()).optional(),
   id: PublicPluginId$outboundSchema,
-  language: PublicPluginLanguage$outboundSchema.optional(),
+  language: z.string().optional(),
   mask: z.nullable(z.array(PublicPluginMask$outboundSchema)).optional(),
   onFailure: PublicPluginOnFailure$outboundSchema.optional(),
+  regions: z.nullable(z.array(z.string())).optional(),
   threshold: z.number().optional(),
 }).transform((v) => {
   return remap$(v, {
+    entityThresholds: "entity_thresholds",
     onFailure: "on_failure",
   });
 });

package/src/models/components/publicresponseresource.ts

@@ -17,6 +17,10 @@ import {
   IncompleteDetails$inboundSchema,
 } from "./incompletedetails.js";
 import { MemoryParam, MemoryParam$inboundSchema } from "./memoryparam.js";
+import {
+  OpenAIPromptCacheOptions,
+  OpenAIPromptCacheOptions$inboundSchema,
+} from "./openaipromptcacheoptions.js";
 import { PublicUsage, PublicUsage$inboundSchema } from "./publicusage.js";
 import { Reasoning, Reasoning$inboundSchema } from "./reasoning.js";
 import { ResponseError, ResponseError$inboundSchema } from "./responseerror.js";
@@ -86,6 +90,7 @@ export type PublicResponseResource = {
   presencePenalty: number;
   previousResponseId: string | null;
   promptCacheKey: string | null;
+  promptCacheOptions: OpenAIPromptCacheOptions | null;
   promptCacheRetention: string | null;
   reasoning: Reasoning | null;
   safetyIdentifier: string | null;
@@ -158,6 +163,7 @@ export const PublicResponseResource$inboundSchema: z.ZodType<
   presence_penalty: z.number(),
   previous_response_id: z.nullable(z.string()),
   prompt_cache_key: z.nullable(z.string()),
+  prompt_cache_options: z.nullable(OpenAIPromptCacheOptions$inboundSchema),
   prompt_cache_retention: z.nullable(z.string()),
   reasoning: z.nullable(Reasoning$inboundSchema),
   safety_identifier: z.nullable(z.string()),
@@ -188,6 +194,7 @@ export const PublicResponseResource$inboundSchema: z.ZodType<
     "presence_penalty": "presencePenalty",
     "previous_response_id": "previousResponseId",
     "prompt_cache_key": "promptCacheKey",
+    "prompt_cache_options": "promptCacheOptions",
     "prompt_cache_retention": "promptCacheRetention",
     "safety_identifier": "safetyIdentifier",
     "service_tier": "serviceTier",

package/src/models/components/reasoningpart.ts

@@ -40,7 +40,7 @@ export const ReasoningPart$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("reasoning_01m1nq4pk1kaabayp8270qmekq"),
+  _id: z.string().default("reasoning_01m1wjdnxt6cmpgxnfnvwyabjg"),
   metadata: z.record(z.any()).optional(),
   kind: z.literal("reasoning"),
   reasoning: z.string(),

package/src/models/components/redactrequest.ts

@@ -3,11 +3,53 @@
  */
 
 import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
 
 export type RedactRequest = {
   text?: string | undefined;
   language?: string | undefined;
   threshold?: number | undefined;
+  /**
+   * Region codes selecting whole regions of coverage, e.g. "nl", "gb". Every
+   *
+   * @remarks
+   *  entity type those regions cover is included, alongside the base catalog.
+   *  ["all"] is exclusive. Leaving this and `entities` both empty also runs every
+   *  region, so selecting nothing is the widest request rather than the narrowest.
+   *  Empty alongside a non-empty `entities` stays strict. See the capabilities
+   *  endpoint for the region list.
+   *
+   *  Combines with `entities`: the detector unions the two selections, so a
+   *  request carrying both covers the regions plus the named types. Note that
+   *  `entities` only narrows coverage when it travels alone.
+   */
+  regions?: Array<string> | undefined;
+  /**
+   * The entity types to cover. A named type fires even when it belongs to a
+   *
+   * @remarks
+   *  region, so a region's types can be selected individually without naming
+   *  the region. Alone this is a strict allowlist; alongside `regions` it adds
+   *  to the region coverage instead of narrowing it.
+   */
+  entities?: Array<string> | undefined;
+  /**
+   * Per-entity confidence cutoff overrides. An override REPLACES the global
+   *
+   * @remarks
+   *  `threshold` for that type and may sit above or below it: the gateway
+   *  lowers the first-pass floor it sends the detector to the smallest value
+   *  in the map, and every selected type carries its own cutoff, so a
+   *  sub-global override detects MORE of that type without widening the rest.
+   *
+   *  This only tunes confidence; it never changes which types are covered.
+   *  Coverage is decided by `entities` alone, so every key here must also
+   *  appear in `entities` — a key that does not is rejected, as is any key at
+   *  all when `entities` is empty.
+   *
+   *  Declarative [0,1] bound mirrors existing constraint on `threshold`.
+   */
+  entityThresholds?: { [k: string]: number } | undefined;
 };
 
 /** @internal */
@@ -15,6 +57,9 @@ export type RedactRequest$Outbound = {
   text?: string | undefined;
   language?: string | undefined;
   threshold?: number | undefined;
+  regions?: Array<string> | undefined;
+  entities?: Array<string> | undefined;
+  entity_thresholds?: { [k: string]: number } | undefined;
 };
 
 /** @internal */
@@ -26,6 +71,13 @@ export const RedactRequest$outboundSchema: z.ZodType<
   text: z.string().optional(),
   language: z.string().optional(),
   threshold: z.number().optional(),
+  regions: z.array(z.string()).optional(),
+  entities: z.array(z.string()).optional(),
+  entityThresholds: z.record(z.number()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    entityThresholds: "entity_thresholds",
+  });
 });
 
 export function redactRequestToJSON(redactRequest: RedactRequest): string {

package/src/models/components/responsehealingplugin.ts

@@ -4,50 +4,27 @@
 
 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";
 
-/**
- * Plugin discriminator. Must be `response_healing`.
- */
-export const ResponseHealingPluginId = {
-  ResponseHealing: "response_healing",
-} as const;
-/**
- * Plugin discriminator. Must be `response_healing`.
- */
-export type ResponseHealingPluginId = ClosedEnum<
-  typeof ResponseHealingPluginId
->;
-
 export type ResponseHealingPlugin = {
   /**
    * Plugin discriminator. Must be `response_healing`.
    */
-  id: ResponseHealingPluginId;
+  id: "response_healing";
 };
 
-/** @internal */
-export const ResponseHealingPluginId$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseHealingPluginId
-> = z.nativeEnum(ResponseHealingPluginId);
-/** @internal */
-export const ResponseHealingPluginId$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseHealingPluginId
-> = ResponseHealingPluginId$inboundSchema;
-
 /** @internal */
 export const ResponseHealingPlugin$inboundSchema: z.ZodType<
   ResponseHealingPlugin,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: ResponseHealingPluginId$inboundSchema,
+  id: z.literal("response_healing"),
 });
 /** @internal */
 export type ResponseHealingPlugin$Outbound = {
-  id: string;
+  id: "response_healing";
 };
 
 /** @internal */
@@ -56,7 +33,7 @@ export const ResponseHealingPlugin$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ResponseHealingPlugin
 > = z.object({
-  id: ResponseHealingPluginId$outboundSchema,
+  id: z.literal("response_healing"),
 });
 
 export function responseHealingPluginToJSON(

package/src/models/components/routingruleplugin.ts

@@ -13,11 +13,30 @@ export type RoutingRulePlugin = {
    * Plugin discriminator.
    */
   id?: string | undefined;
+  /**
+   * Languages, regions and entity types are checked against the live
+   *
+   * @remarks
+   *  pii-detection capabilities catalog when the rule is saved, not pinned
+   *  here, so a language or region the detector gains becomes writable without
+   *  a proto change.
+   */
   language?: string | undefined;
+  /**
+   * Entity types to redact. Mutually exclusive with regions.
+   */
   entities?: Array<string> | undefined;
   onFailure?: string | undefined;
   threshold?: number | undefined;
   mask?: Array<string> | undefined;
+  /**
+   * Regions of coverage by ISO 3166-1 alpha-2 code, or ["all"]. Mutually exclusive with entities.
+   */
+  regions?: Array<string> | undefined;
+  /**
+   * Per-entity-type confidence cutoff. Every key must also appear in entities.
+   */
+  entityThresholds?: { [k: string]: number } | undefined;
 };
 
 /** @internal */
@@ -32,9 +51,12 @@ export const RoutingRulePlugin$inboundSchema: z.ZodType<
   on_failure: z.string().optional(),
   threshold: z.number().optional(),
   mask: z.array(z.string()).optional(),
+  regions: z.array(z.string()).optional(),
+  entity_thresholds: z.record(z.number()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "on_failure": "onFailure",
+    "entity_thresholds": "entityThresholds",
   });
 });
 /** @internal */
@@ -45,6 +67,8 @@ export type RoutingRulePlugin$Outbound = {
   on_failure?: string | undefined;
   threshold?: number | undefined;
   mask?: Array<string> | undefined;
+  regions?: Array<string> | undefined;
+  entity_thresholds?: { [k: string]: number } | undefined;
 };
 
 /** @internal */
@@ -59,9 +83,12 @@ export const RoutingRulePlugin$outboundSchema: z.ZodType<
   onFailure: z.string().optional(),
   threshold: z.number().optional(),
   mask: z.array(z.string()).optional(),
+  regions: z.array(z.string()).optional(),
+  entityThresholds: z.record(z.number()).optional(),
 }).transform((v) => {
   return remap$(v, {
     onFailure: "on_failure",
+    entityThresholds: "entity_thresholds",
   });
 });
 

package/src/models/components/searchhubitemsresponse.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 { HubSearchHit, HubSearchHit$inboundSchema } from "./hubsearchhit.js";
+
+export type SearchHubItemsResponse = {
+  hits: Array<HubSearchHit>;
+};
+
+/** @internal */
+export const SearchHubItemsResponse$inboundSchema: z.ZodType<
+  SearchHubItemsResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  hits: z.array(HubSearchHit$inboundSchema),
+});
+
+export function searchHubItemsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchHubItemsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchHubItemsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchHubItemsResponse' from JSON`,
+  );
+}

package/src/models/components/sessioninterval.ts

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const SessionInterval = {
+  SessionIntervalUnspecified: "SESSION_INTERVAL_UNSPECIFIED",
+  SessionIntervalAllTime: "SESSION_INTERVAL_ALL_TIME",
+  SessionIntervalLast30Minutes: "SESSION_INTERVAL_LAST_30_MINUTES",
+  SessionIntervalLast1Hour: "SESSION_INTERVAL_LAST_1_HOUR",
+  SessionIntervalLast6Hours: "SESSION_INTERVAL_LAST_6_HOURS",
+  SessionIntervalLast24Hours: "SESSION_INTERVAL_LAST_24_HOURS",
+  SessionIntervalLast3Days: "SESSION_INTERVAL_LAST_3_DAYS",
+  SessionIntervalLast7Days: "SESSION_INTERVAL_LAST_7_DAYS",
+  SessionIntervalLast14Days: "SESSION_INTERVAL_LAST_14_DAYS",
+  SessionIntervalLast1Month: "SESSION_INTERVAL_LAST_1_MONTH",
+  SessionIntervalLast3Months: "SESSION_INTERVAL_LAST_3_MONTHS",
+} as const;
+export type SessionInterval = ClosedEnum<typeof SessionInterval>;
+
+/** @internal */
+export const SessionInterval$outboundSchema: z.ZodNativeEnum<
+  typeof SessionInterval
+> = z.nativeEnum(SessionInterval);

package/src/models/components/textcontentpartschema.ts

@@ -43,7 +43,7 @@ export type TextContentPartSchemaType = ClosedEnum<
  *
  * Defaults to `5m`. Only supported by `Anthropic` Claude models.
  */
-export const Ttl = {
+export const TextContentPartSchemaTtl = {
   Fivem: "5m",
   Oneh: "1h",
 } as const;
@@ -57,7 +57,9 @@ export const Ttl = {
  *
  * Defaults to `5m`. Only supported by `Anthropic` Claude models.
  */
-export type Ttl = ClosedEnum<typeof Ttl>;
+export type TextContentPartSchemaTtl = ClosedEnum<
+  typeof TextContentPartSchemaTtl
+>;
 
 export type CacheControl = {
   /**
@@ -74,7 +76,7 @@ export type CacheControl = {
    *
    * Defaults to `5m`. Only supported by `Anthropic` Claude models.
    */
-  ttl?: Ttl | undefined;
+  ttl?: TextContentPartSchemaTtl | undefined;
 };
 
 /**
@@ -110,10 +112,13 @@ export const TextContentPartSchemaType$outboundSchema: z.ZodNativeEnum<
 > = TextContentPartSchemaType$inboundSchema;
 
 /** @internal */
-export const Ttl$inboundSchema: z.ZodNativeEnum<typeof Ttl> = z.nativeEnum(Ttl);
+export const TextContentPartSchemaTtl$inboundSchema: z.ZodNativeEnum<
+  typeof TextContentPartSchemaTtl
+> = z.nativeEnum(TextContentPartSchemaTtl);
 /** @internal */
-export const Ttl$outboundSchema: z.ZodNativeEnum<typeof Ttl> =
-  Ttl$inboundSchema;
+export const TextContentPartSchemaTtl$outboundSchema: z.ZodNativeEnum<
+  typeof TextContentPartSchemaTtl
+> = TextContentPartSchemaTtl$inboundSchema;
 
 /** @internal */
 export const CacheControl$inboundSchema: z.ZodType<
@@ -122,7 +127,7 @@ export const CacheControl$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   type: TextContentPartSchemaType$inboundSchema,
-  ttl: Ttl$inboundSchema.default("5m"),
+  ttl: TextContentPartSchemaTtl$inboundSchema.default("5m"),
 });
 /** @internal */
 export type CacheControl$Outbound = {
@@ -137,7 +142,7 @@ export const CacheControl$outboundSchema: z.ZodType<
   CacheControl
 > = z.object({
   type: TextContentPartSchemaType$outboundSchema,
-  ttl: Ttl$outboundSchema.default("5m"),
+  ttl: TextContentPartSchemaTtl$outboundSchema.default("5m"),
 });
 
 export function cacheControlToJSON(cacheControl: CacheControl): string {

package/src/models/components/thread.ts

@@ -0,0 +1,101 @@
+/*
+ * 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";
+import { ThreadBilling, ThreadBilling$inboundSchema } from "./threadbilling.js";
+import { ThreadKind, ThreadKind$inboundSchema } from "./threadkind.js";
+import { ThreadUsage, ThreadUsage$inboundSchema } from "./threadusage.js";
+
+export type Thread = {
+  /**
+   * Internal thread record ID.
+   */
+  id: string;
+  /**
+   * Client-provided thread identifier used to group related traces.
+   */
+  externalId: string;
+  /**
+   * Total thread duration in milliseconds.
+   */
+  duration: number;
+  /**
+   * Contact IDs associated with the thread.
+   */
+  contactIds: Array<string>;
+  billing: ThreadBilling;
+  usage: ThreadUsage;
+  /**
+   * Number of traces associated with the thread.
+   */
+  tracesCount: number;
+  /**
+   * Tags used to categorize the thread.
+   */
+  tags: Array<string>;
+  projectId?: string | undefined;
+  startedAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+  /**
+   * Display title. Does not replace external_id and is not used to group traces.
+   */
+  title?: string | undefined;
+  /**
+   * Originating coding assistant or client, such as claude-code, cursor, or codex.
+   */
+  client?: string | undefined;
+  /**
+   * Canonical git repository for a coding-agent thread, such as github.com/org/repo.
+   */
+  repo?: string | undefined;
+  kind?: ThreadKind | undefined;
+};
+
+/** @internal */
+export const Thread$inboundSchema: z.ZodType<Thread, z.ZodTypeDef, unknown> = z
+  .object({
+    _id: z.string(),
+    external_id: z.string(),
+    duration: z.number(),
+    contact_ids: z.array(z.string()),
+    billing: ThreadBilling$inboundSchema,
+    usage: ThreadUsage$inboundSchema,
+    traces_count: z.number().int(),
+    tags: z.array(z.string()),
+    project_id: z.string().optional(),
+    started_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ).optional(),
+    updated_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ).optional(),
+    title: z.string().optional(),
+    client: z.string().optional(),
+    repo: z.string().optional(),
+    kind: ThreadKind$inboundSchema.optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "_id": "id",
+      "external_id": "externalId",
+      "contact_ids": "contactIds",
+      "traces_count": "tracesCount",
+      "project_id": "projectId",
+      "started_at": "startedAt",
+      "updated_at": "updatedAt",
+    });
+  });
+
+export function threadFromJSON(
+  jsonString: string,
+): SafeParseResult<Thread, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Thread$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Thread' from JSON`,
+  );
+}

package/src/models/components/threadbilling.ts

@@ -0,0 +1,68 @@
+/*
+ * 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 ThreadBilling = {
+  inputCost: number;
+  outputCost: number;
+  totalCost: number;
+};
+
+/** @internal */
+export const ThreadBilling$inboundSchema: z.ZodType<
+  ThreadBilling,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  input_cost: z.number(),
+  output_cost: z.number(),
+  total_cost: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "input_cost": "inputCost",
+    "output_cost": "outputCost",
+    "total_cost": "totalCost",
+  });
+});
+/** @internal */
+export type ThreadBilling$Outbound = {
+  input_cost: number;
+  output_cost: number;
+  total_cost: number;
+};
+
+/** @internal */
+export const ThreadBilling$outboundSchema: z.ZodType<
+  ThreadBilling$Outbound,
+  z.ZodTypeDef,
+  ThreadBilling
+> = z.object({
+  inputCost: z.number(),
+  outputCost: z.number(),
+  totalCost: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    inputCost: "input_cost",
+    outputCost: "output_cost",
+    totalCost: "total_cost",
+  });
+});
+
+export function threadBillingToJSON(threadBilling: ThreadBilling): string {
+  return JSON.stringify(ThreadBilling$outboundSchema.parse(threadBilling));
+}
+export function threadBillingFromJSON(
+  jsonString: string,
+): SafeParseResult<ThreadBilling, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ThreadBilling$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ThreadBilling' from JSON`,
+  );
+}