@meetkai/mka1 0.49.14 → 0.49.16

package/src/models/components/registrysource.ts

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const RegistrySource = {
+  Byo: "byo",
+  Serving: "serving",
+  Cluster: "cluster",
+} as const;
+export type RegistrySource = ClosedEnum<typeof RegistrySource>;
+
+/** @internal */
+export const RegistrySource$inboundSchema: z.ZodNativeEnum<
+  typeof RegistrySource
+> = z.nativeEnum(RegistrySource);
+/** @internal */
+export const RegistrySource$outboundSchema: z.ZodNativeEnum<
+  typeof RegistrySource
+> = RegistrySource$inboundSchema;

package/src/models/components/reverseaccessentry.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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ReverseAccessEntry = {
+  orgId: string;
+  grantedBy: string;
+  grantedAt: Date;
+  active: boolean;
+  activatedBy: string | null;
+  activatedAt: Date | null;
+};
+
+/** @internal */
+export const ReverseAccessEntry$inboundSchema: z.ZodType<
+  ReverseAccessEntry,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  org_id: z.string(),
+  granted_by: z.string(),
+  granted_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  active: z.boolean(),
+  activated_by: z.nullable(z.string()),
+  activated_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+}).transform((v) => {
+  return remap$(v, {
+    "org_id": "orgId",
+    "granted_by": "grantedBy",
+    "granted_at": "grantedAt",
+    "activated_by": "activatedBy",
+    "activated_at": "activatedAt",
+  });
+});
+/** @internal */
+export type ReverseAccessEntry$Outbound = {
+  org_id: string;
+  granted_by: string;
+  granted_at: string;
+  active: boolean;
+  activated_by: string | null;
+  activated_at: string | null;
+};
+
+/** @internal */
+export const ReverseAccessEntry$outboundSchema: z.ZodType<
+  ReverseAccessEntry$Outbound,
+  z.ZodTypeDef,
+  ReverseAccessEntry
+> = z.object({
+  orgId: z.string(),
+  grantedBy: z.string(),
+  grantedAt: z.date().transform(v => v.toISOString()),
+  active: z.boolean(),
+  activatedBy: z.nullable(z.string()),
+  activatedAt: z.nullable(z.date().transform(v => v.toISOString())),
+}).transform((v) => {
+  return remap$(v, {
+    orgId: "org_id",
+    grantedBy: "granted_by",
+    grantedAt: "granted_at",
+    activatedBy: "activated_by",
+    activatedAt: "activated_at",
+  });
+});
+
+export function reverseAccessEntryToJSON(
+  reverseAccessEntry: ReverseAccessEntry,
+): string {
+  return JSON.stringify(
+    ReverseAccessEntry$outboundSchema.parse(reverseAccessEntry),
+  );
+}
+export function reverseAccessEntryFromJSON(
+  jsonString: string,
+): SafeParseResult<ReverseAccessEntry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReverseAccessEntry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReverseAccessEntry' from JSON`,
+  );
+}

package/src/models/components/reverseaccesslistresponse.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 {
+  ReverseAccessEntry,
+  ReverseAccessEntry$inboundSchema,
+  ReverseAccessEntry$Outbound,
+  ReverseAccessEntry$outboundSchema,
+} from "./reverseaccessentry.js";
+
+export type ReverseAccessListResponse = {
+  object: "list";
+  modelId: string;
+  data: Array<ReverseAccessEntry>;
+};
+
+/** @internal */
+export const ReverseAccessListResponse$inboundSchema: z.ZodType<
+  ReverseAccessListResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: z.literal("list"),
+  model_id: z.string(),
+  data: z.array(ReverseAccessEntry$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "model_id": "modelId",
+  });
+});
+/** @internal */
+export type ReverseAccessListResponse$Outbound = {
+  object: "list";
+  model_id: string;
+  data: Array<ReverseAccessEntry$Outbound>;
+};
+
+/** @internal */
+export const ReverseAccessListResponse$outboundSchema: z.ZodType<
+  ReverseAccessListResponse$Outbound,
+  z.ZodTypeDef,
+  ReverseAccessListResponse
+> = z.object({
+  object: z.literal("list"),
+  modelId: z.string(),
+  data: z.array(ReverseAccessEntry$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    modelId: "model_id",
+  });
+});
+
+export function reverseAccessListResponseToJSON(
+  reverseAccessListResponse: ReverseAccessListResponse,
+): string {
+  return JSON.stringify(
+    ReverseAccessListResponse$outboundSchema.parse(reverseAccessListResponse),
+  );
+}
+export function reverseAccessListResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ReverseAccessListResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReverseAccessListResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReverseAccessListResponse' from JSON`,
+  );
+}

