@meetkai/mka1 0.54.85 → 0.54.88

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

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { authTeamsUpdateMember } from "../../funcs/authTeamsUpdateMember.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.UpdateTeamMemberRequest$inboundSchema,
+};
+
+export const tool$authTeamsUpdateMember: ToolDefinition<typeof args> = {
+  name: "auth-teams-update-member",
+  description: `Set a team member role
+
+Organization owner/admin only. Team admins may manage their own team network policy; other team administration remains org-admin-only.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await authTeamsUpdateMember(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

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

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxConnectorsConnect } from "../../funcs/sandboxConnectorsConnect.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.ConnectSandboxConnectorRequest$inboundSchema,
+};
+
+export const tool$sandboxConnectorsConnect: ToolDefinition<typeof args> = {
+  name: "sandbox-connectors-connect",
+  description: `Finish Connector Sign-In
+
+Exchange the \`code\` and \`state\` from the connector's redirect for a stored connection. Call it as the same signed-in user who started the sign-in. The sandbox service keeps the token encrypted and never returns it.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await sandboxConnectorsConnect(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

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

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxConnectorsCreateAuthorizationIntent } from "../../funcs/sandboxConnectorsCreateAuthorizationIntent.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request:
+    operations.CreateSandboxConnectorAuthorizationIntentRequest$inboundSchema,
+};
+
+export const tool$sandboxConnectorsCreateAuthorizationIntent: ToolDefinition<
+  typeof args
+> = {
+  name: "sandbox-connectors-create-authorization-intent",
+  description: `Start Connector Sign-In
+
+Start connecting an OAuth connector to your account. Send the user to the returned \`authorize_url\`. The connector redirects back to the platform callback page with a \`code\` and the same \`state\`, which it passes to \`POST /connectors/oauth/connections\` before \`expires_in_seconds\` elapses. Each \`state\` works once, and only for the account that started the sign-in.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await sandboxConnectorsCreateAuthorizationIntent(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

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

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxConnectorsDisconnect } from "../../funcs/sandboxConnectorsDisconnect.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.DisconnectSandboxConnectorRequest$inboundSchema,
+};
+
+export const tool$sandboxConnectorsDisconnect: ToolDefinition<typeof args> = {
+  name: "sandbox-connectors-disconnect",
+  description: `Disconnect Connector
+
+Delete your connection to a connector and revoke its token at the connector when it supports revocation. The connection is deleted even if the connector does not confirm the revocation.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await sandboxConnectorsDisconnect(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    return formatResult(void 0, apiCall);
+  },
+};

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

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxConnectorsList } from "../../funcs/sandboxConnectorsList.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.ListSandboxConnectorsRequest$inboundSchema,
+};
+
+export const tool$sandboxConnectorsList: ToolDefinition<typeof args> = {
+  name: "sandbox-connectors-list",
+  description: `List Connectors
+
+List the connectors you can connect and your connection to each, or \`null\` when you have none. \`status\` is \`needs_login\` when the connector must be reconnected. \`tool_allowlist\` set to \`null\` means sessions may call every tool the connector lists, read or write. Only an environment with \`network_access\` set to \`full\` can list connectors, at most \`max_per_environment\` of them.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await sandboxConnectorsList(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

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

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxConnectorsListTools } from "../../funcs/sandboxConnectorsListTools.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.ListSandboxConnectorToolsRequest$inboundSchema,
+};
+
+export const tool$sandboxConnectorsListTools: ToolDefinition<typeof args> = {
+  name: "sandbox-connectors-list-tools",
+  description: `List Connector Tools
+
+List the connector's tools now, with whether each is read-only, your tool allowlist, and \`allowed\`: the tools a session could call. 409 when the connector must be reconnected.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await sandboxConnectorsListTools(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

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

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxConnectorsSetApiKey } from "../../funcs/sandboxConnectorsSetApiKey.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.SetSandboxConnectorApiKeyRequest$inboundSchema,
+};
+
+export const tool$sandboxConnectorsSetApiKey: ToolDefinition<typeof args> = {
+  name: "sandbox-connectors-set-api-key",
+  description: `Set Connector API Key
+
+Connect an API-key connector. The key is checked against the connector before it is stored (422 when the connector refuses it) and is never returned.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await sandboxConnectorsSetApiKey(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

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

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxConnectorsSetTools } from "../../funcs/sandboxConnectorsSetTools.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.SetSandboxConnectorToolsRequest$inboundSchema,
+};
+
+export const tool$sandboxConnectorsSetTools: ToolDefinition<typeof args> = {
+  name: "sandbox-connectors-set-tools",
+  description: `Set Connector Tool Allowlist
+
+Choose which of the connector's tools sessions may call. Send a list of tool names, or \`null\` to allow every tool the connector lists, read or write.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await sandboxConnectorsSetTools(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

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

@@ -14,7 +14,7 @@ export const tool$sandboxCreate: ToolDefinition<typeof args> = {
   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\`.`,
+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\`. An optional caller \`network_policy\` restricts outbound hostnames and is intersected with the organization, team and operator policies. An empty allowlist denies outbound access.`,
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await sandboxCreate(

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

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxNetworkPoliciesEffective } from "../../funcs/sandboxNetworkPoliciesEffective.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GetEffectiveNetworkPolicyRequest$inboundSchema,
+};
+
+export const tool$sandboxNetworkPoliciesEffective: ToolDefinition<typeof args> =
+  {
+    name: "sandbox-network-policies-effective",
+    description: `Get Effective Network Policy
+
+Intersect the authenticated tenant's organization and team hostname allowlists.`,
+    args,
+    tool: async (client, args, ctx) => {
+      const [result, apiCall] = await sandboxNetworkPoliciesEffective(
+        client,
+        args.request,
+        { fetchOptions: { signal: ctx.signal } },
+      ).$inspect();
+
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true,
+        };
+      }
+
+      const value = result.value;
+
+      return formatResult(value, apiCall);
+    },
+  };

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

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxNetworkPoliciesGet } from "../../funcs/sandboxNetworkPoliciesGet.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GetTenantNetworkPolicyRequest$inboundSchema,
+};
+
+export const tool$sandboxNetworkPoliciesGet: ToolDefinition<typeof args> = {
+  name: "sandbox-network-policies-get",
+  description: `Get Tenant Network Policy
+
+Read the authenticated tenant policy; optional expected IDs reject workspace changes, never select tenancy.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await sandboxNetworkPoliciesGet(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

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

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxNetworkPoliciesSet } from "../../funcs/sandboxNetworkPoliciesSet.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.SetTenantNetworkPolicyRequest$inboundSchema,
+};
+
+export const tool$sandboxNetworkPoliciesSet: ToolDefinition<typeof args> = {
+  name: "sandbox-network-policies-set",
+  description: `Set Tenant Network Policy
+
+Administrator-only update with optimistic revision checking. An enabled empty list denies all outbound hosts.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await sandboxNetworkPoliciesSet(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/models/components/connectconnectorrequest.ts

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ConnectConnectorRequest = {
+  code: string;
+  state: string;
+};
+
+/** @internal */
+export const ConnectConnectorRequest$inboundSchema: z.ZodType<
+  ConnectConnectorRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string(),
+  state: z.string(),
+});
+/** @internal */
+export type ConnectConnectorRequest$Outbound = {
+  code: string;
+  state: string;
+};
+
+/** @internal */
+export const ConnectConnectorRequest$outboundSchema: z.ZodType<
+  ConnectConnectorRequest$Outbound,
+  z.ZodTypeDef,
+  ConnectConnectorRequest
+> = z.object({
+  code: z.string(),
+  state: z.string(),
+});
+
+export function connectConnectorRequestToJSON(
+  connectConnectorRequest: ConnectConnectorRequest,
+): string {
+  return JSON.stringify(
+    ConnectConnectorRequest$outboundSchema.parse(connectConnectorRequest),
+  );
+}
+export function connectConnectorRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ConnectConnectorRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConnectConnectorRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConnectConnectorRequest' from JSON`,
+  );
+}

