@meetkai/mka1 0.49.14 → 0.49.16

package/src/models/components/agentrunmcpapproval.ts

@@ -0,0 +1,103 @@
+/*
+ * 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 {
+  AgentRun,
+  AgentRun$inboundSchema,
+  AgentRun$Outbound,
+  AgentRun$outboundSchema,
+} from "./agentrun.js";
+
+export const AgentRunMcpApprovalObject = {
+  AgentRunMcpApproval: "agent.run.mcp_approval",
+} as const;
+export type AgentRunMcpApprovalObject = ClosedEnum<
+  typeof AgentRunMcpApprovalObject
+>;
+
+export type AgentRunMcpApproval = {
+  object: AgentRunMcpApprovalObject;
+  approvalRequestId: string;
+  approved: boolean;
+  sourceRunId: string;
+  continuationRun: AgentRun;
+};
+
+/** @internal */
+export const AgentRunMcpApprovalObject$inboundSchema: z.ZodNativeEnum<
+  typeof AgentRunMcpApprovalObject
+> = z.nativeEnum(AgentRunMcpApprovalObject);
+/** @internal */
+export const AgentRunMcpApprovalObject$outboundSchema: z.ZodNativeEnum<
+  typeof AgentRunMcpApprovalObject
+> = AgentRunMcpApprovalObject$inboundSchema;
+
+/** @internal */
+export const AgentRunMcpApproval$inboundSchema: z.ZodType<
+  AgentRunMcpApproval,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: AgentRunMcpApprovalObject$inboundSchema,
+  approval_request_id: z.string(),
+  approved: z.boolean(),
+  source_run_id: z.string(),
+  continuation_run: AgentRun$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "approval_request_id": "approvalRequestId",
+    "source_run_id": "sourceRunId",
+    "continuation_run": "continuationRun",
+  });
+});
+/** @internal */
+export type AgentRunMcpApproval$Outbound = {
+  object: string;
+  approval_request_id: string;
+  approved: boolean;
+  source_run_id: string;
+  continuation_run: AgentRun$Outbound;
+};
+
+/** @internal */
+export const AgentRunMcpApproval$outboundSchema: z.ZodType<
+  AgentRunMcpApproval$Outbound,
+  z.ZodTypeDef,
+  AgentRunMcpApproval
+> = z.object({
+  object: AgentRunMcpApprovalObject$outboundSchema,
+  approvalRequestId: z.string(),
+  approved: z.boolean(),
+  sourceRunId: z.string(),
+  continuationRun: AgentRun$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    approvalRequestId: "approval_request_id",
+    sourceRunId: "source_run_id",
+    continuationRun: "continuation_run",
+  });
+});
+
+export function agentRunMcpApprovalToJSON(
+  agentRunMcpApproval: AgentRunMcpApproval,
+): string {
+  return JSON.stringify(
+    AgentRunMcpApproval$outboundSchema.parse(agentRunMcpApproval),
+  );
+}
+export function agentRunMcpApprovalFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentRunMcpApproval, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentRunMcpApproval$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentRunMcpApproval' from JSON`,
+  );
+}

package/src/models/components/catalogactivationstate.ts

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const CatalogActivationState = {
+  Active: "active",
+  Available: "available",
+  AvailableNameBlocked: "available_name_blocked",
+} as const;
+export type CatalogActivationState = ClosedEnum<typeof CatalogActivationState>;
+
+/** @internal */
+export const CatalogActivationState$inboundSchema: z.ZodNativeEnum<
+  typeof CatalogActivationState
+> = z.nativeEnum(CatalogActivationState);
+/** @internal */
+export const CatalogActivationState$outboundSchema: z.ZodNativeEnum<
+  typeof CatalogActivationState
+> = CatalogActivationState$inboundSchema;

package/src/models/components/catalogentry.ts

