@meetkai/mka1 0.54.86 → 0.54.87

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`,
+  );
+}

package/src/models/components/connectorconnectionmodel.ts

@@ -0,0 +1,116 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const ConnectorConnectionModelStatus = {
+  Connected: "connected",
+  NeedsLogin: "needs_login",
+} as const;
+export type ConnectorConnectionModelStatus = ClosedEnum<
+  typeof ConnectorConnectionModelStatus
+>;
+
+export type ConnectorConnectionModel = {
+  status: ConnectorConnectionModelStatus;
+  scope?: string | null | undefined;
+  toolAllowlist?: Array<string> | null | undefined;
+  connectedAt: Date;
+  updatedAt: Date;
+  lastUsedAt?: Date | null | undefined;
+  needsLoginAt?: Date | null | undefined;
+};
+
+/** @internal */
+export const ConnectorConnectionModelStatus$inboundSchema: z.ZodNativeEnum<
+  typeof ConnectorConnectionModelStatus
+> = z.nativeEnum(ConnectorConnectionModelStatus);
+/** @internal */
+export const ConnectorConnectionModelStatus$outboundSchema: z.ZodNativeEnum<
+  typeof ConnectorConnectionModelStatus
+> = ConnectorConnectionModelStatus$inboundSchema;
+
+/** @internal */
+export const ConnectorConnectionModel$inboundSchema: z.ZodType<
+  ConnectorConnectionModel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  status: ConnectorConnectionModelStatus$inboundSchema,
+  scope: z.nullable(z.string()).optional(),
+  tool_allowlist: z.nullable(z.array(z.string())).optional(),
+  connected_at: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  last_used_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
+  needs_login_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_allowlist": "toolAllowlist",
+    "connected_at": "connectedAt",
+    "updated_at": "updatedAt",
+    "last_used_at": "lastUsedAt",
+    "needs_login_at": "needsLoginAt",
+  });
+});
+/** @internal */
+export type ConnectorConnectionModel$Outbound = {
+  status: string;
+  scope?: string | null | undefined;
+  tool_allowlist?: Array<string> | null | undefined;
+  connected_at: string;
+  updated_at: string;
+  last_used_at?: string | null | undefined;
+  needs_login_at?: string | null | undefined;
+};
+
+/** @internal */
+export const ConnectorConnectionModel$outboundSchema: z.ZodType<
+  ConnectorConnectionModel$Outbound,
+  z.ZodTypeDef,
+  ConnectorConnectionModel
+> = z.object({
+  status: ConnectorConnectionModelStatus$outboundSchema,
+  scope: z.nullable(z.string()).optional(),
+  toolAllowlist: z.nullable(z.array(z.string())).optional(),
+  connectedAt: z.date().transform(v => v.toISOString()),
+  updatedAt: z.date().transform(v => v.toISOString()),
+  lastUsedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+  needsLoginAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolAllowlist: "tool_allowlist",
+    connectedAt: "connected_at",
+    updatedAt: "updated_at",
+    lastUsedAt: "last_used_at",
+    needsLoginAt: "needs_login_at",
+  });
+});
+
+export function connectorConnectionModelToJSON(
+  connectorConnectionModel: ConnectorConnectionModel,
+): string {
+  return JSON.stringify(
+    ConnectorConnectionModel$outboundSchema.parse(connectorConnectionModel),
+  );
+}
+export function connectorConnectionModelFromJSON(
+  jsonString: string,
+): SafeParseResult<ConnectorConnectionModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConnectorConnectionModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConnectorConnectionModel' from JSON`,
+  );
+}

package/src/models/components/connectormodel.ts

@@ -0,0 +1,90 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ConnectorConnectionModel,
+  ConnectorConnectionModel$inboundSchema,
+  ConnectorConnectionModel$Outbound,
+  ConnectorConnectionModel$outboundSchema,
+} from "./connectorconnectionmodel.js";
+
+export const AuthKind = {
+  Oauth: "oauth",
+  ApiKey: "api_key",
+} as const;
+export type AuthKind = ClosedEnum<typeof AuthKind>;
+
+export type ConnectorModel = {
+  key: string;
+  displayName: string;
+  authKind: AuthKind;
+  connection?: ConnectorConnectionModel | null | undefined;
+};
+
+/** @internal */
+export const AuthKind$inboundSchema: z.ZodNativeEnum<typeof AuthKind> = z
+  .nativeEnum(AuthKind);
+/** @internal */
+export const AuthKind$outboundSchema: z.ZodNativeEnum<typeof AuthKind> =
+  AuthKind$inboundSchema;
+
+/** @internal */
+export const ConnectorModel$inboundSchema: z.ZodType<
+  ConnectorModel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  display_name: z.string(),
+  auth_kind: AuthKind$inboundSchema,
+  connection: z.nullable(ConnectorConnectionModel$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "display_name": "displayName",
+    "auth_kind": "authKind",
+  });
+});
+/** @internal */
+export type ConnectorModel$Outbound = {
+  key: string;
+  display_name: string;
+  auth_kind: string;
+  connection?: ConnectorConnectionModel$Outbound | null | undefined;
+};
+
+/** @internal */
+export const ConnectorModel$outboundSchema: z.ZodType<
+  ConnectorModel$Outbound,
+  z.ZodTypeDef,
+  ConnectorModel
+> = z.object({
+  key: z.string(),
+  displayName: z.string(),
+  authKind: AuthKind$outboundSchema,
+  connection: z.nullable(ConnectorConnectionModel$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    displayName: "display_name",
+    authKind: "auth_kind",
+  });
+});
+
+export function connectorModelToJSON(connectorModel: ConnectorModel): string {
+  return JSON.stringify(ConnectorModel$outboundSchema.parse(connectorModel));
+}
+export function connectorModelFromJSON(
+  jsonString: string,
+): SafeParseResult<ConnectorModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConnectorModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConnectorModel' from JSON`,
+  );
+}

