@meetkai/mka1 0.53.2 → 0.53.3

package/src/funcs/computeServicesListServiceInstances.ts

@@ -0,0 +1,191 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { SDKCore } from "../core.js";
+import { encodeFormQuery, encodeSimple } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.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 { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * List observed service instances
+ */
+export function computeServicesListServiceInstances(
+  client: SDKCore,
+  request: operations.ListServiceInstancesRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    operations.ListServiceInstancesResponse,
+    | SDKError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: SDKCore,
+  request: operations.ListServiceInstancesRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.ListServiceInstancesResponse,
+      | SDKError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) =>
+      operations.ListServiceInstancesRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+
+  const pathParams = {
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent",
+    }),
+  };
+  const path = pathToFunc("/api/v1/compute/services/{id}/instances")(
+    pathParams,
+  );
+
+  const query = encodeFormQuery({
+    "cursor": payload.cursor,
+    "limit": payload.limit,
+    "order": payload.order,
+    "state": payload.state,
+  });
+
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "X-On-Behalf-Of": encodeSimple(
+      "X-On-Behalf-Of",
+      payload["X-On-Behalf-Of"],
+      { explode: false, charEncoding: "none" },
+    ),
+  }));
+
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "listServiceInstances",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 5000,
+          exponent: 1.5,
+          maxElapsedTime: 15000,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    query: query,
+    body: body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const [result] = await M.match<
+    operations.ListServiceInstancesResponse,
+    | SDKError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, operations.ListServiceInstancesResponse$inboundSchema),
+    M.fail("4XX"),
+    M.fail("5XX"),
+    M.json("default", operations.ListServiceInstancesResponse$inboundSchema),
+  )(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/lib/config.ts

@@ -65,7 +65,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.1.0",
-  sdkVersion: "0.53.2",
+  sdkVersion: "0.53.3",
   genVersion: "2.926.8",
-  userAgent: "speakeasy-sdk/typescript 0.53.2 2.926.8 1.1.0 @meetkai/mka1",
+  userAgent: "speakeasy-sdk/typescript 0.53.3 2.926.8 1.1.0 @meetkai/mka1",
 } as const;

package/src/mcp-server/mcp-server.ts

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.53.2",
+    currentVersion: "0.53.3",
   },
 });
 

package/src/mcp-server/server.ts

@@ -96,6 +96,7 @@ import { tool$computeCatalogListComputeProviders } from "./tools/computeCatalogL
 import { tool$computeJobsCreateJob } from "./tools/computeJobsCreateJob.js";
 import { tool$computeJobsGetJob } from "./tools/computeJobsGetJob.js";
 import { tool$computeJobsListJobEvents } from "./tools/computeJobsListJobEvents.js";
+import { tool$computeJobsListJobInstances } from "./tools/computeJobsListJobInstances.js";
 import { tool$computeJobsListJobLogs } from "./tools/computeJobsListJobLogs.js";
 import { tool$computeJobsListJobs } from "./tools/computeJobsListJobs.js";
 import { tool$computeJobsTerminateJob } from "./tools/computeJobsTerminateJob.js";
@@ -106,6 +107,7 @@ import { tool$computeSecretsListComputeSecrets } from "./tools/computeSecretsLis
 import { tool$computeServicesCreateService } from "./tools/computeServicesCreateService.js";
 import { tool$computeServicesGetService } from "./tools/computeServicesGetService.js";
 import { tool$computeServicesListServiceEvents } from "./tools/computeServicesListServiceEvents.js";
+import { tool$computeServicesListServiceInstances } from "./tools/computeServicesListServiceInstances.js";
 import { tool$computeServicesListServiceLogs } from "./tools/computeServicesListServiceLogs.js";
 import { tool$computeServicesListServices } from "./tools/computeServicesListServices.js";
 import { tool$computeServicesTerminateService } from "./tools/computeServicesTerminateService.js";
