@meetkai/mka1 0.54.2 → 0.54.4

package/bin/mcp-server.js

@@ -52876,9 +52876,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.1.0",
-    sdkVersion: "0.54.2",
+    sdkVersion: "0.54.4",
     genVersion: "2.932.9",
-    userAgent: "speakeasy-sdk/typescript 0.54.2 2.932.9 1.1.0 @meetkai/mka1"
+    userAgent: "speakeasy-sdk/typescript 0.54.4 2.932.9 1.1.0 @meetkai/mka1"
   };
 });
 
@@ -61828,12 +61828,14 @@ var init_connection = __esm(() => {
     github_user_id: numberType().int(),
     scopes: stringType(),
     synced_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    token_invalid_at: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))).optional(),
     repositories: arrayType(ConnectedRepository$inboundSchema)
   }).transform((v2) => {
     return remap(v2, {
       github_login: "githubLogin",
       github_user_id: "githubUserId",
-      synced_at: "syncedAt"
+      synced_at: "syncedAt",
+      token_invalid_at: "tokenInvalidAt"
     });
   });
   Connection$outboundSchema = objectType({
@@ -61841,12 +61843,14 @@ var init_connection = __esm(() => {
     githubUserId: numberType().int(),
     scopes: stringType(),
     syncedAt: dateType().transform((v2) => v2.toISOString()),
+    tokenInvalidAt: nullableType(dateType().transform((v2) => v2.toISOString())).optional(),
     repositories: arrayType(ConnectedRepository$outboundSchema)
   }).transform((v2) => {
     return remap(v2, {
       githubLogin: "github_login",
       githubUserId: "github_user_id",
-      syncedAt: "synced_at"
+      syncedAt: "synced_at",
+      tokenInvalidAt: "token_invalid_at"
     });
   });
 });
@@ -67323,6 +67327,145 @@ var init_getpromptresponse = __esm(() => {
   });
 });
 