package/src/models/components/tooldefinition.ts

@@ -26,6 +26,12 @@ import {
   JsonValue$Outbound,
   JsonValue$outboundSchema,
 } from "./jsonvalue.js";
+import {
+  MCPToolFilter,
+  MCPToolFilter$inboundSchema,
+  MCPToolFilter$Outbound,
+  MCPToolFilter$outboundSchema,
+} from "./mcptoolfilter.js";
 
 export const ToolDefinition7Type = {
   Shell: "shell",
@@ -147,11 +153,24 @@ export const ToolDefinition3Type = {
 } as const;
 export type ToolDefinition3Type = ClosedEnum<typeof ToolDefinition3Type>;
 
-export const ThreeRequireApproval = {
+export type ToolDefinitionRequireApproval2 = {
+  always?: MCPToolFilter | undefined;
+  never?: MCPToolFilter | undefined;
+};
+
+export const ToolDefinitionRequireApproval1 = {
   Always: "always",
   Never: "never",
 } as const;
-export type ThreeRequireApproval = ClosedEnum<typeof ThreeRequireApproval>;
+export type ToolDefinitionRequireApproval1 = ClosedEnum<
+  typeof ToolDefinitionRequireApproval1
+>;
+
+export type ThreeRequireApproval =
+  | ToolDefinitionRequireApproval1
+  | ToolDefinitionRequireApproval2;
+
+export type ToolDefinition3AllowedTools = Array<string> | MCPToolFilter;
 
 export type Three2 = {
   type: ToolDefinition3Type;
@@ -161,8 +180,11 @@ export type Three2 = {
   serverUrl?: string | undefined;
   serverDescription?: string | undefined;
   authorization?: string | undefined;
-  requireApproval?: ThreeRequireApproval | undefined;
-  allowedTools?: Array<string> | undefined;
+  requireApproval?:
+    | ToolDefinitionRequireApproval1
+    | ToolDefinitionRequireApproval2
+    | undefined;
+  allowedTools?: Array<string> | MCPToolFilter | undefined;
   headers?: { [k: string]: string } | undefined;
 };
 
@@ -171,11 +193,20 @@ export const ThreeType = {
 } as const;
 export type ThreeType = ClosedEnum<typeof ThreeType>;
 
-export const RequireApproval = {
+export type RequireApproval2 = {
+  always?: MCPToolFilter | undefined;
+  never?: MCPToolFilter | undefined;
+};
+
+export const RequireApproval1 = {
   Always: "always",
   Never: "never",
 } as const;
-export type RequireApproval = ClosedEnum<typeof RequireApproval>;
+export type RequireApproval1 = ClosedEnum<typeof RequireApproval1>;
+
+export type RequireApproval = RequireApproval1 | RequireApproval2;
+
+export type ThreeAllowedTools = Array<string> | MCPToolFilter;
 
 export type Three1 = {
   type: ThreeType;
@@ -185,8 +216,8 @@ export type Three1 = {
   serverUrl?: string | undefined;
   serverDescription?: string | undefined;
   authorization?: string | undefined;
-  requireApproval?: RequireApproval | undefined;
-  allowedTools?: Array<string> | undefined;
+  requireApproval?: RequireApproval1 | RequireApproval2 | undefined;
+  allowedTools?: Array<string> | MCPToolFilter | undefined;
   headers?: { [k: string]: string } | undefined;
 };
 
@@ -967,13 +998,135 @@ export const ToolDefinition3Type$outboundSchema: z.ZodNativeEnum<
 > = ToolDefinition3Type$inboundSchema;
 
 /** @internal */
-export const ThreeRequireApproval$inboundSchema: z.ZodNativeEnum<
-  typeof ThreeRequireApproval
-> = z.nativeEnum(ThreeRequireApproval);
+export const ToolDefinitionRequireApproval2$inboundSchema: z.ZodType<
+  ToolDefinitionRequireApproval2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  always: MCPToolFilter$inboundSchema.optional(),
+  never: MCPToolFilter$inboundSchema.optional(),
+});
+/** @internal */
+export type ToolDefinitionRequireApproval2$Outbound = {
+  always?: MCPToolFilter$Outbound | undefined;
+  never?: MCPToolFilter$Outbound | undefined;
+};
+
+/** @internal */
+export const ToolDefinitionRequireApproval2$outboundSchema: z.ZodType<
+  ToolDefinitionRequireApproval2$Outbound,
+  z.ZodTypeDef,
+  ToolDefinitionRequireApproval2
+> = z.object({
+  always: MCPToolFilter$outboundSchema.optional(),
+  never: MCPToolFilter$outboundSchema.optional(),
+});
+
+export function toolDefinitionRequireApproval2ToJSON(
+  toolDefinitionRequireApproval2: ToolDefinitionRequireApproval2,
+): string {
+  return JSON.stringify(
+    ToolDefinitionRequireApproval2$outboundSchema.parse(
+      toolDefinitionRequireApproval2,
+    ),
+  );
+}
+export function toolDefinitionRequireApproval2FromJSON(
+  jsonString: string,
+): SafeParseResult<ToolDefinitionRequireApproval2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolDefinitionRequireApproval2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolDefinitionRequireApproval2' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolDefinitionRequireApproval1$inboundSchema: z.ZodNativeEnum<
+  typeof ToolDefinitionRequireApproval1
+> = z.nativeEnum(ToolDefinitionRequireApproval1);
+/** @internal */
+export const ToolDefinitionRequireApproval1$outboundSchema: z.ZodNativeEnum<
+  typeof ToolDefinitionRequireApproval1
+> = ToolDefinitionRequireApproval1$inboundSchema;
+
+/** @internal */
+export const ThreeRequireApproval$inboundSchema: z.ZodType<
+  ThreeRequireApproval,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  ToolDefinitionRequireApproval1$inboundSchema,
+  z.lazy(() => ToolDefinitionRequireApproval2$inboundSchema),
+]);
+/** @internal */
+export type ThreeRequireApproval$Outbound =
+  | string
+  | ToolDefinitionRequireApproval2$Outbound;
+
+/** @internal */
+export const ThreeRequireApproval$outboundSchema: z.ZodType<
+  ThreeRequireApproval$Outbound,
+  z.ZodTypeDef,
+  ThreeRequireApproval
+> = z.union([
+  ToolDefinitionRequireApproval1$outboundSchema,
+  z.lazy(() => ToolDefinitionRequireApproval2$outboundSchema),
+]);
+
+export function threeRequireApprovalToJSON(
+  threeRequireApproval: ThreeRequireApproval,
+): string {
+  return JSON.stringify(
+    ThreeRequireApproval$outboundSchema.parse(threeRequireApproval),
+  );
+}
+export function threeRequireApprovalFromJSON(
+  jsonString: string,
+): SafeParseResult<ThreeRequireApproval, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ThreeRequireApproval$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ThreeRequireApproval' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolDefinition3AllowedTools$inboundSchema: z.ZodType<
+  ToolDefinition3AllowedTools,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.array(z.string()), MCPToolFilter$inboundSchema]);
+/** @internal */
+export type ToolDefinition3AllowedTools$Outbound =
+  | Array<string>
+  | MCPToolFilter$Outbound;
+
 /** @internal */