package/src/models/components/connectorauthorizeintentmodel.ts

@@ -0,0 +1,72 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ConnectorAuthorizeIntentModel = {
+  state: string;
+  authorizeUrl: string;
+  expiresInSeconds: number;
+};
+
+/** @internal */
+export const ConnectorAuthorizeIntentModel$inboundSchema: z.ZodType<
+  ConnectorAuthorizeIntentModel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  state: z.string(),
+  authorize_url: z.string(),
+  expires_in_seconds: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "authorize_url": "authorizeUrl",
+    "expires_in_seconds": "expiresInSeconds",
+  });
+});
+/** @internal */
+export type ConnectorAuthorizeIntentModel$Outbound = {
+  state: string;
+  authorize_url: string;
+  expires_in_seconds: number;
+};
+
+/** @internal */
+export const ConnectorAuthorizeIntentModel$outboundSchema: z.ZodType<
+  ConnectorAuthorizeIntentModel$Outbound,
+  z.ZodTypeDef,
+  ConnectorAuthorizeIntentModel
+> = z.object({
+  state: z.string(),
+  authorizeUrl: z.string(),
+  expiresInSeconds: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    authorizeUrl: "authorize_url",
+    expiresInSeconds: "expires_in_seconds",
+  });
+});
+
+export function connectorAuthorizeIntentModelToJSON(
+  connectorAuthorizeIntentModel: ConnectorAuthorizeIntentModel,
+): string {
+  return JSON.stringify(
+    ConnectorAuthorizeIntentModel$outboundSchema.parse(
+      connectorAuthorizeIntentModel,
+    ),
+  );
+}
+export function connectorAuthorizeIntentModelFromJSON(
+  jsonString: string,
+): SafeParseResult<ConnectorAuthorizeIntentModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConnectorAuthorizeIntentModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConnectorAuthorizeIntentModel' from JSON`,
+  );
+}