+// src/models/components/githubpullrequestrequest.ts
+var GitHubPullRequestRequest$inboundSchema, GitHubPullRequestRequest$outboundSchema;
+var init_githubpullrequestrequest = __esm(() => {
+  init_esm();
+  GitHubPullRequestRequest$inboundSchema = objectType({
+    branch: stringType(),
+    title: stringType(),
+    body: stringType().default(""),
+    base: nullableType(stringType()).optional(),
+    draft: booleanType().default(false)
+  });
+  GitHubPullRequestRequest$outboundSchema = objectType({
+    branch: stringType(),
+    title: stringType(),
+    body: stringType().default(""),
+    base: nullableType(stringType()).optional(),
+    draft: booleanType().default(false)
+  });
+});
+
+// src/models/components/githubpullrequestresult.ts
+var GitHubPullRequestResult$inboundSchema, GitHubPullRequestResult$outboundSchema;
+var init_githubpullrequestresult = __esm(() => {
+  init_esm();
+  init_primitives();
+  GitHubPullRequestResult$inboundSchema = objectType({
+    session_id: stringType(),
+    repository_id: numberType().int(),
+    owner: stringType(),
+    repository: stringType(),
+    number: numberType().int(),
+    url: stringType(),
+    state: stringType(),
+    draft: booleanType(),
+    head_branch: stringType(),
+    base_branch: nullableType(stringType()),
+    created: booleanType()
+  }).transform((v2) => {
+    return remap(v2, {
+      session_id: "sessionId",
+      repository_id: "repositoryId",
+      head_branch: "headBranch",
+      base_branch: "baseBranch"
+    });
+  });
+  GitHubPullRequestResult$outboundSchema = objectType({
+    sessionId: stringType(),
+    repositoryId: numberType().int(),
+    owner: stringType(),
+    repository: stringType(),
+    number: numberType().int(),
+    url: stringType(),
+    state: stringType(),
+    draft: booleanType(),
+    headBranch: stringType(),
+    baseBranch: nullableType(stringType()),
+    created: booleanType()
+  }).transform((v2) => {
+    return remap(v2, {
+      sessionId: "session_id",
+      repositoryId: "repository_id",
+      headBranch: "head_branch",
+      baseBranch: "base_branch"
+    });
+  });
+});
+
+// src/models/components/githubpushrequest.ts
+var GitHubPushRequest$inboundSchema, GitHubPushRequest$outboundSchema;
+var init_githubpushrequest = __esm(() => {
+  init_esm();
+  init_primitives();
+  GitHubPushRequest$inboundSchema = objectType({
+    assignment_generation: numberType().int(),
+    branch: stringType(),
+    checkout_path: stringType().default(""),
+    force: booleanType().default(false)
+  }).transform((v2) => {
+    return remap(v2, {
+      assignment_generation: "assignmentGeneration",
+      checkout_path: "checkoutPath"
+    });
+  });
+  GitHubPushRequest$outboundSchema = objectType({
+    assignmentGeneration: numberType().int(),
+    branch: stringType(),
+    checkoutPath: stringType().default(""),
+    force: booleanType().default(false)
+  }).transform((v2) => {
+    return remap(v2, {
+      assignmentGeneration: "assignment_generation",
+      checkoutPath: "checkout_path"
+    });
+  });
+});
+
+// src/models/components/githubpushresult.ts
+var GitHubPushResult$inboundSchema, GitHubPushResult$outboundSchema;
+var init_githubpushresult = __esm(() => {
+  init_esm();
+  init_primitives();
+  GitHubPushResult$inboundSchema = objectType({
+    session_id: stringType(),
+    assignment_generation: numberType().int(),
+    repository_id: numberType().int(),
+    owner: stringType(),
+    repository: stringType(),
+    branch: stringType(),
+    remote_head_sha: stringType(),
+    no_changes: booleanType()
+  }).transform((v2) => {
+    return remap(v2, {
+      session_id: "sessionId",
+      assignment_generation: "assignmentGeneration",
+      repository_id: "repositoryId",
+      remote_head_sha: "remoteHeadSha",
+      no_changes: "noChanges"
+    });
+  });
+  GitHubPushResult$outboundSchema = objectType({
+    sessionId: stringType(),
+    assignmentGeneration: numberType().int(),
+    repositoryId: numberType().int(),
+    owner: stringType(),
+    repository: stringType(),
+    branch: stringType(),
+    remoteHeadSha: stringType(),
+    noChanges: booleanType()
+  }).transform((v2) => {
+    return remap(v2, {
+      sessionId: "session_id",
+      assignmentGeneration: "assignment_generation",
+      repositoryId: "repository_id",
+      remoteHeadSha: "remote_head_sha",
+      noChanges: "no_changes"
+    });
+  });
+});
+
 // src/models/components/githubreadclonerequest.ts
 var GitHubReadCloneRequest$inboundSchema, GitHubReadCloneRequest$outboundSchema;
 var init_githubreadclonerequest = __esm(() => {
@@ -77949,6 +78092,10 @@ var init_components = __esm(() => {
   init_getfeedbackresponse();
   init_getguardrailsresponse();
   init_getpromptresponse();
+  init_githubpullrequestrequest();
+  init_githubpullrequestresult();
+  init_githubpushrequest();
+  init_githubpushresult();
   init_githubreadclonerequest();
   init_githubreadcloneresult();
   init_grammarformat();
@@ -88035,6 +88182,36 @@ var init_creatememorystore = __esm(() => {
   });
 });
 
+// src/models/operations/createorupdateapiv1sandboxsessionssessionidgithubpullrequestpost.ts
+var CreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPostRequest$inboundSchema, CreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPostRequest$outboundSchema;
+var init_createorupdateapiv1sandboxsessionssessionidgithubpullrequestpost = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  CreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPostRequest$inboundSchema = objectType({
+    session_id: stringType(),
+    "X-On-Behalf-Of": stringType().optional(),
+    GitHubPullRequestRequest: GitHubPullRequestRequest$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      session_id: "sessionId",
+      "X-On-Behalf-Of": "xOnBehalfOf",
+      GitHubPullRequestRequest: "gitHubPullRequestRequest"
+    });
+  });
+  CreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPostRequest$outboundSchema = objectType({
+    sessionId: stringType(),
+    xOnBehalfOf: stringType().optional(),
+    gitHubPullRequestRequest: GitHubPullRequestRequest$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      sessionId: "session_id",
+      xOnBehalfOf: "X-On-Behalf-Of",
+      gitHubPullRequestRequest: "GitHubPullRequestRequest"
+    });
+  });
+});
+
 // src/models/operations/createprompt.ts
 var CreatePromptRequest$inboundSchema2, CreatePromptRequest$outboundSchema2;
 var init_createprompt = __esm(() => {
@@ -91408,6 +91585,7 @@ var init_getconnectionapiv1sandboxgithuboauthconnectionsget = __esm(() => {
   init_esm();
   init_primitives();
   GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$inboundSchema = objectType({
+    verify: booleanType().default(false),
     "X-On-Behalf-Of": stringType().optional()
   }).transform((v2) => {
     return remap(v2, {
@@ -91415,6 +91593,7 @@ var init_getconnectionapiv1sandboxgithuboauthconnectionsget = __esm(() => {
     });
   });
   GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$outboundSchema = objectType({
+    verify: booleanType().default(false),
     xOnBehalfOf: stringType().optional()
   }).transform((v2) => {
     return remap(v2, {
@@ -99568,6 +99747,36 @@ var init_proxybrowserportrequest = __esm(() => {
   });
 });
 
+// src/models/operations/pushapiv1sandboxsessionssessionidgithubpushpost.ts
+var PushApiV1SandboxSessionsSessionIdGithubPushPostRequest$inboundSchema, PushApiV1SandboxSessionsSessionIdGithubPushPostRequest$outboundSchema;
+var init_pushapiv1sandboxsessionssessionidgithubpushpost = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  PushApiV1SandboxSessionsSessionIdGithubPushPostRequest$inboundSchema = objectType({
+    session_id: stringType(),
+    "X-On-Behalf-Of": stringType().optional(),
+    GitHubPushRequest: GitHubPushRequest$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      session_id: "sessionId",
+      "X-On-Behalf-Of": "xOnBehalfOf",
+      GitHubPushRequest: "gitHubPushRequest"
+    });
+  });
+  PushApiV1SandboxSessionsSessionIdGithubPushPostRequest$outboundSchema = objectType({
+    sessionId: stringType(),
+    xOnBehalfOf: stringType().optional(),
+    gitHubPushRequest: GitHubPushRequest$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      sessionId: "session_id",
+      xOnBehalfOf: "X-On-Behalf-Of",
+      gitHubPushRequest: "GitHubPushRequest"
+    });
+  });
+});
+
 // src/models/operations/putcomputetenant.ts
 var PutComputeTenantRequest$inboundSchema, PutComputeTenantRequest$outboundSchema, PutComputeTenantResponse$inboundSchema, PutComputeTenantResponse$outboundSchema;
 var init_putcomputetenant = __esm(() => {
@@ -104182,6 +104391,7 @@ var init_operations = __esm(() => {
   init_createmcpserver();
   init_creatememoryentry();
   init_creatememorystore();
+  init_createorupdateapiv1sandboxsessionssessionidgithubpullrequestpost();
   init_createprompt();
   init_createpromptversion();
   init_createrepo();
@@ -104407,6 +104617,7 @@ var init_operations = __esm(() => {
   init_pauseagentschedule();
   init_pausefinetuningjob();
   init_proxybrowserportrequest();
+  init_pushapiv1sandboxsessionssessionidgithubpushpost();
   init_putcomputetenant();
   init_putorgautomodel();
   init_readcloneapiv1sandboxsessionssessionidgithubreadclonepost();
@@ -145371,11 +145582,132 @@ var init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost2 = __esm(()
   };
 });
 
-// src/funcs/schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete.ts
-function schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, request, options) {
+// src/funcs/schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost.ts
+function schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost(client, request, options) {
   return new APIPromise($do349(client, request, options));
 }
 async function $do349(client, request, options) {
+  const parsed = safeParse4(request, (value) => CreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPostRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.GitHubPullRequestRequest, {
+    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/pull-request")(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, [0]);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create_or_update_api_v1_sandbox_sessions__session_id__github_pull_request_post",
+    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, GitHubPullRequestResult$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_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost = __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/schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost.ts
+var args340, tool$schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost;
+var init_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost2 = __esm(() => {
+  init_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost();
+  init_operations();
+  init_tools();
+  args340 = {
+    request: CreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPostRequest$inboundSchema
+  };
+  tool$schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost = {
+    name: "schema-3-other-create-or-update-api-v1-sandbox-sessions-session-id-github-pull-request-post",
+    description: `Create Or Update`,
+    args: args340,
+    tool: async (client, args341, ctx) => {
+      const [result, apiCall] = await schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost(client, args341.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/schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete.ts
+function schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, request, options) {
+  return new APIPromise($do350(client, request, options));
+}
+async function $do350(client, request, options) {
   const parsed = safeParse4(request, (value) => DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145453,20 +145785,20 @@ var init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete = __esm(
 });
 
 // src/mcp-server/tools/schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete.ts
-var args340, tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete;
+var args341, tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete;
 var init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete2 = __esm(() => {
   init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete();
   init_operations();
   init_tools();
-  args340 = {
+  args341 = {
     request: DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$inboundSchema
   };
   tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete = {
     name: "schema-3-other-disconnect-api-v1-sandbox-github-oauth-connections-delete",
     description: `Disconnect`,
-    args: args340,
-    tool: async (client, args341, ctx) => {
-      const [result, apiCall] = await schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, args341.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args341,
+    tool: async (client, args342, ctx) => {
+      const [result, apiCall] = await schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, args342.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145480,9 +145812,9 @@ var init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete2 = __esm
 
 // src/funcs/schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet.ts
 function schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet(client, request, options) {
-  return new APIPromise($do350(client, request, options));
+  return new APIPromise($do351(client, request, options));
 }
-async function $do350(client, request, options) {
+async function $do351(client, request, options) {
   const parsed = safeParse4(request, (value) => GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145490,6 +145822,9 @@ async function $do350(client, request, options) {
   const payload = parsed.value;
   const body = null;
   const path = pathToFunc("/api/v1/sandbox/github/oauth/connections")();
+  const query = encodeFormQuery({
+    verify: payload.verify
+  });
   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" })
@@ -145522,6 +145857,7 @@ async function $do350(client, request, options) {
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -145540,7 +145876,10 @@ async function $do350(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(json(200, ConnectionEnvelope$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, ConnectionEnvelope$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -145555,25 +145894,26 @@ var init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet = __esm(
   init_security();
   init_url();
   init_components();
+  init_errors4();
   init_operations();
   init_async();
 });
 
 // src/mcp-server/tools/schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet.ts
-var args341, tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet;
+var args342, tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet;
 var init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet2 = __esm(() => {
   init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet();
   init_operations();
   init_tools();
-  args341 = {
+  args342 = {
     request: GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$inboundSchema
   };
   tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet = {
     name: "schema-3-other-get-connection-api-v1-sandbox-github-oauth-connections-get",
     description: `Get Connection`,
-    args: args341,
-    tool: async (client, args342, ctx) => {
-      const [result, apiCall] = await schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet(client, args342.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args342,
+    tool: async (client, args343, ctx) => {
+      const [result, apiCall] = await schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet(client, args343.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145588,9 +145928,9 @@ var init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet2 = __esm
 
 // src/funcs/schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet.ts
 function schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet(client, request, options) {
-  return new APIPromise($do351(client, request, options));
+  return new APIPromise($do352(client, request, options));
 }
-async function $do351(client, request, options) {
+async function $do352(client, request, options) {
   const parsed = safeParse4(request, (value) => ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145668,20 +146008,139 @@ var init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet = __esm((
 });
 
 // src/mcp-server/tools/schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet.ts
-var args342, tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet;
+var args343, tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet;
 var init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet2 = __esm(() => {
   init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet();
   init_operations();
   init_tools();
-  args342 = {
+  args343 = {
     request: ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$inboundSchema
   };
   tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet = {
     name: "schema-3-other-list-repositories-api-v1-sandbox-github-repositories-get",
     description: `List Repositories`,
-    args: args342,
-    tool: async (client, args343, ctx) => {
-      const [result, apiCall] = await schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet(client, args343.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args343,
+    tool: async (client, args344, ctx) => {
+      const [result, apiCall] = await schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet(client, args344.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/schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost.ts
+function schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost(client, request, options) {
+  return new APIPromise($do353(client, request, options));
+}
+async function $do353(client, request, options) {
+  const parsed = safeParse4(request, (value) => PushApiV1SandboxSessionsSessionIdGithubPushPostRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.GitHubPushRequest, { 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/push")(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, [0]);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "push_api_v1_sandbox_sessions__session_id__github_push_post",
+    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, GitHubPushResult$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_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost = __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/schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost.ts
+var args344, tool$schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost;
+var init_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost2 = __esm(() => {
+  init_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost();
+  init_operations();
+  init_tools();
+  args344 = {
+    request: PushApiV1SandboxSessionsSessionIdGithubPushPostRequest$inboundSchema
+  };
+  tool$schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost = {
+    name: "schema-3-other-push-api-v1-sandbox-sessions-session-id-github-push-post",
+    description: `Push`,
+    args: args344,
+    tool: async (client, args345, ctx) => {
+      const [result, apiCall] = await schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost(client, args345.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145696,9 +146155,9 @@ var init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet2 = __esm(
 
 // src/funcs/schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost.ts
 function schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, request, options) {
-  return new APIPromise($do352(client, request, options));
+  return new APIPromise($do354(client, request, options));
 }
-async function $do352(client, request, options) {
+async function $do354(client, request, options) {
   const parsed = safeParse4(request, (value) => ReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145789,20 +146248,20 @@ var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost =
 });
 
 // src/mcp-server/tools/schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost.ts
-var args343, tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost;
+var args345, tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost;
 var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost2 = __esm(() => {
   init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost();
   init_operations();
   init_tools();
-  args343 = {
+  args345 = {
     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: args343,
-    tool: async (client, args344, ctx) => {
-      const [result, apiCall] = await schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, args344.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args345,
+    tool: async (client, args346, ctx) => {
+      const [result, apiCall] = await schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, args346.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145817,9 +146276,9 @@ var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost2
 
 // src/funcs/schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost.ts
 function schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost(client, request, options) {
-  return new APIPromise($do353(client, request, options));
+  return new APIPromise($do355(client, request, options));
 }
-async function $do353(client, request, options) {
+async function $do355(client, request, options) {
   const parsed = safeParse4(request, (value) => RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145897,20 +146356,20 @@ var init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPos
 });
 
 // src/mcp-server/tools/schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost.ts
-var args344, tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost;
+var args346, tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost;
 var init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost2 = __esm(() => {
   init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost();
   init_operations();
   init_tools();
-  args344 = {
+  args346 = {
     request: RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$inboundSchema
   };
   tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost = {
     name: "schema-3-other-refresh-repositories-api-v1-sandbox-github-repositories-refresh-post",
     description: `Refresh Repositories`,
-    args: args344,
-    tool: async (client, args345, ctx) => {
-      const [result, apiCall] = await schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost(client, args345.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args346,
+    tool: async (client, args347, ctx) => {
+      const [result, apiCall] = await schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost(client, args347.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145925,9 +146384,9 @@ var init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPos
 
 // src/funcs/schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost.ts
 function schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost(client, request, options) {
-  return new APIPromise($do354(client, request, options));
+  return new APIPromise($do356(client, request, options));
 }
-async function $do354(client, request, options) {
+async function $do356(client, request, options) {
   const parsed = safeParse4(request, (value) => ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -146012,20 +146471,20 @@ var init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost =
 });
 
 // src/mcp-server/tools/schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost.ts
-var args345, tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost;
+var args347, tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost;
 var init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost2 = __esm(() => {
   init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost();
   init_operations();
   init_tools();
-  args345 = {
+  args347 = {
     request: ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$inboundSchema
   };
   tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost = {
     name: "schema-3-other-resolve-reference-api-v1-sandbox-github-repositories-resolve-post",
     description: `Resolve Reference`,
-    args: args345,
-    tool: async (client, args346, ctx) => {
-      const [result, apiCall] = await schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost(client, args346.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args347,
+    tool: async (client, args348, ctx) => {
+      const [result, apiCall] = await schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost(client, args348.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -146040,9 +146499,9 @@ var init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost2
 
 // src/funcs/usageCosts.ts
 function usageCosts(client, request, options) {
-  return new APIPromise($do355(client, request, options));
+  return new APIPromise($do357(client, request, options));
 }
-async function $do355(client, request, options) {
+async function $do357(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCostsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -146125,12 +146584,12 @@ var init_usageCosts = __esm(() => {
 });
 
 // src/mcp-server/tools/usageCosts.ts
-var args346, tool$usageCosts;
+var args348, tool$usageCosts;
 var init_usageCosts2 = __esm(() => {
   init_usageCosts();
   init_operations();
   init_tools();
-  args346 = {
+  args348 = {
     request: GetCostsRequest$inboundSchema
   };
   tool$usageCosts = {
@@ -146138,9 +146597,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: args346,
-    tool: async (client, args347, ctx) => {
-      const [result, apiCall] = await usageCosts(client, args347.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args348,
+    tool: async (client, args349, ctx) => {
+      const [result, apiCall] = await usageCosts(client, args349.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -146155,9 +146614,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($do356(client, request, options));
+  return new APIPromise($do358(client, request, options));
 }
-async function $do356(client, request, options) {
+async function $do358(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSandboxUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -146248,12 +146707,12 @@ var init_usageSandbox = __esm(() => {
 });
 
 // src/mcp-server/tools/usageSandbox.ts
-var args347, tool$usageSandbox;
+var args349, tool$usageSandbox;
 var init_usageSandbox2 = __esm(() => {
   init_usageSandbox();
   init_operations();
   init_tools();
-  args347 = {
+  args349 = {
     request: GetSandboxUsageRequest$inboundSchema
   };
   tool$usageSandbox = {
@@ -146261,9 +146720,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: args347,
-    tool: async (client, args348, ctx) => {
-      const [result, apiCall] = await usageSandbox(client, args348.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args349,
+    tool: async (client, args350, ctx) => {
+      const [result, apiCall] = await usageSandbox(client, args350.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -146280,7 +146739,7 @@ Aggregate sandbox usage (session lifecycle, execution, and workspace operations)
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.54.2"
+    version: "0.54.4"
   });
   const client = new SDKCore({
     bearerAuth: deps.bearerAuth,
@@ -146300,13 +146759,15 @@ function createMCPServer(deps) {
   tool(tool$guardrailsListGuardrailsPolicies);
   tool(tool$guardrailsTestGuardrails);
   tool(tool$schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost);
-  tool(tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet);
   tool(tool$schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost);
+  tool(tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet);
   tool(tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete);
   tool(tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet);
   tool(tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost);
   tool(tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost);
   tool(tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost);
+  tool(tool$schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost);
+  tool(tool$schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost);
   tool(tool$sandboxCreate);
   tool(tool$sandboxList);
   tool(tool$sandboxGet);
@@ -147005,9 +147466,11 @@ var init_server2 = __esm(() => {
   init_sandboxUploadFile2();
   init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost2();
   init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost2();
+  init_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost2();
   init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete2();
   init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet2();
   init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet2();
+  init_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost2();
   init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost2();
   init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost2();
   init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost2();
@@ -148190,7 +148653,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.54.2"
+    currentVersion: "0.54.4"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -148198,5 +148661,5 @@ export {
   app
 };
 
-//# debugId=69F140A960CB197764756E2164756E21
+//# debugId=8304397CE0FC72BE64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map