@meetkai/mka1 0.53.29 → 0.53.30

package/bin/mcp-server.js

@@ -52876,9 +52876,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.1.0",
-    sdkVersion: "0.53.29",
-    genVersion: "2.930.0",
-    userAgent: "speakeasy-sdk/typescript 0.53.29 2.930.0 1.1.0 @meetkai/mka1"
+    sdkVersion: "0.53.30",
+    genVersion: "2.931.0",
+    userAgent: "speakeasy-sdk/typescript 0.53.30 2.931.0 1.1.0 @meetkai/mka1"
   };
 });
 
@@ -56701,6 +56701,33 @@ var init_allowedtools = __esm(() => {
   });
 });
 
+// src/models/components/authorizeintent.ts
+var AuthorizeIntent$inboundSchema, AuthorizeIntent$outboundSchema;
+var init_authorizeintent = __esm(() => {
+  init_esm();
+  init_primitives();
+  AuthorizeIntent$inboundSchema = objectType({
+    state: stringType(),
+    authorize_url: stringType(),
+    expires_in_seconds: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      authorize_url: "authorizeUrl",
+      expires_in_seconds: "expiresInSeconds"
+    });
+  });
+  AuthorizeIntent$outboundSchema = objectType({
+    state: stringType(),
+    authorizeUrl: stringType(),
+    expiresInSeconds: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      authorizeUrl: "authorize_url",
+      expiresInSeconds: "expires_in_seconds"
+    });
+  });
+});
+
 // src/models/components/autochunkingstrategy.ts
 var AutoChunkingStrategy$inboundSchema, AutoChunkingStrategy$outboundSchema;
 var init_autochunkingstrategy = __esm(() => {
@@ -61721,6 +61748,98 @@ var init_computeusage = __esm(() => {
   });
 });
 
+// src/models/components/connectedrepository.ts
+var ConnectedRepository$inboundSchema, ConnectedRepository$outboundSchema;
+var init_connectedrepository = __esm(() => {
+  init_esm();
+  init_primitives();
+  ConnectedRepository$inboundSchema = objectType({
+    repository_id: numberType().int(),
+    owner: stringType(),
+    repository: stringType(),
+    private: booleanType(),
+    default_branch: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      repository_id: "repositoryId",
+      default_branch: "defaultBranch"
+    });
+  });
+  ConnectedRepository$outboundSchema = objectType({
+    repositoryId: numberType().int(),
+    owner: stringType(),
+    repository: stringType(),
+    private: booleanType(),
+    defaultBranch: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      repositoryId: "repository_id",
+      defaultBranch: "default_branch"
+    });
+  });
+});
+
+// src/models/components/connection.ts
+var Connection$inboundSchema, Connection$outboundSchema;
+var init_connection = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_connectedrepository();
+  Connection$inboundSchema = objectType({
+    github_login: stringType(),
+    github_user_id: numberType().int(),
+    scopes: stringType(),
+    synced_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    repositories: arrayType(ConnectedRepository$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      github_login: "githubLogin",
+      github_user_id: "githubUserId",
+      synced_at: "syncedAt"
+    });
+  });
+  Connection$outboundSchema = objectType({
+    githubLogin: stringType(),
+    githubUserId: numberType().int(),
+    scopes: stringType(),
+    syncedAt: dateType().transform((v2) => v2.toISOString()),
+    repositories: arrayType(ConnectedRepository$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      githubLogin: "github_login",
+      githubUserId: "github_user_id",
+      syncedAt: "synced_at"
+    });
+  });
+});
+
+// src/models/components/connectionenvelope.ts
+var ConnectionEnvelope$inboundSchema, ConnectionEnvelope$outboundSchema;
+var init_connectionenvelope = __esm(() => {
+  init_esm();
+  init_connection();
+  ConnectionEnvelope$inboundSchema = objectType({
+    connection: nullableType(Connection$inboundSchema).optional()
+  });
+  ConnectionEnvelope$outboundSchema = objectType({
+    connection: nullableType(Connection$outboundSchema).optional()
+  });
+});
+
+// src/models/components/connectrequest.ts
+var ConnectRequest$inboundSchema, ConnectRequest$outboundSchema;
+var init_connectrequest = __esm(() => {
+  init_esm();
+  ConnectRequest$inboundSchema = objectType({
+    code: stringType(),
+    state: stringType()
+  });
+  ConnectRequest$outboundSchema = objectType({
+    code: stringType(),
+    state: stringType()
+  });
+});
+
 // src/models/components/conversation.ts
 var Conversation$inboundSchema, Conversation$outboundSchema;
 var init_conversation = __esm(() => {
@@ -67173,7 +67292,6 @@ var init_githubreadclonerequest = __esm(() => {
   init_primitives();
   GitHubReadCloneRequest$inboundSchema = objectType({
     assignment_generation: numberType().int(),
-    installation_id: numberType().int(),
     repository_id: numberType().int(),
     owner: stringType(),
     repository: stringType(),
@@ -67181,14 +67299,12 @@ var init_githubreadclonerequest = __esm(() => {
   }).transform((v2) => {
     return remap(v2, {
       assignment_generation: "assignmentGeneration",
-      installation_id: "installationId",
       repository_id: "repositoryId",
       base_sha: "baseSha"
     });
   });
   GitHubReadCloneRequest$outboundSchema = objectType({
     assignmentGeneration: numberType().int(),
-    installationId: numberType().int(),
     repositoryId: numberType().int(),
     owner: stringType(),
     repository: stringType(),
@@ -67196,7 +67312,6 @@ var init_githubreadclonerequest = __esm(() => {
   }).transform((v2) => {
     return remap(v2, {
       assignmentGeneration: "assignment_generation",
-      installationId: "installation_id",
       repositoryId: "repository_id",
       baseSha: "base_sha"
     });
@@ -71296,6 +71411,75 @@ var init_repo = __esm(() => {
   });
 });
 
+// src/models/components/repositorylist.ts
+var RepositoryList$inboundSchema, RepositoryList$outboundSchema;
+var init_repositorylist = __esm(() => {
+  init_esm();
+  init_connectedrepository();
+  RepositoryList$inboundSchema = objectType({
+    repositories: arrayType(ConnectedRepository$inboundSchema)
+  });
+  RepositoryList$outboundSchema = objectType({
+    repositories: arrayType(ConnectedRepository$outboundSchema)
+  });
+});
+
+// src/models/components/resolvedreference.ts
+var ResolvedReference$inboundSchema, ResolvedReference$outboundSchema;
+var init_resolvedreference = __esm(() => {
+  init_esm();
+  init_primitives();
+  ResolvedReference$inboundSchema = objectType({
+    repository_id: numberType().int(),
+    owner: stringType(),
+    repository: stringType(),
+    ref: stringType(),
+    sha: stringType(),
+    default_branch: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      repository_id: "repositoryId",
+      default_branch: "defaultBranch"
+    });
+  });
+  ResolvedReference$outboundSchema = objectType({
+    repositoryId: numberType().int(),
+    owner: stringType(),
+    repository: stringType(),
+    ref: stringType(),
+    sha: stringType(),
+    defaultBranch: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      repositoryId: "repository_id",
+      defaultBranch: "default_branch"
+    });
+  });
+});
+
+// src/models/components/resolvereferencerequest.ts
+var ResolveReferenceRequest$inboundSchema, ResolveReferenceRequest$outboundSchema;
+var init_resolvereferencerequest = __esm(() => {
+  init_esm();
+  init_primitives();
+  ResolveReferenceRequest$inboundSchema = objectType({
+    repository_id: numberType().int(),
+    ref: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      repository_id: "repositoryId"
+    });
+  });
+  ResolveReferenceRequest$outboundSchema = objectType({
+    repositoryId: numberType().int(),
+    ref: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      repositoryId: "repository_id"
+    });
+  });
+});
+
 // src/models/components/responsestatus.ts
 var ResponseStatus, ResponseStatus$inboundSchema, ResponseStatus$outboundSchema;
 var init_responsestatus = __esm(() => {
@@ -77480,6 +77664,7 @@ var init_components = __esm(() => {
   init_agentversion();
   init_agentversionlist();
   init_allowedtools();
+  init_authorizeintent();
   init_autochunkingstrategy();
   init_autoendpoint();
   init_banwordsconfig();
@@ -77585,6 +77770,10 @@ var init_components = __esm(() => {
   init_computevolumedata();
   init_computevolumedatainput();
   init_computevolumeinput();
+  init_connectedrepository();
+  init_connection();
+  init_connectionenvelope();
+  init_connectrequest();
   init_containerfilecitation();
   init_conversation();
   init_conversationdeletedobject();
@@ -77851,7 +78040,10 @@ var init_components = __esm(() => {
   init_registrysource();
   init_reinforcementhyperparameters();
   init_repo();
+  init_repositorylist();
   init_requestcounts();
+  init_resolvedreference();
+  init_resolvereferencerequest();
   init_resourcerole();
   init_responsecancelledevent();
   init_responsecodeinterpretercallcodedeltaevent();
@@ -84501,6 +84693,32 @@ var init_compactresponse = __esm(() => {
   });
 });
 
+// src/models/operations/connectapiv1sandboxgithuboauthconnectionspost.ts
+var ConnectApiV1SandboxGithubOauthConnectionsPostRequest$inboundSchema, ConnectApiV1SandboxGithubOauthConnectionsPostRequest$outboundSchema;
+var init_connectapiv1sandboxgithuboauthconnectionspost = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  ConnectApiV1SandboxGithubOauthConnectionsPostRequest$inboundSchema = objectType({
+    "X-On-Behalf-Of": stringType().optional(),
+    ConnectRequest: ConnectRequest$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf",
+      ConnectRequest: "connectRequest"
+    });
+  });
+  ConnectApiV1SandboxGithubOauthConnectionsPostRequest$outboundSchema = objectType({
+    xOnBehalfOf: stringType().optional(),
+    connectRequest: ConnectRequest$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of",
+      connectRequest: "ConnectRequest"
+    });
+  });
+});
+
 // src/models/operations/conversationscreate.ts
 var ConversationsCreateRequest$inboundSchema, ConversationsCreateRequest$outboundSchema;
 var init_conversationscreate = __esm(() => {
@@ -86353,6 +86571,27 @@ var init_createimage = __esm(() => {
   });
 });
 
