@meetkai/mka1 0.54.50 → 0.54.51

package/bin/mcp-server.js

@@ -52917,9 +52917,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.1.0",
-    sdkVersion: "0.54.50",
-    genVersion: "2.938.0",
-    userAgent: "speakeasy-sdk/typescript 0.54.50 2.938.0 1.1.0 @meetkai/mka1"
+    sdkVersion: "0.54.51",
+    genVersion: "2.941.0",
+    userAgent: "speakeasy-sdk/typescript 0.54.51 2.941.0 1.1.0 @meetkai/mka1"
   };
 });
 
@@ -75932,6 +75932,7 @@ var init_repo = __esm(() => {
   init_repokind();
   Repo$inboundSchema = objectType({
     created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    creator: nullableType(stringType()),
     description: stringType(),
     id: stringType(),
     kind: nullableType(RepoKind$inboundSchema),
@@ -75944,6 +75945,7 @@ var init_repo = __esm(() => {
   });
   Repo$outboundSchema = objectType({
     createdAt: dateType().transform((v2) => v2.toISOString()),
+    creator: nullableType(stringType()),
     description: stringType(),
     id: stringType(),
     kind: nullableType(RepoKind$outboundSchema),
@@ -75969,6 +75971,52 @@ var init_repositorylist = __esm(() => {
   });
 });
 
+// src/models/components/repotag.ts
+var RepoTag$inboundSchema, RepoTag$outboundSchema;
+var init_repotag = __esm(() => {
+  init_esm();
+  init_primitives();
+  RepoTag$inboundSchema = objectType({
+    digest: stringType(),
+    media_type: stringType(),
+    size: nullableType(numberType().int()),
+    tag: stringType(),
+    updated_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+  }).transform((v2) => {
+    return remap(v2, {
+      media_type: "mediaType",
+      updated_at: "updatedAt"
+    });
+  });
+  RepoTag$outboundSchema = objectType({
+    digest: stringType(),
+    mediaType: stringType(),
+    size: nullableType(numberType().int()),
+    tag: stringType(),
+    updatedAt: dateType().transform((v2) => v2.toISOString())
+  }).transform((v2) => {
+    return remap(v2, {
+      mediaType: "media_type",
+      updatedAt: "updated_at"
+    });
+  });
+});
+
+// src/models/components/repotaglist.ts
+var RepoTagList$inboundSchema, RepoTagList$outboundSchema;
+var init_repotaglist = __esm(() => {
+  init_esm();
+  init_repotag();
+  RepoTagList$inboundSchema = objectType({
+    tags: arrayType(RepoTag$inboundSchema),
+    truncated: booleanType()
+  });
+  RepoTagList$outboundSchema = objectType({
+    tags: arrayType(RepoTag$outboundSchema),
+    truncated: booleanType()
+  });
+});
+
 // src/models/components/resolvedreference.ts
 var ResolvedReference$inboundSchema, ResolvedReference$outboundSchema;
 var init_resolvedreference = __esm(() => {
@@ -83164,6 +83212,8 @@ var init_components = __esm(() => {
   init_repo();
   init_repokind();
   init_repositorylist();
+  init_repotag();
+  init_repotaglist();
   init_requestcounts();
   init_resolvedreference();
   init_resolvereferencerequest();
@@ -96373,6 +96423,33 @@ var init_deleterepo = __esm(() => {
   });
 });
 
+// src/models/operations/deleterepotag.ts
+var DeleteRepoTagRequest$inboundSchema, DeleteRepoTagRequest$outboundSchema;
+var init_deleterepotag = __esm(() => {
+  init_esm();
+  init_primitives();
+  DeleteRepoTagRequest$inboundSchema = objectType({
+    org: stringType(),
+    name: stringType(),
+    tag: stringType(),
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  DeleteRepoTagRequest$outboundSchema = objectType({
+    org: stringType(),
+    name: stringType(),
+    tag: stringType(),
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+});
+
 // src/models/operations/deleteresponse.ts
 var DeleteResponseRequest$inboundSchema, DeleteResponseRequest$outboundSchema;
 var init_deleteresponse = __esm(() => {
@@ -106393,6 +106470,31 @@ var init_listrepositoriesapiv1sandboxgithubrepositoriesget = __esm(() => {
   });
 });
 
+// src/models/operations/listrepotags.ts
+var ListRepoTagsRequest$inboundSchema, ListRepoTagsRequest$outboundSchema;
+var init_listrepotags = __esm(() => {
+  init_esm();
+  init_primitives();
+  ListRepoTagsRequest$inboundSchema = objectType({
+    org: stringType(),
+    name: stringType(),
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  ListRepoTagsRequest$outboundSchema = objectType({
+    org: stringType(),
+    name: stringType(),
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+});
+
 // src/models/operations/listresponsefeedback.ts
 var ListResponseFeedbackQueryParamOrder, ListResponseFeedbackQueryParamRating, ListResponseFeedbackQueryParamOrder$inboundSchema, ListResponseFeedbackQueryParamOrder$outboundSchema, ListResponseFeedbackQueryParamRating$inboundSchema, ListResponseFeedbackQueryParamRating$outboundSchema, ListResponseFeedbackRequest$inboundSchema, ListResponseFeedbackRequest$outboundSchema;
 var init_listresponsefeedback = __esm(() => {
@@ -113943,6 +114045,7 @@ var init_operations = __esm(() => {
   init_deleteorgbudget();
   init_deleteprompt();
   init_deleterepo();
+  init_deleterepotag();
   init_deleteresponse();
   init_deleteserviceaccount2();
   init_deleteserviceaccountapikey2();
@@ -114124,6 +114227,7 @@ var init_operations = __esm(() => {
   init_listpromptversions();
   init_listrepos();
   init_listrepositoriesapiv1sandboxgithubrepositoriesget();
+  init_listrepotags();
   init_listresponsefeedback();
   init_listresponses();
   init_listscopedapikeys2();
@@ -159064,11 +159168,287 @@ only.
   };
 });
 
-// src/funcs/reposUpdate.ts
-function reposUpdate(client, request, options) {
+// src/funcs/reposTagsDelete.ts
+function reposTagsDelete(client, request, options) {
   return new APIPromise($do382(client, request, options));
 }
 async function $do382(client, request, options) {
+  const parsed = safeParse4(request, (value) => DeleteRepoTagRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    name: encodeSimple("name", payload.name, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    org: encodeSimple("org", payload.org, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    tag: encodeSimple("tag", payload.tag, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/repos/{org}/{name}/tags/{tag}")(pathParams);
+  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, [0]);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "deleteRepoTag",
+    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
+    },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "DELETE",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    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) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(nil(204, voidType()), jsonErr([401, 403, 404], RepoError$inboundSchema), jsonErr(500, RepoError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_reposTagsDelete = __esm(() => {
+  init_esm();
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/reposTagsDelete.ts
+var args374, tool$reposTagsDelete;
+var init_reposTagsDelete2 = __esm(() => {
+  init_reposTagsDelete();
+  init_operations();
+  init_tools();
+  args374 = {
+    request: DeleteRepoTagRequest$inboundSchema
+  };
+  tool$reposTagsDelete = {
+    name: "repos-tags-delete",
+    description: `Delete an image tag
+
+Removes one tag; org owner/admin only (\`write:repos\` for a key). The
+same untag as the registry's \`DELETE /v2/{org}/{name}/manifests/{tag}\`:
+the name goes and the image stays, reachable by digest and by any
+other tag that names it.
+
+What makes a repository convertible afterwards is the kind switch
+itself: \`PATCH\` to another \`kind\` first collects every image no tag
+reaches (a multi-arch index's per-platform images included) and is
+refused with \`409 kind_has_content\` only for images a tag still
+names. So delete the tags the listing shows, then switch.
+`,
+    args: args374,
+    tool: async (client, args375, ctx) => {
+      const [result, apiCall] = await reposTagsDelete(client, args375.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(undefined, apiCall);
+    }
+  };
+});
+
+// src/funcs/reposTagsList.ts
+function reposTagsList(client, request, options) {
+  return new APIPromise($do383(client, request, options));
+}
+async function $do383(client, request, options) {
+  const parsed = safeParse4(request, (value) => ListRepoTagsRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    name: encodeSimple("name", payload.name, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    org: encodeSimple("org", payload.org, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/repos/{org}/{name}/tags")(pathParams);
+  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, [0]);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "listRepoTags",
+    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
+    },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    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) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, RepoTagList$inboundSchema), jsonErr([401, 403, 404], RepoError$inboundSchema), jsonErr(500, RepoError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_reposTagsList = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_components();
+  init_errors4();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/reposTagsList.ts
+var args375, tool$reposTagsList;
+var init_reposTagsList2 = __esm(() => {
+  init_reposTagsList();
+  init_operations();
+  init_tools();
+  args375 = {
+    request: ListRepoTagsRequest$inboundSchema
+  };
+  tool$reposTagsList = {
+    name: "repos-tags-list",
+    description: `List an image repository's tags
+
+Lists the container-image tags a repository holds, newest-moved first,
+each with the manifest it points at, the manifest's media type, the
+image's declared size and when the tag last moved. The same access
+check as reading the repository (org owner/admin; \`read:repos\` for a
+key).
+
+It is a fact about what the repository HOLDS, not about its \`kind\`:
+a \`model\` lists \`[]\`, and a legacy \`kind: null\` repository that still
+holds images lists them — those are the tags a \`409 kind_has_content\`
+on PATCH is about, and deleting them through this API is what makes
+that PATCH go through.
+
+One page, of at most 1000 tags; \`truncated\` says whether the
+repository holds more. The registry's own \`GET /v2/{org}/{name}/tags/list\`
+is the paginated, names-only listing every OCI client speaks.
+`,
+    args: args375,
+    tool: async (client, args376, ctx) => {
+      const [result, apiCall] = await reposTagsList(client, args376.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);
+    }
+  };
+});
+
+// src/funcs/reposUpdate.ts
+function reposUpdate(client, request, options) {
+  return new APIPromise($do384(client, request, options));
+}
+async function $do384(client, request, options) {
   const parsed = safeParse4(request, (value) => PatchRepoRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -159161,12 +159541,12 @@ var init_reposUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/reposUpdate.ts
-var args374, tool$reposUpdate;
+var args376, tool$reposUpdate;
 var init_reposUpdate2 = __esm(() => {
   init_reposUpdate();
   init_operations();
   init_tools();
-  args374 = {
+  args376 = {
     request: PatchRepoRequest$inboundSchema2
   };
   tool$reposUpdate = {
@@ -159181,14 +159561,17 @@ only. The repository id is stable, so a rename is a one-row DB update
 protocol planes never change it): it types a legacy \`kind: null\`
 repository and corrects a wrong kind. \`repo\`, \`model\` and \`dataset\`
 convert freely and any repository may become \`image\`; a repository
-that still holds container-image content can be given no other kind
-— leaving \`image\`, or typing a legacy \`null\` row as anything else, is
-refused with \`409 kind_has_content\` (delete the tags through the
-registry first). A kind is never un-set.
+whose container images are still named by a tag can be given no
+other kind — leaving \`image\`, or typing a legacy \`null\` row as
+anything else, is refused with \`409 kind_has_content\` (list and
+delete the tags through this API first). A switch away from \`image\`
+collects every image no tag reaches before it is judged, so an image
+only ever pushed by digest, or untagged through the registry, never
+blocks it. A kind is never un-set.
 `,
-    args: args374,
-    tool: async (client, args375, ctx) => {
-      const [result, apiCall] = await reposUpdate(client, args375.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args376,
+    tool: async (client, args377, ctx) => {
+      const [result, apiCall] = await reposUpdate(client, args377.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -159203,9 +159586,9 @@ registry first). A kind is never un-set.
 
 // src/funcs/sandboxCreate.ts
 function sandboxCreate(client, request, options) {
-  return new APIPromise($do383(client, request, options));
+  return new APIPromise($do385(client, request, options));
 }
-async function $do383(client, request, options) {
+async function $do385(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateSessionRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -159290,12 +159673,12 @@ var init_sandboxCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxCreate.ts
-var args375, tool$sandboxCreate;
+var args377, tool$sandboxCreate;
 var init_sandboxCreate2 = __esm(() => {
   init_sandboxCreate();
   init_operations();
   init_tools();
-  args375 = {
+  args377 = {
     request: CreateSessionRequest$inboundSchema2
   };
   tool$sandboxCreate = {
@@ -159303,9 +159686,9 @@ var init_sandboxCreate2 = __esm(() => {
     description: `Create Session
 
 Create a sandbox session and return its public session metadata, session token, and provider. Set \`session_kind\` to \`browser\` to start a browser-backed session instead of a standard command/code sandbox. Set \`queue_if_full\` to \`true\` to queue the request instead of failing when runner capacity is temporarily unavailable. It does not queue requests for session kinds the deployment does not support. Browser sessions require a Firecracker-backed deployment; standard-only deployments reject them immediately with \`browser_sessions_not_enabled\`.`,
-    args: args375,
-    tool: async (client, args376, ctx) => {
-      const [result, apiCall] = await sandboxCreate(client, args376.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args377,
+    tool: async (client, args378, ctx) => {
+      const [result, apiCall] = await sandboxCreate(client, args378.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -159320,9 +159703,9 @@ Create a sandbox session and return its public session metadata, session token,
 
 // src/funcs/sandboxDownloadArchive.ts
 function sandboxDownloadArchive(client, request, options) {
-  return new APIPromise($do384(client, request, options));
+  return new APIPromise($do386(client, request, options));
 }
-async function $do384(client, request, options) {
+async function $do386(client, request, options) {
   const parsed = safeParse4(request, (value) => DownloadWorkspaceArchiveRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -159419,12 +159802,12 @@ var init_sandboxDownloadArchive = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxDownloadArchive.ts
-var args376, tool$sandboxDownloadArchive;
+var args378, tool$sandboxDownloadArchive;
 var init_sandboxDownloadArchive2 = __esm(() => {
   init_sandboxDownloadArchive();
   init_operations();
   init_tools();
-  args376 = {
+  args378 = {
     request: DownloadWorkspaceArchiveRequest$inboundSchema
   };
   tool$sandboxDownloadArchive = {
@@ -159432,9 +159815,9 @@ var init_sandboxDownloadArchive2 = __esm(() => {
     description: `Download Workspace Archive
 
 Download a zip archive containing the selected workspace paths.`,
-    args: args376,
-    tool: async (client, args377, ctx) => {
-      const [result, apiCall] = await sandboxDownloadArchive(client, args377.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args378,
+    tool: async (client, args379, ctx) => {
+      const [result, apiCall] = await sandboxDownloadArchive(client, args379.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -159449,9 +159832,9 @@ Download a zip archive containing the selected workspace paths.`,
 
 // src/funcs/sandboxDownloadFile.ts
 function sandboxDownloadFile(client, request, options) {
-  return new APIPromise($do385(client, request, options));
+  return new APIPromise($do387(client, request, options));
 }
-async function $do385(client, request, options) {
+async function $do387(client, request, options) {
   const parsed = safeParse4(request, (value) => DownloadWorkspaceFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -159547,12 +159930,12 @@ var init_sandboxDownloadFile = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxDownloadFile.ts
-var args377, tool$sandboxDownloadFile;
+var args379, tool$sandboxDownloadFile;
 var init_sandboxDownloadFile2 = __esm(() => {
   init_sandboxDownloadFile();
   init_operations();
   init_tools();
-  args377 = {
+  args379 = {
     request: DownloadWorkspaceFileRequest$inboundSchema
   };
   tool$sandboxDownloadFile = {
@@ -159560,9 +159943,9 @@ var init_sandboxDownloadFile2 = __esm(() => {
     description: `Download Workspace File
 
 Download raw bytes from a file in the session workspace.`,
-    args: args377,
-    tool: async (client, args378, ctx) => {
-      const [result, apiCall] = await sandboxDownloadFile(client, args378.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args379,
+    tool: async (client, args380, ctx) => {
+      const [result, apiCall] = await sandboxDownloadFile(client, args380.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -159577,9 +159960,9 @@ Download raw bytes from a file in the session workspace.`,
 
 // src/funcs/sandboxGet.ts
 function sandboxGet(client, request, options) {
-  return new APIPromise($do386(client, request, options));
+  return new APIPromise($do388(client, request, options));
 }
-async function $do386(client, request, options) {
+async function $do388(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -159667,12 +160050,12 @@ var init_sandboxGet = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxGet.ts
-var args378, tool$sandboxGet;
+var args380, tool$sandboxGet;
 var init_sandboxGet2 = __esm(() => {
   init_sandboxGet();
   init_operations();
   init_tools();
-  args378 = {
+  args380 = {
     request: GetSessionRequest$inboundSchema
   };
   tool$sandboxGet = {
@@ -159680,9 +160063,9 @@ var init_sandboxGet2 = __esm(() => {
     description: `Get Session
 
 Return the current state, configuration, and resource allocation for a sandbox session.`,
-    args: args378,
-    tool: async (client, args379, ctx) => {
-      const [result, apiCall] = await sandboxGet(client, args379.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args380,
+    tool: async (client, args381, ctx) => {
+      const [result, apiCall] = await sandboxGet(client, args381.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -159697,9 +160080,9 @@ Return the current state, configuration, and resource allocation for a sandbox s
 
 // src/funcs/sandboxGetBrowserUrl.ts
 function sandboxGetBrowserUrl(client, request, options) {
-  return new APIPromise($do387(client, request, options));
+  return new APIPromise($do389(client, request, options));
 }
-async function $do387(client, request, options) {
+async function $do389(client, request, options) {
   const parsed = safeParse4(request, (value) => GetBrowserSessionUrlRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -159791,12 +160174,12 @@ var init_sandboxGetBrowserUrl = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxGetBrowserUrl.ts
-var args379, tool$sandboxGetBrowserUrl;
+var args381, tool$sandboxGetBrowserUrl;
 var init_sandboxGetBrowserUrl2 = __esm(() => {
   init_sandboxGetBrowserUrl();
   init_operations();
   init_tools();
-  args379 = {
+  args381 = {
     request: GetBrowserSessionUrlRequest$inboundSchema
   };
   tool$sandboxGetBrowserUrl = {
@@ -159804,9 +160187,9 @@ var init_sandboxGetBrowserUrl2 = __esm(() => {
     description: `Get Browser Session URL
 
 Return the public gateway URL for a browser session's Chrome DevTools Protocol endpoint. Playwright can use this HTTP endpoint directly. For clients that require a WebSocket endpoint, request \`json/version\` and use its rewritten \`webSocketDebuggerUrl\`. Insert subpaths before the query string; for example, use \`/ports/9222/json/version?session_token=...\`. Send the same MKA1 API-key authorization header on the HTTP and WebSocket requests. Standard sessions do not expose a public URL; use the command, code, and workspace operations instead.`,
-    args: args379,
-    tool: async (client, args380, ctx) => {
-      const [result, apiCall] = await sandboxGetBrowserUrl(client, args380.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args381,
+    tool: async (client, args382, ctx) => {
+      const [result, apiCall] = await sandboxGetBrowserUrl(client, args382.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -159821,9 +160204,9 @@ Return the public gateway URL for a browser session's Chrome DevTools Protocol e
 
 // src/funcs/sandboxGetPricing.ts
 function sandboxGetPricing(client, options) {
-  return new APIPromise($do388(client, options));
+  return new APIPromise($do390(client, options));
 }
-async function $do388(client, options) {
+async function $do390(client, options) {
   const path = pathToFunc("/api/v1/sandbox/pricing")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -159915,9 +160298,9 @@ Current sandbox pricing rate card, keyed by SKU (\`standard\`, \`browser\`, \`ev
 
 // src/funcs/sandboxGetWorkspace.ts
 function sandboxGetWorkspace(client, request, options) {
-  return new APIPromise($do389(client, request, options));
+  return new APIPromise($do391(client, request, options));
 }
-async function $do389(client, request, options) {
+async function $do391(client, request, options) {
   const parsed = safeParse4(request, (value) => GetWorkspaceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -160009,12 +160392,12 @@ var init_sandboxGetWorkspace = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxGetWorkspace.ts
-var args380, tool$sandboxGetWorkspace;
+var args382, tool$sandboxGetWorkspace;
 var init_sandboxGetWorkspace2 = __esm(() => {
   init_sandboxGetWorkspace();
   init_operations();
   init_tools();
-  args380 = {
+  args382 = {
     request: GetWorkspaceRequest$inboundSchema
   };
   tool$sandboxGetWorkspace = {
@@ -160022,9 +160405,9 @@ var init_sandboxGetWorkspace2 = __esm(() => {
     description: `Get Workspace Manifest
 
 List files currently stored in the session workspace, including paths, sizes, and etags.`,
-    args: args380,
-    tool: async (client, args381, ctx) => {
-      const [result, apiCall] = await sandboxGetWorkspace(client, args381.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args382,
+    tool: async (client, args383, ctx) => {
+      const [result, apiCall] = await sandboxGetWorkspace(client, args383.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -160039,9 +160422,9 @@ List files currently stored in the session workspace, including paths, sizes, an
 
 // src/funcs/sandboxList.ts
 function sandboxList(client, request, options) {
-  return new APIPromise($do390(client, request, options));
+  return new APIPromise($do392(client, request, options));
 }
-async function $do390(client, request, options) {
+async function $do392(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSessionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -160124,12 +160507,12 @@ var init_sandboxList = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxList.ts
-var args381, tool$sandboxList;
+var args383, tool$sandboxList;
 var init_sandboxList2 = __esm(() => {
   init_sandboxList();
   init_operations();
   init_tools();
-  args381 = {
+  args383 = {
     request: ListSessionsRequest$inboundSchema
   };
   tool$sandboxList = {
@@ -160137,9 +160520,9 @@ var init_sandboxList2 = __esm(() => {
     description: `List Sessions
 
 List sandbox sessions visible to the authenticated caller.`,
-    args: args381,
-    tool: async (client, args382, ctx) => {
-      const [result, apiCall] = await sandboxList(client, args382.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args383,
+    tool: async (client, args384, ctx) => {
+      const [result, apiCall] = await sandboxList(client, args384.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -160154,9 +160537,9 @@ List sandbox sessions visible to the authenticated caller.`,
 
 // src/funcs/sandboxProxyBrowserPortRequest.ts
 function sandboxProxyBrowserPortRequest(client, request, options) {
-  return new APIPromise($do391(client, request, options));
+  return new APIPromise($do393(client, request, options));
 }
-async function $do391(client, request, options) {
+async function $do393(client, request, options) {
   const parsed = safeParse4(request, (value) => ProxyBrowserPortRequestRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -160256,12 +160639,12 @@ var init_sandboxProxyBrowserPortRequest = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxProxyBrowserPortRequest.ts
-var args382, tool$sandboxProxyBrowserPortRequest;
+var args384, tool$sandboxProxyBrowserPortRequest;
 var init_sandboxProxyBrowserPortRequest2 = __esm(() => {
   init_sandboxProxyBrowserPortRequest();
   init_operations();
   init_tools();
-  args382 = {
+  args384 = {
     request: ProxyBrowserPortRequestRequest$inboundSchema
   };
   tool$sandboxProxyBrowserPortRequest = {
@@ -160269,9 +160652,9 @@ var init_sandboxProxyBrowserPortRequest2 = __esm(() => {
     description: `Proxy Browser Port Request
 
 Proxy an HTTP request to an exposed browser-session port through the gateway. Use the URL returned by \`GET /sessions/{session_id}/browser-url\` as the base. Insert CDP subpaths such as \`json/version\` or \`json/list\` before its query string, preserving the \`session_token\` parameter. This low-level proxy is intended for browser sessions on port \`9222\` and still requires the normal MKA1 API-key authorization header.`,
-    args: args382,
-    tool: async (client, args383, ctx) => {
-      const [result, apiCall] = await sandboxProxyBrowserPortRequest(client, args383.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args384,
+    tool: async (client, args385, ctx) => {
+      const [result, apiCall] = await sandboxProxyBrowserPortRequest(client, args385.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -160286,9 +160669,9 @@ Proxy an HTTP request to an exposed browser-session port through the gateway. Us
 
 // src/funcs/sandboxRunCode.ts
 function sandboxRunCode(client, request, options) {
-  return new APIPromise($do392(client, request, options));
+  return new APIPromise($do394(client, request, options));
 }
-async function $do392(client, request, options) {
+async function $do394(client, request, options) {
   const parsed = safeParse4(request, (value) => RunCodeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -160377,12 +160760,12 @@ var init_sandboxRunCode = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxRunCode.ts
-var args383, tool$sandboxRunCode;
+var args385, tool$sandboxRunCode;
 var init_sandboxRunCode2 = __esm(() => {
   init_sandboxRunCode();
   init_operations();
   init_tools();
-  args383 = {
+  args385 = {
     request: RunCodeRequest$inboundSchema
   };
   tool$sandboxRunCode = {
@@ -160390,9 +160773,9 @@ var init_sandboxRunCode2 = __esm(() => {
     description: `Run Code
 
 Execute source code in the session workspace using a supported runtime and return the execution result.`,
-    args: args383,
-    tool: async (client, args384, ctx) => {
-      const [result, apiCall] = await sandboxRunCode(client, args384.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args385,
+    tool: async (client, args386, ctx) => {
+      const [result, apiCall] = await sandboxRunCode(client, args386.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -160407,9 +160790,9 @@ Execute source code in the session workspace using a supported runtime and retur
 
 // src/funcs/sandboxRunCommand.ts
 function sandboxRunCommand(client, request, options) {
-  return new APIPromise($do393(client, request, options));
+  return new APIPromise($do395(client, request, options));
 }
-async function $do393(client, request, options) {
+async function $do395(client, request, options) {
   const parsed = safeParse4(request, (value) => RunCommandRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -160498,12 +160881,12 @@ var init_sandboxRunCommand = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxRunCommand.ts
-var args384, tool$sandboxRunCommand;
+var args386, tool$sandboxRunCommand;
 var init_sandboxRunCommand2 = __esm(() => {
   init_sandboxRunCommand();
   init_operations();
   init_tools();
-  args384 = {
+  args386 = {
     request: RunCommandRequest$inboundSchema
   };
   tool$sandboxRunCommand = {
@@ -160511,9 +160894,9 @@ var init_sandboxRunCommand2 = __esm(() => {
     description: `Run Command
 
 Run a command in the session workspace and return stdout, stderr, exit code, and changed files.`,
-    args: args384,
-    tool: async (client, args385, ctx) => {
-      const [result, apiCall] = await sandboxRunCommand(client, args385.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args386,
+    tool: async (client, args387, ctx) => {
+      const [result, apiCall] = await sandboxRunCommand(client, args387.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -160528,9 +160911,9 @@ Run a command in the session workspace and return stdout, stderr, exit code, and
 
 // src/funcs/sandboxSetPricing.ts
 function sandboxSetPricing(client, request, options) {
-  return new APIPromise($do394(client, request, options));
+  return new APIPromise($do396(client, request, options));
 }
-async function $do394(client, request, options) {
+async function $do396(client, request, options) {
   const parsed = safeParse4(request, (value) => SandboxPricingUpdate$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -160611,12 +160994,12 @@ var init_sandboxSetPricing = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxSetPricing.ts
-var args385, tool$sandboxSetPricing;
+var args387, tool$sandboxSetPricing;
 var init_sandboxSetPricing2 = __esm(() => {
   init_sandboxSetPricing();
   init_components();
   init_tools();
-  args385 = {
+  args387 = {
     request: SandboxPricingUpdate$inboundSchema
   };
   tool$sandboxSetPricing = {
@@ -160624,9 +161007,9 @@ var init_sandboxSetPricing2 = __esm(() => {
     description: `Set Sandbox Pricing
 
 Replace the sandbox pricing rate card. Full-replace semantics: SKUs omitted from the request become unpriced and accrue no spend. Takes effect on the next meter window without a restart. Cluster admins only.`,
-    args: args385,
-    tool: async (client, args386, ctx) => {
-      const [result, apiCall] = await sandboxSetPricing(client, args386.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args387,
+    tool: async (client, args388, ctx) => {
+      const [result, apiCall] = await sandboxSetPricing(client, args388.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -160641,9 +161024,9 @@ Replace the sandbox pricing rate card. Full-replace semantics: SKUs omitted from
 
 // src/funcs/sandboxTerminate.ts
 function sandboxTerminate(client, request, options) {
-  return new APIPromise($do395(client, request, options));
+  return new APIPromise($do397(client, request, options));
 }
-async function $do395(client, request, options) {
+async function $do397(client, request, options) {
   const parsed = safeParse4(request, (value) => TerminateSessionRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -160734,12 +161117,12 @@ var init_sandboxTerminate = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxTerminate.ts
-var args386, tool$sandboxTerminate;
+var args388, tool$sandboxTerminate;
 var init_sandboxTerminate2 = __esm(() => {
   init_sandboxTerminate();
   init_operations();
   init_tools();
-  args386 = {
+  args388 = {
     request: TerminateSessionRequest$inboundSchema2
   };
   tool$sandboxTerminate = {
@@ -160747,9 +161130,9 @@ var init_sandboxTerminate2 = __esm(() => {
     description: `Terminate Session
 
 Stop a sandbox session and release the backing sandbox resources.`,
-    args: args386,
-    tool: async (client, args387, ctx) => {
-      const [result, apiCall] = await sandboxTerminate(client, args387.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args388,
+    tool: async (client, args389, ctx) => {
+      const [result, apiCall] = await sandboxTerminate(client, args389.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -160764,9 +161147,9 @@ Stop a sandbox session and release the backing sandbox resources.`,
 
 // src/funcs/sandboxUploadArchive.ts
 function sandboxUploadArchive(client, request, options) {
-  return new APIPromise($do396(client, request, options));
+  return new APIPromise($do398(client, request, options));
 }
-async function $do396(client, request, options) {
+async function $do398(client, request, options) {
   const parsed = safeParse4(request, (value) => UploadWorkspaceArchiveRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -160859,12 +161242,12 @@ var init_sandboxUploadArchive = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxUploadArchive.ts
-var args387, tool$sandboxUploadArchive;
+var args389, tool$sandboxUploadArchive;
 var init_sandboxUploadArchive2 = __esm(() => {
   init_sandboxUploadArchive();
   init_operations();
   init_tools();
-  args387 = {
+  args389 = {
     request: UploadWorkspaceArchiveRequest$inboundSchema
   };
   tool$sandboxUploadArchive = {
@@ -160872,9 +161255,9 @@ var init_sandboxUploadArchive2 = __esm(() => {
     description: `Upload Workspace Archive
 
 Upload a zip archive and extract its files into the session workspace.`,
-    args: args387,
-    tool: async (client, args388, ctx) => {
-      const [result, apiCall] = await sandboxUploadArchive(client, args388.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args389,
+    tool: async (client, args390, ctx) => {
+      const [result, apiCall] = await sandboxUploadArchive(client, args390.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -160889,9 +161272,9 @@ Upload a zip archive and extract its files into the session workspace.`,
 
 // src/funcs/sandboxUploadFile.ts
 function sandboxUploadFile(client, request, options) {
-  return new APIPromise($do397(client, request, options));
+  return new APIPromise($do399(client, request, options));
 }
-async function $do397(client, request, options) {
+async function $do399(client, request, options) {
   const parsed = safeParse4(request, (value) => UploadWorkspaceFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -160988,12 +161371,12 @@ var init_sandboxUploadFile = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxUploadFile.ts
-var args388, tool$sandboxUploadFile;
+var args390, tool$sandboxUploadFile;
 var init_sandboxUploadFile2 = __esm(() => {
   init_sandboxUploadFile();
   init_operations();
   init_tools();
-  args388 = {
+  args390 = {
     request: UploadWorkspaceFileRequest$inboundSchema
   };
   tool$sandboxUploadFile = {
@@ -161001,9 +161384,9 @@ var init_sandboxUploadFile2 = __esm(() => {
     description: `Upload Workspace File
 
 Upload raw bytes into the session workspace at the given path.`,
-    args: args388,
-    tool: async (client, args389, ctx) => {
-      const [result, apiCall] = await sandboxUploadFile(client, args389.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args390,
+    tool: async (client, args391, ctx) => {
+      const [result, apiCall] = await sandboxUploadFile(client, args391.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -161018,9 +161401,9 @@ Upload raw bytes into the session workspace at the given path.`,
 
 // src/funcs/schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost.ts
 function schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost(client, request, options) {
-  return new APIPromise($do398(client, request, options));
+  return new APIPromise($do400(client, request, options));
 }
-async function $do398(client, request, options) {
+async function $do400(client, request, options) {
   const parsed = safeParse4(request, (value) => ConnectApiV1SandboxGithubOauthConnectionsPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -161103,20 +161486,20 @@ var init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost = __esm(() =>
 });
 
 // src/mcp-server/tools/schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost.ts
-var args389, tool$schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost;
+var args391, tool$schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost;
 var init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost2 = __esm(() => {
   init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost();
   init_operations();
   init_tools();
-  args389 = {
+  args391 = {
     request: ConnectApiV1SandboxGithubOauthConnectionsPostRequest$inboundSchema
   };
   tool$schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost = {
     name: "schema-3-other-connect-api-v1-sandbox-github-oauth-connections-post",
     description: `Connect`,
-    args: args389,
-    tool: async (client, args390, ctx) => {
-      const [result, apiCall] = await schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost(client, args390.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args391,
+    tool: async (client, args392, ctx) => {
+      const [result, apiCall] = await schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost(client, args392.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -161131,9 +161514,9 @@ var init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost2 = __esm(() =
 
 // src/funcs/schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost.ts
 function schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost(client, request, options) {
-  return new APIPromise($do399(client, request, options));
+  return new APIPromise($do401(client, request, options));
 }
-async function $do399(client, request, options) {
+async function $do401(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateEnvironmentApiV1SandboxEnvironmentsPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -161218,20 +161601,20 @@ var init_schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost = __esm(() =>
 });
 
 // src/mcp-server/tools/schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost.ts
-var args390, tool$schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost;
+var args392, tool$schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost;
 var init_schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost2 = __esm(() => {
   init_schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost();
   init_operations();
   init_tools();
-  args390 = {
+  args392 = {
     request: CreateEnvironmentApiV1SandboxEnvironmentsPostRequest$inboundSchema
   };
   tool$schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost = {
     name: "schema-3-other-create-environment-api-v1-sandbox-environments-post",
     description: `Create Environment`,
-    args: args390,
-    tool: async (client, args391, ctx) => {
-      const [result, apiCall] = await schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost(client, args391.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args392,
+    tool: async (client, args393, ctx) => {
+      const [result, apiCall] = await schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost(client, args393.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -161246,9 +161629,9 @@ var init_schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost2 = __esm(() =
 
 // src/funcs/schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost.ts
 function schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost(client, request, options) {
-  return new APIPromise($do400(client, request, options));
+  return new APIPromise($do402(client, request, options));
 }
-async function $do400(client, request, options) {
+async function $do402(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateIntentApiV1SandboxGithubOauthIntentsPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -161326,20 +161709,20 @@ var init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost = __esm(() =
 });
 
 // src/mcp-server/tools/schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost.ts
-var args391, tool$schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost;
+var args393, tool$schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost;
 var init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost2 = __esm(() => {
   init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost();
   init_operations();
   init_tools();
-  args391 = {
+  args393 = {
     request: CreateIntentApiV1SandboxGithubOauthIntentsPostRequest$inboundSchema
   };
   tool$schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost = {
     name: "schema-3-other-create-intent-api-v1-sandbox-github-oauth-intents-post",
     description: `Create Intent`,
-    args: args391,
-    tool: async (client, args392, ctx) => {
-      const [result, apiCall] = await schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost(client, args392.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args393,
+    tool: async (client, args394, ctx) => {
+      const [result, apiCall] = await schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost(client, args394.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -161354,9 +161737,9 @@ var init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost2 = __esm(()
 
 // src/funcs/schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost.ts
 function schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost(client, request, options) {
-  return new APIPromise($do401(client, request, options));
+  return new APIPromise($do403(client, request, options));
 }
-async function $do401(client, request, options) {
+async function $do403(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -161447,20 +161830,20 @@ var init_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullReques
 });
 
 // src/mcp-server/tools/schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost.ts
-var args392, tool$schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost;
+var args394, tool$schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost;
 var init_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost2 = __esm(() => {
   init_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost();
   init_operations();
   init_tools();
-  args392 = {
+  args394 = {
     request: CreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPostRequest$inboundSchema
   };
   tool$schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost = {
     name: "schema-3-other-create-or-update-api-v1-sandbox-sessions-session-id-github-pull-request-post",
     description: `Create Or Update`,
-    args: args392,
-    tool: async (client, args393, ctx) => {
-      const [result, apiCall] = await schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost(client, args393.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args394,
+    tool: async (client, args395, ctx) => {
+      const [result, apiCall] = await schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost(client, args395.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -161475,9 +161858,9 @@ var init_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullReques
 
 // src/funcs/schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete.ts
 function schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete(client, request, options) {
-  return new APIPromise($do402(client, request, options));
+  return new APIPromise($do404(client, request, options));
 }
-async function $do402(client, request, options) {
+async function $do404(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -161565,20 +161948,20 @@ var init_schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelet
 });
 
 // src/mcp-server/tools/schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete.ts
-var args393, tool$schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete;
+var args395, tool$schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete;
 var init_schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete2 = __esm(() => {
   init_schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete();
   init_operations();
   init_tools();
-  args393 = {
+  args395 = {
     request: DeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDeleteRequest$inboundSchema
   };
   tool$schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete = {
     name: "schema-3-other-delete-environment-api-v1-sandbox-environments-environment-id-delete",
     description: `Delete Environment`,
-    args: args393,
-    tool: async (client, args394, ctx) => {
-      const [result, apiCall] = await schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete(client, args394.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args395,
+    tool: async (client, args396, ctx) => {
+      const [result, apiCall] = await schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete(client, args396.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -161592,9 +161975,9 @@ var init_schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelet
 
 // src/funcs/schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete.ts
 function schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, request, options) {
-  return new APIPromise($do403(client, request, options));
+  return new APIPromise($do405(client, request, options));
 }
-async function $do403(client, request, options) {
+async function $do405(client, request, options) {
   const parsed = safeParse4(request, (value) => DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -161672,20 +162055,20 @@ var init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete = __esm(
 });
 
 // src/mcp-server/tools/schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete.ts
-var args394, tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete;
+var args396, tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete;
 var init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete2 = __esm(() => {
   init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete();
   init_operations();
   init_tools();
-  args394 = {
+  args396 = {
     request: DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$inboundSchema
   };
   tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete = {
     name: "schema-3-other-disconnect-api-v1-sandbox-github-oauth-connections-delete",
     description: `Disconnect`,
-    args: args394,
-    tool: async (client, args395, ctx) => {
-      const [result, apiCall] = await schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, args395.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args396,
+    tool: async (client, args397, ctx) => {
+      const [result, apiCall] = await schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, args397.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -161699,9 +162082,9 @@ var init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete2 = __esm
 
 // src/funcs/schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete.ts
 function schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete(client, request, options) {
-  return new APIPromise($do404(client, request, options));
+  return new APIPromise($do406(client, request, options));
 }
-async function $do404(client, request, options) {
+async function $do406(client, request, options) {
   const parsed = safeParse4(request, (value) => DismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -161796,20 +162179,20 @@ var init_schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubReposit
 });
 
 // src/mcp-server/tools/schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete.ts
-var args395, tool$schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete;
+var args397, tool$schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete;
 var init_schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete2 = __esm(() => {
   init_schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete();
   init_operations();
   init_tools();
-  args395 = {
+  args397 = {
     request: DismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDeleteRequest$inboundSchema
   };
   tool$schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete = {
     name: "schema-3-other-dismiss-repository-api-v1-sandbox-sessions-session-id-github-repositories-repository-id-delete",
     description: `Dismiss Repository`,
-    args: args395,
-    tool: async (client, args396, ctx) => {
-      const [result, apiCall] = await schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete(client, args396.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args397,
+    tool: async (client, args398, ctx) => {
+      const [result, apiCall] = await schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete(client, args398.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -161823,9 +162206,9 @@ var init_schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubReposit
 
 // src/funcs/schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet.ts
 function schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet(client, request, options) {
-  return new APIPromise($do405(client, request, options));
+  return new APIPromise($do407(client, request, options));
 }
-async function $do405(client, request, options) {
+async function $do407(client, request, options) {
   const parsed = safeParse4(request, (value) => GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -161911,20 +162294,20 @@ var init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet = __esm(
 });
 
 // src/mcp-server/tools/schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet.ts
-var args396, tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet;
+var args398, tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet;
 var init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet2 = __esm(() => {
   init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet();
   init_operations();
   init_tools();
-  args396 = {
+  args398 = {
     request: GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$inboundSchema
   };
   tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet = {
     name: "schema-3-other-get-connection-api-v1-sandbox-github-oauth-connections-get",
     description: `Get Connection`,
-    args: args396,
-    tool: async (client, args397, ctx) => {
-      const [result, apiCall] = await schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet(client, args397.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args398,
+    tool: async (client, args399, ctx) => {
+      const [result, apiCall] = await schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet(client, args399.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -161939,9 +162322,9 @@ var init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet2 = __esm
 
 // src/funcs/schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet.ts
 function schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet(client, request, options) {
-  return new APIPromise($do406(client, request, options));
+  return new APIPromise($do408(client, request, options));
 }
-async function $do406(client, request, options) {
+async function $do408(client, request, options) {
   const parsed = safeParse4(request, (value) => GetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -162029,20 +162412,20 @@ var init_schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet = __
 });
 
 // src/mcp-server/tools/schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet.ts
-var args397, tool$schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet;
+var args399, tool$schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet;
 var init_schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet2 = __esm(() => {
   init_schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet();
   init_operations();
   init_tools();
-  args397 = {
+  args399 = {
     request: GetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGetRequest$inboundSchema
   };
   tool$schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet = {
     name: "schema-3-other-get-environment-api-v1-sandbox-environments-environment-id-get",
     description: `Get Environment`,
-    args: args397,
-    tool: async (client, args398, ctx) => {
-      const [result, apiCall] = await schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet(client, args398.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args399,
+    tool: async (client, args400, ctx) => {
+      const [result, apiCall] = await schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet(client, args400.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -162057,9 +162440,9 @@ var init_schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet2 = _
 
 // src/funcs/schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet.ts
 function schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet(client, request, options) {
-  return new APIPromise($do407(client, request, options));
+  return new APIPromise($do409(client, request, options));
 }
-async function $do407(client, request, options) {
+async function $do409(client, request, options) {
   const parsed = safeParse4(request, (value) => ListEnvironmentsApiV1SandboxEnvironmentsGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -162137,20 +162520,20 @@ var init_schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet.ts
-var args398, tool$schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet;
+var args400, tool$schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet;
 var init_schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet2 = __esm(() => {
   init_schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet();
   init_operations();
   init_tools();
-  args398 = {
+  args400 = {
     request: ListEnvironmentsApiV1SandboxEnvironmentsGetRequest$inboundSchema
   };
   tool$schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet = {
     name: "schema-3-other-list-environments-api-v1-sandbox-environments-get",
     description: `List Environments`,
-    args: args398,
-    tool: async (client, args399, ctx) => {
-      const [result, apiCall] = await schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet(client, args399.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args400,
+    tool: async (client, args401, ctx) => {
+      const [result, apiCall] = await schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet(client, args401.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -162165,9 +162548,9 @@ var init_schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet2 = __esm(() =>
 
 // src/funcs/schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet.ts
 function schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet(client, request, options) {
-  return new APIPromise($do408(client, request, options));
+  return new APIPromise($do410(client, request, options));
 }
-async function $do408(client, request, options) {
+async function $do410(client, request, options) {
   const parsed = safeParse4(request, (value) => ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -162245,20 +162628,20 @@ var init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet = __esm((
 });
 
 // src/mcp-server/tools/schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet.ts
-var args399, tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet;
+var args401, tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet;
 var init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet2 = __esm(() => {
   init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet();
   init_operations();
   init_tools();
-  args399 = {
+  args401 = {
     request: ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$inboundSchema
   };
   tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet = {
     name: "schema-3-other-list-repositories-api-v1-sandbox-github-repositories-get",
     description: `List Repositories`,
-    args: args399,
-    tool: async (client, args400, ctx) => {
-      const [result, apiCall] = await schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet(client, args400.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args401,
+    tool: async (client, args402, ctx) => {
+      const [result, apiCall] = await schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet(client, args402.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -162273,9 +162656,9 @@ var init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet2 = __esm(
 
 // src/funcs/schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet.ts
 function schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet(client, request, options) {
-  return new APIPromise($do409(client, request, options));
+  return new APIPromise($do411(client, request, options));
 }
-async function $do409(client, request, options) {
+async function $do411(client, request, options) {
   const parsed = safeParse4(request, (value) => ManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -162363,20 +162746,20 @@ var init_schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet
 });
 
 // src/mcp-server/tools/schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet.ts
-var args400, tool$schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet;
+var args402, tool$schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet;
 var init_schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet2 = __esm(() => {
   init_schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet();
   init_operations();
   init_tools();
-  args400 = {
+  args402 = {
     request: ManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGetRequest$inboundSchema
   };
   tool$schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet = {
     name: "schema-3-other-manifest-api-v1-sandbox-sessions-session-id-github-repositories-get",
     description: `Manifest`,
-    args: args400,
-    tool: async (client, args401, ctx) => {
-      const [result, apiCall] = await schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet(client, args401.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args402,
+    tool: async (client, args403, ctx) => {
+      const [result, apiCall] = await schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet(client, args403.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -162391,9 +162774,9 @@ var init_schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet2
 
 // src/funcs/schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost.ts
 function schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost(client, request, options) {
-  return new APIPromise($do410(client, request, options));
+  return new APIPromise($do412(client, request, options));
 }
-async function $do410(client, request, options) {
+async function $do412(client, request, options) {
   const parsed = safeParse4(request, (value) => PushApiV1SandboxSessionsSessionIdGithubPushPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -162482,20 +162865,20 @@ var init_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost = __esm(()
 });
 
 // src/mcp-server/tools/schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost.ts
-var args401, tool$schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost;
+var args403, tool$schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost;
 var init_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost2 = __esm(() => {
   init_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost();
   init_operations();
   init_tools();
-  args401 = {
+  args403 = {
     request: PushApiV1SandboxSessionsSessionIdGithubPushPostRequest$inboundSchema
   };
   tool$schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost = {
     name: "schema-3-other-push-api-v1-sandbox-sessions-session-id-github-push-post",
     description: `Push`,
-    args: args401,
-    tool: async (client, args402, ctx) => {
-      const [result, apiCall] = await schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost(client, args402.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args403,
+    tool: async (client, args404, ctx) => {
+      const [result, apiCall] = await schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost(client, args404.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -162510,9 +162893,9 @@ var init_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost2 = __esm(()
 
 // src/funcs/schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut.ts
 function schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut(client, request, options) {
-  return new APIPromise($do411(client, request, options));
+  return new APIPromise($do413(client, request, options));
 }
-async function $do411(client, request, options) {
+async function $do413(client, request, options) {
   const parsed = safeParse4(request, (value) => PutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPutRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -162607,20 +162990,20 @@ var init_schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositorie
 });
 
 // src/mcp-server/tools/schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut.ts
-var args402, tool$schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut;
+var args404, tool$schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut;
 var init_schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut2 = __esm(() => {
   init_schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut();
   init_operations();
   init_tools();
-  args402 = {
+  args404 = {
     request: PutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPutRequest$inboundSchema
   };
   tool$schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut = {
     name: "schema-3-other-put-repository-api-v1-sandbox-sessions-session-id-github-repositories-repository-id-put",
     description: `Put Repository`,
-    args: args402,
-    tool: async (client, args403, ctx) => {
-      const [result, apiCall] = await schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut(client, args403.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args404,
+    tool: async (client, args405, ctx) => {
+      const [result, apiCall] = await schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut(client, args405.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -162635,9 +163018,9 @@ var init_schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositorie
 
 // src/funcs/schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost.ts
 function schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, request, options) {
-  return new APIPromise($do412(client, request, options));
+  return new APIPromise($do414(client, request, options));
 }
-async function $do412(client, request, options) {
+async function $do414(client, request, options) {
   const parsed = safeParse4(request, (value) => ReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -162728,20 +163111,20 @@ var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost =
 });
 
 // src/mcp-server/tools/schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost.ts
-var args403, tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost;
+var args405, tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost;
 var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost2 = __esm(() => {
   init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost();
   init_operations();
   init_tools();
-  args403 = {
+  args405 = {
     request: ReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePostRequest$inboundSchema
   };
   tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost = {
     name: "schema-3-other-read-clone-api-v1-sandbox-sessions-session-id-github-read-clone-post",
     description: `Read Clone`,
-    args: args403,
-    tool: async (client, args404, ctx) => {
-      const [result, apiCall] = await schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, args404.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args405,
+    tool: async (client, args406, ctx) => {
+      const [result, apiCall] = await schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, args406.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -162756,9 +163139,9 @@ var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost2
 
 // src/funcs/schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost.ts
 function schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost(client, request, options) {
-  return new APIPromise($do413(client, request, options));
+  return new APIPromise($do415(client, request, options));
 }
-async function $do413(client, request, options) {
+async function $do415(client, request, options) {
   const parsed = safeParse4(request, (value) => RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -162836,20 +163219,20 @@ var init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPos
 });
 
 // src/mcp-server/tools/schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost.ts
-var args404, tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost;
+var args406, tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost;
 var init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost2 = __esm(() => {
   init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost();
   init_operations();
   init_tools();
-  args404 = {
+  args406 = {
     request: RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$inboundSchema
   };
   tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost = {
     name: "schema-3-other-refresh-repositories-api-v1-sandbox-github-repositories-refresh-post",
     description: `Refresh Repositories`,
-    args: args404,
-    tool: async (client, args405, ctx) => {
-      const [result, apiCall] = await schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost(client, args405.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args406,
+    tool: async (client, args407, ctx) => {
+      const [result, apiCall] = await schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost(client, args407.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -162864,9 +163247,9 @@ var init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPos
 
 // src/funcs/schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost.ts
 function schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost(client, request, options) {
-  return new APIPromise($do414(client, request, options));
+  return new APIPromise($do416(client, request, options));
 }
-async function $do414(client, request, options) {
+async function $do416(client, request, options) {
   const parsed = safeParse4(request, (value) => ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -162951,20 +163334,20 @@ var init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost =
 });
 
 // src/mcp-server/tools/schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost.ts
-var args405, tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost;
+var args407, tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost;
 var init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost2 = __esm(() => {
   init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost();
   init_operations();
   init_tools();
-  args405 = {
+  args407 = {
     request: ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$inboundSchema
   };
   tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost = {
     name: "schema-3-other-resolve-reference-api-v1-sandbox-github-repositories-resolve-post",
     description: `Resolve Reference`,
-    args: args405,
-    tool: async (client, args406, ctx) => {
-      const [result, apiCall] = await schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost(client, args406.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args407,
+    tool: async (client, args408, ctx) => {
+      const [result, apiCall] = await schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost(client, args408.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -162979,9 +163362,9 @@ var init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost2
 
 // src/funcs/schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost.ts
 function schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost(client, request, options) {
-  return new APIPromise($do415(client, request, options));
+  return new APIPromise($do417(client, request, options));
 }
-async function $do415(client, request, options) {
+async function $do417(client, request, options) {
   const parsed = safeParse4(request, (value) => RunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -163069,20 +163452,20 @@ var init_schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironment
 });
 
 // src/mcp-server/tools/schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost.ts
-var args406, tool$schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost;
+var args408, tool$schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost;
 var init_schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost2 = __esm(() => {
   init_schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost();
   init_operations();
   init_tools();
-  args406 = {
+  args408 = {
     request: RunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPostRequest$inboundSchema
   };
   tool$schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost = {
     name: "schema-3-other-run-environment-setup-api-v1-sandbox-sessions-session-id-environment-setup-post",
     description: `Run Environment Setup`,
-    args: args406,
-    tool: async (client, args407, ctx) => {
-      const [result, apiCall] = await schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost(client, args407.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args408,
+    tool: async (client, args409, ctx) => {
+      const [result, apiCall] = await schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost(client, args409.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -163097,9 +163480,9 @@ var init_schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironment
 
 // src/funcs/schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut.ts
 function schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut(client, request, options) {
-  return new APIPromise($do416(client, request, options));
+  return new APIPromise($do418(client, request, options));
 }
-async function $do416(client, request, options) {
+async function $do418(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPutRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -163190,20 +163573,20 @@ var init_schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut =
 });
 
 // src/mcp-server/tools/schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut.ts
-var args407, tool$schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut;
+var args409, tool$schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut;
 var init_schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut2 = __esm(() => {
   init_schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut();
   init_operations();
   init_tools();
-  args407 = {
+  args409 = {
     request: UpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPutRequest$inboundSchema
   };
   tool$schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut = {
     name: "schema-3-other-update-environment-api-v1-sandbox-environments-environment-id-put",
     description: `Update Environment`,
-    args: args407,
-    tool: async (client, args408, ctx) => {
-      const [result, apiCall] = await schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut(client, args408.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args409,
+    tool: async (client, args410, ctx) => {
+      const [result, apiCall] = await schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut(client, args410.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -163218,9 +163601,9 @@ var init_schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut2
 
 // src/funcs/trackingExperimentsCreate.ts
 function trackingExperimentsCreate(client, request, options) {
-  return new APIPromise($do417(client, request, options));
+  return new APIPromise($do419(client, request, options));
 }
-async function $do417(client, request, options) {
+async function $do419(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingExperimentsCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -163298,12 +163681,12 @@ var init_trackingExperimentsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingExperimentsCreate.ts
-var args408, tool$trackingExperimentsCreate;
+var args410, tool$trackingExperimentsCreate;
 var init_trackingExperimentsCreate2 = __esm(() => {
   init_trackingExperimentsCreate();
   init_operations();
   init_tools();
-  args408 = {
+  args410 = {
     request: TrackingExperimentsCreateRequest$inboundSchema
   };
   tool$trackingExperimentsCreate = {
@@ -163311,9 +163694,9 @@ var init_trackingExperimentsCreate2 = __esm(() => {
     description: `Create
 
 Create a namespaced experiment. Artifact locations are managed by the service. Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args408,
-    tool: async (client, args409, ctx) => {
-      const [result, apiCall] = await trackingExperimentsCreate(client, args409.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args410,
+    tool: async (client, args411, ctx) => {
+      const [result, apiCall] = await trackingExperimentsCreate(client, args411.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -163328,9 +163711,9 @@ Create a namespaced experiment. Artifact locations are managed by the service. R
 
 // src/funcs/trackingExperimentsDelete.ts
 function trackingExperimentsDelete(client, request, options) {
-  return new APIPromise($do418(client, request, options));
+  return new APIPromise($do420(client, request, options));
 }
-async function $do418(client, request, options) {
+async function $do420(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingExperimentsDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -163408,12 +163791,12 @@ var init_trackingExperimentsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingExperimentsDelete.ts
-var args409, tool$trackingExperimentsDelete;
+var args411, tool$trackingExperimentsDelete;
 var init_trackingExperimentsDelete2 = __esm(() => {
   init_trackingExperimentsDelete();
   init_operations();
   init_tools();
-  args409 = {
+  args411 = {
     request: TrackingExperimentsDeleteRequest$inboundSchema
   };
   tool$trackingExperimentsDelete = {
@@ -163421,9 +163804,9 @@ var init_trackingExperimentsDelete2 = __esm(() => {
     description: `Delete
 
  Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args409,
-    tool: async (client, args410, ctx) => {
-      const [result, apiCall] = await trackingExperimentsDelete(client, args410.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args411,
+    tool: async (client, args412, ctx) => {
+      const [result, apiCall] = await trackingExperimentsDelete(client, args412.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -163438,9 +163821,9 @@ var init_trackingExperimentsDelete2 = __esm(() => {
 
 // src/funcs/trackingExperimentsGet.ts
 function trackingExperimentsGet(client, request, options) {
-  return new APIPromise($do419(client, request, options));
+  return new APIPromise($do421(client, request, options));
 }
-async function $do419(client, request, options) {
+async function $do421(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingExperimentsGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -163521,12 +163904,12 @@ var init_trackingExperimentsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingExperimentsGet.ts
-var args410, tool$trackingExperimentsGet;
+var args412, tool$trackingExperimentsGet;
 var init_trackingExperimentsGet2 = __esm(() => {
   init_trackingExperimentsGet();
   init_operations();
   init_tools();
-  args410 = {
+  args412 = {
     request: TrackingExperimentsGetRequest$inboundSchema
   };
   tool$trackingExperimentsGet = {
@@ -163534,9 +163917,9 @@ var init_trackingExperimentsGet2 = __esm(() => {
     description: `Get
 
  Requires \`read:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args410,
-    tool: async (client, args411, ctx) => {
-      const [result, apiCall] = await trackingExperimentsGet(client, args411.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args412,
+    tool: async (client, args413, ctx) => {
+      const [result, apiCall] = await trackingExperimentsGet(client, args413.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -163551,9 +163934,9 @@ var init_trackingExperimentsGet2 = __esm(() => {
 
 // src/funcs/trackingExperimentsGetByName.ts
 function trackingExperimentsGetByName(client, request, options) {
-  return new APIPromise($do420(client, request, options));
+  return new APIPromise($do422(client, request, options));
 }
-async function $do420(client, request, options) {
+async function $do422(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingExperimentsGetByNameRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -163634,12 +164017,12 @@ var init_trackingExperimentsGetByName = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingExperimentsGetByName.ts
-var args411, tool$trackingExperimentsGetByName;
+var args413, tool$trackingExperimentsGetByName;
 var init_trackingExperimentsGetByName2 = __esm(() => {
   init_trackingExperimentsGetByName();
   init_operations();
   init_tools();
-  args411 = {
+  args413 = {
     request: TrackingExperimentsGetByNameRequest$inboundSchema
   };
   tool$trackingExperimentsGetByName = {
@@ -163647,9 +164030,9 @@ var init_trackingExperimentsGetByName2 = __esm(() => {
     description: `GetByName
 
  Requires \`read:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args411,
-    tool: async (client, args412, ctx) => {
-      const [result, apiCall] = await trackingExperimentsGetByName(client, args412.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args413,
+    tool: async (client, args414, ctx) => {
+      const [result, apiCall] = await trackingExperimentsGetByName(client, args414.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -163664,9 +164047,9 @@ var init_trackingExperimentsGetByName2 = __esm(() => {
 
 // src/funcs/trackingExperimentsSearch.ts
 function trackingExperimentsSearch(client, request, options) {
-  return new APIPromise($do421(client, request, options));
+  return new APIPromise($do423(client, request, options));
 }
-async function $do421(client, request, options) {
+async function $do423(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingExperimentsSearchRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -163744,12 +164127,12 @@ var init_trackingExperimentsSearch = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingExperimentsSearch.ts
-var args412, tool$trackingExperimentsSearch;
+var args414, tool$trackingExperimentsSearch;
 var init_trackingExperimentsSearch2 = __esm(() => {
   init_trackingExperimentsSearch();
   init_operations();
   init_tools();
-  args412 = {
+  args414 = {
     request: TrackingExperimentsSearchRequest$inboundSchema
   };
   tool$trackingExperimentsSearch = {
@@ -163757,9 +164140,9 @@ var init_trackingExperimentsSearch2 = __esm(() => {
     description: `Search
 
  Requires \`read:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args412,
-    tool: async (client, args413, ctx) => {
-      const [result, apiCall] = await trackingExperimentsSearch(client, args413.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args414,
+    tool: async (client, args415, ctx) => {
+      const [result, apiCall] = await trackingExperimentsSearch(client, args415.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -163774,9 +164157,9 @@ var init_trackingExperimentsSearch2 = __esm(() => {
 
 // src/funcs/trackingRunsCreate.ts
 function trackingRunsCreate(client, request, options) {
-  return new APIPromise($do422(client, request, options));
+  return new APIPromise($do424(client, request, options));
 }
-async function $do422(client, request, options) {
+async function $do424(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsCreateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -163854,12 +164237,12 @@ var init_trackingRunsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsCreate.ts
-var args413, tool$trackingRunsCreate;
+var args415, tool$trackingRunsCreate;
 var init_trackingRunsCreate2 = __esm(() => {
   init_trackingRunsCreate();
   init_operations();
   init_tools();
-  args413 = {
+  args415 = {
     request: TrackingRunsCreateRequest$inboundSchema
   };
   tool$trackingRunsCreate = {
@@ -163867,9 +164250,9 @@ var init_trackingRunsCreate2 = __esm(() => {
     description: `Create
 
  Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args413,
-    tool: async (client, args414, ctx) => {
-      const [result, apiCall] = await trackingRunsCreate(client, args414.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args415,
+    tool: async (client, args416, ctx) => {
+      const [result, apiCall] = await trackingRunsCreate(client, args416.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -163884,9 +164267,9 @@ var init_trackingRunsCreate2 = __esm(() => {
 
 // src/funcs/trackingRunsDelete.ts
 function trackingRunsDelete(client, request, options) {
-  return new APIPromise($do423(client, request, options));
+  return new APIPromise($do425(client, request, options));
 }
-async function $do423(client, request, options) {
+async function $do425(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -163964,12 +164347,12 @@ var init_trackingRunsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsDelete.ts
-var args414, tool$trackingRunsDelete;
+var args416, tool$trackingRunsDelete;
 var init_trackingRunsDelete2 = __esm(() => {
   init_trackingRunsDelete();
   init_operations();
   init_tools();
-  args414 = {
+  args416 = {
     request: TrackingRunsDeleteRequest$inboundSchema
   };
   tool$trackingRunsDelete = {
@@ -163977,9 +164360,9 @@ var init_trackingRunsDelete2 = __esm(() => {
     description: `Delete
 
  Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args414,
-    tool: async (client, args415, ctx) => {
-      const [result, apiCall] = await trackingRunsDelete(client, args415.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args416,
+    tool: async (client, args417, ctx) => {
+      const [result, apiCall] = await trackingRunsDelete(client, args417.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -163994,9 +164377,9 @@ var init_trackingRunsDelete2 = __esm(() => {
 
 // src/funcs/trackingRunsDeleteTag.ts
 function trackingRunsDeleteTag(client, request, options) {
-  return new APIPromise($do424(client, request, options));
+  return new APIPromise($do426(client, request, options));
 }
-async function $do424(client, request, options) {
+async function $do426(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsDeleteTagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -164074,12 +164457,12 @@ var init_trackingRunsDeleteTag = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsDeleteTag.ts
-var args415, tool$trackingRunsDeleteTag;
+var args417, tool$trackingRunsDeleteTag;
 var init_trackingRunsDeleteTag2 = __esm(() => {
   init_trackingRunsDeleteTag();
   init_operations();
   init_tools();
-  args415 = {
+  args417 = {
     request: TrackingRunsDeleteTagRequest$inboundSchema
   };
   tool$trackingRunsDeleteTag = {
@@ -164087,9 +164470,9 @@ var init_trackingRunsDeleteTag2 = __esm(() => {
     description: `DeleteTag
 
  Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args415,
-    tool: async (client, args416, ctx) => {
-      const [result, apiCall] = await trackingRunsDeleteTag(client, args416.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args417,
+    tool: async (client, args418, ctx) => {
+      const [result, apiCall] = await trackingRunsDeleteTag(client, args418.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -164104,9 +164487,9 @@ var init_trackingRunsDeleteTag2 = __esm(() => {
 
 // src/funcs/trackingRunsGet.ts
 function trackingRunsGet(client, request, options) {
-  return new APIPromise($do425(client, request, options));
+  return new APIPromise($do427(client, request, options));
 }
-async function $do425(client, request, options) {
+async function $do427(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -164187,12 +164570,12 @@ var init_trackingRunsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsGet.ts
-var args416, tool$trackingRunsGet;
+var args418, tool$trackingRunsGet;
 var init_trackingRunsGet2 = __esm(() => {
   init_trackingRunsGet();
   init_operations();
   init_tools();
-  args416 = {
+  args418 = {
     request: TrackingRunsGetRequest$inboundSchema
   };
   tool$trackingRunsGet = {
@@ -164200,9 +164583,9 @@ var init_trackingRunsGet2 = __esm(() => {
     description: `Get
 
  Requires \`read:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args416,
-    tool: async (client, args417, ctx) => {
-      const [result, apiCall] = await trackingRunsGet(client, args417.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args418,
+    tool: async (client, args419, ctx) => {
+      const [result, apiCall] = await trackingRunsGet(client, args419.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -164217,9 +164600,9 @@ var init_trackingRunsGet2 = __esm(() => {
 
 // src/funcs/trackingRunsGetMetricHistory.ts
 function trackingRunsGetMetricHistory(client, request, options) {
-  return new APIPromise($do426(client, request, options));
+  return new APIPromise($do428(client, request, options));
 }
-async function $do426(client, request, options) {
+async function $do428(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsGetMetricHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -164303,12 +164686,12 @@ var init_trackingRunsGetMetricHistory = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsGetMetricHistory.ts
-var args417, tool$trackingRunsGetMetricHistory;
+var args419, tool$trackingRunsGetMetricHistory;
 var init_trackingRunsGetMetricHistory2 = __esm(() => {
   init_trackingRunsGetMetricHistory();
   init_operations();
   init_tools();
-  args417 = {
+  args419 = {
     request: TrackingRunsGetMetricHistoryRequest$inboundSchema
   };
   tool$trackingRunsGetMetricHistory = {
@@ -164316,9 +164699,9 @@ var init_trackingRunsGetMetricHistory2 = __esm(() => {
     description: `GetMetricHistory
 
  Requires \`read:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args417,
-    tool: async (client, args418, ctx) => {
-      const [result, apiCall] = await trackingRunsGetMetricHistory(client, args418.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args419,
+    tool: async (client, args420, ctx) => {
+      const [result, apiCall] = await trackingRunsGetMetricHistory(client, args420.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -164333,9 +164716,9 @@ var init_trackingRunsGetMetricHistory2 = __esm(() => {
 
 // src/funcs/trackingRunsLogBatch.ts
 function trackingRunsLogBatch(client, request, options) {
-  return new APIPromise($do427(client, request, options));
+  return new APIPromise($do429(client, request, options));
 }
-async function $do427(client, request, options) {
+async function $do429(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsLogBatchRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -164413,12 +164796,12 @@ var init_trackingRunsLogBatch = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsLogBatch.ts
-var args418, tool$trackingRunsLogBatch;
+var args420, tool$trackingRunsLogBatch;
 var init_trackingRunsLogBatch2 = __esm(() => {
   init_trackingRunsLogBatch();
   init_operations();
   init_tools();
-  args418 = {
+  args420 = {
     request: TrackingRunsLogBatchRequest$inboundSchema
   };
   tool$trackingRunsLogBatch = {
@@ -164426,9 +164809,9 @@ var init_trackingRunsLogBatch2 = __esm(() => {
     description: `LogBatch
 
  Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args418,
-    tool: async (client, args419, ctx) => {
-      const [result, apiCall] = await trackingRunsLogBatch(client, args419.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args420,
+    tool: async (client, args421, ctx) => {
+      const [result, apiCall] = await trackingRunsLogBatch(client, args421.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -164443,9 +164826,9 @@ var init_trackingRunsLogBatch2 = __esm(() => {
 
 // src/funcs/trackingRunsLogInputs.ts
 function trackingRunsLogInputs(client, request, options) {
-  return new APIPromise($do428(client, request, options));
+  return new APIPromise($do430(client, request, options));
 }
-async function $do428(client, request, options) {
+async function $do430(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsLogInputsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -164523,12 +164906,12 @@ var init_trackingRunsLogInputs = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsLogInputs.ts
-var args419, tool$trackingRunsLogInputs;
+var args421, tool$trackingRunsLogInputs;
 var init_trackingRunsLogInputs2 = __esm(() => {
   init_trackingRunsLogInputs();
   init_operations();
   init_tools();
-  args419 = {
+  args421 = {
     request: TrackingRunsLogInputsRequest$inboundSchema
   };
   tool$trackingRunsLogInputs = {
@@ -164536,9 +164919,9 @@ var init_trackingRunsLogInputs2 = __esm(() => {
     description: `LogInputs
 
  Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args419,
-    tool: async (client, args420, ctx) => {
-      const [result, apiCall] = await trackingRunsLogInputs(client, args420.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args421,
+    tool: async (client, args422, ctx) => {
+      const [result, apiCall] = await trackingRunsLogInputs(client, args422.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -164553,9 +164936,9 @@ var init_trackingRunsLogInputs2 = __esm(() => {
 
 // src/funcs/trackingRunsLogMetric.ts
 function trackingRunsLogMetric(client, request, options) {
-  return new APIPromise($do429(client, request, options));
+  return new APIPromise($do431(client, request, options));
 }
-async function $do429(client, request, options) {
+async function $do431(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsLogMetricRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -164633,12 +165016,12 @@ var init_trackingRunsLogMetric = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsLogMetric.ts
-var args420, tool$trackingRunsLogMetric;
+var args422, tool$trackingRunsLogMetric;
 var init_trackingRunsLogMetric2 = __esm(() => {
   init_trackingRunsLogMetric();
   init_operations();
   init_tools();
-  args420 = {
+  args422 = {
     request: TrackingRunsLogMetricRequest$inboundSchema
   };
   tool$trackingRunsLogMetric = {
@@ -164646,9 +165029,9 @@ var init_trackingRunsLogMetric2 = __esm(() => {
     description: `LogMetric
 
  Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args420,
-    tool: async (client, args421, ctx) => {
-      const [result, apiCall] = await trackingRunsLogMetric(client, args421.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args422,
+    tool: async (client, args423, ctx) => {
+      const [result, apiCall] = await trackingRunsLogMetric(client, args423.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -164663,9 +165046,9 @@ var init_trackingRunsLogMetric2 = __esm(() => {
 
 // src/funcs/trackingRunsLogParameter.ts
 function trackingRunsLogParameter(client, request, options) {
-  return new APIPromise($do430(client, request, options));
+  return new APIPromise($do432(client, request, options));
 }
-async function $do430(client, request, options) {
+async function $do432(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsLogParameterRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -164743,12 +165126,12 @@ var init_trackingRunsLogParameter = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsLogParameter.ts
-var args421, tool$trackingRunsLogParameter;
+var args423, tool$trackingRunsLogParameter;
 var init_trackingRunsLogParameter2 = __esm(() => {
   init_trackingRunsLogParameter();
   init_operations();
   init_tools();
-  args421 = {
+  args423 = {
     request: TrackingRunsLogParameterRequest$inboundSchema
   };
   tool$trackingRunsLogParameter = {
@@ -164756,9 +165139,9 @@ var init_trackingRunsLogParameter2 = __esm(() => {
     description: `LogParameter
 
  Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args421,
-    tool: async (client, args422, ctx) => {
-      const [result, apiCall] = await trackingRunsLogParameter(client, args422.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args423,
+    tool: async (client, args424, ctx) => {
+      const [result, apiCall] = await trackingRunsLogParameter(client, args424.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -164773,9 +165156,9 @@ var init_trackingRunsLogParameter2 = __esm(() => {
 
 // src/funcs/trackingRunsRestore.ts
 function trackingRunsRestore(client, request, options) {
-  return new APIPromise($do431(client, request, options));
+  return new APIPromise($do433(client, request, options));
 }
-async function $do431(client, request, options) {
+async function $do433(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsRestoreRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -164853,12 +165236,12 @@ var init_trackingRunsRestore = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsRestore.ts
-var args422, tool$trackingRunsRestore;
+var args424, tool$trackingRunsRestore;
 var init_trackingRunsRestore2 = __esm(() => {
   init_trackingRunsRestore();
   init_operations();
   init_tools();
-  args422 = {
+  args424 = {
     request: TrackingRunsRestoreRequest$inboundSchema
   };
   tool$trackingRunsRestore = {
@@ -164866,9 +165249,9 @@ var init_trackingRunsRestore2 = __esm(() => {
     description: `Restore
 
  Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args422,
-    tool: async (client, args423, ctx) => {
-      const [result, apiCall] = await trackingRunsRestore(client, args423.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args424,
+    tool: async (client, args425, ctx) => {
+      const [result, apiCall] = await trackingRunsRestore(client, args425.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -164883,9 +165266,9 @@ var init_trackingRunsRestore2 = __esm(() => {
 
 // src/funcs/trackingRunsSearch.ts
 function trackingRunsSearch(client, request, options) {
-  return new APIPromise($do432(client, request, options));
+  return new APIPromise($do434(client, request, options));
 }
-async function $do432(client, request, options) {
+async function $do434(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsSearchRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -164963,12 +165346,12 @@ var init_trackingRunsSearch = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsSearch.ts
-var args423, tool$trackingRunsSearch;
+var args425, tool$trackingRunsSearch;
 var init_trackingRunsSearch2 = __esm(() => {
   init_trackingRunsSearch();
   init_operations();
   init_tools();
-  args423 = {
+  args425 = {
     request: TrackingRunsSearchRequest$inboundSchema
   };
   tool$trackingRunsSearch = {
@@ -164976,9 +165359,9 @@ var init_trackingRunsSearch2 = __esm(() => {
     description: `Search
 
 Explicit experiment IDs are required; every experiment must belong to the caller. Requires \`read:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args423,
-    tool: async (client, args424, ctx) => {
-      const [result, apiCall] = await trackingRunsSearch(client, args424.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args425,
+    tool: async (client, args426, ctx) => {
+      const [result, apiCall] = await trackingRunsSearch(client, args426.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -164993,9 +165376,9 @@ Explicit experiment IDs are required; every experiment must belong to the caller
 
 // src/funcs/trackingRunsSetTag.ts
 function trackingRunsSetTag(client, request, options) {
-  return new APIPromise($do433(client, request, options));
+  return new APIPromise($do435(client, request, options));
 }
-async function $do433(client, request, options) {
+async function $do435(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsSetTagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -165073,12 +165456,12 @@ var init_trackingRunsSetTag = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsSetTag.ts
-var args424, tool$trackingRunsSetTag;
+var args426, tool$trackingRunsSetTag;
 var init_trackingRunsSetTag2 = __esm(() => {
   init_trackingRunsSetTag();
   init_operations();
   init_tools();
-  args424 = {
+  args426 = {
     request: TrackingRunsSetTagRequest$inboundSchema
   };
   tool$trackingRunsSetTag = {
@@ -165086,9 +165469,9 @@ var init_trackingRunsSetTag2 = __esm(() => {
     description: `SetTag
 
  Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args424,
-    tool: async (client, args425, ctx) => {
-      const [result, apiCall] = await trackingRunsSetTag(client, args425.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args426,
+    tool: async (client, args427, ctx) => {
+      const [result, apiCall] = await trackingRunsSetTag(client, args427.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -165103,9 +165486,9 @@ var init_trackingRunsSetTag2 = __esm(() => {
 
 // src/funcs/trackingRunsUpdate.ts
 function trackingRunsUpdate(client, request, options) {
-  return new APIPromise($do434(client, request, options));
+  return new APIPromise($do436(client, request, options));
 }
-async function $do434(client, request, options) {
+async function $do436(client, request, options) {
   const parsed = safeParse4(request, (value) => TrackingRunsUpdateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -165183,12 +165566,12 @@ var init_trackingRunsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/trackingRunsUpdate.ts
-var args425, tool$trackingRunsUpdate;
+var args427, tool$trackingRunsUpdate;
 var init_trackingRunsUpdate2 = __esm(() => {
   init_trackingRunsUpdate();
   init_operations();
   init_tools();
-  args425 = {
+  args427 = {
     request: TrackingRunsUpdateRequest$inboundSchema
   };
   tool$trackingRunsUpdate = {
@@ -165196,9 +165579,9 @@ var init_trackingRunsUpdate2 = __esm(() => {
     description: `Update
 
  Requires \`write:tracking\`. Results are restricted to the API key organization and team.`,
-    args: args425,
-    tool: async (client, args426, ctx) => {
-      const [result, apiCall] = await trackingRunsUpdate(client, args426.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args427,
+    tool: async (client, args428, ctx) => {
+      const [result, apiCall] = await trackingRunsUpdate(client, args428.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -165213,9 +165596,9 @@ var init_trackingRunsUpdate2 = __esm(() => {
 
 // src/funcs/usageCosts.ts
 function usageCosts(client, request, options) {
-  return new APIPromise($do435(client, request, options));
+  return new APIPromise($do437(client, request, options));
 }
-async function $do435(client, request, options) {
+async function $do437(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCostsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -165298,12 +165681,12 @@ var init_usageCosts = __esm(() => {
 });
 
 // src/mcp-server/tools/usageCosts.ts
-var args426, tool$usageCosts;
+var args428, tool$usageCosts;
 var init_usageCosts2 = __esm(() => {
   init_usageCosts();
   init_operations();
   init_tools();
-  args426 = {
+  args428 = {
     request: GetCostsRequest$inboundSchema
   };
   tool$usageCosts = {
@@ -165311,9 +165694,9 @@ var init_usageCosts2 = __esm(() => {
     description: `Aggregate cost by dimension
 
 Sums stored per-entry cost over [start_time, end_time), grouped by any of service, task_type, model, api_key_id, team_id, user_id, external_user_id, org_id. Point-in-time correct for chargeback/showback.`,
-    args: args426,
-    tool: async (client, args427, ctx) => {
-      const [result, apiCall] = await usageCosts(client, args427.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args428,
+    tool: async (client, args429, ctx) => {
+      const [result, apiCall] = await usageCosts(client, args429.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -165328,9 +165711,9 @@ Sums stored per-entry cost over [start_time, end_time), grouped by any of servic
 
 // src/funcs/usageSandbox.ts
 function usageSandbox(client, request, options) {
-  return new APIPromise($do436(client, request, options));
+  return new APIPromise($do438(client, request, options));
 }
-async function $do436(client, request, options) {
+async function $do438(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSandboxUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -165421,12 +165804,12 @@ var init_usageSandbox = __esm(() => {
 });
 
 // src/mcp-server/tools/usageSandbox.ts
-var args427, tool$usageSandbox;
+var args429, tool$usageSandbox;
 var init_usageSandbox2 = __esm(() => {
   init_usageSandbox();
   init_operations();
   init_tools();
-  args427 = {
+  args429 = {
     request: GetSandboxUsageRequest$inboundSchema
   };
   tool$usageSandbox = {
@@ -165434,9 +165817,9 @@ var init_usageSandbox2 = __esm(() => {
     description: `Get Sandbox Usage
 
 Aggregate sandbox usage (session lifecycle, execution, and workspace operations) over a time range, bucketed and optionally grouped. Buckets are calendar-aligned in UTC: \`start_time\` is snapped down and \`end_time\` snapped up to the nearest bucket-width boundary, so the first and last buckets may extend slightly beyond the requested range. Org-scoped: callers see their own usage, org admins their team's; cluster admins may pass \`all_orgs\` or \`org_ids\`. Cost and spend reporting lives in the budgeting API (\`/api/v1/budgeting/usage/costs\`).`,
-    args: args427,
-    tool: async (client, args428, ctx) => {
-      const [result, apiCall] = await usageSandbox(client, args428.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args429,
+    tool: async (client, args430, ctx) => {
+      const [result, apiCall] = await usageSandbox(client, args430.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -165453,7 +165836,7 @@ Aggregate sandbox usage (session lifecycle, execution, and workspace operations)
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.54.50"
+    version: "0.54.51"
   });
   const client = new SDKCore({
     bearerAuth: deps.bearerAuth,
@@ -165868,6 +166251,8 @@ function createMCPServer(deps) {
   tool(tool$authClusterInviteInfo);
   tool(tool$authClusterAcceptInvite);
   tool(tool$authApiKeyGetJwtFromKey);
+  tool(tool$reposTagsList);
+  tool(tool$reposTagsDelete);
   tool(tool$trackingExperimentsCreate);
   tool(tool$trackingExperimentsSearch);
   tool(tool$trackingExperimentsGet);
@@ -166291,6 +166676,8 @@ var init_server2 = __esm(() => {
   init_reposDelete2();
   init_reposGet2();
   init_reposList2();
+  init_reposTagsDelete2();
+  init_reposTagsList2();
   init_reposUpdate2();
   init_sandboxCreate2();
   init_sandboxDownloadArchive2();
@@ -167523,7 +167910,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.54.50"
+    currentVersion: "0.54.51"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -167531,5 +167918,5 @@ export {
   app
 };
 
-//# debugId=D648F820F3950E2E64756E2164756E21
+//# debugId=FFD333A4CE528E6F64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map