@meetkai/mka1 0.54.32 → 0.54.34

package/src/models/operations/listmodels.ts

@@ -7,6 +7,7 @@ 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 { RFCDate } from "../../types/rfcdate.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type ListModelsRequest = {
@@ -53,6 +54,18 @@ export type ListModelsData = {
    * Modalities this model can produce, mirroring the registry's `capabilities.modalities.output`. Unconstrained strings rather than a closed enum so a new registry modality reaches clients without a breaking schema change.
    */
   outputModalities: Array<string>;
+  /**
+   * Total parameter count of the weights behind this model, mirroring the registry's `modelCard.parameterCount`. Null when the registry does not record one (closed-weight API models, or entries nobody has filled in yet).
+   */
+  parameterCount: number | null;
+  /**
+   * Parameters active per token for mixture-of-experts models, mirroring the registry's `modelCard.activeParameterCount`. Null for dense models and whenever unrecorded.
+   */
+  activeParameterCount: number | null;
+  /**
+   * Public release date of the model as an ISO calendar date (YYYY-MM-DD), mirroring the registry's `modelCard.releaseDate`. Null when unrecorded.
+   */
+  releaseDate: RFCDate | null;
   /**
    * Curated public sampling capabilities for this model.
    */
@@ -188,6 +201,9 @@ export const ListModelsData$inboundSchema: z.ZodType<
   model_type: ListModelsModelType$inboundSchema,
   input_modalities: z.array(z.string()),
   output_modalities: z.array(z.string()),
+  parameter_count: z.nullable(z.number().int()),
+  active_parameter_count: z.nullable(z.number().int()),
+  release_date: z.nullable(z.string().transform(v => new RFCDate(v))),
   capabilities: z.lazy(() => ListModelsCapabilities$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
@@ -195,6 +211,9 @@ export const ListModelsData$inboundSchema: z.ZodType<
     "model_type": "modelType",
     "input_modalities": "inputModalities",
     "output_modalities": "outputModalities",
+    "parameter_count": "parameterCount",
+    "active_parameter_count": "activeParameterCount",
+    "release_date": "releaseDate",
   });
 });
 /** @internal */
@@ -206,6 +225,9 @@ export type ListModelsData$Outbound = {
   model_type: string;
   input_modalities: Array<string>;
   output_modalities: Array<string>;
+  parameter_count: number | null;
+  active_parameter_count: number | null;
+  release_date: string | null;
   capabilities: ListModelsCapabilities$Outbound;
 };
 
@@ -222,6 +244,9 @@ export const ListModelsData$outboundSchema: z.ZodType<
   modelType: ListModelsModelType$outboundSchema,
   inputModalities: z.array(z.string()),
   outputModalities: z.array(z.string()),
+  parameterCount: z.nullable(z.number().int()),
+  activeParameterCount: z.nullable(z.number().int()),
+  releaseDate: z.nullable(z.instanceof(RFCDate).transform(v => v.toString())),
   capabilities: z.lazy(() => ListModelsCapabilities$outboundSchema),
 }).transform((v) => {
   return remap$(v, {
@@ -229,6 +254,9 @@ export const ListModelsData$outboundSchema: z.ZodType<
     modelType: "model_type",
     inputModalities: "input_modalities",
     outputModalities: "output_modalities",
+    parameterCount: "parameter_count",
+    activeParameterCount: "active_parameter_count",
+    releaseDate: "release_date",
   });
 });
 

package/src/models/operations/listserviceinstances.ts