package/src/models/components/connectortoolmodel.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 ConnectorToolModel = {
+  name: string;
+  title?: string | null | undefined;
+  description?: string | null | undefined;
+  readOnly: boolean;
+};
+
+/** @internal */
+export const ConnectorToolModel$inboundSchema: z.ZodType<
+  ConnectorToolModel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+  title: z.nullable(z.string()).optional(),
+  description: z.nullable(z.string()).optional(),
+  read_only: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    "read_only": "readOnly",
+  });
+});
+/** @internal */
+export type ConnectorToolModel$Outbound = {
+  name: string;
+  title?: string | null | undefined;
+  description?: string | null | undefined;
+  read_only: boolean;
+};
+
+/** @internal */
+export const ConnectorToolModel$outboundSchema: z.ZodType<
+  ConnectorToolModel$Outbound,
+  z.ZodTypeDef,
+  ConnectorToolModel
+> = z.object({
+  name: z.string(),
+  title: z.nullable(z.string()).optional(),
+  description: z.nullable(z.string()).optional(),
+  readOnly: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    readOnly: "read_only",
+  });
+});
+
+export function connectorToolModelToJSON(
+  connectorToolModel: ConnectorToolModel,
+): string {
+  return JSON.stringify(
+    ConnectorToolModel$outboundSchema.parse(connectorToolModel),
+  );
+}
+export function connectorToolModelFromJSON(
+  jsonString: string,
+): SafeParseResult<ConnectorToolModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConnectorToolModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConnectorToolModel' from JSON`,
+  );
+}

package/src/models/components/connectortoolsmodel.ts

@@ -0,0 +1,74 @@
+/*
+ * 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 {
+  ConnectorToolModel,
+  ConnectorToolModel$inboundSchema,
+  ConnectorToolModel$Outbound,
+  ConnectorToolModel$outboundSchema,
+} from "./connectortoolmodel.js";
+
+export type ConnectorToolsModel = {
+  tools: Array<ConnectorToolModel>;
+  toolAllowlist?: Array<string> | null | undefined;
+  allowed: Array<string>;
+};
+
+/** @internal */
+export const ConnectorToolsModel$inboundSchema: z.ZodType<
+  ConnectorToolsModel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  tools: z.array(ConnectorToolModel$inboundSchema),
+  tool_allowlist: z.nullable(z.array(z.string())).optional(),
+  allowed: z.array(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_allowlist": "toolAllowlist",
+  });
+});
+/** @internal */
+export type ConnectorToolsModel$Outbound = {
+  tools: Array<ConnectorToolModel$Outbound>;
+  tool_allowlist?: Array<string> | null | undefined;
+  allowed: Array<string>;
+};
+
+/** @internal */
+export const ConnectorToolsModel$outboundSchema: z.ZodType<
+  ConnectorToolsModel$Outbound,
+  z.ZodTypeDef,
+  ConnectorToolsModel
+> = z.object({
+  tools: z.array(ConnectorToolModel$outboundSchema),
+  toolAllowlist: z.nullable(z.array(z.string())).optional(),
+  allowed: z.array(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    toolAllowlist: "tool_allowlist",
+  });
+});
+
+export function connectorToolsModelToJSON(
+  connectorToolsModel: ConnectorToolsModel,
+): string {
+  return JSON.stringify(
+    ConnectorToolsModel$outboundSchema.parse(connectorToolsModel),
+  );
+}
+export function connectorToolsModelFromJSON(
+  jsonString: string,
+): SafeParseResult<ConnectorToolsModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConnectorToolsModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConnectorToolsModel' from JSON`,
+  );
+}