-export const ThreeRequireApproval$outboundSchema: z.ZodNativeEnum<
-  typeof ThreeRequireApproval
-> = ThreeRequireApproval$inboundSchema;
+export const ToolDefinition3AllowedTools$outboundSchema: z.ZodType<
+  ToolDefinition3AllowedTools$Outbound,
+  z.ZodTypeDef,
+  ToolDefinition3AllowedTools
+> = z.union([z.array(z.string()), MCPToolFilter$outboundSchema]);
+
+export function toolDefinition3AllowedToolsToJSON(
+  toolDefinition3AllowedTools: ToolDefinition3AllowedTools,
+): string {
+  return JSON.stringify(
+    ToolDefinition3AllowedTools$outboundSchema.parse(
+      toolDefinition3AllowedTools,
+    ),
+  );
+}
+export function toolDefinition3AllowedToolsFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolDefinition3AllowedTools, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolDefinition3AllowedTools$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolDefinition3AllowedTools' from JSON`,
+  );
+}
 
 /** @internal */
 export const Three2$inboundSchema: z.ZodType<Three2, z.ZodTypeDef, unknown> = z
@@ -985,8 +1138,12 @@ export const Three2$inboundSchema: z.ZodType<Three2, z.ZodTypeDef, unknown> = z
     server_url: z.string().optional(),
     server_description: z.string().optional(),
     authorization: z.string().optional(),