package/src/models/components/connectorcatalogmodel.ts

@@ -0,0 +1,91 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ConnectorModel,
+  ConnectorModel$inboundSchema,
+  ConnectorModel$Outbound,
+  ConnectorModel$outboundSchema,
+} from "./connectormodel.js";
+import {
+  NetworkAccess,
+  NetworkAccess$inboundSchema,
+  NetworkAccess$outboundSchema,
+} from "./networkaccess.js";
+
+export type ConnectorCatalogModel = {
+  /**
+   * How much of the internet a Coding Harness guest reaches through the proxy.
+   *
+   * @remarks
+   *
+   * Ordered: each level includes the one before it. The model broker and the
+   * ``mka1-github`` push/PR tool reach the runner directly, and the
+   * Environment's repositories are cloned on the host before boot, so all of
+   * them work at every level, including ``none``.
+   */
+  requiredNetworkAccess?: NetworkAccess | undefined;
+  maxPerEnvironment?: number | undefined;
+  connectors: Array<ConnectorModel>;
+};
+
+/** @internal */
+export const ConnectorCatalogModel$inboundSchema: z.ZodType<
+  ConnectorCatalogModel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  required_network_access: NetworkAccess$inboundSchema.optional(),
+  max_per_environment: z.number().int().default(8),
+  connectors: z.array(ConnectorModel$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "required_network_access": "requiredNetworkAccess",
+    "max_per_environment": "maxPerEnvironment",
+  });
+});
+/** @internal */
+export type ConnectorCatalogModel$Outbound = {
+  required_network_access?: string | undefined;
+  max_per_environment: number;
+  connectors: Array<ConnectorModel$Outbound>;
+};
+
+/** @internal */
+export const ConnectorCatalogModel$outboundSchema: z.ZodType<
+  ConnectorCatalogModel$Outbound,
+  z.ZodTypeDef,
+  ConnectorCatalogModel
+> = z.object({
+  requiredNetworkAccess: NetworkAccess$outboundSchema.optional(),
+  maxPerEnvironment: z.number().int().default(8),
+  connectors: z.array(ConnectorModel$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    requiredNetworkAccess: "required_network_access",
+    maxPerEnvironment: "max_per_environment",
+  });
+});
+
+export function connectorCatalogModelToJSON(
+  connectorCatalogModel: ConnectorCatalogModel,
+): string {
+  return JSON.stringify(
+    ConnectorCatalogModel$outboundSchema.parse(connectorCatalogModel),
+  );
+}
+export function connectorCatalogModelFromJSON(
+  jsonString: string,
+): SafeParseResult<ConnectorCatalogModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConnectorCatalogModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConnectorCatalogModel' from JSON`,
+  );
+}