+// src/models/operations/createintentapiv1sandboxgithuboauthintentspost.ts
+var CreateIntentApiV1SandboxGithubOauthIntentsPostRequest$inboundSchema, CreateIntentApiV1SandboxGithubOauthIntentsPostRequest$outboundSchema;
+var init_createintentapiv1sandboxgithuboauthintentspost = __esm(() => {
+  init_esm();
+  init_primitives();
+  CreateIntentApiV1SandboxGithubOauthIntentsPostRequest$inboundSchema = objectType({
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  CreateIntentApiV1SandboxGithubOauthIntentsPostRequest$outboundSchema = objectType({
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+});
+
 // src/models/operations/createjob.ts
 var CreateJobRequest$inboundSchema, CreateJobRequest$outboundSchema, CreateJobResponse$inboundSchema, CreateJobResponse$outboundSchema;
 var init_createjob = __esm(() => {
@@ -88211,6 +88450,27 @@ var init_deletevectorstorefile = __esm(() => {
   });
 });
 
+// src/models/operations/disconnectapiv1sandboxgithuboauthconnectionsdelete.ts
+var DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$inboundSchema, DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$outboundSchema;
+var init_disconnectapiv1sandboxgithuboauthconnectionsdelete = __esm(() => {
+  init_esm();
+  init_primitives();
+  DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$inboundSchema = objectType({
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$outboundSchema = objectType({
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+});
+
 // src/models/operations/downloadworkspacearchive.ts
 var DownloadWorkspaceArchiveRequest$inboundSchema, DownloadWorkspaceArchiveRequest$outboundSchema;
 var init_downloadworkspacearchive = __esm(() => {
@@ -89360,6 +89620,27 @@ var init_getcomputeusage = __esm(() => {
   ]);
 });
 
+// src/models/operations/getconnectionapiv1sandboxgithuboauthconnectionsget.ts
+var GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$inboundSchema, GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$outboundSchema;
+var init_getconnectionapiv1sandboxgithuboauthconnectionsget = __esm(() => {
+  init_esm();
+  init_primitives();
+  GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$inboundSchema = objectType({
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$outboundSchema = objectType({
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+});
+
 // src/models/operations/getconversationsusage.ts
 var GetConversationsUsageRequest$inboundSchema, GetConversationsUsageRequest$outboundSchema, GetConversationsUsageData$inboundSchema, GetConversationsUsageData$outboundSchema, GetConversationsUsageResponseBody$inboundSchema, GetConversationsUsageResponseBody$outboundSchema;
 var init_getconversationsusage = __esm(() => {
@@ -95148,6 +95429,27 @@ var init_listrepos = __esm(() => {
   });
 });
 
+// src/models/operations/listrepositoriesapiv1sandboxgithubrepositoriesget.ts
+var ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$inboundSchema, ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$outboundSchema;
+var init_listrepositoriesapiv1sandboxgithubrepositoriesget = __esm(() => {
+  init_esm();
+  init_primitives();
+  ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$inboundSchema = objectType({
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$outboundSchema = objectType({
+    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(() => {
@@ -96258,6 +96560,27 @@ var init_readcloneapiv1sandboxsessionssessionidgithubreadclonepost = __esm(() =>
   });
 });
 
+// src/models/operations/refreshrepositoriesapiv1sandboxgithubrepositoriesrefreshpost.ts
+var RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$inboundSchema, RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$outboundSchema;
+var init_refreshrepositoriesapiv1sandboxgithubrepositoriesrefreshpost = __esm(() => {
+  init_esm();
+  init_primitives();
+  RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$inboundSchema = objectType({
+    "X-On-Behalf-Of": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf"
+    });
+  });
+  RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$outboundSchema = objectType({
+    xOnBehalfOf: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of"
+    });
+  });
+});
+
 // src/models/operations/regeneratescopedapikey.ts
 var RegenerateScopedApiKeyRequestBody$inboundSchema, RegenerateScopedApiKeyRequestBody$outboundSchema, RegenerateScopedApiKeyRequest$inboundSchema, RegenerateScopedApiKeyRequest$outboundSchema, RegenerateScopedApiKeyResponseBody$inboundSchema2, RegenerateScopedApiKeyResponseBody$outboundSchema2;
 var init_regeneratescopedapikey2 = __esm(() => {
@@ -96724,6 +97047,32 @@ var init_rerunfailedevalsamples = __esm(() => {
   });
 });
 
+// src/models/operations/resolvereferenceapiv1sandboxgithubrepositoriesresolvepost.ts
+var ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$inboundSchema, ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$outboundSchema;
+var init_resolvereferenceapiv1sandboxgithubrepositoriesresolvepost = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$inboundSchema = objectType({
+    "X-On-Behalf-Of": stringType().optional(),
+    ResolveReferenceRequest: ResolveReferenceRequest$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf",
+      ResolveReferenceRequest: "resolveReferenceRequest"
+    });
+  });
+  ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$outboundSchema = objectType({
+    xOnBehalfOf: stringType().optional(),
+    resolveReferenceRequest: ResolveReferenceRequest$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of",
+      resolveReferenceRequest: "ResolveReferenceRequest"
+    });
+  });
+});
+
 // src/models/operations/resumeagentschedule.ts
 var ResumeAgentScheduleRequest$inboundSchema, ResumeAgentScheduleRequest$outboundSchema;
 var init_resumeagentschedule = __esm(() => {
@@ -99609,6 +99958,7 @@ var init_operations = __esm(() => {
   init_clearclusterprice();
   init_clearorgprice();
   init_compactresponse();
+  init_connectapiv1sandboxgithuboauthconnectionspost();
   init_conversationscreate();
   init_conversationsdelete();
   init_conversationsitemscreate();
@@ -99636,6 +99986,7 @@ var init_operations = __esm(() => {
   init_createevalsuiteversion();
   init_createextractschema();
   init_createimage();
+  init_createintentapiv1sandboxgithuboauthintentspost();
   init_createjob();
   init_createmcpcredential();
   init_createmcpserver();
@@ -99689,6 +100040,7 @@ var init_operations = __esm(() => {
   init_deletetexttospeechhistory();
   init_deletevectorstore();
   init_deletevectorstorefile();
+  init_disconnectapiv1sandboxgithuboauthconnectionsdelete();
   init_downloadworkspacearchive();
   init_downloadworkspacefile();
   init_embed();
@@ -99714,6 +100066,7 @@ var init_operations = __esm(() => {
   init_getcomputesecret();
   init_getcomputetenant();
   init_getcomputeusage();
+  init_getconnectionapiv1sandboxgithuboauthconnectionsget();
   init_getconversationsusage();
   init_getcosts();
   init_getcostsusage();
@@ -99816,6 +100169,7 @@ var init_operations = __esm(() => {
   init_listprompts();
   init_listpromptversions();
   init_listrepos();
+  init_listrepositoriesapiv1sandboxgithubrepositoriesget();
   init_listresponsefeedback();
   init_listresponses();
   init_listscopedapikeys2();
@@ -99847,12 +100201,14 @@ var init_operations = __esm(() => {
   init_putcomputetenant();
   init_putorgautomodel();
   init_readcloneapiv1sandboxsessionssessionidgithubreadclonepost();
+  init_refreshrepositoriesapiv1sandboxgithubrepositoriesrefreshpost();
   init_regeneratescopedapikey2();
   init_regenerateserviceaccountapikey2();
   init_reissueownerkey2();
   init_removeteammember2();
   init_replacemodelcatalogorgaccess();
   init_rerunfailedevalsamples();
+  init_resolvereferenceapiv1sandboxgithubrepositoriesresolvepost();
   init_resumeagentschedule();
   init_resumefinetuningjob();
   init_retrievefinetuningjob();
@@ -135693,13 +136049,978 @@ async function $do305(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, ListReposResponseBody$inboundSchema), jsonErr([401, 403], RepoError$inboundSchema), jsonErr([500, 503], RepoError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, ListReposResponseBody$inboundSchema), jsonErr([401, 403], RepoError$inboundSchema), jsonErr([500, 503], 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_reposList = __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/reposList.ts
+var args297, tool$reposList;
+var init_reposList2 = __esm(() => {
+  init_reposList();
+  init_operations();
+  init_tools();
+  args297 = {
+    request: ListReposRequest$inboundSchema
+  };
+  tool$reposList = {
+    name: "repos-list",
+    description: `List the caller's org's repositories
+
+Returns every repository in the caller's org (org owner/admin only).
+Pure DB read.
+`,
+    args: args297,
+    tool: async (client, args298, ctx) => {
+      const [result, apiCall] = await reposList(client, args298.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($do306(client, request, options));
+}
+async function $do306(client, request, options) {
+  const parsed = safeParse4(request, (value) => PatchRepoRequest$outboundSchema2.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.PatchRepoRequest, { explode: true });
+  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}")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "patchRepo",
+    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: "PATCH",
+    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, Repo$inboundSchema), jsonErr([400, 401, 403, 404, 409], 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_reposUpdate = __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/reposUpdate.ts
+var args298, tool$reposUpdate;
+var init_reposUpdate2 = __esm(() => {
+  init_reposUpdate();
+  init_operations();
+  init_tools();
+  args298 = {
+    request: PatchRepoRequest$inboundSchema2
+  };
+  tool$reposUpdate = {
+    name: "repos-update",
+    description: `Update a repository's labels
+
+Applies a label-only update (name/description); org owner/admin only.
+The repository id is stable, so a rename is a one-row DB update — no
+Gitea write. Omitted fields are left unchanged.
+`,
+    args: args298,
+    tool: async (client, args299, ctx) => {
+      const [result, apiCall] = await reposUpdate(client, args299.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/sandboxCreate.ts
+function sandboxCreate(client, request, options) {
+  return new APIPromise($do307(client, request, options));
+}
+async function $do307(client, request, options) {
+  const parsed = safeParse4(request, (value) => CreateSessionRequest$outboundSchema2.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.CreateSessionRequest, {
+    explode: true
+  });
+  const path = pathToFunc("/api/v1/sandbox/sessions")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "createSession",
+    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: "POST",
+    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, 202], CreateSessionResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail([501, "5XX"]))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_sandboxCreate = __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/sandboxCreate.ts
+var args299, tool$sandboxCreate;
+var init_sandboxCreate2 = __esm(() => {
+  init_sandboxCreate();
+  init_operations();
+  init_tools();
+  args299 = {
+    request: CreateSessionRequest$inboundSchema2
+  };
+  tool$sandboxCreate = {
+    name: "sandbox-create",
+    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: args299,
+    tool: async (client, args300, ctx) => {
+      const [result, apiCall] = await sandboxCreate(client, args300.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/sandboxDownloadArchive.ts
+function sandboxDownloadArchive(client, request, options) {
+  return new APIPromise($do308(client, request, options));
+}
+async function $do308(client, request, options) {
+  const parsed = safeParse4(request, (value) => DownloadWorkspaceArchiveRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.WorkspaceArchiveRequest, {
+    explode: true
+  });
+  const pathParams = {
+    session_id: encodeSimple("session_id", payload.session_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/workspace/archive")(pathParams);
+  const query = encodeFormQuery({
+    session_token: payload.session_token
+  });
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/zip",
+    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "downloadWorkspaceArchive",
+    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: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    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(stream(200, instanceOfType(ReadableStream), {
+    ctype: "application/zip"
+  }), jsonErr(422, HTTPValidationError$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_sandboxDownloadArchive = __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/sandboxDownloadArchive.ts
+var args300, tool$sandboxDownloadArchive;
+var init_sandboxDownloadArchive2 = __esm(() => {
+  init_sandboxDownloadArchive();
+  init_operations();
+  init_tools();
+  args300 = {
+    request: DownloadWorkspaceArchiveRequest$inboundSchema
+  };
+  tool$sandboxDownloadArchive = {
+    name: "sandbox-download-archive",
+    description: `Download Workspace Archive
+
+Download a zip archive containing the selected workspace paths.`,
+    args: args300,
+    tool: async (client, args301, ctx) => {
+      const [result, apiCall] = await sandboxDownloadArchive(client, args301.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/sandboxDownloadFile.ts
+function sandboxDownloadFile(client, request, options) {
+  return new APIPromise($do309(client, request, options));
+}
+async function $do309(client, request, options) {
+  const parsed = safeParse4(request, (value) => DownloadWorkspaceFileRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    file_path: encodeSimple("file_path", payload.file_path, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    session_id: encodeSimple("session_id", payload.session_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/workspace/files/{file_path}")(pathParams);
+  const query = encodeFormQuery({
+    session_token: payload.session_token
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/octet-stream",
+    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "downloadWorkspaceFile",
+    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,
+    query,
+    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(stream(200, instanceOfType(ReadableStream)), jsonErr(422, HTTPValidationError$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_sandboxDownloadFile = __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/sandboxDownloadFile.ts
+var args301, tool$sandboxDownloadFile;
+var init_sandboxDownloadFile2 = __esm(() => {
+  init_sandboxDownloadFile();
+  init_operations();
+  init_tools();
+  args301 = {
+    request: DownloadWorkspaceFileRequest$inboundSchema
+  };
+  tool$sandboxDownloadFile = {
+    name: "sandbox-download-file",
+    description: `Download Workspace File
+
+Download raw bytes from a file in the session workspace.`,
+    args: args301,
+    tool: async (client, args302, ctx) => {
+      const [result, apiCall] = await sandboxDownloadFile(client, args302.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/sandboxGet.ts
+function sandboxGet(client, request, options) {
+  return new APIPromise($do310(client, request, options));
+}
+async function $do310(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetSessionRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    session_id: encodeSimple("session_id", payload.session_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}")(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);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getSession",
+    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, SessionRecord$inboundSchema), jsonErr(422, HTTPValidationError$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_sandboxGet = __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/sandboxGet.ts
+var args302, tool$sandboxGet;
+var init_sandboxGet2 = __esm(() => {
+  init_sandboxGet();
+  init_operations();
+  init_tools();
+  args302 = {
+    request: GetSessionRequest$inboundSchema
+  };
+  tool$sandboxGet = {
+    name: "sandbox-get",
+    description: `Get Session
+
+Return the current state, configuration, and resource allocation for a sandbox session.`,
+    args: args302,
+    tool: async (client, args303, ctx) => {
+      const [result, apiCall] = await sandboxGet(client, args303.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/sandboxGetBrowserUrl.ts
+function sandboxGetBrowserUrl(client, request, options) {
+  return new APIPromise($do311(client, request, options));
+}
+async function $do311(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetBrowserSessionUrlRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    session_id: encodeSimple("session_id", payload.session_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/browser-url")(pathParams);
+  const query = encodeFormQuery({
+    session_token: payload.session_token
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getBrowserSessionUrl",
+    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,
+    query,
+    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, SessionUrlResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail([501, "5XX"]))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_sandboxGetBrowserUrl = __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/sandboxGetBrowserUrl.ts
+var args303, tool$sandboxGetBrowserUrl;
+var init_sandboxGetBrowserUrl2 = __esm(() => {
+  init_sandboxGetBrowserUrl();
+  init_operations();
+  init_tools();
+  args303 = {
+    request: GetBrowserSessionUrlRequest$inboundSchema
+  };
+  tool$sandboxGetBrowserUrl = {
+    name: "sandbox-get-browser-url",
+    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: args303,
+    tool: async (client, args304, ctx) => {
+      const [result, apiCall] = await sandboxGetBrowserUrl(client, args304.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/sandboxGetPricing.ts
+function sandboxGetPricing(client, options) {
+  return new APIPromise($do312(client, options));
+}
+async function $do312(client, options) {
+  const path = pathToFunc("/api/v1/sandbox/pricing")();
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getSandboxPricing",
+    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,
+    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 [result] = await match(json(200, SandboxPricingCard$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_sandboxGetPricing = __esm(() => {
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_security();
+  init_url();
+  init_components();
+  init_async();
+});
+
+// src/mcp-server/tools/sandboxGetPricing.ts
+var tool$sandboxGetPricing;
+var init_sandboxGetPricing2 = __esm(() => {
+  init_sandboxGetPricing();
+  init_tools();
+  tool$sandboxGetPricing = {
+    name: "sandbox-get-pricing",
+    description: `Get Sandbox Pricing
+
+Current sandbox pricing rate card, keyed by SKU (\`standard\`, \`browser\`, \`eval-python\`). Metered sandbox usage is billed \`hours × (per_hour + reserved_memory_GiB × per_gib_hour)\`; SKUs without a configured rate accrue no spend. Cluster admins only.`,
+    tool: async (client, ctx) => {
+      const [result, apiCall] = await sandboxGetPricing(client, { 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/sandboxGetWorkspace.ts
+function sandboxGetWorkspace(client, request, options) {
+  return new APIPromise($do313(client, request, options));
+}
+async function $do313(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetWorkspaceRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    session_id: encodeSimple("session_id", payload.session_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/workspace")(pathParams);
+  const query = encodeFormQuery({
+    session_token: payload.session_token
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getWorkspace",
+    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,
+    query,
+    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, WorkspaceManifest$inboundSchema), jsonErr(422, HTTPValidationError$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_reposList = __esm(() => {
+var init_sandboxGetWorkspace = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -135707,30 +137028,29 @@ var init_reposList = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
+  init_components();
   init_errors4();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/reposList.ts
-var args297, tool$reposList;
-var init_reposList2 = __esm(() => {
-  init_reposList();
+// src/mcp-server/tools/sandboxGetWorkspace.ts
+var args304, tool$sandboxGetWorkspace;
+var init_sandboxGetWorkspace2 = __esm(() => {
+  init_sandboxGetWorkspace();
   init_operations();
   init_tools();
-  args297 = {
-    request: ListReposRequest$inboundSchema
+  args304 = {
+    request: GetWorkspaceRequest$inboundSchema
   };
-  tool$reposList = {
-    name: "repos-list",
-    description: `List the caller's org's repositories
+  tool$sandboxGetWorkspace = {
+    name: "sandbox-get-workspace",
+    description: `Get Workspace Manifest
 
-Returns every repository in the caller's org (org owner/admin only).
-Pure DB read.
-`,
-    args: args297,
-    tool: async (client, args298, ctx) => {
-      const [result, apiCall] = await reposList(client, args298.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+List files currently stored in the session workspace, including paths, sizes, and etags.`,
+    args: args304,
+    tool: async (client, args305, ctx) => {
+      const [result, apiCall] = await sandboxGetWorkspace(client, args305.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135743,30 +137063,19 @@ Pure DB read.
   };
 });
 
-// src/funcs/reposUpdate.ts
-function reposUpdate(client, request, options) {
-  return new APIPromise($do306(client, request, options));
+// src/funcs/sandboxList.ts
+function sandboxList(client, request, options) {
+  return new APIPromise($do314(client, request, options));
 }
-async function $do306(client, request, options) {
-  const parsed = safeParse4(request, (value) => PatchRepoRequest$outboundSchema2.parse(value), "Input validation failed");
+async function $do314(client, request, options) {
+  const parsed = safeParse4(request, (value) => ListSessionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.PatchRepoRequest, { explode: true });
-  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}")(pathParams);
+  const body = null;
+  const path = pathToFunc("/api/v1/sandbox/sessions")();
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
     Accept: "application/json",
     "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
   }));
@@ -135776,7 +137085,7 @@ async function $do306(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "patchRepo",
+    operationID: "listSessions",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -135794,7 +137103,7 @@ async function $do306(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "PATCH",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -135819,13 +137128,14 @@ async function $do306(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, Repo$inboundSchema), jsonErr([400, 401, 403, 404, 409], RepoError$inboundSchema), jsonErr(500, RepoError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, arrayType(SessionRecord$inboundSchema)), jsonErr(422, HTTPValidationError$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_reposUpdate = __esm(() => {
+var init_sandboxList = __esm(() => {
+  init_esm();
   init_encodings();
   init_http();
   init_matchers();
@@ -135839,26 +137149,23 @@ var init_reposUpdate = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/reposUpdate.ts
-var args298, tool$reposUpdate;
-var init_reposUpdate2 = __esm(() => {
-  init_reposUpdate();
+// src/mcp-server/tools/sandboxList.ts
+var args305, tool$sandboxList;
+var init_sandboxList2 = __esm(() => {
+  init_sandboxList();
   init_operations();
   init_tools();
-  args298 = {
-    request: PatchRepoRequest$inboundSchema2
+  args305 = {
+    request: ListSessionsRequest$inboundSchema
   };
-  tool$reposUpdate = {
-    name: "repos-update",
-    description: `Update a repository's labels
+  tool$sandboxList = {
+    name: "sandbox-list",
+    description: `List Sessions
 
-Applies a label-only update (name/description); org owner/admin only.
-The repository id is stable, so a rename is a one-row DB update — no
-Gitea write. Omitted fields are left unchanged.
-`,
-    args: args298,
-    tool: async (client, args299, ctx) => {
-      const [result, apiCall] = await reposUpdate(client, args299.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+List sandbox sessions visible to the authenticated caller.`,
+    args: args305,
+    tool: async (client, args306, ctx) => {
+      const [result, apiCall] = await sandboxList(client, args306.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135871,22 +137178,36 @@ Gitea write. Omitted fields are left unchanged.
   };
 });
 
-// src/funcs/sandboxCreate.ts
-function sandboxCreate(client, request, options) {
-  return new APIPromise($do307(client, request, options));
+// src/funcs/sandboxProxyBrowserPortRequest.ts
+function sandboxProxyBrowserPortRequest(client, request, options) {
+  return new APIPromise($do315(client, request, options));
 }
-async function $do307(client, request, options) {
-  const parsed = safeParse4(request, (value) => CreateSessionRequest$outboundSchema2.parse(value), "Input validation failed");
+async function $do315(client, request, options) {
+  const parsed = safeParse4(request, (value) => ProxyBrowserPortRequestRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.CreateSessionRequest, {
-    explode: true
+  const body = null;
+  const pathParams = {
+    port: encodeSimple("port", payload.port, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    session_id: encodeSimple("session_id", payload.session_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    subpath: encodeSimple("subpath", payload.subpath, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/ports/{port}/{subpath}")(pathParams);
+  const query = encodeFormQuery({
+    session_token: payload.session_token
   });
-  const path = pathToFunc("/api/v1/sandbox/sessions")();
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
     Accept: "application/json",
     "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
   }));
@@ -135896,7 +137217,7 @@ async function $do307(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "createSession",
+    operationID: "proxyBrowserPortRequest",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -135914,10 +137235,11 @@ async function $do307(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -135939,13 +137261,14 @@ async function $do307(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json([200, 202], CreateSessionResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail([501, "5XX"]))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, anyType()), jsonErr(422, HTTPValidationError$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_sandboxCreate = __esm(() => {
+var init_sandboxProxyBrowserPortRequest = __esm(() => {
+  init_esm();
   init_encodings();
   init_http();
   init_matchers();
@@ -135953,29 +137276,28 @@ var init_sandboxCreate = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
-  init_components();
   init_errors4();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/sandboxCreate.ts
-var args299, tool$sandboxCreate;
-var init_sandboxCreate2 = __esm(() => {
-  init_sandboxCreate();
+// src/mcp-server/tools/sandboxProxyBrowserPortRequest.ts
+var args306, tool$sandboxProxyBrowserPortRequest;
+var init_sandboxProxyBrowserPortRequest2 = __esm(() => {
+  init_sandboxProxyBrowserPortRequest();
   init_operations();
   init_tools();
-  args299 = {
-    request: CreateSessionRequest$inboundSchema2
+  args306 = {
+    request: ProxyBrowserPortRequestRequest$inboundSchema
   };
-  tool$sandboxCreate = {
-    name: "sandbox-create",
-    description: `Create Session
+  tool$sandboxProxyBrowserPortRequest = {
+    name: "sandbox-proxy-browser-port-request",
+    description: `Proxy Browser Port Request
 
-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: args299,
-    tool: async (client, args300, ctx) => {
-      const [result, apiCall] = await sandboxCreate(client, args300.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+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: args306,
+    tool: async (client, args307, ctx) => {
+      const [result, apiCall] = await sandboxProxyBrowserPortRequest(client, args307.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -135988,32 +137310,27 @@ Create a sandbox session and return its public session metadata, session token,
   };
 });
 
-// src/funcs/sandboxDownloadArchive.ts
-function sandboxDownloadArchive(client, request, options) {
-  return new APIPromise($do308(client, request, options));
+// src/funcs/sandboxRunCode.ts
+function sandboxRunCode(client, request, options) {
+  return new APIPromise($do316(client, request, options));
 }
-async function $do308(client, request, options) {
-  const parsed = safeParse4(request, (value) => DownloadWorkspaceArchiveRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do316(client, request, options) {
+  const parsed = safeParse4(request, (value) => RunCodeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.WorkspaceArchiveRequest, {
-    explode: true
-  });
+  const body = encodeJSON("body", payload.CodeRequest, { explode: true });
   const pathParams = {
     session_id: encodeSimple("session_id", payload.session_id, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/workspace/archive")(pathParams);
-  const query = encodeFormQuery({
-    session_token: payload.session_token
-  });
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/code")(pathParams);
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
-    Accept: "application/zip",
+    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);
@@ -136022,7 +137339,7 @@ async function $do308(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "downloadWorkspaceArchive",
+    operationID: "runCode",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -136044,7 +137361,6 @@ async function $do308(client, request, options) {
     baseURL: options?.serverURL,
     path,
     headers,
-    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -136066,16 +137382,13 @@ async function $do308(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(stream(200, instanceOfType(ReadableStream), {
-    ctype: "application/zip"
-  }), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, CodeResult$inboundSchema), jsonErr(422, HTTPValidationError$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_sandboxDownloadArchive = __esm(() => {
-  init_esm();
+var init_sandboxRunCode = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -136083,28 +137396,29 @@ var init_sandboxDownloadArchive = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
+  init_components();
   init_errors4();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/sandboxDownloadArchive.ts
-var args300, tool$sandboxDownloadArchive;
-var init_sandboxDownloadArchive2 = __esm(() => {
-  init_sandboxDownloadArchive();
+// src/mcp-server/tools/sandboxRunCode.ts
+var args307, tool$sandboxRunCode;
+var init_sandboxRunCode2 = __esm(() => {
+  init_sandboxRunCode();
   init_operations();
   init_tools();
-  args300 = {
-    request: DownloadWorkspaceArchiveRequest$inboundSchema
+  args307 = {
+    request: RunCodeRequest$inboundSchema
   };
-  tool$sandboxDownloadArchive = {
-    name: "sandbox-download-archive",
-    description: `Download Workspace Archive
+  tool$sandboxRunCode = {
+    name: "sandbox-run-code",
+    description: `Run Code
 
-Download a zip archive containing the selected workspace paths.`,
-    args: args300,
-    tool: async (client, args301, ctx) => {
-      const [result, apiCall] = await sandboxDownloadArchive(client, args301.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Execute source code in the session workspace using a supported runtime and return the execution result.`,
+    args: args307,
+    tool: async (client, args308, ctx) => {
+      const [result, apiCall] = await sandboxRunCode(client, args308.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136117,33 +137431,27 @@ Download a zip archive containing the selected workspace paths.`,
   };
 });
 
-// src/funcs/sandboxDownloadFile.ts
-function sandboxDownloadFile(client, request, options) {
-  return new APIPromise($do309(client, request, options));
+// src/funcs/sandboxRunCommand.ts
+function sandboxRunCommand(client, request, options) {
+  return new APIPromise($do317(client, request, options));
 }
-async function $do309(client, request, options) {
-  const parsed = safeParse4(request, (value) => DownloadWorkspaceFileRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do317(client, request, options) {
+  const parsed = safeParse4(request, (value) => RunCommandRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
+  const body = encodeJSON("body", payload.CommandRequest, { explode: true });
   const pathParams = {
-    file_path: encodeSimple("file_path", payload.file_path, {
-      explode: false,
-      charEncoding: "percent"
-    }),
     session_id: encodeSimple("session_id", payload.session_id, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/workspace/files/{file_path}")(pathParams);
-  const query = encodeFormQuery({
-    session_token: payload.session_token
-  });
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/commands")(pathParams);
   const headers = new Headers(compactMap({
-    Accept: "application/octet-stream",
+    "Content-Type": "application/json",
+    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);
@@ -136152,7 +137460,7 @@ async function $do309(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "downloadWorkspaceFile",
+    operationID: "runCommand",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -136170,11 +137478,10 @@ async function $do309(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
-    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -136196,14 +137503,13 @@ async function $do309(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(stream(200, instanceOfType(ReadableStream)), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, CommandResult$inboundSchema), jsonErr(422, HTTPValidationError$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_sandboxDownloadFile = __esm(() => {
-  init_esm();
+var init_sandboxRunCommand = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -136211,28 +137517,29 @@ var init_sandboxDownloadFile = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
+  init_components();
   init_errors4();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/sandboxDownloadFile.ts
-var args301, tool$sandboxDownloadFile;
-var init_sandboxDownloadFile2 = __esm(() => {
-  init_sandboxDownloadFile();
+// src/mcp-server/tools/sandboxRunCommand.ts
+var args308, tool$sandboxRunCommand;
+var init_sandboxRunCommand2 = __esm(() => {
+  init_sandboxRunCommand();
   init_operations();
   init_tools();
-  args301 = {
-    request: DownloadWorkspaceFileRequest$inboundSchema
+  args308 = {
+    request: RunCommandRequest$inboundSchema
   };
-  tool$sandboxDownloadFile = {
-    name: "sandbox-download-file",
-    description: `Download Workspace File
+  tool$sandboxRunCommand = {
+    name: "sandbox-run-command",
+    description: `Run Command
 
-Download raw bytes from a file in the session workspace.`,
-    args: args301,
-    tool: async (client, args302, ctx) => {
-      const [result, apiCall] = await sandboxDownloadFile(client, args302.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Run a command in the session workspace and return stdout, stderr, exit code, and changed files.`,
+    args: args308,
+    tool: async (client, args309, ctx) => {
+      const [result, apiCall] = await sandboxRunCommand(client, args309.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136245,27 +137552,21 @@ Download raw bytes from a file in the session workspace.`,
   };
 });
 
-// src/funcs/sandboxGet.ts
-function sandboxGet(client, request, options) {
-  return new APIPromise($do310(client, request, options));
+// src/funcs/sandboxSetPricing.ts
+function sandboxSetPricing(client, request, options) {
+  return new APIPromise($do318(client, request, options));
 }
-async function $do310(client, request, options) {
-  const parsed = safeParse4(request, (value) => GetSessionRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do318(client, request, options) {
+  const parsed = safeParse4(request, (value) => SandboxPricingUpdate$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
-  const pathParams = {
-    session_id: encodeSimple("session_id", payload.session_id, {
-      explode: false,
-      charEncoding: "percent"
-    })
-  };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}")(pathParams);
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/api/v1/sandbox/pricing")();
   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" })
+    "Content-Type": "application/json",
+    Accept: "application/json"
   }));
   const secConfig = await extractSecurity(client._options.bearerAuth);
   const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
@@ -136273,7 +137574,7 @@ async function $do310(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getSession",
+    operationID: "setSandboxPricing",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -136291,7 +137592,7 @@ async function $do310(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "PUT",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -136316,13 +137617,13 @@ async function $do310(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, SessionRecord$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, SandboxPricingCard$inboundSchema), jsonErr(422, HTTPValidationError$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_sandboxGet = __esm(() => {
+var init_sandboxSetPricing = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -136332,27 +137633,26 @@ var init_sandboxGet = __esm(() => {
   init_url();
   init_components();
   init_errors4();
-  init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/sandboxGet.ts
-var args302, tool$sandboxGet;
-var init_sandboxGet2 = __esm(() => {
-  init_sandboxGet();
-  init_operations();
+// src/mcp-server/tools/sandboxSetPricing.ts
+var args309, tool$sandboxSetPricing;
+var init_sandboxSetPricing2 = __esm(() => {
+  init_sandboxSetPricing();
+  init_components();
   init_tools();
-  args302 = {
-    request: GetSessionRequest$inboundSchema
+  args309 = {
+    request: SandboxPricingUpdate$inboundSchema
   };
-  tool$sandboxGet = {
-    name: "sandbox-get",
-    description: `Get Session
+  tool$sandboxSetPricing = {
+    name: "sandbox-set-pricing",
+    description: `Set Sandbox Pricing
 
-Return the current state, configuration, and resource allocation for a sandbox session.`,
-    args: args302,
-    tool: async (client, args303, ctx) => {
-      const [result, apiCall] = await sandboxGet(client, args303.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+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: args309,
+    tool: async (client, args310, ctx) => {
+      const [result, apiCall] = await sandboxSetPricing(client, args310.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136365,28 +137665,28 @@ Return the current state, configuration, and resource allocation for a sandbox s
   };
 });
 
-// src/funcs/sandboxGetBrowserUrl.ts
-function sandboxGetBrowserUrl(client, request, options) {
-  return new APIPromise($do311(client, request, options));
+// src/funcs/sandboxTerminate.ts
+function sandboxTerminate(client, request, options) {
+  return new APIPromise($do319(client, request, options));
 }
-async function $do311(client, request, options) {
-  const parsed = safeParse4(request, (value) => GetBrowserSessionUrlRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do319(client, request, options) {
+  const parsed = safeParse4(request, (value) => TerminateSessionRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
+  const body = encodeJSON("body", payload.TerminateSessionRequest, {
+    explode: true
+  });
   const pathParams = {
     session_id: encodeSimple("session_id", payload.session_id, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/browser-url")(pathParams);
-  const query = encodeFormQuery({
-    session_token: payload.session_token
-  });
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/terminate")(pathParams);
   const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
     Accept: "application/json",
     "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
   }));
@@ -136396,7 +137696,7 @@ async function $do311(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getBrowserSessionUrl",
+    operationID: "terminateSession",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -136414,11 +137714,10 @@ async function $do311(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
-    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -136440,13 +137739,13 @@ async function $do311(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, SessionUrlResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail([501, "5XX"]))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, TerminateSessionResponse$inboundSchema), jsonErr(422, HTTPValidationError$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_sandboxGetBrowserUrl = __esm(() => {
+var init_sandboxTerminate = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -136460,23 +137759,23 @@ var init_sandboxGetBrowserUrl = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/sandboxGetBrowserUrl.ts
-var args303, tool$sandboxGetBrowserUrl;
-var init_sandboxGetBrowserUrl2 = __esm(() => {
-  init_sandboxGetBrowserUrl();
+// src/mcp-server/tools/sandboxTerminate.ts
+var args310, tool$sandboxTerminate;
+var init_sandboxTerminate2 = __esm(() => {
+  init_sandboxTerminate();
   init_operations();
   init_tools();
-  args303 = {
-    request: GetBrowserSessionUrlRequest$inboundSchema
+  args310 = {
+    request: TerminateSessionRequest$inboundSchema2
   };
-  tool$sandboxGetBrowserUrl = {
-    name: "sandbox-get-browser-url",
-    description: `Get Browser Session URL
+  tool$sandboxTerminate = {
+    name: "sandbox-terminate",
+    description: `Terminate Session
 
-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: args303,
-    tool: async (client, args304, ctx) => {
-      const [result, apiCall] = await sandboxGetBrowserUrl(client, args304.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Stop a sandbox session and release the backing sandbox resources.`,
+    args: args310,
+    tool: async (client, args311, ctx) => {
+      const [result, apiCall] = await sandboxTerminate(client, args311.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136489,14 +137788,31 @@ 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($do312(client, options));
+// src/funcs/sandboxUploadArchive.ts
+function sandboxUploadArchive(client, request, options) {
+  return new APIPromise($do320(client, request, options));
 }
-async function $do312(client, options) {
-  const path = pathToFunc("/api/v1/sandbox/pricing")();
+async function $do320(client, request, options) {
+  const parsed = safeParse4(request, (value) => UploadWorkspaceArchiveRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = payload.RequestBody instanceof Uint8Array ? new Uint8Array(payload.RequestBody).buffer : payload.RequestBody;
+  const pathParams = {
+    session_id: encodeSimple("session_id", payload.session_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/workspace/archive")(pathParams);
+  const query = encodeFormQuery({
+    session_token: payload.session_token
+  });
   const headers = new Headers(compactMap({
-    Accept: "application/json"
+    "Content-Type": "application/zip",
+    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 };
@@ -136504,7 +137820,7 @@ async function $do312(client, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getSandboxPricing",
+    operationID: "uploadWorkspaceArchive",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -136522,10 +137838,12 @@ async function $do312(client, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "PUT",
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
+    body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
@@ -136543,34 +137861,46 @@ async function $do312(client, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(json(200, SandboxPricingCard$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, recordType(stringType())), jsonErr(422, HTTPValidationError$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_sandboxGetPricing = __esm(() => {
+var init_sandboxUploadArchive = __esm(() => {
+  init_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/sandboxGetPricing.ts
-var tool$sandboxGetPricing;
-var init_sandboxGetPricing2 = __esm(() => {
-  init_sandboxGetPricing();
+// src/mcp-server/tools/sandboxUploadArchive.ts
+var args311, tool$sandboxUploadArchive;
+var init_sandboxUploadArchive2 = __esm(() => {
+  init_sandboxUploadArchive();
+  init_operations();
   init_tools();
-  tool$sandboxGetPricing = {
-    name: "sandbox-get-pricing",
-    description: `Get Sandbox Pricing
+  args311 = {
+    request: UploadWorkspaceArchiveRequest$inboundSchema
+  };
+  tool$sandboxUploadArchive = {
+    name: "sandbox-upload-archive",
+    description: `Upload Workspace Archive
 
-Current sandbox pricing rate card, keyed by SKU (\`standard\`, \`browser\`, \`eval-python\`). Metered sandbox usage is billed \`hours × (per_hour + reserved_memory_GiB × per_gib_hour)\`; SKUs without a configured rate accrue no spend. Cluster admins only.`,
-    tool: async (client, ctx) => {
-      const [result, apiCall] = await sandboxGetPricing(client, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Upload a zip archive and extract its files into the session workspace.`,
+    args: args311,
+    tool: async (client, args312, ctx) => {
+      const [result, apiCall] = await sandboxUploadArchive(client, args312.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136583,28 +137913,33 @@ Current sandbox pricing rate card, keyed by SKU (\`standard\`, \`browser\`, \`ev
   };
 });
 
-// src/funcs/sandboxGetWorkspace.ts
-function sandboxGetWorkspace(client, request, options) {
-  return new APIPromise($do313(client, request, options));
+// src/funcs/sandboxUploadFile.ts
+function sandboxUploadFile(client, request, options) {
+  return new APIPromise($do321(client, request, options));
 }
-async function $do313(client, request, options) {
-  const parsed = safeParse4(request, (value) => GetWorkspaceRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do321(client, request, options) {
+  const parsed = safeParse4(request, (value) => UploadWorkspaceFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
+  const body = payload.RequestBody instanceof Uint8Array ? new Uint8Array(payload.RequestBody).buffer : payload.RequestBody;
   const pathParams = {
+    file_path: encodeSimple("file_path", payload.file_path, {
+      explode: false,
+      charEncoding: "percent"
+    }),
     session_id: encodeSimple("session_id", payload.session_id, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/workspace")(pathParams);
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/workspace/files/{file_path}")(pathParams);
   const query = encodeFormQuery({
     session_token: payload.session_token
   });
   const headers = new Headers(compactMap({
+    "Content-Type": "application/octet-stream",
     Accept: "application/json",
     "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
   }));
@@ -136614,7 +137949,7 @@ async function $do313(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getWorkspace",
+    operationID: "uploadWorkspaceFile",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -136632,7 +137967,7 @@ async function $do313(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "PUT",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -136658,13 +137993,14 @@ async function $do313(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, WorkspaceManifest$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, recordType(stringType())), jsonErr(422, HTTPValidationError$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_sandboxGetWorkspace = __esm(() => {
+var init_sandboxUploadFile = __esm(() => {
+  init_esm();
   init_encodings();
   init_http();
   init_matchers();
@@ -136672,29 +138008,28 @@ var init_sandboxGetWorkspace = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
-  init_components();
   init_errors4();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/sandboxGetWorkspace.ts
-var args304, tool$sandboxGetWorkspace;
-var init_sandboxGetWorkspace2 = __esm(() => {
-  init_sandboxGetWorkspace();
+// src/mcp-server/tools/sandboxUploadFile.ts
+var args312, tool$sandboxUploadFile;
+var init_sandboxUploadFile2 = __esm(() => {
+  init_sandboxUploadFile();
   init_operations();
   init_tools();
-  args304 = {
-    request: GetWorkspaceRequest$inboundSchema
+  args312 = {
+    request: UploadWorkspaceFileRequest$inboundSchema
   };
-  tool$sandboxGetWorkspace = {
-    name: "sandbox-get-workspace",
-    description: `Get Workspace Manifest
+  tool$sandboxUploadFile = {
+    name: "sandbox-upload-file",
+    description: `Upload Workspace File
 
-List files currently stored in the session workspace, including paths, sizes, and etags.`,
-    args: args304,
-    tool: async (client, args305, ctx) => {
-      const [result, apiCall] = await sandboxGetWorkspace(client, args305.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Upload raw bytes into the session workspace at the given path.`,
+    args: args312,
+    tool: async (client, args313, ctx) => {
+      const [result, apiCall] = await sandboxUploadFile(client, args313.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136707,19 +138042,20 @@ List files currently stored in the session workspace, including paths, sizes, an
   };
 });
 
-// src/funcs/sandboxList.ts
-function sandboxList(client, request, options) {
-  return new APIPromise($do314(client, request, options));
+// src/funcs/schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost.ts
+function schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost(client, request, options) {
+  return new APIPromise($do322(client, request, options));
 }
-async function $do314(client, request, options) {
-  const parsed = safeParse4(request, (value) => ListSessionsRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do322(client, request, options) {
+  const parsed = safeParse4(request, (value) => ConnectApiV1SandboxGithubOauthConnectionsPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
-  const path = pathToFunc("/api/v1/sandbox/sessions")();
+  const body = encodeJSON("body", payload.ConnectRequest, { explode: true });
+  const path = pathToFunc("/api/v1/sandbox/github/oauth/connections")();
   const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
     Accept: "application/json",
     "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
   }));
@@ -136729,7 +138065,7 @@ async function $do314(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "listSessions",
+    operationID: "connect_api_v1_sandbox_github_oauth_connections_post",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -136747,7 +138083,7 @@ async function $do314(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -136772,14 +138108,13 @@ async function $do314(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, arrayType(SessionRecord$inboundSchema)), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(201, Connection$inboundSchema), jsonErr(422, HTTPValidationError$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_sandboxList = __esm(() => {
-  init_esm();
+var init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -136793,23 +138128,21 @@ var init_sandboxList = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/sandboxList.ts
-var args305, tool$sandboxList;
-var init_sandboxList2 = __esm(() => {
-  init_sandboxList();
+// src/mcp-server/tools/schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost.ts
+var args313, tool$schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost;
+var init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost2 = __esm(() => {
+  init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost();
   init_operations();
   init_tools();
-  args305 = {
-    request: ListSessionsRequest$inboundSchema
+  args313 = {
+    request: ConnectApiV1SandboxGithubOauthConnectionsPostRequest$inboundSchema
   };
-  tool$sandboxList = {
-    name: "sandbox-list",
-    description: `List Sessions
-
-List sandbox sessions visible to the authenticated caller.`,
-    args: args305,
-    tool: async (client, args306, ctx) => {
-      const [result, apiCall] = await sandboxList(client, args306.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  tool$schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost = {
+    name: "schema-3-other-connect-api-v1-sandbox-github-oauth-connections-post",
+    description: `Connect`,
+    args: args313,
+    tool: async (client, args314, ctx) => {
+      const [result, apiCall] = await schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost(client, args314.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136822,35 +138155,18 @@ List sandbox sessions visible to the authenticated caller.`,
   };
 });
 
-// src/funcs/sandboxProxyBrowserPortRequest.ts
-function sandboxProxyBrowserPortRequest(client, request, options) {
-  return new APIPromise($do315(client, request, options));
+// src/funcs/schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost.ts
+function schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost(client, request, options) {
+  return new APIPromise($do323(client, request, options));
 }
-async function $do315(client, request, options) {
-  const parsed = safeParse4(request, (value) => ProxyBrowserPortRequestRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do323(client, request, options) {
+  const parsed = safeParse4(request, (value) => CreateIntentApiV1SandboxGithubOauthIntentsPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
-  const pathParams = {
-    port: encodeSimple("port", payload.port, {
-      explode: false,
-      charEncoding: "percent"
-    }),
-    session_id: encodeSimple("session_id", payload.session_id, {
-      explode: false,
-      charEncoding: "percent"
-    }),
-    subpath: encodeSimple("subpath", payload.subpath, {
-      explode: false,
-      charEncoding: "percent"
-    })
-  };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/ports/{port}/{subpath}")(pathParams);
-  const query = encodeFormQuery({
-    session_token: payload.session_token
-  });
+  const path = pathToFunc("/api/v1/sandbox/github/oauth/intents")();
   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" })
@@ -136861,7 +138177,7 @@ async function $do315(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "proxyBrowserPortRequest",
+    operationID: "create_intent_api_v1_sandbox_github_oauth_intents_post",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -136879,11 +138195,10 @@ async function $do315(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
-    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -136902,17 +138217,13 @@ async function $do315(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const responseFields = {
-    HttpMeta: { Response: response, Request: req }
-  };
-  const [result] = await match(json(200, anyType()), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(201, AuthorizeIntent$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_sandboxProxyBrowserPortRequest = __esm(() => {
-  init_esm();
+var init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -136920,28 +138231,26 @@ var init_sandboxProxyBrowserPortRequest = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
-  init_errors4();
+  init_components();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/sandboxProxyBrowserPortRequest.ts
-var args306, tool$sandboxProxyBrowserPortRequest;
-var init_sandboxProxyBrowserPortRequest2 = __esm(() => {
-  init_sandboxProxyBrowserPortRequest();
+// src/mcp-server/tools/schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost.ts
+var args314, tool$schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost;
+var init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost2 = __esm(() => {
+  init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost();
   init_operations();
   init_tools();
-  args306 = {
-    request: ProxyBrowserPortRequestRequest$inboundSchema
+  args314 = {
+    request: CreateIntentApiV1SandboxGithubOauthIntentsPostRequest$inboundSchema
   };
-  tool$sandboxProxyBrowserPortRequest = {
-    name: "sandbox-proxy-browser-port-request",
-    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: args306,
-    tool: async (client, args307, ctx) => {
-      const [result, apiCall] = await sandboxProxyBrowserPortRequest(client, args307.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  tool$schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost = {
+    name: "schema-3-other-create-intent-api-v1-sandbox-github-oauth-intents-post",
+    description: `Create Intent`,
+    args: args314,
+    tool: async (client, args315, ctx) => {
+      const [result, apiCall] = await schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost(client, args315.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -136954,27 +138263,20 @@ 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($do316(client, request, options));
+// src/funcs/schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete.ts
+function schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, request, options) {
+  return new APIPromise($do324(client, request, options));
 }
-async function $do316(client, request, options) {
-  const parsed = safeParse4(request, (value) => RunCodeRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do324(client, request, options) {
+  const parsed = safeParse4(request, (value) => DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.CodeRequest, { explode: true });
-  const pathParams = {
-    session_id: encodeSimple("session_id", payload.session_id, {
-      explode: false,
-      charEncoding: "percent"
-    })
-  };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/code")(pathParams);
+  const body = null;
+  const path = pathToFunc("/api/v1/sandbox/github/oauth/connections")();
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
-    Accept: "application/json",
+    Accept: "*/*",
     "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);
@@ -136983,7 +138285,7 @@ async function $do316(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "runCode",
+    operationID: "disconnect_api_v1_sandbox_github_oauth_connections_delete",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -137001,7 +138303,7 @@ async function $do316(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "DELETE",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -137023,16 +138325,14 @@ async function $do316(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const responseFields = {
-    HttpMeta: { Response: response, Request: req }
-  };
-  const [result] = await match(json(200, CodeResult$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(nil(204, voidType()), fail("4XX"), fail("5XX"))(response, req);
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_sandboxRunCode = __esm(() => {
+var init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete = __esm(() => {
+  init_esm();
   init_encodings();
   init_http();
   init_matchers();
@@ -137040,61 +138340,49 @@ var init_sandboxRunCode = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
-  init_components();
-  init_errors4();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/sandboxRunCode.ts
-var args307, tool$sandboxRunCode;
-var init_sandboxRunCode2 = __esm(() => {
-  init_sandboxRunCode();
+// src/mcp-server/tools/schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete.ts
+var args315, tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete;
+var init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete2 = __esm(() => {
+  init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete();
   init_operations();
   init_tools();
-  args307 = {
-    request: RunCodeRequest$inboundSchema
+  args315 = {
+    request: DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$inboundSchema
   };
-  tool$sandboxRunCode = {
-    name: "sandbox-run-code",
-    description: `Run Code
-
-Execute source code in the session workspace using a supported runtime and return the execution result.`,
-    args: args307,
-    tool: async (client, args308, ctx) => {
-      const [result, apiCall] = await sandboxRunCode(client, args308.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete = {
+    name: "schema-3-other-disconnect-api-v1-sandbox-github-oauth-connections-delete",
+    description: `Disconnect`,
+    args: args315,
+    tool: async (client, args316, ctx) => {
+      const [result, apiCall] = await schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, args316.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);
+      return formatResult(undefined, apiCall);
     }
   };
 });
 
-// src/funcs/sandboxRunCommand.ts
-function sandboxRunCommand(client, request, options) {
-  return new APIPromise($do317(client, request, options));
+// src/funcs/schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet.ts
+function schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet(client, request, options) {
+  return new APIPromise($do325(client, request, options));
 }
-async function $do317(client, request, options) {
-  const parsed = safeParse4(request, (value) => RunCommandRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do325(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.CommandRequest, { explode: true });
-  const pathParams = {
-    session_id: encodeSimple("session_id", payload.session_id, {
-      explode: false,
-      charEncoding: "percent"
-    })
-  };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/commands")(pathParams);
+  const body = null;
+  const path = pathToFunc("/api/v1/sandbox/github/oauth/connections")();
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
     Accept: "application/json",
     "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
   }));
@@ -137104,7 +138392,7 @@ async function $do317(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "runCommand",
+    operationID: "get_connection_api_v1_sandbox_github_oauth_connections_get",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -137122,7 +138410,7 @@ async function $do317(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -137144,16 +138432,13 @@ async function $do317(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const responseFields = {
-    HttpMeta: { Response: response, Request: req }
-  };
-  const [result] = await match(json(200, CommandResult$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, ConnectionEnvelope$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_sandboxRunCommand = __esm(() => {
+var init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -137162,28 +138447,25 @@ var init_sandboxRunCommand = __esm(() => {
   init_security();
   init_url();
   init_components();
-  init_errors4();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/sandboxRunCommand.ts
-var args308, tool$sandboxRunCommand;
-var init_sandboxRunCommand2 = __esm(() => {
-  init_sandboxRunCommand();
+// src/mcp-server/tools/schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet.ts
+var args316, tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet;
+var init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet2 = __esm(() => {
+  init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet();
   init_operations();
   init_tools();
-  args308 = {
-    request: RunCommandRequest$inboundSchema
-  };
-  tool$sandboxRunCommand = {
-    name: "sandbox-run-command",
-    description: `Run Command
-
-Run a command in the session workspace and return stdout, stderr, exit code, and changed files.`,
-    args: args308,
-    tool: async (client, args309, ctx) => {
-      const [result, apiCall] = await sandboxRunCommand(client, args309.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  args316 = {
+    request: GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$inboundSchema
+  };
+  tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet = {
+    name: "schema-3-other-get-connection-api-v1-sandbox-github-oauth-connections-get",
+    description: `Get Connection`,
+    args: args316,
+    tool: async (client, args317, ctx) => {
+      const [result, apiCall] = await schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet(client, args317.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137196,21 +138478,21 @@ 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($do318(client, request, options));
+// src/funcs/schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet.ts
+function schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet(client, request, options) {
+  return new APIPromise($do326(client, request, options));
 }
-async function $do318(client, request, options) {
-  const parsed = safeParse4(request, (value) => SandboxPricingUpdate$outboundSchema.parse(value), "Input validation failed");
+async function $do326(client, request, options) {
+  const parsed = safeParse4(request, (value) => ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload, { explode: true });
-  const path = pathToFunc("/api/v1/sandbox/pricing")();
+  const body = null;
+  const path = pathToFunc("/api/v1/sandbox/github/repositories")();
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
-    Accept: "application/json"
+    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 };
@@ -137218,7 +138500,7 @@ async function $do318(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "setSandboxPricing",
+    operationID: "list_repositories_api_v1_sandbox_github_repositories_get",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -137236,7 +138518,7 @@ async function $do318(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "PUT",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -137258,16 +138540,13 @@ async function $do318(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const responseFields = {
-    HttpMeta: { Response: response, Request: req }
-  };
-  const [result] = await match(json(200, SandboxPricingCard$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, RepositoryList$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_sandboxSetPricing = __esm(() => {
+var init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -137276,27 +138555,25 @@ var init_sandboxSetPricing = __esm(() => {
   init_security();
   init_url();
   init_components();
-  init_errors4();
+  init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/sandboxSetPricing.ts
-var args309, tool$sandboxSetPricing;
-var init_sandboxSetPricing2 = __esm(() => {
-  init_sandboxSetPricing();
-  init_components();
+// src/mcp-server/tools/schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet.ts
+var args317, tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet;
+var init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet2 = __esm(() => {
+  init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet();
+  init_operations();
   init_tools();
-  args309 = {
-    request: SandboxPricingUpdate$inboundSchema
-  };
-  tool$sandboxSetPricing = {
-    name: "sandbox-set-pricing",
-    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: args309,
-    tool: async (client, args310, ctx) => {
-      const [result, apiCall] = await sandboxSetPricing(client, args310.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  args317 = {
+    request: ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$inboundSchema
+  };
+  tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet = {
+    name: "schema-3-other-list-repositories-api-v1-sandbox-github-repositories-get",
+    description: `List Repositories`,
+    args: args317,
+    tool: async (client, args318, ctx) => {
+      const [result, apiCall] = await schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet(client, args318.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137309,17 +138586,17 @@ Replace the sandbox pricing rate card. Full-replace semantics: SKUs omitted from
   };
 });
 
-// src/funcs/sandboxTerminate.ts
-function sandboxTerminate(client, request, options) {
-  return new APIPromise($do319(client, request, options));
+// src/funcs/schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost.ts
+function schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, request, options) {
+  return new APIPromise($do327(client, request, options));
 }
-async function $do319(client, request, options) {
-  const parsed = safeParse4(request, (value) => TerminateSessionRequest$outboundSchema2.parse(value), "Input validation failed");
+async function $do327(client, request, options) {
+  const parsed = safeParse4(request, (value) => ReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.TerminateSessionRequest, {
+  const body = encodeJSON("body", payload.GitHubReadCloneRequest, {
     explode: true
   });
   const pathParams = {
@@ -137328,7 +138605,7 @@ async function $do319(client, request, options) {
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/terminate")(pathParams);
+  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/github/read-clone")(pathParams);
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
     Accept: "application/json",
@@ -137340,7 +138617,7 @@ async function $do319(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "terminateSession",
+    operationID: "read_clone_api_v1_sandbox_sessions__session_id__github_read_clone_post",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -137383,13 +138660,13 @@ async function $do319(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, TerminateSessionResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, GitHubReadCloneResult$inboundSchema), jsonErr(422, HTTPValidationError$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_sandboxTerminate = __esm(() => {
+var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -137403,148 +138680,21 @@ var init_sandboxTerminate = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/sandboxTerminate.ts
-var args310, tool$sandboxTerminate;
-var init_sandboxTerminate2 = __esm(() => {
-  init_sandboxTerminate();
-  init_operations();
-  init_tools();
-  args310 = {
-    request: TerminateSessionRequest$inboundSchema2
-  };
-  tool$sandboxTerminate = {
-    name: "sandbox-terminate",
-    description: `Terminate Session
-
-Stop a sandbox session and release the backing sandbox resources.`,
-    args: args310,
-    tool: async (client, args311, ctx) => {
-      const [result, apiCall] = await sandboxTerminate(client, args311.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/sandboxUploadArchive.ts
-function sandboxUploadArchive(client, request, options) {
-  return new APIPromise($do320(client, request, options));
-}
-async function $do320(client, request, options) {
-  const parsed = safeParse4(request, (value) => UploadWorkspaceArchiveRequest$outboundSchema.parse(value), "Input validation failed");
-  if (!parsed.ok) {
-    return [parsed, { status: "invalid" }];
-  }
-  const payload = parsed.value;
-  const body = payload.RequestBody instanceof Uint8Array ? new Uint8Array(payload.RequestBody).buffer : payload.RequestBody;
-  const pathParams = {
-    session_id: encodeSimple("session_id", payload.session_id, {
-      explode: false,
-      charEncoding: "percent"
-    })
-  };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/workspace/archive")(pathParams);
-  const query = encodeFormQuery({
-    session_token: payload.session_token
-  });
-  const headers = new Headers(compactMap({
-    "Content-Type": "application/zip",
-    Accept: "application/json",
-    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
-  }));
-  const secConfig = await extractSecurity(client._options.bearerAuth);
-  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
-  const context = {
-    options: client._options,
-    baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "uploadWorkspaceArchive",
-    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: "PUT",
-    baseURL: options?.serverURL,
-    path,
-    headers,
-    query,
-    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, recordType(stringType())), jsonErr(422, HTTPValidationError$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_sandboxUploadArchive = __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/sandboxUploadArchive.ts
-var args311, tool$sandboxUploadArchive;
-var init_sandboxUploadArchive2 = __esm(() => {
-  init_sandboxUploadArchive();
+// src/mcp-server/tools/schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost.ts
+var args318, tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost;
+var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost2 = __esm(() => {
+  init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost();
   init_operations();
   init_tools();
-  args311 = {
-    request: UploadWorkspaceArchiveRequest$inboundSchema
+  args318 = {
+    request: ReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePostRequest$inboundSchema
   };
-  tool$sandboxUploadArchive = {
-    name: "sandbox-upload-archive",
-    description: `Upload Workspace Archive
-
-Upload a zip archive and extract its files into the session workspace.`,
-    args: args311,
-    tool: async (client, args312, ctx) => {
-      const [result, apiCall] = await sandboxUploadArchive(client, args312.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost = {
+    name: "schema-3-other-read-clone-api-v1-sandbox-sessions-session-id-github-read-clone-post",
+    description: `Read Clone`,
+    args: args318,
+    tool: async (client, args319, ctx) => {
+      const [result, apiCall] = await schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, args319.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137557,33 +138707,19 @@ Upload a zip archive and extract its files into the session workspace.`,
   };
 });
 
-// src/funcs/sandboxUploadFile.ts
-function sandboxUploadFile(client, request, options) {
-  return new APIPromise($do321(client, request, options));
+// src/funcs/schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost.ts
+function schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost(client, request, options) {
+  return new APIPromise($do328(client, request, options));
 }
-async function $do321(client, request, options) {
-  const parsed = safeParse4(request, (value) => UploadWorkspaceFileRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do328(client, request, options) {
+  const parsed = safeParse4(request, (value) => RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = payload.RequestBody instanceof Uint8Array ? new Uint8Array(payload.RequestBody).buffer : payload.RequestBody;
-  const pathParams = {
-    file_path: encodeSimple("file_path", payload.file_path, {
-      explode: false,
-      charEncoding: "percent"
-    }),
-    session_id: encodeSimple("session_id", payload.session_id, {
-      explode: false,
-      charEncoding: "percent"
-    })
-  };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/workspace/files/{file_path}")(pathParams);
-  const query = encodeFormQuery({
-    session_token: payload.session_token
-  });
+  const body = null;
+  const path = pathToFunc("/api/v1/sandbox/github/repositories/refresh")();
   const headers = new Headers(compactMap({
-    "Content-Type": "application/octet-stream",
     Accept: "application/json",
     "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
   }));
@@ -137593,7 +138729,7 @@ async function $do321(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "uploadWorkspaceFile",
+    operationID: "refresh_repositories_api_v1_sandbox_github_repositories_refresh_post",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -137611,11 +138747,10 @@ async function $do321(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "PUT",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
-    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -137634,17 +138769,13 @@ async function $do321(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const responseFields = {
-    HttpMeta: { Response: response, Request: req }
-  };
-  const [result] = await match(json(200, recordType(stringType())), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, RepositoryList$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_sandboxUploadFile = __esm(() => {
-  init_esm();
+var init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -137652,28 +138783,26 @@ var init_sandboxUploadFile = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
-  init_errors4();
+  init_components();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/sandboxUploadFile.ts
-var args312, tool$sandboxUploadFile;
-var init_sandboxUploadFile2 = __esm(() => {
-  init_sandboxUploadFile();
+// src/mcp-server/tools/schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost.ts
+var args319, tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost;
+var init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost2 = __esm(() => {
+  init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost();
   init_operations();
   init_tools();
-  args312 = {
-    request: UploadWorkspaceFileRequest$inboundSchema
-  };
-  tool$sandboxUploadFile = {
-    name: "sandbox-upload-file",
-    description: `Upload Workspace File
-
-Upload raw bytes into the session workspace at the given path.`,
-    args: args312,
-    tool: async (client, args313, ctx) => {
-      const [result, apiCall] = await sandboxUploadFile(client, args313.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  args319 = {
+    request: RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$inboundSchema
+  };
+  tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost = {
+    name: "schema-3-other-refresh-repositories-api-v1-sandbox-github-repositories-refresh-post",
+    description: `Refresh Repositories`,
+    args: args319,
+    tool: async (client, args320, ctx) => {
+      const [result, apiCall] = await schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost(client, args320.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137686,26 +138815,20 @@ Upload raw bytes into the session workspace at the given path.`,
   };
 });
 
-// src/funcs/schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost.ts
-function schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, request, options) {
-  return new APIPromise($do322(client, request, options));
+// src/funcs/schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost.ts
+function schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost(client, request, options) {
+  return new APIPromise($do329(client, request, options));
 }
-async function $do322(client, request, options) {
-  const parsed = safeParse4(request, (value) => ReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePostRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do329(client, request, options) {
+  const parsed = safeParse4(request, (value) => ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.GitHubReadCloneRequest, {
+  const body = encodeJSON("body", payload.ResolveReferenceRequest, {
     explode: true
   });
-  const pathParams = {
-    session_id: encodeSimple("session_id", payload.session_id, {
-      explode: false,
-      charEncoding: "percent"
-    })
-  };
-  const path = pathToFunc("/api/v1/sandbox/sessions/{session_id}/github/read-clone")(pathParams);
+  const path = pathToFunc("/api/v1/sandbox/github/repositories/resolve")();
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
     Accept: "application/json",
@@ -137717,7 +138840,7 @@ async function $do322(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "read_clone_api_v1_sandbox_sessions__session_id__github_read_clone_post",
+    operationID: "resolve_reference_api_v1_sandbox_github_repositories_resolve_post",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -137760,13 +138883,13 @@ async function $do322(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, GitHubReadCloneResult$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, ResolvedReference$inboundSchema), jsonErr(422, HTTPValidationError$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_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost = __esm(() => {
+var init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -137780,21 +138903,21 @@ var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost =
   init_async();
 });
 
-// src/mcp-server/tools/schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost.ts
-var args313, tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost;
-var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost2 = __esm(() => {
-  init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost();
+// src/mcp-server/tools/schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost.ts
+var args320, tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost;
+var init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost2 = __esm(() => {
+  init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost();
   init_operations();
   init_tools();
-  args313 = {
-    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: args313,
-    tool: async (client, args314, ctx) => {
-      const [result, apiCall] = await schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, args314.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  args320 = {
+    request: ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$inboundSchema
+  };
+  tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost = {
+    name: "schema-3-other-resolve-reference-api-v1-sandbox-github-repositories-resolve-post",
+    description: `Resolve Reference`,
+    args: args320,
+    tool: async (client, args321, ctx) => {
+      const [result, apiCall] = await schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost(client, args321.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137809,9 +138932,9 @@ var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost2
 
 // src/funcs/usageCosts.ts
 function usageCosts(client, request, options) {
-  return new APIPromise($do323(client, request, options));
+  return new APIPromise($do330(client, request, options));
 }
-async function $do323(client, request, options) {
+async function $do330(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCostsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -137894,12 +139017,12 @@ var init_usageCosts = __esm(() => {
 });
 
 // src/mcp-server/tools/usageCosts.ts
-var args314, tool$usageCosts;
+var args321, tool$usageCosts;
 var init_usageCosts2 = __esm(() => {
   init_usageCosts();
   init_operations();
   init_tools();
-  args314 = {
+  args321 = {
     request: GetCostsRequest$inboundSchema
   };
   tool$usageCosts = {
@@ -137907,9 +139030,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: args314,
-    tool: async (client, args315, ctx) => {
-      const [result, apiCall] = await usageCosts(client, args315.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args321,
+    tool: async (client, args322, ctx) => {
+      const [result, apiCall] = await usageCosts(client, args322.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -137924,9 +139047,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($do324(client, request, options));
+  return new APIPromise($do331(client, request, options));
 }
-async function $do324(client, request, options) {
+async function $do331(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSandboxUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138017,12 +139140,12 @@ var init_usageSandbox = __esm(() => {
 });
 
 // src/mcp-server/tools/usageSandbox.ts
-var args315, tool$usageSandbox;
+var args322, tool$usageSandbox;
 var init_usageSandbox2 = __esm(() => {
   init_usageSandbox();
   init_operations();
   init_tools();
-  args315 = {
+  args322 = {
     request: GetSandboxUsageRequest$inboundSchema
   };
   tool$usageSandbox = {
@@ -138030,9 +139153,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: args315,
-    tool: async (client, args316, ctx) => {
-      const [result, apiCall] = await usageSandbox(client, args316.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args322,
+    tool: async (client, args323, ctx) => {
+      const [result, apiCall] = await usageSandbox(client, args323.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138049,7 +139172,7 @@ Aggregate sandbox usage (session lifecycle, execution, and workspace operations)
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.53.29"
+    version: "0.53.30"
   });
   const client = new SDKCore({
     bearerAuth: deps.bearerAuth,
@@ -138068,6 +139191,13 @@ function createMCPServer(deps) {
   tool(tool$guardrailsDeleteGuardrails);
   tool(tool$guardrailsListGuardrailsPolicies);
   tool(tool$guardrailsTestGuardrails);
+  tool(tool$schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost);
+  tool(tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet);
+  tool(tool$schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost);
+  tool(tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete);
+  tool(tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet);
+  tool(tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost);
+  tool(tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost);
   tool(tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost);
   tool(tool$sandboxCreate);
   tool(tool$sandboxList);
@@ -138715,7 +139845,14 @@ var init_server2 = __esm(() => {
   init_sandboxTerminate2();
   init_sandboxUploadArchive2();
   init_sandboxUploadFile2();
+  init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost2();
+  init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost2();
+  init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete2();
+  init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet2();
+  init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet2();
   init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost2();
+  init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost2();
+  init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost2();
   init_usageCosts2();
   init_usageSandbox2();
 });
@@ -139895,7 +141032,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.53.29"
+    currentVersion: "0.53.30"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -139903,5 +141040,5 @@ export {
   app
 };
 
-//# debugId=18CCB62BC341AA7B64756E2164756E21
+//# debugId=9E12A5F4A668EBC064756E2164756E21
 //# sourceMappingURL=mcp-server.js.map