@@ -18,6 +18,10 @@ export type ListServiceInstancesRequest = {
    * asc pages oldest-first (default); desc pages newest-first. A cursor is only valid within a traversal that keeps the same order.
    */
   order?: components.ComputeOrder | undefined;
+  /**
+   * Include retained terminal service-incarnation history. The default returns only current non-terminal incarnations.
+   */
+  history?: boolean | undefined;
   /**
    * Optional external end-user identifier forwarded by the API gateway.
    */
@@ -39,6 +43,7 @@ export const ListServiceInstancesRequest$inboundSchema: z.ZodType<
   cursor: z.string().optional(),
   limit: z.number().int().default(50),
   order: components.ComputeOrder$inboundSchema.default("asc"),
+  history: z.boolean().default(false),
   "X-On-Behalf-Of": z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -52,6 +57,7 @@ export type ListServiceInstancesRequest$Outbound = {
   cursor?: string | undefined;
   limit: number;
   order: string;
+  history: boolean;
   "X-On-Behalf-Of"?: string | undefined;
 };
 
@@ -66,6 +72,7 @@ export const ListServiceInstancesRequest$outboundSchema: z.ZodType<
   cursor: z.string().optional(),
   limit: z.number().int().default(50),
   order: components.ComputeOrder$outboundSchema.default("asc"),
+  history: z.boolean().default(false),
   xOnBehalfOf: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/operations/updateservicescaling.ts

@@ -0,0 +1,206 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type UpdateServiceScalingRequest = {
+  id: string;
+  idempotencyKey: string;
+  /**
+   * Optional strong entity tag containing the current desired scaling-policy generation.
+   */
+  ifMatch?: string | undefined;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  computeScalingInput: components.ComputeScalingInput;
+};
+
+export type UpdateServiceScalingResponseResult =
+  | components.ComputeService
+  | components.ComputeErrorEnvelope;
+
+export type UpdateServiceScalingResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.ComputeService | components.ComputeErrorEnvelope;
+};
+
+/** @internal */
+export const UpdateServiceScalingRequest$inboundSchema: z.ZodType<
+  UpdateServiceScalingRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  "Idempotency-Key": z.string(),
+  "If-Match": z.string().optional(),
+  "X-On-Behalf-Of": z.string().optional(),
+  ComputeScalingInput: components.ComputeScalingInput$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Idempotency-Key": "idempotencyKey",
+    "If-Match": "ifMatch",
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "ComputeScalingInput": "computeScalingInput",
+  });
+});
+/** @internal */
+export type UpdateServiceScalingRequest$Outbound = {
+  id: string;
+  "Idempotency-Key": string;
+  "If-Match"?: string | undefined;
+  "X-On-Behalf-Of"?: string | undefined;
+  ComputeScalingInput: components.ComputeScalingInput$Outbound;
+};
+
+/** @internal */
+export const UpdateServiceScalingRequest$outboundSchema: z.ZodType<
+  UpdateServiceScalingRequest$Outbound,
+  z.ZodTypeDef,
+  UpdateServiceScalingRequest
+> = z.object({
+  id: z.string(),
+  idempotencyKey: z.string(),
+  ifMatch: z.string().optional(),
+  xOnBehalfOf: z.string().optional(),
+  computeScalingInput: components.ComputeScalingInput$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    idempotencyKey: "Idempotency-Key",
+    ifMatch: "If-Match",
+    xOnBehalfOf: "X-On-Behalf-Of",
+    computeScalingInput: "ComputeScalingInput",
+  });
+});
+
+export function updateServiceScalingRequestToJSON(
+  updateServiceScalingRequest: UpdateServiceScalingRequest,
+): string {
+  return JSON.stringify(
+    UpdateServiceScalingRequest$outboundSchema.parse(
+      updateServiceScalingRequest,
+    ),
+  );
+}
+export function updateServiceScalingRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateServiceScalingRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateServiceScalingRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateServiceScalingRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateServiceScalingResponseResult$inboundSchema: z.ZodType<
+  UpdateServiceScalingResponseResult,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  components.ComputeService$inboundSchema,
+  components.ComputeErrorEnvelope$inboundSchema,
+]);
+/** @internal */
+export type UpdateServiceScalingResponseResult$Outbound =
+  | components.ComputeService$Outbound
+  | components.ComputeErrorEnvelope$Outbound;
+
+/** @internal */
+export const UpdateServiceScalingResponseResult$outboundSchema: z.ZodType<
+  UpdateServiceScalingResponseResult$Outbound,
+  z.ZodTypeDef,
+  UpdateServiceScalingResponseResult
+> = z.union([
+  components.ComputeService$outboundSchema,
+  components.ComputeErrorEnvelope$outboundSchema,
+]);
+
+export function updateServiceScalingResponseResultToJSON(
+  updateServiceScalingResponseResult: UpdateServiceScalingResponseResult,
+): string {
+  return JSON.stringify(
+    UpdateServiceScalingResponseResult$outboundSchema.parse(
+      updateServiceScalingResponseResult,
+    ),
+  );
+}
+export function updateServiceScalingResponseResultFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateServiceScalingResponseResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateServiceScalingResponseResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateServiceScalingResponseResult' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateServiceScalingResponse$inboundSchema: z.ZodType<
+  UpdateServiceScalingResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: z.union([
+    components.ComputeService$inboundSchema,
+    components.ComputeErrorEnvelope$inboundSchema,
+  ]),
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+/** @internal */
+export type UpdateServiceScalingResponse$Outbound = {
+  Headers: { [k: string]: Array<string> };
+  Result:
+    | components.ComputeService$Outbound
+    | components.ComputeErrorEnvelope$Outbound;
+};
+
+/** @internal */
+export const UpdateServiceScalingResponse$outboundSchema: z.ZodType<
+  UpdateServiceScalingResponse$Outbound,
+  z.ZodTypeDef,
+  UpdateServiceScalingResponse
+> = z.object({
+  headers: z.record(z.array(z.string())),
+  result: z.union([
+    components.ComputeService$outboundSchema,
+    components.ComputeErrorEnvelope$outboundSchema,
+  ]),
+}).transform((v) => {
+  return remap$(v, {
+    headers: "Headers",
+    result: "Result",
+  });
+});
+
+export function updateServiceScalingResponseToJSON(
+  updateServiceScalingResponse: UpdateServiceScalingResponse,
+): string {
+  return JSON.stringify(
+    UpdateServiceScalingResponse$outboundSchema.parse(
+      updateServiceScalingResponse,
+    ),
+  );
+}
+export function updateServiceScalingResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateServiceScalingResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateServiceScalingResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateServiceScalingResponse' from JSON`,
+  );
+}

package/src/react-query/computeServicesListServiceInstances.core.ts