@@ -345,7 +347,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.53.2",
+    version: "0.53.3",
   });
 
   const client = new SDKCore({
@@ -444,6 +446,7 @@ export function createMCPServer(deps: {
   tool(tool$computeJobsCreateJob);
   tool(tool$computeJobsGetJob);
   tool(tool$computeJobsListJobEvents);
+  tool(tool$computeJobsListJobInstances);
   tool(tool$computeJobsListJobLogs);
   tool(tool$computeJobsTerminateJob);
   tool(tool$computeSecretsListComputeSecrets);
@@ -454,6 +457,7 @@ export function createMCPServer(deps: {
   tool(tool$computeServicesCreateService);
   tool(tool$computeServicesGetService);
   tool(tool$computeServicesListServiceEvents);
+  tool(tool$computeServicesListServiceInstances);
   tool(tool$computeServicesListServiceLogs);
   tool(tool$computeServicesTerminateService);
   tool(tool$computeTenantsListComputeTenants);

package/src/mcp-server/tools/computeJobsListJobInstances.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { computeJobsListJobInstances } from "../../funcs/computeJobsListJobInstances.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.ListJobInstancesRequest$inboundSchema,
+};
+
+export const tool$computeJobsListJobInstances: ToolDefinition<typeof args> = {
+  name: "compute-jobs-list-job-instances",
+  description: `List observed job instances`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await computeJobsListJobInstances(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/computeServicesListServiceInstances.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { computeServicesListServiceInstances } from "../../funcs/computeServicesListServiceInstances.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.ListServiceInstancesRequest$inboundSchema,
+};
+
+export const tool$computeServicesListServiceInstances: ToolDefinition<
+  typeof args
+> = {
+  name: "compute-services-list-service-instances",
+  description: `List observed service instances`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await computeServicesListServiceInstances(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/models/components/computeinstance.ts

@@ -0,0 +1,188 @@
+/*
+ * 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 {
+  ComputeEndpoint,
+  ComputeEndpoint$inboundSchema,
+  ComputeEndpoint$Outbound,
+  ComputeEndpoint$outboundSchema,
+} from "./computeendpoint.js";
+import {
+  ComputeHardware,
+  ComputeHardware$inboundSchema,
+  ComputeHardware$Outbound,
+  ComputeHardware$outboundSchema,
+} from "./computehardware.js";
+import {
+  ComputeInstanceState,
+  ComputeInstanceState$inboundSchema,
+  ComputeInstanceState$outboundSchema,
+} from "./computeinstancestate.js";
+import {
+  ComputeReason,
+  ComputeReason$inboundSchema,
+  ComputeReason$Outbound,
+  ComputeReason$outboundSchema,
+} from "./computereason.js";
+import {
+  ComputeSSH,
+  ComputeSSH$inboundSchema,
+  ComputeSSH$Outbound,
+  ComputeSSH$outboundSchema,
+} from "./computessh.js";
+
+export type ComputeInstance = {
+  createdAt?: Date | undefined;
+  endpoints: Array<ComputeEndpoint>;
+  exitCode?: number | undefined;
+  hardware: ComputeHardware;
+  host?: string | undefined;
+  id: string;
+  priceUsdHr?: number | undefined;
+  privateHost?: string | undefined;
+  providerId: string;
+  /**
+   * Provider-native type, such as pod, instant_cluster_pod, or instance.
+   */
+  providerResourceType: string;
+  rank?: number | undefined;
+  ready?: boolean | undefined;
+  readyAt?: Date | undefined;
+  reason?: ComputeReason | undefined;
+  region?: string | undefined;
+  replicaIndex?: number | undefined;
+  ssh?: ComputeSSH | undefined;
+  startedAt?: Date | undefined;
+  state: ComputeInstanceState;
+  terminalAt?: Date | undefined;
+};
+
+/** @internal */
+export const ComputeInstance$inboundSchema: z.ZodType<
+  ComputeInstance,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  endpoints: z.array(ComputeEndpoint$inboundSchema),
+  exit_code: z.number().int().optional(),
+  hardware: ComputeHardware$inboundSchema,
+  host: z.string().optional(),
+  id: z.string(),
+  price_usd_hr: z.number().optional(),
+  private_host: z.string().optional(),
+  provider_id: z.string(),
+  provider_resource_type: z.string(),
+  rank: z.number().int().optional(),
+  ready: z.boolean().optional(),
+  ready_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  reason: ComputeReason$inboundSchema.optional(),
+  region: z.string().optional(),
+  replica_index: z.number().int().optional(),
+  ssh: ComputeSSH$inboundSchema.optional(),
+  started_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  state: ComputeInstanceState$inboundSchema,
+  terminal_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "created_at": "createdAt",
+    "exit_code": "exitCode",
+    "price_usd_hr": "priceUsdHr",
+    "private_host": "privateHost",
+    "provider_id": "providerId",
+    "provider_resource_type": "providerResourceType",
+    "ready_at": "readyAt",
+    "replica_index": "replicaIndex",
+    "started_at": "startedAt",
+    "terminal_at": "terminalAt",
+  });
+});
+/** @internal */
+export type ComputeInstance$Outbound = {
+  created_at?: string | undefined;
+  endpoints: Array<ComputeEndpoint$Outbound>;
+  exit_code?: number | undefined;
+  hardware: ComputeHardware$Outbound;
+  host?: string | undefined;
+  id: string;
+  price_usd_hr?: number | undefined;
+  private_host?: string | undefined;
+  provider_id: string;
+  provider_resource_type: string;
+  rank?: number | undefined;
+  ready?: boolean | undefined;
+  ready_at?: string | undefined;
+  reason?: ComputeReason$Outbound | undefined;
+  region?: string | undefined;
+  replica_index?: number | undefined;
+  ssh?: ComputeSSH$Outbound | undefined;
+  started_at?: string | undefined;
+  state: string;
+  terminal_at?: string | undefined;
+};
+
+/** @internal */
+export const ComputeInstance$outboundSchema: z.ZodType<
+  ComputeInstance$Outbound,
+  z.ZodTypeDef,
+  ComputeInstance
+> = z.object({
+  createdAt: z.date().transform(v => v.toISOString()).optional(),
+  endpoints: z.array(ComputeEndpoint$outboundSchema),
+  exitCode: z.number().int().optional(),
+  hardware: ComputeHardware$outboundSchema,
+  host: z.string().optional(),
+  id: z.string(),
+  priceUsdHr: z.number().optional(),
+  privateHost: z.string().optional(),
+  providerId: z.string(),
+  providerResourceType: z.string(),
+  rank: z.number().int().optional(),
+  ready: z.boolean().optional(),
+  readyAt: z.date().transform(v => v.toISOString()).optional(),
+  reason: ComputeReason$outboundSchema.optional(),
+  region: z.string().optional(),
+  replicaIndex: z.number().int().optional(),
+  ssh: ComputeSSH$outboundSchema.optional(),
+  startedAt: z.date().transform(v => v.toISOString()).optional(),
+  state: ComputeInstanceState$outboundSchema,
+  terminalAt: z.date().transform(v => v.toISOString()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    createdAt: "created_at",
+    exitCode: "exit_code",
+    priceUsdHr: "price_usd_hr",
+    privateHost: "private_host",
+    providerId: "provider_id",
+    providerResourceType: "provider_resource_type",
+    readyAt: "ready_at",
+    replicaIndex: "replica_index",
+    startedAt: "started_at",
+    terminalAt: "terminal_at",
+  });
+});
+
+export function computeInstanceToJSON(
+  computeInstance: ComputeInstance,
+): string {
+  return JSON.stringify(ComputeInstance$outboundSchema.parse(computeInstance));
+}
+export function computeInstanceFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeInstance, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeInstance$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeInstance' from JSON`,
+  );
+}