-    require_approval: ThreeRequireApproval$inboundSchema.optional(),
-    allowed_tools: z.array(z.string()).optional(),
+    require_approval: z.union([
+      ToolDefinitionRequireApproval1$inboundSchema,
+      z.lazy(() => ToolDefinitionRequireApproval2$inboundSchema),
+    ]).optional(),
+    allowed_tools: z.union([z.array(z.string()), MCPToolFilter$inboundSchema])
+      .optional(),
     headers: z.record(z.string()).optional(),
   }).transform((v) => {
     return remap$(v, {
@@ -1008,8 +1165,11 @@ export type Three2$Outbound = {
   server_url?: string | undefined;
   server_description?: string | undefined;
   authorization?: string | undefined;
-  require_approval?: string | undefined;
-  allowed_tools?: Array<string> | undefined;
+  require_approval?:
+    | string
+    | ToolDefinitionRequireApproval2$Outbound
+    | undefined;
+  allowed_tools?: Array<string> | MCPToolFilter$Outbound | undefined;
   headers?: { [k: string]: string } | undefined;
 };
 
@@ -1026,8 +1186,12 @@ export const Three2$outboundSchema: z.ZodType<
   serverUrl: z.string().optional(),
   serverDescription: z.string().optional(),
   authorization: z.string().optional(),
-  requireApproval: ThreeRequireApproval$outboundSchema.optional(),
-  allowedTools: z.array(z.string()).optional(),
+  requireApproval: z.union([
+    ToolDefinitionRequireApproval1$outboundSchema,
+    z.lazy(() => ToolDefinitionRequireApproval2$outboundSchema),
+  ]).optional(),
+  allowedTools: z.union([z.array(z.string()), MCPToolFilter$outboundSchema])
+    .optional(),
   headers: z.record(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -1062,13 +1226,125 @@ export const ThreeType$outboundSchema: z.ZodNativeEnum<typeof ThreeType> =
   ThreeType$inboundSchema;
 
 /** @internal */
-export const RequireApproval$inboundSchema: z.ZodNativeEnum<
-  typeof RequireApproval
-> = z.nativeEnum(RequireApproval);
+export const RequireApproval2$inboundSchema: z.ZodType<
+  RequireApproval2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  always: MCPToolFilter$inboundSchema.optional(),
+  never: MCPToolFilter$inboundSchema.optional(),
+});
+/** @internal */
+export type RequireApproval2$Outbound = {
+  always?: MCPToolFilter$Outbound | undefined;
+  never?: MCPToolFilter$Outbound | undefined;
+};
+
+/** @internal */
+export const RequireApproval2$outboundSchema: z.ZodType<
+  RequireApproval2$Outbound,
+  z.ZodTypeDef,
+  RequireApproval2
+> = z.object({
+  always: MCPToolFilter$outboundSchema.optional(),
+  never: MCPToolFilter$outboundSchema.optional(),
+});
+
+export function requireApproval2ToJSON(
+  requireApproval2: RequireApproval2,
+): string {
+  return JSON.stringify(
+    RequireApproval2$outboundSchema.parse(requireApproval2),
+  );
+}
+export function requireApproval2FromJSON(
+  jsonString: string,
+): SafeParseResult<RequireApproval2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RequireApproval2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RequireApproval2' from JSON`,
+  );
+}
+
+/** @internal */
+export const RequireApproval1$inboundSchema: z.ZodNativeEnum<
+  typeof RequireApproval1
+> = z.nativeEnum(RequireApproval1);
+/** @internal */
+export const RequireApproval1$outboundSchema: z.ZodNativeEnum<
+  typeof RequireApproval1
+> = RequireApproval1$inboundSchema;
+
+/** @internal */
+export const RequireApproval$inboundSchema: z.ZodType<
+  RequireApproval,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  RequireApproval1$inboundSchema,
+  z.lazy(() => RequireApproval2$inboundSchema),
+]);
+/** @internal */
+export type RequireApproval$Outbound = string | RequireApproval2$Outbound;
+
+/** @internal */
+export const RequireApproval$outboundSchema: z.ZodType<
+  RequireApproval$Outbound,
+  z.ZodTypeDef,
+  RequireApproval
+> = z.union([
+  RequireApproval1$outboundSchema,
+  z.lazy(() => RequireApproval2$outboundSchema),
+]);
+
+export function requireApprovalToJSON(
+  requireApproval: RequireApproval,
+): string {
+  return JSON.stringify(RequireApproval$outboundSchema.parse(requireApproval));
+}
+export function requireApprovalFromJSON(
+  jsonString: string,
+): SafeParseResult<RequireApproval, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RequireApproval$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RequireApproval' from JSON`,
+  );
+}
+
+/** @internal */
+export const ThreeAllowedTools$inboundSchema: z.ZodType<
+  ThreeAllowedTools,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.array(z.string()), MCPToolFilter$inboundSchema]);
 /** @internal */