@@ -0,0 +1,153 @@
+/*
+ * 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 {
+  CatalogActivationState,
+  CatalogActivationState$inboundSchema,
+  CatalogActivationState$outboundSchema,
+} from "./catalogactivationstate.js";
+import {
+  CatalogHealth,
+  CatalogHealth$inboundSchema,
+  CatalogHealth$Outbound,
+  CatalogHealth$outboundSchema,
+} from "./cataloghealth.js";
+import {
+  CatalogPricePreview,
+  CatalogPricePreview$inboundSchema,
+  CatalogPricePreview$Outbound,
+  CatalogPricePreview$outboundSchema,
+} from "./catalogpricepreview.js";
+import {
+  RegistryModelOrigin,
+  RegistryModelOrigin$inboundSchema,
+  RegistryModelOrigin$outboundSchema,
+} from "./registrymodelorigin.js";
+import {
+  RegistrySource,
+  RegistrySource$inboundSchema,
+  RegistrySource$outboundSchema,
+} from "./registrysource.js";
+
+export type CatalogEntry = {
+  modelId: string;
+  source: RegistrySource;
+  origin: RegistryModelOrigin | null;
+  activationState: CatalogActivationState;
+  blockerSource: RegistrySource | null;
+  activatedBy: string | null;
+  activatedAt: Date | null;
+  provider: string;
+  providerModelId: string;
+  definition: { [k: string]: any };
+  health: CatalogHealth;
+  createdAt: number | null;
+  updatedAt: number | null;
+  effectivePrice: CatalogPricePreview;
+};
+
+/** @internal */
+export const CatalogEntry$inboundSchema: z.ZodType<
+  CatalogEntry,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model_id: z.string(),
+  source: RegistrySource$inboundSchema,
+  origin: z.nullable(RegistryModelOrigin$inboundSchema),
+  activation_state: CatalogActivationState$inboundSchema,
+  blocker_source: z.nullable(RegistrySource$inboundSchema),
+  activated_by: z.nullable(z.string()),
+  activated_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+  provider: z.string(),
+  provider_model_id: z.string(),
+  definition: z.record(z.any()),
+  health: CatalogHealth$inboundSchema,
+  created_at: z.nullable(z.number()),
+  updated_at: z.nullable(z.number()),
+  effective_price: CatalogPricePreview$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "model_id": "modelId",
+    "activation_state": "activationState",
+    "blocker_source": "blockerSource",
+    "activated_by": "activatedBy",
+    "activated_at": "activatedAt",
+    "provider_model_id": "providerModelId",
+    "created_at": "createdAt",
+    "updated_at": "updatedAt",
+    "effective_price": "effectivePrice",
+  });
+});
+/** @internal */
+export type CatalogEntry$Outbound = {
+  model_id: string;
+  source: string;
+  origin: string | null;
+  activation_state: string;
+  blocker_source: string | null;
+  activated_by: string | null;
+  activated_at: string | null;
+  provider: string;
+  provider_model_id: string;
+  definition: { [k: string]: any };
+  health: CatalogHealth$Outbound;
+  created_at: number | null;
+  updated_at: number | null;
+  effective_price: CatalogPricePreview$Outbound;
+};
+
+/** @internal */
+export const CatalogEntry$outboundSchema: z.ZodType<
+  CatalogEntry$Outbound,
+  z.ZodTypeDef,
+  CatalogEntry
+> = z.object({
+  modelId: z.string(),
+  source: RegistrySource$outboundSchema,
+  origin: z.nullable(RegistryModelOrigin$outboundSchema),
+  activationState: CatalogActivationState$outboundSchema,
+  blockerSource: z.nullable(RegistrySource$outboundSchema),
+  activatedBy: z.nullable(z.string()),
+  activatedAt: z.nullable(z.date().transform(v => v.toISOString())),
+  provider: z.string(),
+  providerModelId: z.string(),
+  definition: z.record(z.any()),
+  health: CatalogHealth$outboundSchema,
+  createdAt: z.nullable(z.number()),
+  updatedAt: z.nullable(z.number()),
+  effectivePrice: CatalogPricePreview$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    modelId: "model_id",
+    activationState: "activation_state",
+    blockerSource: "blocker_source",
+    activatedBy: "activated_by",
+    activatedAt: "activated_at",
+    providerModelId: "provider_model_id",
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+    effectivePrice: "effective_price",
+  });
+});
+
+export function catalogEntryToJSON(catalogEntry: CatalogEntry): string {
+  return JSON.stringify(CatalogEntry$outboundSchema.parse(catalogEntry));
+}
+export function catalogEntryFromJSON(
+  jsonString: string,
+): SafeParseResult<CatalogEntry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CatalogEntry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CatalogEntry' from JSON`,
+  );
+}