package/src/models/components/computeinstancelist.ts

@@ -0,0 +1,74 @@
+/*
+ * 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 {
+  ComputeInstance,
+  ComputeInstance$inboundSchema,
+  ComputeInstance$Outbound,
+  ComputeInstance$outboundSchema,
+} from "./computeinstance.js";
+
+export type ComputeInstanceList = {
+  nextCursor: string | null;
+  total: number;
+  data: Array<ComputeInstance>;
+};
+
+/** @internal */
+export const ComputeInstanceList$inboundSchema: z.ZodType<
+  ComputeInstanceList,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  next_cursor: z.nullable(z.string()),
+  total: z.number().int(),
+  data: z.array(ComputeInstance$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "next_cursor": "nextCursor",
+  });
+});
+/** @internal */
+export type ComputeInstanceList$Outbound = {
+  next_cursor: string | null;
+  total: number;
+  data: Array<ComputeInstance$Outbound>;
+};
+
+/** @internal */
+export const ComputeInstanceList$outboundSchema: z.ZodType<
+  ComputeInstanceList$Outbound,
+  z.ZodTypeDef,
+  ComputeInstanceList
+> = z.object({
+  nextCursor: z.nullable(z.string()),
+  total: z.number().int(),
+  data: z.array(ComputeInstance$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    nextCursor: "next_cursor",
+  });
+});
+
+export function computeInstanceListToJSON(
+  computeInstanceList: ComputeInstanceList,
+): string {
+  return JSON.stringify(
+    ComputeInstanceList$outboundSchema.parse(computeInstanceList),
+  );
+}
+export function computeInstanceListFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeInstanceList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeInstanceList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeInstanceList' from JSON`,
+  );
+}