-export const RequireApproval$outboundSchema: z.ZodNativeEnum<
-  typeof RequireApproval
-> = RequireApproval$inboundSchema;
+export type ThreeAllowedTools$Outbound = Array<string> | MCPToolFilter$Outbound;
+
+/** @internal */
+export const ThreeAllowedTools$outboundSchema: z.ZodType<
+  ThreeAllowedTools$Outbound,
+  z.ZodTypeDef,
+  ThreeAllowedTools
+> = z.union([z.array(z.string()), MCPToolFilter$outboundSchema]);
+
+export function threeAllowedToolsToJSON(
+  threeAllowedTools: ThreeAllowedTools,
+): string {
+  return JSON.stringify(
+    ThreeAllowedTools$outboundSchema.parse(threeAllowedTools),
+  );
+}
+export function threeAllowedToolsFromJSON(
+  jsonString: string,
+): SafeParseResult<ThreeAllowedTools, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ThreeAllowedTools$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ThreeAllowedTools' from JSON`,
+  );
+}
 
 /** @internal */
 export const Three1$inboundSchema: z.ZodType<Three1, z.ZodTypeDef, unknown> = z
@@ -1080,8 +1356,12 @@ export const Three1$inboundSchema: z.ZodType<Three1, z.ZodTypeDef, unknown> = z
     server_url: z.string().optional(),
     server_description: z.string().optional(),
     authorization: z.string().optional(),
-    require_approval: RequireApproval$inboundSchema.optional(),
-    allowed_tools: z.array(z.string()).optional(),
+    require_approval: z.union([
+      RequireApproval1$inboundSchema,
+      z.lazy(() => RequireApproval2$inboundSchema),
+    ]).optional(),
+    allowed_tools: z.union([z.array(z.string()), MCPToolFilter$inboundSchema])
+      .optional(),
     headers: z.record(z.string()).optional(),
   }).transform((v) => {
     return remap$(v, {
@@ -1103,8 +1383,8 @@ export type Three1$Outbound = {
   server_url?: string | undefined;
   server_description?: string | undefined;
   authorization?: string | undefined;
-  require_approval?: string | undefined;
-  allowed_tools?: Array<string> | undefined;
+  require_approval?: string | RequireApproval2$Outbound | undefined;
+  allowed_tools?: Array<string> | MCPToolFilter$Outbound | undefined;
   headers?: { [k: string]: string } | undefined;
 };
 
@@ -1121,8 +1401,12 @@ export const Three1$outboundSchema: z.ZodType<
   serverUrl: z.string().optional(),
   serverDescription: z.string().optional(),
   authorization: z.string().optional(),
-  requireApproval: RequireApproval$outboundSchema.optional(),
-  allowedTools: z.array(z.string()).optional(),
+  requireApproval: z.union([
+    RequireApproval1$outboundSchema,
+    z.lazy(() => RequireApproval2$outboundSchema),
+  ]).optional(),
+  allowedTools: z.union([z.array(z.string()), MCPToolFilter$outboundSchema])
+    .optional(),
   headers: z.record(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {