@meetkai/mka1 0.48.25 → 0.48.27

package/src/models/components/promptinjectionguardrail.ts

@@ -3,6 +3,7 @@
  */
 
 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";
@@ -22,6 +23,10 @@ export type PromptInjectionGuardrail = {
    * Whether this guardrail is enabled
    */
   enabled?: boolean | undefined;
+  /**
+   * Also apply this guardrail to model output, not just the request
+   */
+  checkOutput?: boolean | undefined;
   /**
    * Configuration for prompt injection detection guardrail
    */
@@ -36,12 +41,18 @@ export const PromptInjectionGuardrail$inboundSchema: z.ZodType<
 > = z.object({
   mode: z.literal("prompt_injection"),
   enabled: z.boolean().default(true),
+  check_output: z.boolean().optional(),
   config: PromptInjectionConfig$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "check_output": "checkOutput",
+  });
 });
 /** @internal */
 export type PromptInjectionGuardrail$Outbound = {
   mode: "prompt_injection";
   enabled: boolean;
+  check_output?: boolean | undefined;
   config?: PromptInjectionConfig$Outbound | undefined;
 };
 
@@ -53,7 +64,12 @@ export const PromptInjectionGuardrail$outboundSchema: z.ZodType<
 > = z.object({
   mode: z.literal("prompt_injection"),
   enabled: z.boolean().default(true),
+  checkOutput: z.boolean().optional(),
   config: PromptInjectionConfig$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    checkOutput: "check_output",
+  });
 });
 
 export function promptInjectionGuardrailToJSON(

package/src/models/components/putbudgetbody.ts

@@ -0,0 +1,108 @@
+/*
+ * 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 {
+  BudgetLimitKind,
+  BudgetLimitKind$inboundSchema,
+  BudgetLimitKind$outboundSchema,
+} from "./budgetlimitkind.js";
+import {
+  BudgetOwner,
+  BudgetOwner$inboundSchema,
+  BudgetOwner$outboundSchema,
+} from "./budgetowner.js";
+import {
+  BudgetPeriod,
+  BudgetPeriod$inboundSchema,
+  BudgetPeriod$outboundSchema,
+} from "./budgetperiod.js";
+import {
+  BudgetThresholdInput,
+  BudgetThresholdInput$inboundSchema,
+  BudgetThresholdInput$Outbound,
+  BudgetThresholdInput$outboundSchema,
+} from "./budgetthresholdinput.js";
+
+export type PutBudgetBody = {
+  owner?: BudgetOwner | undefined;
+  period: BudgetPeriod;
+  limitKind: BudgetLimitKind;
+  /**
+   * Limit in major units: currency amount for cost, token count for tokens
+   */
+  limit: number;
+  thresholds: Array<BudgetThresholdInput>;
+  webhookUrl?: string | null | undefined;
+  webhookSecret?: string | null | undefined;
+};
+
+/** @internal */
+export const PutBudgetBody$inboundSchema: z.ZodType<
+  PutBudgetBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  owner: BudgetOwner$inboundSchema.optional(),
+  period: BudgetPeriod$inboundSchema,
+  limit_kind: BudgetLimitKind$inboundSchema,
+  limit: z.number(),
+  thresholds: z.array(BudgetThresholdInput$inboundSchema),
+  webhook_url: z.nullable(z.string()).optional(),
+  webhook_secret: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "limit_kind": "limitKind",
+    "webhook_url": "webhookUrl",
+    "webhook_secret": "webhookSecret",
+  });
+});
+/** @internal */
+export type PutBudgetBody$Outbound = {
+  owner?: string | undefined;
+  period: string;
+  limit_kind: string;
+  limit: number;
+  thresholds: Array<BudgetThresholdInput$Outbound>;
+  webhook_url?: string | null | undefined;
+  webhook_secret?: string | null | undefined;
+};
+
+/** @internal */
+export const PutBudgetBody$outboundSchema: z.ZodType<
+  PutBudgetBody$Outbound,
+  z.ZodTypeDef,
+  PutBudgetBody
+> = z.object({
+  owner: BudgetOwner$outboundSchema.optional(),
+  period: BudgetPeriod$outboundSchema,
+  limitKind: BudgetLimitKind$outboundSchema,
+  limit: z.number(),
+  thresholds: z.array(BudgetThresholdInput$outboundSchema),
+  webhookUrl: z.nullable(z.string()).optional(),
+  webhookSecret: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    limitKind: "limit_kind",
+    webhookUrl: "webhook_url",
+    webhookSecret: "webhook_secret",
+  });
+});
+
+export function putBudgetBodyToJSON(putBudgetBody: PutBudgetBody): string {
+  return JSON.stringify(PutBudgetBody$outboundSchema.parse(putBudgetBody));
+}
+export function putBudgetBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PutBudgetBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PutBudgetBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PutBudgetBody' from JSON`,
+  );
+}

package/src/models/components/putclustercurrencybody.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 PutClusterCurrencyBody = {
+  currency: string;
+};
+
+/** @internal */
+export const PutClusterCurrencyBody$inboundSchema: z.ZodType<
+  PutClusterCurrencyBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  currency: z.string(),
+});
+/** @internal */
+export type PutClusterCurrencyBody$Outbound = {
+  currency: string;
+};
+
+/** @internal */
+export const PutClusterCurrencyBody$outboundSchema: z.ZodType<
+  PutClusterCurrencyBody$Outbound,
+  z.ZodTypeDef,
+  PutClusterCurrencyBody
+> = z.object({
+  currency: z.string(),
+});
+
+export function putClusterCurrencyBodyToJSON(
+  putClusterCurrencyBody: PutClusterCurrencyBody,
+): string {
+  return JSON.stringify(
+    PutClusterCurrencyBody$outboundSchema.parse(putClusterCurrencyBody),
+  );
+}
+export function putClusterCurrencyBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PutClusterCurrencyBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PutClusterCurrencyBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PutClusterCurrencyBody' from JSON`,
+  );
+}

package/src/models/components/putmodelpricebody.ts

@@ -0,0 +1,147 @@
+/*
+ * 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 PutModelPriceBodyRates = {
+  inputTokens?: number | undefined;
+  outputTokens?: number | undefined;
+  cachedTokens?: number | undefined;
+  reasoningTokens?: number | undefined;
+  characters?: number | undefined;
+  seconds?: number | undefined;
+  image?: number | undefined;
+  imageTiers?: { [k: string]: number } | undefined;
+  searches?: number | undefined;
+};
+
+export type PutModelPriceBody = {
+  model: string;
+  rates: PutModelPriceBodyRates;
+};
+
+/** @internal */
+export const PutModelPriceBodyRates$inboundSchema: z.ZodType<
+  PutModelPriceBodyRates,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  input_tokens: z.number().optional(),
+  output_tokens: z.number().optional(),
+  cached_tokens: z.number().optional(),
+  reasoning_tokens: z.number().optional(),
+  characters: z.number().optional(),
+  seconds: z.number().optional(),
+  image: z.number().optional(),
+  image_tiers: z.record(z.number()).optional(),
+  searches: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "input_tokens": "inputTokens",
+    "output_tokens": "outputTokens",
+    "cached_tokens": "cachedTokens",
+    "reasoning_tokens": "reasoningTokens",
+    "image_tiers": "imageTiers",
+  });
+});
+/** @internal */
+export type PutModelPriceBodyRates$Outbound = {
+  input_tokens?: number | undefined;
+  output_tokens?: number | undefined;
+  cached_tokens?: number | undefined;
+  reasoning_tokens?: number | undefined;
+  characters?: number | undefined;
+  seconds?: number | undefined;
+  image?: number | undefined;
+  image_tiers?: { [k: string]: number } | undefined;
+  searches?: number | undefined;
+};
+
+/** @internal */
+export const PutModelPriceBodyRates$outboundSchema: z.ZodType<
+  PutModelPriceBodyRates$Outbound,
+  z.ZodTypeDef,
+  PutModelPriceBodyRates
+> = z.object({
+  inputTokens: z.number().optional(),
+  outputTokens: z.number().optional(),
+  cachedTokens: z.number().optional(),
+  reasoningTokens: z.number().optional(),
+  characters: z.number().optional(),
+  seconds: z.number().optional(),
+  image: z.number().optional(),
+  imageTiers: z.record(z.number()).optional(),
+  searches: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    inputTokens: "input_tokens",
+    outputTokens: "output_tokens",
+    cachedTokens: "cached_tokens",
+    reasoningTokens: "reasoning_tokens",
+    imageTiers: "image_tiers",
+  });
+});
+
+export function putModelPriceBodyRatesToJSON(
+  putModelPriceBodyRates: PutModelPriceBodyRates,
+): string {
+  return JSON.stringify(
+    PutModelPriceBodyRates$outboundSchema.parse(putModelPriceBodyRates),
+  );
+}
+export function putModelPriceBodyRatesFromJSON(
+  jsonString: string,
+): SafeParseResult<PutModelPriceBodyRates, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PutModelPriceBodyRates$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PutModelPriceBodyRates' from JSON`,
+  );
+}
+
+/** @internal */
+export const PutModelPriceBody$inboundSchema: z.ZodType<
+  PutModelPriceBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.string(),
+  rates: z.lazy(() => PutModelPriceBodyRates$inboundSchema),
+});
+/** @internal */
+export type PutModelPriceBody$Outbound = {
+  model: string;
+  rates: PutModelPriceBodyRates$Outbound;
+};
+
+/** @internal */
+export const PutModelPriceBody$outboundSchema: z.ZodType<
+  PutModelPriceBody$Outbound,
+  z.ZodTypeDef,
+  PutModelPriceBody
+> = z.object({
+  model: z.string(),
+  rates: z.lazy(() => PutModelPriceBodyRates$outboundSchema),
+});
+
+export function putModelPriceBodyToJSON(
+  putModelPriceBody: PutModelPriceBody,
+): string {
+  return JSON.stringify(
+    PutModelPriceBody$outboundSchema.parse(putModelPriceBody),
+  );
+}
+export function putModelPriceBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PutModelPriceBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PutModelPriceBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PutModelPriceBody' from JSON`,
+  );
+}

package/src/models/components/spendgauge.ts

@@ -0,0 +1,102 @@
+/*
+ * 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";
+
+export const SpendGaugeStatus = {
+  Ok: "ok",
+  Blocked: "blocked",
+} as const;
+export type SpendGaugeStatus = ClosedEnum<typeof SpendGaugeStatus>;
+
+export type SpendGauge = {
+  window: string;
+  /**
+   * Spend in integer NANO-units (1e9 per major currency unit, NOT cents); use `cost_spent` for the major amount.
+   */
+  costSpentNano: string;
+  /**
+   * Spend in major currency units (e.g. dollars)
+   */
+  costSpent: number;
+  tokensSpent: string;
+  pct: number;
+  status: SpendGaugeStatus;
+};
+
+/** @internal */
+export const SpendGaugeStatus$inboundSchema: z.ZodNativeEnum<
+  typeof SpendGaugeStatus
+> = z.nativeEnum(SpendGaugeStatus);
+/** @internal */
+export const SpendGaugeStatus$outboundSchema: z.ZodNativeEnum<
+  typeof SpendGaugeStatus
+> = SpendGaugeStatus$inboundSchema;
+
+/** @internal */
+export const SpendGauge$inboundSchema: z.ZodType<
+  SpendGauge,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  window: z.string(),
+  cost_spent_nano: z.string(),
+  cost_spent: z.number(),
+  tokens_spent: z.string(),
+  pct: z.number(),
+  status: SpendGaugeStatus$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "cost_spent_nano": "costSpentNano",
+    "cost_spent": "costSpent",
+    "tokens_spent": "tokensSpent",
+  });
+});
+/** @internal */
+export type SpendGauge$Outbound = {
+  window: string;
+  cost_spent_nano: string;
+  cost_spent: number;
+  tokens_spent: string;
+  pct: number;
+  status: string;
+};
+
+/** @internal */
+export const SpendGauge$outboundSchema: z.ZodType<
+  SpendGauge$Outbound,
+  z.ZodTypeDef,
+  SpendGauge
+> = z.object({
+  window: z.string(),
+  costSpentNano: z.string(),
+  costSpent: z.number(),
+  tokensSpent: z.string(),
+  pct: z.number(),
+  status: SpendGaugeStatus$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    costSpentNano: "cost_spent_nano",
+    costSpent: "cost_spent",
+    tokensSpent: "tokens_spent",
+  });
+});
+
+export function spendGaugeToJSON(spendGauge: SpendGauge): string {
+  return JSON.stringify(SpendGauge$outboundSchema.parse(spendGauge));
+}
+export function spendGaugeFromJSON(
+  jsonString: string,
+): SafeParseResult<SpendGauge, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SpendGauge$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SpendGauge' from JSON`,
+  );
+}

package/src/models/components/usagecostsresponse.ts

@@ -0,0 +1,110 @@
+/*
+ * 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 {
+  CostGroupRow,
+  CostGroupRow$inboundSchema,
+  CostGroupRow$Outbound,
+  CostGroupRow$outboundSchema,
+} from "./costgrouprow.js";
+import {
+  CostsUsageGroupBy,
+  CostsUsageGroupBy$inboundSchema,
+  CostsUsageGroupBy$outboundSchema,
+} from "./costsusagegroupby.js";
+
+export type UsageCostsResponse = {
+  object: "usage.costs";
+  currency: string | null;
+  startTime: number;
+  endTime: number;
+  groupBy: Array<CostsUsageGroupBy>;
+  data: Array<CostGroupRow>;
+  totalCost: number;
+  /**
+   * Total cost in integer NANO-units (1e9 per major unit, NOT cents); use `total_cost` for the major amount.
+   */
+  totalCostNano: string;
+};
+
+/** @internal */
+export const UsageCostsResponse$inboundSchema: z.ZodType<
+  UsageCostsResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: z.literal("usage.costs"),
+  currency: z.nullable(z.string()),
+  start_time: z.number().int(),
+  end_time: z.number().int(),
+  group_by: z.array(CostsUsageGroupBy$inboundSchema),
+  data: z.array(CostGroupRow$inboundSchema),
+  total_cost: z.number(),
+  total_cost_nano: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "start_time": "startTime",
+    "end_time": "endTime",
+    "group_by": "groupBy",
+    "total_cost": "totalCost",
+    "total_cost_nano": "totalCostNano",
+  });
+});
+/** @internal */
+export type UsageCostsResponse$Outbound = {
+  object: "usage.costs";
+  currency: string | null;
+  start_time: number;
+  end_time: number;
+  group_by: Array<string>;
+  data: Array<CostGroupRow$Outbound>;
+  total_cost: number;
+  total_cost_nano: string;
+};
+
+/** @internal */
+export const UsageCostsResponse$outboundSchema: z.ZodType<
+  UsageCostsResponse$Outbound,
+  z.ZodTypeDef,
+  UsageCostsResponse
+> = z.object({
+  object: z.literal("usage.costs"),
+  currency: z.nullable(z.string()),
+  startTime: z.number().int(),
+  endTime: z.number().int(),
+  groupBy: z.array(CostsUsageGroupBy$outboundSchema),
+  data: z.array(CostGroupRow$outboundSchema),
+  totalCost: z.number(),
+  totalCostNano: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    startTime: "start_time",
+    endTime: "end_time",
+    groupBy: "group_by",
+    totalCost: "total_cost",
+    totalCostNano: "total_cost_nano",
+  });
+});
+
+export function usageCostsResponseToJSON(
+  usageCostsResponse: UsageCostsResponse,
+): string {
+  return JSON.stringify(
+    UsageCostsResponse$outboundSchema.parse(usageCostsResponse),
+  );
+}
+export function usageCostsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<UsageCostsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UsageCostsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UsageCostsResponse' from JSON`,
+  );
+}

package/src/models/operations/clearclusterprice.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 ClearClusterPriceRequest = {
+  model: string;
+};
+
+/** @internal */
+export const ClearClusterPriceRequest$inboundSchema: z.ZodType<
+  ClearClusterPriceRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.string(),
+});
+/** @internal */
+export type ClearClusterPriceRequest$Outbound = {
+  model: string;
+};
+
+/** @internal */
+export const ClearClusterPriceRequest$outboundSchema: z.ZodType<
+  ClearClusterPriceRequest$Outbound,
+  z.ZodTypeDef,
+  ClearClusterPriceRequest
+> = z.object({
+  model: z.string(),
+});
+
+export function clearClusterPriceRequestToJSON(
+  clearClusterPriceRequest: ClearClusterPriceRequest,
+): string {
+  return JSON.stringify(
+    ClearClusterPriceRequest$outboundSchema.parse(clearClusterPriceRequest),
+  );
+}
+export function clearClusterPriceRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ClearClusterPriceRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ClearClusterPriceRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ClearClusterPriceRequest' from JSON`,
+  );
+}

package/src/models/operations/clearorgprice.ts

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