package/src/models/components/cataloghealth.ts

@@ -0,0 +1,66 @@
+/*
+ * 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 CatalogHealth = {
+  isAvailable: boolean;
+  lastHealthCheck: number | null;
+  error: string | null;
+};
+
+/** @internal */
+export const CatalogHealth$inboundSchema: z.ZodType<
+  CatalogHealth,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  is_available: z.boolean(),
+  last_health_check: z.nullable(z.number()),
+  error: z.nullable(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "is_available": "isAvailable",
+    "last_health_check": "lastHealthCheck",
+  });
+});
+/** @internal */
+export type CatalogHealth$Outbound = {
+  is_available: boolean;
+  last_health_check: number | null;
+  error: string | null;
+};
+
+/** @internal */
+export const CatalogHealth$outboundSchema: z.ZodType<
+  CatalogHealth$Outbound,
+  z.ZodTypeDef,
+  CatalogHealth
+> = z.object({
+  isAvailable: z.boolean(),
+  lastHealthCheck: z.nullable(z.number()),
+  error: z.nullable(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    isAvailable: "is_available",
+    lastHealthCheck: "last_health_check",
+  });
+});
+
+export function catalogHealthToJSON(catalogHealth: CatalogHealth): string {
+  return JSON.stringify(CatalogHealth$outboundSchema.parse(catalogHealth));
+}
+export function catalogHealthFromJSON(
+  jsonString: string,
+): SafeParseResult<CatalogHealth, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CatalogHealth$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CatalogHealth' from JSON`,
+  );
+}

package/src/models/components/cataloghealthresponse.ts

@@ -0,0 +1,70 @@
+/*
+ * 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 CatalogHealthResponse = {
+  isAvailable: boolean;
+  error?: string | undefined;
+  checkedAt: number;
+};
+
+/** @internal */
+export const CatalogHealthResponse$inboundSchema: z.ZodType<
+  CatalogHealthResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  is_available: z.boolean(),
+  error: z.string().optional(),
+  checked_at: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "is_available": "isAvailable",
+    "checked_at": "checkedAt",
+  });
+});
+/** @internal */
+export type CatalogHealthResponse$Outbound = {
+  is_available: boolean;
+  error?: string | undefined;
+  checked_at: number;
+};
+
+/** @internal */
+export const CatalogHealthResponse$outboundSchema: z.ZodType<
+  CatalogHealthResponse$Outbound,
+  z.ZodTypeDef,
+  CatalogHealthResponse
+> = z.object({
+  isAvailable: z.boolean(),
+  error: z.string().optional(),
+  checkedAt: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    isAvailable: "is_available",
+    checkedAt: "checked_at",
+  });
+});
+
+export function catalogHealthResponseToJSON(
+  catalogHealthResponse: CatalogHealthResponse,
+): string {
+  return JSON.stringify(
+    CatalogHealthResponse$outboundSchema.parse(catalogHealthResponse),
+  );
+}
+export function catalogHealthResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CatalogHealthResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CatalogHealthResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CatalogHealthResponse' from JSON`,
+  );
+}

package/src/models/components/cataloglistresponse.ts