@@ -48,6 +48,7 @@ export function buildComputeServicesListServiceInstancesQuery(
       cursor: request.cursor,
       limit: request.limit,
       order: request.order,
+      history: request.history,
       xOnBehalfOf: request.xOnBehalfOf,
     }),
     queryFn: async function computeServicesListServiceInstancesQueryFn(
@@ -80,6 +81,7 @@ export function queryKeyComputeServicesListServiceInstances(
     cursor?: string | undefined;
     limit?: number | undefined;
     order?: components.ComputeOrder | undefined;
+    history?: boolean | undefined;
     xOnBehalfOf?: string | undefined;
   },
 ): QueryKey {

package/src/react-query/computeServicesListServiceInstances.ts

@@ -108,6 +108,7 @@ export function setComputeServicesListServiceInstancesData(
       cursor?: string | undefined;
       limit?: number | undefined;
       order?: components.ComputeOrder | undefined;
+      history?: boolean | undefined;
       xOnBehalfOf?: string | undefined;
     },
   ],
@@ -131,6 +132,7 @@ export function invalidateComputeServicesListServiceInstances(
         cursor?: string | undefined;
         limit?: number | undefined;
         order?: components.ComputeOrder | undefined;
+        history?: boolean | undefined;
         xOnBehalfOf?: string | undefined;
       },
     ]

package/src/react-query/computeServicesUpdateServiceScaling.ts

@@ -0,0 +1,106 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { SDKCore } from "../core.js";
+import { computeServicesUpdateServiceScaling } from "../funcs/computeServicesUpdateServiceScaling.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKError } from "../models/errors/sdkerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useSDKContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export type ComputeServicesUpdateServiceScalingMutationVariables = {
+  request: operations.UpdateServiceScalingRequest;
+  options?: RequestOptions;
+};
+
+export type ComputeServicesUpdateServiceScalingMutationData =
+  operations.UpdateServiceScalingResponse;
+
+export type ComputeServicesUpdateServiceScalingMutationError =
+  | SDKError
+  | ResponseValidationError
+  | ConnectionError
+  | RequestAbortedError
+  | RequestTimeoutError
+  | InvalidRequestError
+  | UnexpectedClientError
+  | SDKValidationError;
+
+/**
+ * Replace a service scaling policy
+ */
+export function useComputeServicesUpdateServiceScalingMutation(
+  options?: MutationHookOptions<
+    ComputeServicesUpdateServiceScalingMutationData,
+    ComputeServicesUpdateServiceScalingMutationError,
+    ComputeServicesUpdateServiceScalingMutationVariables
+  >,
+): UseMutationResult<
+  ComputeServicesUpdateServiceScalingMutationData,
+  ComputeServicesUpdateServiceScalingMutationError,
+  ComputeServicesUpdateServiceScalingMutationVariables
+> {
+  const client = useSDKContext();
+  return useMutation({
+    ...buildComputeServicesUpdateServiceScalingMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeyComputeServicesUpdateServiceScaling(): MutationKey {
+  return ["@meetkai/mka1", "Compute Services", "updateServiceScaling"];
+}
+
+export function buildComputeServicesUpdateServiceScalingMutation(
+  client$: SDKCore,
+  hookOptions?: RequestOptions,
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: ComputeServicesUpdateServiceScalingMutationVariables,
+  ) => Promise<ComputeServicesUpdateServiceScalingMutationData>;
+} {
+  return {
+    mutationKey: mutationKeyComputeServicesUpdateServiceScaling(),
+    mutationFn: function computeServicesUpdateServiceScalingMutationFn({
+      request,
+      options,
+    }): Promise<ComputeServicesUpdateServiceScalingMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(computeServicesUpdateServiceScaling(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}

package/src/react-query/index.ts

@@ -132,6 +132,7 @@ export * from "./computeServicesListServiceInstances.js";
 export * from "./computeServicesListServiceLogs.js";
 export * from "./computeServicesListServices.js";
 export * from "./computeServicesTerminateService.js";
+export * from "./computeServicesUpdateServiceScaling.js";
 export * from "./computeTenantsGetComputeTenant.js";
 export * from "./computeTenantsListComputeTenants.js";
 export * from "./computeTenantsPutComputeTenant.js";

package/src/sdk/computeservices.ts

@@ -9,6 +9,7 @@ import { computeServicesListServiceInstances } from "../funcs/computeServicesLis
 import { computeServicesListServiceLogs } from "../funcs/computeServicesListServiceLogs.js";
 import { computeServicesListServices } from "../funcs/computeServicesListServices.js";
 import { computeServicesTerminateService } from "../funcs/computeServicesTerminateService.js";
+import { computeServicesUpdateServiceScaling } from "../funcs/computeServicesUpdateServiceScaling.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
@@ -98,6 +99,20 @@ export class ComputeServices extends ClientSDK {
     ));
   }
 
+  /**
+   * Replace a service scaling policy
+   */
+  async updateServiceScaling(
+    request: operations.UpdateServiceScalingRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateServiceScalingResponse> {
+    return unwrapAsync(computeServicesUpdateServiceScaling(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Terminate a service
    */