@meetkai/mka1 0.51.24 → 0.51.25

package/src/funcs/{servingDeploymentsList.ts → fineTuneJobsListServingRuns.ts}

@@ -28,18 +28,15 @@ import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
- * List deployments
- *
- * @remarks
- * List your inference deployments.
+ * List runs
  */
-export function servingDeploymentsList(
+export function fineTuneJobsListServingRuns(
   client: SDKCore,
-  request: operations.ListDeploymentsRequest,
+  request: operations.ListServingRunsRequest,
   options?: RequestOptions,
 ): APIPromise<
   Result<
-    components.PageDeployment,
+    components.PageRun,
     | errors.ServingError
     | errors.ServingHTTPValidationError
     | SDKError
@@ -61,12 +58,12 @@ export function servingDeploymentsList(
 
 async function $do(
   client: SDKCore,
-  request: operations.ListDeploymentsRequest,
+  request: operations.ListServingRunsRequest,
   options?: RequestOptions,
 ): Promise<
   [
     Result<
-      components.PageDeployment,
+      components.PageRun,
       | errors.ServingError
       | errors.ServingHTTPValidationError
       | SDKError
@@ -83,7 +80,7 @@ async function $do(
 > {
   const parsed = safeParse(
     request,
-    (value) => operations.ListDeploymentsRequest$outboundSchema.parse(value),
+    (value) => operations.ListServingRunsRequest$outboundSchema.parse(value),
     "Input validation failed",
   );
   if (!parsed.ok) {
@@ -92,10 +89,11 @@ async function $do(
   const payload = parsed.value;
   const body = null;
 
-  const path = pathToFunc("/api/v1/serving/deployments")();
+  const path = pathToFunc("/api/v1/serving/runs")();
 
   const query = encodeFormQuery({
     "cursor": payload.cursor,
+    "kind": payload.kind,
     "limit": payload.limit,
   });
 
@@ -115,7 +113,7 @@ async function $do(
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "listDeployments",
+    operationID: "listServingRuns",
     oAuth2Scopes: null,
 
     resolvedSecurity: requestSecurity,
@@ -170,7 +168,7 @@ async function $do(
   };
 
   const [result] = await M.match<
-    components.PageDeployment,
+    components.PageRun,
     | errors.ServingError
     | errors.ServingHTTPValidationError
     | SDKError
@@ -182,8 +180,8 @@ async function $do(
     | UnexpectedClientError
     | SDKValidationError
   >(
-    M.json(200, components.PageDeployment$inboundSchema),
-    M.jsonErr([401, 403], errors.ServingError$inboundSchema),
+    M.json(200, components.PageRun$inboundSchema),
+    M.jsonErr([401, 403, 404], errors.ServingError$inboundSchema),
     M.jsonErr(422, errors.ServingHTTPValidationError$inboundSchema),
     M.jsonErr([500, 503], errors.ServingError$inboundSchema),
     M.fail("4XX"),

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.51.24",
+  sdkVersion: "0.51.25",
   genVersion: "2.924.0",
-  userAgent: "speakeasy-sdk/typescript 0.51.24 2.924.0 1.1.0 @meetkai/mka1",
+  userAgent: "speakeasy-sdk/typescript 0.51.25 2.924.0 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.51.24",
+    currentVersion: "0.51.25",
   },
 });
 

package/src/mcp-server/server.ts

@@ -88,6 +88,12 @@ import { tool$budgetsOrgEvents } from "./tools/budgetsOrgEvents.js";
 import { tool$budgetsSetApiKey } from "./tools/budgetsSetApiKey.js";
 import { tool$budgetsSetCurrency } from "./tools/budgetsSetCurrency.js";
 import { tool$budgetsSetOrg } from "./tools/budgetsSetOrg.js";
+import { tool$deploymentsDeleteServingRun } from "./tools/deploymentsDeleteServingRun.js";
+import { tool$fineTuneJobsCreateServingRun } from "./tools/fineTuneJobsCreateServingRun.js";
+import { tool$fineTuneJobsGetServingRun } from "./tools/fineTuneJobsGetServingRun.js";
+import { tool$fineTuneJobsGetServingRunEvents } from "./tools/fineTuneJobsGetServingRunEvents.js";
+import { tool$fineTuneJobsGetServingRunLogs } from "./tools/fineTuneJobsGetServingRunLogs.js";
+import { tool$fineTuneJobsListServingRuns } from "./tools/fineTuneJobsListServingRuns.js";
 import { tool$guardrailsDeleteGuardrails } from "./tools/guardrailsDeleteGuardrails.js";
 import { tool$guardrailsGetGuardrails } from "./tools/guardrailsGetGuardrails.js";
 import { tool$guardrailsListGuardrailsPolicies } from "./tools/guardrailsListGuardrailsPolicies.js";
@@ -302,17 +308,6 @@ import { tool$sandboxUploadArchive } from "./tools/sandboxUploadArchive.js";
 import { tool$sandboxUploadFile } from "./tools/sandboxUploadFile.js";
 import { tool$servingAcceleratorsGet } from "./tools/servingAcceleratorsGet.js";
 import { tool$servingAcceleratorsList } from "./tools/servingAcceleratorsList.js";
-import { tool$servingDeploymentsCreate } from "./tools/servingDeploymentsCreate.js";
-import { tool$servingDeploymentsDelete } from "./tools/servingDeploymentsDelete.js";
-import { tool$servingDeploymentsGet } from "./tools/servingDeploymentsGet.js";
-import { tool$servingDeploymentsGetLogs } from "./tools/servingDeploymentsGetLogs.js";
-import { tool$servingDeploymentsList } from "./tools/servingDeploymentsList.js";
-import { tool$servingFinetuneJobsCancel } from "./tools/servingFinetuneJobsCancel.js";
-import { tool$servingFinetuneJobsCreate } from "./tools/servingFinetuneJobsCreate.js";
-import { tool$servingFinetuneJobsGet } from "./tools/servingFinetuneJobsGet.js";
-import { tool$servingFinetuneJobsGetEvents } from "./tools/servingFinetuneJobsGetEvents.js";
-import { tool$servingFinetuneJobsGetLogs } from "./tools/servingFinetuneJobsGetLogs.js";
-import { tool$servingFinetuneJobsList } from "./tools/servingFinetuneJobsList.js";
 import { tool$servingSecretsCreate } from "./tools/servingSecretsCreate.js";
 import { tool$servingSecretsDelete } from "./tools/servingSecretsDelete.js";
 import { tool$servingSecretsGet } from "./tools/servingSecretsGet.js";
@@ -334,7 +329,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.51.24",
+    version: "0.51.25",
   });
 
   const client = new SDKCore({
@@ -424,6 +419,12 @@ export function createMCPServer(deps: {
   tool(tool$budgetsApiKeyEvents);
   tool(tool$budgetsGetCurrency);
   tool(tool$budgetsSetCurrency);
+  tool(tool$fineTuneJobsListServingRuns);
+  tool(tool$fineTuneJobsCreateServingRun);
+  tool(tool$fineTuneJobsGetServingRun);
+  tool(tool$fineTuneJobsGetServingRunEvents);
+  tool(tool$fineTuneJobsGetServingRunLogs);
+  tool(tool$deploymentsDeleteServingRun);
   tool(tool$permissionsLlmGrant);
   tool(tool$permissionsLlmRevoke);
   tool(tool$permissionsLlmCheck);
@@ -655,17 +656,6 @@ export function createMCPServer(deps: {
   tool(tool$authApiKeyGetJwtFromKey);
   tool(tool$servingAcceleratorsList);
   tool(tool$servingAcceleratorsGet);
-  tool(tool$servingDeploymentsList);
-  tool(tool$servingDeploymentsCreate);
-  tool(tool$servingDeploymentsDelete);
-  tool(tool$servingDeploymentsGet);
-  tool(tool$servingDeploymentsGetLogs);
-  tool(tool$servingFinetuneJobsList);
-  tool(tool$servingFinetuneJobsCreate);
-  tool(tool$servingFinetuneJobsGet);
-  tool(tool$servingFinetuneJobsCancel);
-  tool(tool$servingFinetuneJobsGetEvents);
-  tool(tool$servingFinetuneJobsGetLogs);
   tool(tool$servingSecretsList);
   tool(tool$servingSecretsCreate);
   tool(tool$servingSecretsDelete);

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

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { deploymentsDeleteServingRun } from "../../funcs/deploymentsDeleteServingRun.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.DeleteServingRunRequest$inboundSchema,
+};
+
+export const tool$deploymentsDeleteServingRun: ToolDefinition<typeof args> = {
+  name: "deployments-delete-serving-run",
+  description: `Stop and delete a run
+
+Terminates the pod at the provider and marks the row deleted. Answers 204 with no body. This is the only way to stop a run: rows are never removed, so the record still proves we terminated it and prevents re-issuing against a stale provider id.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await deploymentsDeleteServingRun(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    return formatResult(void 0, apiCall);
+  },
+};

package/src/mcp-server/tools/{servingFinetuneJobsGetEvents.ts → fineTuneJobsCreateServingRun.ts}

@@ -2,22 +2,22 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { servingFinetuneJobsGetEvents } from "../../funcs/servingFinetuneJobsGetEvents.js";
+import { fineTuneJobsCreateServingRun } from "../../funcs/fineTuneJobsCreateServingRun.js";
 import * as operations from "../../models/operations/index.js";
 import { formatResult, ToolDefinition } from "../tools.js";
 
 const args = {
-  request: operations.GetFinetuneEventsRequest$inboundSchema,
+  request: operations.CreateServingRunRequest$inboundSchema,
 };
 
-export const tool$servingFinetuneJobsGetEvents: ToolDefinition<typeof args> = {
-  name: "serving-finetune-jobs-get-events",
-  description: `Status timeline
+export const tool$fineTuneJobsCreateServingRun: ToolDefinition<typeof args> = {
+  name: "fine-tune-jobs-create-serving-run",
+  description: `Create a run
 
-Return the job's status timeline (queued, running, checkpoints, completion).`,
+Rent one GPU node from one provider, start one container from a public image, and run the supplied bash script in it. Exactly one of the two budget forms is required: hours bounds time exactly and cost approximately, max_usd the reverse.`,
   args,
   tool: async (client, args, ctx) => {
-    const [result, apiCall] = await servingFinetuneJobsGetEvents(
+    const [result, apiCall] = await fineTuneJobsCreateServingRun(
       client,
       args.request,
       { fetchOptions: { signal: ctx.signal } },

package/src/mcp-server/tools/{servingFinetuneJobsList.ts → fineTuneJobsGetServingRun.ts}

@@ -2,22 +2,20 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { servingFinetuneJobsList } from "../../funcs/servingFinetuneJobsList.js";
+import { fineTuneJobsGetServingRun } from "../../funcs/fineTuneJobsGetServingRun.js";
 import * as operations from "../../models/operations/index.js";
 import { formatResult, ToolDefinition } from "../tools.js";
 
 const args = {
-  request: operations.ListFinetuneJobsRequest$inboundSchema,
+  request: operations.GetServingRunRequest$inboundSchema,
 };
 
-export const tool$servingFinetuneJobsList: ToolDefinition<typeof args> = {
-  name: "serving-finetune-jobs-list",
-  description: `List fine-tune jobs
-
-List your fine-tune jobs.`,
+export const tool$fineTuneJobsGetServingRun: ToolDefinition<typeof args> = {
+  name: "fine-tune-jobs-get-serving-run",
+  description: `Get a run`,
   args,
   tool: async (client, args, ctx) => {
-    const [result, apiCall] = await servingFinetuneJobsList(
+    const [result, apiCall] = await fineTuneJobsGetServingRun(
       client,
       args.request,
       { fetchOptions: { signal: ctx.signal } },

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

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { fineTuneJobsGetServingRunEvents } from "../../funcs/fineTuneJobsGetServingRunEvents.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GetServingRunEventsRequest$inboundSchema,
+};
+
+export const tool$fineTuneJobsGetServingRunEvents: ToolDefinition<typeof args> =
+  {
+    name: "fine-tune-jobs-get-serving-run-events",
+    description: `Get a run's event timeline`,
+    args,
+    tool: async (client, args, ctx) => {
+      const [result, apiCall] = await fineTuneJobsGetServingRunEvents(
+        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/{servingDeploymentsGet.ts → fineTuneJobsGetServingRunLogs.ts}

@@ -2,22 +2,20 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { servingDeploymentsGet } from "../../funcs/servingDeploymentsGet.js";
+import { fineTuneJobsGetServingRunLogs } from "../../funcs/fineTuneJobsGetServingRunLogs.js";
 import * as operations from "../../models/operations/index.js";
 import { formatResult, ToolDefinition } from "../tools.js";
 
 const args = {
-  request: operations.GetDeploymentRequest$inboundSchema,
+  request: operations.GetServingRunLogsRequest$inboundSchema,
 };
 
-export const tool$servingDeploymentsGet: ToolDefinition<typeof args> = {
-  name: "serving-deployments-get",
-  description: `Get a deployment
-
-Retrieve a single deployment, including its status and endpoint URL.`,
+export const tool$fineTuneJobsGetServingRunLogs: ToolDefinition<typeof args> = {
+  name: "fine-tune-jobs-get-serving-run-logs",
+  description: `Get a run's logs`,
   args,
   tool: async (client, args, ctx) => {
-    const [result, apiCall] = await servingDeploymentsGet(
+    const [result, apiCall] = await fineTuneJobsGetServingRunLogs(
       client,
       args.request,
       { fetchOptions: { signal: ctx.signal } },

package/src/mcp-server/tools/{servingDeploymentsList.ts → fineTuneJobsListServingRuns.ts}

@@ -2,22 +2,20 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { servingDeploymentsList } from "../../funcs/servingDeploymentsList.js";
+import { fineTuneJobsListServingRuns } from "../../funcs/fineTuneJobsListServingRuns.js";
 import * as operations from "../../models/operations/index.js";
 import { formatResult, ToolDefinition } from "../tools.js";
 
 const args = {
-  request: operations.ListDeploymentsRequest$inboundSchema,
+  request: operations.ListServingRunsRequest$inboundSchema,
 };
 
-export const tool$servingDeploymentsList: ToolDefinition<typeof args> = {
-  name: "serving-deployments-list",
-  description: `List deployments
-
-List your inference deployments.`,
+export const tool$fineTuneJobsListServingRuns: ToolDefinition<typeof args> = {
+  name: "fine-tune-jobs-list-serving-runs",
+  description: `List runs`,
   args,
   tool: async (client, args, ctx) => {
-    const [result, apiCall] = await servingDeploymentsList(
+    const [result, apiCall] = await fineTuneJobsListServingRuns(
       client,
       args.request,
       { fetchOptions: { signal: ctx.signal } },

package/src/models/components/index.ts

@@ -136,8 +136,6 @@ export * from "./deletemodelpriceresponse.js";
 export * from "./deleteorgautomodelresponse.js";
 export * from "./deletepromptresponse.js";
 export * from "./deleteresponseobject.js";
-export * from "./deployment.js";
-export * from "./deploymentcreate.js";
 export * from "./doubleclickaction.js";
 export * from "./dpohyperparameters.js";
 export * from "./dragaction.js";
@@ -199,8 +197,6 @@ export * from "./filesgroupby.js";
 export * from "./filewithmetadata.js";
 export * from "./filter.js";
 export * from "./findaction.js";
-export * from "./finetunejob.js";
-export * from "./finetunejobcreate.js";
 export * from "./finetuningcheckpoint.js";
 export * from "./finetuningerror.js";
 export * from "./finetuningevent.js";
@@ -326,10 +322,9 @@ export * from "./outputmessagewithid.js";
 export * from "./outputtext.js";
 export * from "./outputtokensdetails.js";
 export * from "./pageacceleratortype.js";
-export * from "./pagedeployment.js";
-export * from "./pagefinetunejob.js";
 export * from "./pagejobevent.js";
 export * from "./pagelogline.js";
+export * from "./pagerun.js";
 export * from "./pagesecret.js";
 export * from "./pageservingtenant.js";
 export * from "./pendingsafetycheck.js";
@@ -431,6 +426,8 @@ export * from "./responsewebsearchcallsearchingevent.js";
 export * from "./reverseaccessentry.js";
 export * from "./reverseaccesslistresponse.js";
 export * from "./revokepermissionrequest.js";
+export * from "./run.js";
+export * from "./runcreate.js";
 export * from "./rundeadline.js";
 export * from "./runssh.js";
 export * from "./runtimeresourceusage.js";

package/src/models/components/pagerun.ts

@@ -0,0 +1,73 @@
+/*
+ * 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 {
+  Run,
+  Run$inboundSchema,
+  Run$Outbound,
+  Run$outboundSchema,
+} from "./run.js";
+
+export type PageRun = {
+  data: Array<Run>;
+  /**
+   * Opaque cursor for the next page; null when there are no further items.
+   */
+  nextCursor: string | null;
+  /**
+   * Total number of items, or null when counting is expensive.
+   */
+  total: number | null;
+};
+
+/** @internal */
+export const PageRun$inboundSchema: z.ZodType<PageRun, z.ZodTypeDef, unknown> =
+  z.object({
+    data: z.array(Run$inboundSchema),
+    next_cursor: z.nullable(z.string()),
+    total: z.nullable(z.number().int()),
+  }).transform((v) => {
+    return remap$(v, {
+      "next_cursor": "nextCursor",
+    });
+  });
+/** @internal */
+export type PageRun$Outbound = {
+  data: Array<Run$Outbound>;
+  next_cursor: string | null;
+  total: number | null;
+};
+
+/** @internal */
+export const PageRun$outboundSchema: z.ZodType<
+  PageRun$Outbound,
+  z.ZodTypeDef,
+  PageRun
+> = z.object({
+  data: z.array(Run$outboundSchema),
+  nextCursor: z.nullable(z.string()),
+  total: z.nullable(z.number().int()),
+}).transform((v) => {
+  return remap$(v, {
+    nextCursor: "next_cursor",
+  });
+});
+
+export function pageRunToJSON(pageRun: PageRun): string {
+  return JSON.stringify(PageRun$outboundSchema.parse(pageRun));
+}
+export function pageRunFromJSON(
+  jsonString: string,
+): SafeParseResult<PageRun, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PageRun$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PageRun' from JSON`,
+  );
+}

package/src/models/components/run.ts

@@ -0,0 +1,193 @@
+/*
+ * 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 {
+  RunSSH,
+  RunSSH$inboundSchema,
+  RunSSH$Outbound,
+  RunSSH$outboundSchema,
+} from "./runssh.js";
+
+/**
+ * What the run is for. A fine-tune ends on its own and its exit code is the outcome; a deployment serves traffic and runs until it is deleted. They are one resource because they are one pod, one provider and one script — the kind selects terminal semantics, not a different machine.
+ */
+export const RunKind = {
+  Finetune: "finetune",
+  Deployment: "deployment",
+} as const;
+/**
+ * What the run is for. A fine-tune ends on its own and its exit code is the outcome; a deployment serves traffic and runs until it is deleted. They are one resource because they are one pod, one provider and one script — the kind selects terminal semantics, not a different machine.
+ */
+export type RunKind = ClosedEnum<typeof RunKind>;
+
+export const State = {
+  Requested: "requested",
+  Provisioning: "provisioning",
+  Running: "running",
+  Succeeded: "succeeded",
+  Failed: "failed",
+  Terminated: "terminated",
+} as const;
+export type State = ClosedEnum<typeof State>;
+
+export type Run = {
+  accelerator?: string | undefined;
+  createdAt: Date;
+  deadlineAt?: Date | undefined;
+  /**
+   * Where the workload serves, once it is running. Only a deployment declares ports, so only a deployment reports an endpoint.
+   */
+  endpoint?: string | undefined;
+  /**
+   * The workload's exit status. Provider status is not trusted for this: one provider reports the VM rather than the container.
+   */
+  exitCode?: number | undefined;
+  gpuCount?: number | undefined;
+  id: string;
+  image?: string | undefined;
+  /**
+   * What the run is for. A fine-tune ends on its own and its exit code is the outcome; a deployment serves traffic and runs until it is deleted. They are one resource because they are one pod, one provider and one script — the kind selects terminal semantics, not a different machine.
+   */
+  kind: RunKind;
+  name?: string | undefined;
+  priceUsdHr?: number | undefined;
+  provider?: string | undefined;
+  /**
+   * Why the run is in this state, e.g. ssh_setup_failed or budget_exhausted.
+   */
+  reason?: string | undefined;
+  /**
+   * Connection details. The login user is provider dependent and is read from the provider, never assumed.
+   */
+  ssh?: RunSSH | undefined;
+  startedAt?: Date | undefined;
+  state: State;
+  terminalAt?: Date | undefined;
+};
+
+/** @internal */
+export const RunKind$inboundSchema: z.ZodNativeEnum<typeof RunKind> = z
+  .nativeEnum(RunKind);
+/** @internal */
+export const RunKind$outboundSchema: z.ZodNativeEnum<typeof RunKind> =
+  RunKind$inboundSchema;
+
+/** @internal */
+export const State$inboundSchema: z.ZodNativeEnum<typeof State> = z.nativeEnum(
+  State,
+);
+/** @internal */
+export const State$outboundSchema: z.ZodNativeEnum<typeof State> =
+  State$inboundSchema;
+
+/** @internal */
+export const Run$inboundSchema: z.ZodType<Run, z.ZodTypeDef, unknown> = z
+  .object({
+    accelerator: z.string().optional(),
+    created_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ),
+    deadline_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ).optional(),
+    endpoint: z.string().optional(),
+    exit_code: z.number().int().optional(),
+    gpu_count: z.number().int().optional(),
+    id: z.string(),
+    image: z.string().optional(),
+    kind: RunKind$inboundSchema,
+    name: z.string().optional(),
+    price_usd_hr: z.number().optional(),
+    provider: z.string().optional(),
+    reason: z.string().optional(),
+    ssh: RunSSH$inboundSchema.optional(),
+    started_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ).optional(),
+    state: State$inboundSchema,
+    terminal_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "created_at": "createdAt",
+      "deadline_at": "deadlineAt",
+      "exit_code": "exitCode",
+      "gpu_count": "gpuCount",
+      "price_usd_hr": "priceUsdHr",
+      "started_at": "startedAt",
+      "terminal_at": "terminalAt",
+    });
+  });
+/** @internal */
+export type Run$Outbound = {
+  accelerator?: string | undefined;
+  created_at: string;
+  deadline_at?: string | undefined;
+  endpoint?: string | undefined;
+  exit_code?: number | undefined;
+  gpu_count?: number | undefined;
+  id: string;
+  image?: string | undefined;
+  kind: string;
+  name?: string | undefined;
+  price_usd_hr?: number | undefined;
+  provider?: string | undefined;
+  reason?: string | undefined;
+  ssh?: RunSSH$Outbound | undefined;
+  started_at?: string | undefined;
+  state: string;
+  terminal_at?: string | undefined;
+};
+
+/** @internal */
+export const Run$outboundSchema: z.ZodType<Run$Outbound, z.ZodTypeDef, Run> = z
+  .object({
+    accelerator: z.string().optional(),
+    createdAt: z.date().transform(v => v.toISOString()),
+    deadlineAt: z.date().transform(v => v.toISOString()).optional(),
+    endpoint: z.string().optional(),
+    exitCode: z.number().int().optional(),
+    gpuCount: z.number().int().optional(),
+    id: z.string(),
+    image: z.string().optional(),
+    kind: RunKind$outboundSchema,
+    name: z.string().optional(),
+    priceUsdHr: z.number().optional(),
+    provider: z.string().optional(),
+    reason: z.string().optional(),
+    ssh: RunSSH$outboundSchema.optional(),
+    startedAt: z.date().transform(v => v.toISOString()).optional(),
+    state: State$outboundSchema,
+    terminalAt: z.date().transform(v => v.toISOString()).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      createdAt: "created_at",
+      deadlineAt: "deadline_at",
+      exitCode: "exit_code",
+      gpuCount: "gpu_count",
+      priceUsdHr: "price_usd_hr",
+      startedAt: "started_at",
+      terminalAt: "terminal_at",
+    });
+  });
+
+export function runToJSON(run: Run): string {
+  return JSON.stringify(Run$outboundSchema.parse(run));
+}
+export function runFromJSON(
+  jsonString: string,
+): SafeParseResult<Run, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Run$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Run' from JSON`,
+  );
+}