@@ -0,0 +1,65 @@
+/*
+ * 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 {
+  CatalogEntry,
+  CatalogEntry$inboundSchema,
+  CatalogEntry$Outbound,
+  CatalogEntry$outboundSchema,
+} from "./catalogentry.js";
+
+export type CatalogListResponse = {
+  object: "list";
+  currency: string | null;
+  data: Array<CatalogEntry>;
+};
+
+/** @internal */
+export const CatalogListResponse$inboundSchema: z.ZodType<
+  CatalogListResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: z.literal("list"),
+  currency: z.nullable(z.string()),
+  data: z.array(CatalogEntry$inboundSchema),
+});
+/** @internal */
+export type CatalogListResponse$Outbound = {
+  object: "list";
+  currency: string | null;
+  data: Array<CatalogEntry$Outbound>;
+};
+
+/** @internal */
+export const CatalogListResponse$outboundSchema: z.ZodType<
+  CatalogListResponse$Outbound,
+  z.ZodTypeDef,
+  CatalogListResponse
+> = z.object({
+  object: z.literal("list"),
+  currency: z.nullable(z.string()),
+  data: z.array(CatalogEntry$outboundSchema),
+});
+
+export function catalogListResponseToJSON(
+  catalogListResponse: CatalogListResponse,
+): string {
+  return JSON.stringify(
+    CatalogListResponse$outboundSchema.parse(catalogListResponse),
+  );
+}
+export function catalogListResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CatalogListResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CatalogListResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CatalogListResponse' from JSON`,
+  );
+}

package/src/models/components/catalogpricepreview.ts

@@ -0,0 +1,159 @@
+/*
+ * 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 type Rates = {
+  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 const CatalogPricePreviewSource = {
+  OrgOverride: "org_override",
+  ClusterDefault: "cluster_default",
+  Unpriced: "unpriced",
+} as const;
+export type CatalogPricePreviewSource = ClosedEnum<
+  typeof CatalogPricePreviewSource
+>;
+
+export type CatalogPricePreview = {
+  rates: Rates | null;
+  source: CatalogPricePreviewSource;
+};
+
+/** @internal */
+export const Rates$inboundSchema: z.ZodType<Rates, 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 Rates$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 Rates$outboundSchema: z.ZodType<
+  Rates$Outbound,
+  z.ZodTypeDef,
+  Rates
+> = 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 ratesToJSON(rates: Rates): string {
+  return JSON.stringify(Rates$outboundSchema.parse(rates));
+}
+export function ratesFromJSON(
+  jsonString: string,
+): SafeParseResult<Rates, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Rates$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Rates' from JSON`,
+  );
+}
+
+/** @internal */
+export const CatalogPricePreviewSource$inboundSchema: z.ZodNativeEnum<
+  typeof CatalogPricePreviewSource
+> = z.nativeEnum(CatalogPricePreviewSource);
+/** @internal */
+export const CatalogPricePreviewSource$outboundSchema: z.ZodNativeEnum<
+  typeof CatalogPricePreviewSource
+> = CatalogPricePreviewSource$inboundSchema;
+
+/** @internal */
+export const CatalogPricePreview$inboundSchema: z.ZodType<
+  CatalogPricePreview,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  rates: z.nullable(z.lazy(() => Rates$inboundSchema)),
+  source: CatalogPricePreviewSource$inboundSchema,
+});
+/** @internal */
+export type CatalogPricePreview$Outbound = {
+  rates: Rates$Outbound | null;
+  source: string;
+};
+
+/** @internal */
+export const CatalogPricePreview$outboundSchema: z.ZodType<
+  CatalogPricePreview$Outbound,
+  z.ZodTypeDef,
+  CatalogPricePreview
+> = z.object({
+  rates: z.nullable(z.lazy(() => Rates$outboundSchema)),
+  source: CatalogPricePreviewSource$outboundSchema,
+});
+
+export function catalogPricePreviewToJSON(
+  catalogPricePreview: CatalogPricePreview,
+): string {
+  return JSON.stringify(
+    CatalogPricePreview$outboundSchema.parse(catalogPricePreview),
+  );
+}
+export function catalogPricePreviewFromJSON(
+  jsonString: string,
+): SafeParseResult<CatalogPricePreview, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CatalogPricePreview$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CatalogPricePreview' from JSON`,
+  );
+}

package/src/models/components/deactivateregistryentryresponse.ts

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