package/src/models/components/computeinstancestate.ts

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const ComputeInstanceState = {
+  Requested: "requested",
+  Starting: "starting",
+  Running: "running",
+  Ready: "ready",
+  Busy: "busy",
+  Stopping: "stopping",
+  Stopped: "stopped",
+  Succeeded: "succeeded",
+  Failed: "failed",
+  Lost: "lost",
+  Unknown: "unknown",
+} as const;
+export type ComputeInstanceState = ClosedEnum<typeof ComputeInstanceState>;
+
+/** @internal */
+export const ComputeInstanceState$inboundSchema: z.ZodNativeEnum<
+  typeof ComputeInstanceState
+> = z.nativeEnum(ComputeInstanceState);
+/** @internal */
+export const ComputeInstanceState$outboundSchema: z.ZodNativeEnum<
+  typeof ComputeInstanceState
+> = ComputeInstanceState$inboundSchema;

package/src/models/components/computelog.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 { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
@@ -22,6 +23,7 @@ export type Stream = ClosedEnum<typeof Stream>;
 
 export type ComputeLog = {
   id: string;
+  instanceRank?: number | undefined;
   message: string;
   source: ComputeLogSource1;
   stream: Stream;
@@ -51,14 +53,20 @@ export const ComputeLog$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string(),
+  instance_rank: z.number().int().optional(),
   message: z.string(),
   source: ComputeLogSource1$inboundSchema,
   stream: Stream$inboundSchema,
   timestamp: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+}).transform((v) => {
+  return remap$(v, {
+    "instance_rank": "instanceRank",
+  });
 });
 /** @internal */
 export type ComputeLog$Outbound = {
   id: string;
+  instance_rank?: number | undefined;
   message: string;
   source: string;
   stream: string;
@@ -72,10 +80,15 @@ export const ComputeLog$outboundSchema: z.ZodType<
   ComputeLog
 > = z.object({
   id: z.string(),
+  instanceRank: z.number().int().optional(),
   message: z.string(),
   source: ComputeLogSource1$outboundSchema,
   stream: Stream$outboundSchema,
   timestamp: z.date().transform(v => v.toISOString()),
+}).transform((v) => {
+  return remap$(v, {
+    instanceRank: "instance_rank",
+  });
 });
 
 export function computeLogToJSON(computeLog: ComputeLog): string {