@meetkai/mka1 0.49.11 → 0.49.12

package/dist/esm/sdk/agentconnectors.js

@@ -22,7 +22,7 @@ export class AgentConnectors extends ClientSDK {
      * Create a connector
      *
      * @remarks
-     * Connects the agent to a Telegram bot, validates the bot token, and registers the agent's webhook. Telegram text, photos, and gateway-supported documents can invoke the agent; inbound media additionally requires write:files. Managed outbound files require read:files, and generated images require both file scopes so their transient provider URLs can be materialized before delivery. The optional write:feedback scope enables native thumbs reaction synchronization to gateway response feedback. These conditional scopes are deliberately not part of x-required-scopes because text-only connectors do not need them. An API key with every listed scope is required; its identity tuple and current scopes are stored as a non-widening ceiling, then revalidated with mk-authentication before every connector run; session and delegated end-user contexts are rejected. The required access policy controls which Telegram chats may invoke the agent.
+     * Connects the agent to a Telegram bot or WhatsApp Business phone number, validates the provider credentials, and registers the agent's webhook. Text, photos, and gateway-supported documents can invoke the agent; inbound media additionally requires write:files. Managed outbound files require read:files, and generated images require both file scopes so their transient provider URLs can be materialized before delivery. The optional write:feedback scope enables native thumbs reaction synchronization to gateway response feedback. These conditional scopes are deliberately not part of x-required-scopes because text-only connectors do not need them. An API key with every listed scope is required; its identity tuple and current scopes are stored as a non-widening ceiling, then revalidated with mk-authentication before every connector run; session and delegated end-user contexts are rejected. The required access policy controls which provider users or chats may invoke the agent.
      */
     async createAgentConnector(request, options) {
         return unwrapAsync(agentConnectorsCreateAgentConnector(this, request, options));
@@ -40,7 +40,7 @@ export class AgentConnectors extends ClientSDK {
      * Delete a connector
      *
      * @remarks
-     * Unregisters the provider webhook, drops its pending Telegram updates, and deletes the stored connector credentials.
+     * Unregisters the connector-specific provider webhook and deletes the stored connector credentials. Telegram pending updates are dropped; WhatsApp deletion clears only the phone-number callback and does not unsubscribe other numbers in the business account.
      */
     async deleteAgentConnector(request, options) {
         return unwrapAsync(agentConnectorsDeleteAgentConnector(this, request, options));
@@ -49,7 +49,7 @@ export class AgentConnectors extends ClientSDK {
      * Activate a connector
      *
      * @remarks
-     * Revalidates the stored Telegram credentials and registers the provider webhook. Use this to retry a connector left in an error state or rotate its key. API-key authentication with every listed scope is required; session authentication is rejected, and the new key must belong to the connector's original user or service-account principal so existing conversations keep the same owner.
+     * Revalidates the stored provider credentials and registers the provider webhook. Use this to retry a connector left in an error state. API-key authentication with every listed scope is required; session authentication is rejected, and the key must belong to the connector's original user or service-account principal so existing conversations keep the same owner.
      */
     async activateAgentConnector(request, options) {
         return unwrapAsync(agentConnectorsActivateAgentConnector(this, request, options));

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@meetkai/mka1",
-  "version": "0.49.11",
+  "version": "0.49.12",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetkai/mka1",
-  "version": "0.49.11",
+  "version": "0.49.12",
   "author": "Daniel Wilder <dauncy@gmail.com>",
   "homepage": "https://docs.mka1.com",
   "publishConfig": {

package/src/funcs/agentConnectorsActivateAgentConnector.ts

@@ -31,7 +31,7 @@ import { Result } from "../types/fp.js";
  * Activate a connector
  *
  * @remarks
- * Revalidates the stored Telegram credentials and registers the provider webhook. Use this to retry a connector left in an error state or rotate its key. API-key authentication with every listed scope is required; session authentication is rejected, and the new key must belong to the connector's original user or service-account principal so existing conversations keep the same owner.
+ * Revalidates the stored provider credentials and registers the provider webhook. Use this to retry a connector left in an error state. API-key authentication with every listed scope is required; session authentication is rejected, and the key must belong to the connector's original user or service-account principal so existing conversations keep the same owner.
  */
 export function agentConnectorsActivateAgentConnector(
   client: SDKCore,

package/src/funcs/agentConnectorsCreateAgentConnector.ts

@@ -31,7 +31,7 @@ import { Result } from "../types/fp.js";
  * Create a connector
  *
  * @remarks
- * Connects the agent to a Telegram bot, validates the bot token, and registers the agent's webhook. Telegram text, photos, and gateway-supported documents can invoke the agent; inbound media additionally requires write:files. Managed outbound files require read:files, and generated images require both file scopes so their transient provider URLs can be materialized before delivery. The optional write:feedback scope enables native thumbs reaction synchronization to gateway response feedback. These conditional scopes are deliberately not part of x-required-scopes because text-only connectors do not need them. An API key with every listed scope is required; its identity tuple and current scopes are stored as a non-widening ceiling, then revalidated with mk-authentication before every connector run; session and delegated end-user contexts are rejected. The required access policy controls which Telegram chats may invoke the agent.
+ * Connects the agent to a Telegram bot or WhatsApp Business phone number, validates the provider credentials, and registers the agent's webhook. Text, photos, and gateway-supported documents can invoke the agent; inbound media additionally requires write:files. Managed outbound files require read:files, and generated images require both file scopes so their transient provider URLs can be materialized before delivery. The optional write:feedback scope enables native thumbs reaction synchronization to gateway response feedback. These conditional scopes are deliberately not part of x-required-scopes because text-only connectors do not need them. An API key with every listed scope is required; its identity tuple and current scopes are stored as a non-widening ceiling, then revalidated with mk-authentication before every connector run; session and delegated end-user contexts are rejected. The required access policy controls which provider users or chats may invoke the agent.
  */
 export function agentConnectorsCreateAgentConnector(
   client: SDKCore,

package/src/funcs/agentConnectorsDeleteAgentConnector.ts

@@ -31,7 +31,7 @@ import { Result } from "../types/fp.js";
  * Delete a connector
  *
  * @remarks
- * Unregisters the provider webhook, drops its pending Telegram updates, and deletes the stored connector credentials.
+ * Unregisters the connector-specific provider webhook and deletes the stored connector credentials. Telegram pending updates are dropped; WhatsApp deletion clears only the phone-number callback and does not unsubscribe other numbers in the business account.
  */
 export function agentConnectorsDeleteAgentConnector(
   client: SDKCore,

package/src/lib/config.ts

@@ -65,7 +65,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.1.0",
-  sdkVersion: "0.49.11",
+  sdkVersion: "0.49.12",
   genVersion: "2.918.3",
-  userAgent: "speakeasy-sdk/typescript 0.49.11 2.918.3 1.1.0 @meetkai/mka1",
+  userAgent: "speakeasy-sdk/typescript 0.49.12 2.918.3 1.1.0 @meetkai/mka1",
 } as const;

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

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.49.11",
+    currentVersion: "0.49.12",
   },
 });
 

package/src/mcp-server/server.ts

@@ -345,7 +345,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.49.11",
+    version: "0.49.12",
   });
 
   const client = new SDKCore({

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

@@ -16,7 +16,7 @@ export const tool$agentConnectorsActivateAgentConnector: ToolDefinition<
   name: "agent-connectors-activate-agent-connector",
   description: `Activate a connector
 
-Revalidates the stored Telegram credentials and registers the provider webhook. Use this to retry a connector left in an error state or rotate its key. API-key authentication with every listed scope is required; session authentication is rejected, and the new key must belong to the connector's original user or service-account principal so existing conversations keep the same owner.`,
+Revalidates the stored provider credentials and registers the provider webhook. Use this to retry a connector left in an error state. API-key authentication with every listed scope is required; session authentication is rejected, and the key must belong to the connector's original user or service-account principal so existing conversations keep the same owner.`,
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await agentConnectorsActivateAgentConnector(

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

@@ -16,7 +16,7 @@ export const tool$agentConnectorsCreateAgentConnector: ToolDefinition<
   name: "agent-connectors-create-agent-connector",
   description: `Create a connector
 
-Connects the agent to a Telegram bot, validates the bot token, and registers the agent's webhook. Telegram text, photos, and gateway-supported documents can invoke the agent; inbound media additionally requires write:files. Managed outbound files require read:files, and generated images require both file scopes so their transient provider URLs can be materialized before delivery. The optional write:feedback scope enables native thumbs reaction synchronization to gateway response feedback. These conditional scopes are deliberately not part of x-required-scopes because text-only connectors do not need them. An API key with every listed scope is required; its identity tuple and current scopes are stored as a non-widening ceiling, then revalidated with mk-authentication before every connector run; session and delegated end-user contexts are rejected. The required access policy controls which Telegram chats may invoke the agent.`,
+Connects the agent to a Telegram bot or WhatsApp Business phone number, validates the provider credentials, and registers the agent's webhook. Text, photos, and gateway-supported documents can invoke the agent; inbound media additionally requires write:files. Managed outbound files require read:files, and generated images require both file scopes so their transient provider URLs can be materialized before delivery. The optional write:feedback scope enables native thumbs reaction synchronization to gateway response feedback. These conditional scopes are deliberately not part of x-required-scopes because text-only connectors do not need them. An API key with every listed scope is required; its identity tuple and current scopes are stored as a non-widening ceiling, then revalidated with mk-authentication before every connector run; session and delegated end-user contexts are rejected. The required access policy controls which provider users or chats may invoke the agent.`,
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await agentConnectorsCreateAgentConnector(

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

@@ -16,7 +16,7 @@ export const tool$agentConnectorsDeleteAgentConnector: ToolDefinition<
   name: "agent-connectors-delete-agent-connector",
   description: `Delete a connector
 
-Unregisters the provider webhook, drops its pending Telegram updates, and deletes the stored connector credentials.`,
+Unregisters the connector-specific provider webhook and deletes the stored connector credentials. Telegram pending updates are dropped; WhatsApp deletion clears only the phone-number callback and does not unsubscribe other numbers in the business account.`,
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await agentConnectorsDeleteAgentConnector(

package/src/models/components/agentconnector.ts

@@ -22,6 +22,7 @@ export type AgentConnectorObject = ClosedEnum<typeof AgentConnectorObject>;
 
 export const Provider = {
   Telegram: "telegram",
+  Whatsapp: "whatsapp",
 } as const;
 export type Provider = ClosedEnum<typeof Provider>;
 
@@ -36,11 +37,11 @@ export type AgentConnector = {
    */
   status: string;
   /**
-   * The Telegram bot user ID.
+   * The provider account ID: Telegram bot user ID or WhatsApp phone-number ID.
    */
   providerAccountId: string;
   /**
-   * The Telegram bot username when one is available.
+   * Provider account display name when one is available.
    */
   providerAccountName: string | null;
   config: JsonValue | null;

package/src/models/components/createagentconnectorrequest.ts

@@ -3,218 +3,49 @@
  */
 
 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";
-
-/**
- * Telegram Bot API connector. Supports text, photos up to the Bot API's 20 MiB download limit, gateway-supported documents, and response feedback through native thumbs reactions.
- */
-export const CreateAgentConnectorRequestProvider = {
-  Telegram: "telegram",
-} as const;
-/**
- * Telegram Bot API connector. Supports text, photos up to the Bot API's 20 MiB download limit, gateway-supported documents, and response feedback through native thumbs reactions.
- */
-export type CreateAgentConnectorRequestProvider = ClosedEnum<
-  typeof CreateAgentConnectorRequestProvider
->;
-
-export type Credentials = {
-  /**
-   * Telegram bot token issued by BotFather. It is encrypted at rest and is never returned by the API.
-   */
-  botToken: string;
-};
-
-export const CreateAgentConnectorRequestMode = {
-  Allowlist: "allowlist",
-} as const;
-export type CreateAgentConnectorRequestMode = ClosedEnum<
-  typeof CreateAgentConnectorRequestMode
->;
-
-/**
- * The explicit Telegram chat allowlist permitted to invoke the agent.
- */
-export type CreateAgentConnectorRequestAccess = {
-  mode: CreateAgentConnectorRequestMode;
-  chatIds: Array<number>;
-};
-
-export type CreateAgentConnectorRequest = {
-  /**
-   * Telegram Bot API connector. Supports text, photos up to the Bot API's 20 MiB download limit, gateway-supported documents, and response feedback through native thumbs reactions.
-   */
-  provider: CreateAgentConnectorRequestProvider;
-  name?: string | undefined;
-  credentials: Credentials;
-  /**
-   * The explicit Telegram chat allowlist permitted to invoke the agent.
-   */
-  access: CreateAgentConnectorRequestAccess;
-  /**
-   * Always true: Telegram discards updates queued before this tenancy's webhook is registered.
-   */
-  dropPendingUpdates?: true | undefined;
-};
-
-/** @internal */
-export const CreateAgentConnectorRequestProvider$inboundSchema: z.ZodNativeEnum<
-  typeof CreateAgentConnectorRequestProvider
-> = z.nativeEnum(CreateAgentConnectorRequestProvider);
-/** @internal */
-export const CreateAgentConnectorRequestProvider$outboundSchema:
-  z.ZodNativeEnum<typeof CreateAgentConnectorRequestProvider> =
-    CreateAgentConnectorRequestProvider$inboundSchema;
-
-/** @internal */
-export const Credentials$inboundSchema: z.ZodType<
-  Credentials,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  bot_token: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "bot_token": "botToken",
-  });
-});
-/** @internal */
-export type Credentials$Outbound = {
-  bot_token: string;
-};
-
-/** @internal */
-export const Credentials$outboundSchema: z.ZodType<
-  Credentials$Outbound,
-  z.ZodTypeDef,
-  Credentials
-> = z.object({
-  botToken: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    botToken: "bot_token",
-  });
-});
-
-export function credentialsToJSON(credentials: Credentials): string {
-  return JSON.stringify(Credentials$outboundSchema.parse(credentials));
-}
-export function credentialsFromJSON(
-  jsonString: string,
-): SafeParseResult<Credentials, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Credentials$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Credentials' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateAgentConnectorRequestMode$inboundSchema: z.ZodNativeEnum<
-  typeof CreateAgentConnectorRequestMode
-> = z.nativeEnum(CreateAgentConnectorRequestMode);
-/** @internal */
-export const CreateAgentConnectorRequestMode$outboundSchema: z.ZodNativeEnum<
-  typeof CreateAgentConnectorRequestMode
-> = CreateAgentConnectorRequestMode$inboundSchema;
-
-/** @internal */
-export const CreateAgentConnectorRequestAccess$inboundSchema: z.ZodType<
-  CreateAgentConnectorRequestAccess,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  mode: CreateAgentConnectorRequestMode$inboundSchema,
-  chat_ids: z.array(z.number().int()),
-}).transform((v) => {
-  return remap$(v, {
-    "chat_ids": "chatIds",
-  });
-});
-/** @internal */
-export type CreateAgentConnectorRequestAccess$Outbound = {
-  mode: string;
-  chat_ids: Array<number>;
-};
-
-/** @internal */
-export const CreateAgentConnectorRequestAccess$outboundSchema: z.ZodType<
-  CreateAgentConnectorRequestAccess$Outbound,
-  z.ZodTypeDef,
-  CreateAgentConnectorRequestAccess
-> = z.object({
-  mode: CreateAgentConnectorRequestMode$outboundSchema,
-  chatIds: z.array(z.number().int()),
-}).transform((v) => {
-  return remap$(v, {
-    chatIds: "chat_ids",
-  });
-});
-
-export function createAgentConnectorRequestAccessToJSON(
-  createAgentConnectorRequestAccess: CreateAgentConnectorRequestAccess,
-): string {
-  return JSON.stringify(
-    CreateAgentConnectorRequestAccess$outboundSchema.parse(
-      createAgentConnectorRequestAccess,
-    ),
-  );
-}
-export function createAgentConnectorRequestAccessFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateAgentConnectorRequestAccess, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateAgentConnectorRequestAccess$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateAgentConnectorRequestAccess' from JSON`,
-  );
-}
+import {
+  CreateTelegramAgentConnectorRequest,
+  CreateTelegramAgentConnectorRequest$inboundSchema,
+  CreateTelegramAgentConnectorRequest$Outbound,
+  CreateTelegramAgentConnectorRequest$outboundSchema,
+} from "./createtelegramagentconnectorrequest.js";
+import {
+  CreateWhatsAppAgentConnectorRequest,
+  CreateWhatsAppAgentConnectorRequest$inboundSchema,
+  CreateWhatsAppAgentConnectorRequest$Outbound,
+  CreateWhatsAppAgentConnectorRequest$outboundSchema,
+} from "./createwhatsappagentconnectorrequest.js";
+
+export type CreateAgentConnectorRequest =
+  | CreateTelegramAgentConnectorRequest
+  | CreateWhatsAppAgentConnectorRequest;
 
 /** @internal */
 export const CreateAgentConnectorRequest$inboundSchema: z.ZodType<
   CreateAgentConnectorRequest,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  provider: CreateAgentConnectorRequestProvider$inboundSchema,
-  name: z.string().optional(),
-  credentials: z.lazy(() => Credentials$inboundSchema),
-  access: z.lazy(() => CreateAgentConnectorRequestAccess$inboundSchema),
-  drop_pending_updates: z.literal(true).default(true),
-}).transform((v) => {
-  return remap$(v, {
-    "drop_pending_updates": "dropPendingUpdates",
-  });
-});
+> = z.union([
+  CreateTelegramAgentConnectorRequest$inboundSchema,
+  CreateWhatsAppAgentConnectorRequest$inboundSchema,
+]);
 /** @internal */
-export type CreateAgentConnectorRequest$Outbound = {
-  provider: string;
-  name?: string | undefined;
-  credentials: Credentials$Outbound;
-  access: CreateAgentConnectorRequestAccess$Outbound;
-  drop_pending_updates: true;
-};
+export type CreateAgentConnectorRequest$Outbound =
+  | CreateTelegramAgentConnectorRequest$Outbound
+  | CreateWhatsAppAgentConnectorRequest$Outbound;
 
 /** @internal */
 export const CreateAgentConnectorRequest$outboundSchema: z.ZodType<
   CreateAgentConnectorRequest$Outbound,
   z.ZodTypeDef,
   CreateAgentConnectorRequest
-> = z.object({
-  provider: CreateAgentConnectorRequestProvider$outboundSchema,
-  name: z.string().optional(),
-  credentials: z.lazy(() => Credentials$outboundSchema),
-  access: z.lazy(() => CreateAgentConnectorRequestAccess$outboundSchema),
-  dropPendingUpdates: z.literal(true).default(true as const),
-}).transform((v) => {
-  return remap$(v, {
-    dropPendingUpdates: "drop_pending_updates",
-  });
-});
+> = z.union([
+  CreateTelegramAgentConnectorRequest$outboundSchema,
+  CreateWhatsAppAgentConnectorRequest$outboundSchema,
+]);
 
 export function createAgentConnectorRequestToJSON(
   createAgentConnectorRequest: CreateAgentConnectorRequest,

package/src/models/components/createtelegramagentconnectorrequest.ts

@@ -0,0 +1,225 @@
+/*
+ * 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 type Credentials = {
+  /**
+   * Telegram bot token issued by BotFather. It is encrypted at rest and is never returned by the API.
+   */
+  botToken: string;
+};
+
+export const CreateTelegramAgentConnectorRequestMode = {
+  Allowlist: "allowlist",
+} as const;
+export type CreateTelegramAgentConnectorRequestMode = ClosedEnum<
+  typeof CreateTelegramAgentConnectorRequestMode
+>;
+
+/**
+ * The explicit Telegram chat allowlist permitted to invoke the agent.
+ */
+export type CreateTelegramAgentConnectorRequestAccess = {
+  mode: CreateTelegramAgentConnectorRequestMode;
+  chatIds: Array<number>;
+};
+
+export type CreateTelegramAgentConnectorRequest = {
+  /**
+   * Telegram Bot API connector. Supports text, photos up to the Bot API's 20 MiB download limit, gateway-supported documents, and response feedback through native thumbs reactions.
+   */
+  provider: "telegram";
+  name?: string | undefined;
+  credentials: Credentials;
+  /**
+   * The explicit Telegram chat allowlist permitted to invoke the agent.
+   */
+  access: CreateTelegramAgentConnectorRequestAccess;
+  /**
+   * Always true: Telegram discards updates queued before this tenancy's webhook is registered.
+   */
+  dropPendingUpdates?: true | undefined;
+};
+
+/** @internal */
+export const Credentials$inboundSchema: z.ZodType<
+  Credentials,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bot_token: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "bot_token": "botToken",
+  });
+});
+/** @internal */
+export type Credentials$Outbound = {
+  bot_token: string;
+};
+
+/** @internal */
+export const Credentials$outboundSchema: z.ZodType<
+  Credentials$Outbound,
+  z.ZodTypeDef,
+  Credentials
+> = z.object({
+  botToken: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    botToken: "bot_token",
+  });
+});
+
+export function credentialsToJSON(credentials: Credentials): string {
+  return JSON.stringify(Credentials$outboundSchema.parse(credentials));
+}
+export function credentialsFromJSON(
+  jsonString: string,
+): SafeParseResult<Credentials, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Credentials$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Credentials' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateTelegramAgentConnectorRequestMode$inboundSchema:
+  z.ZodNativeEnum<typeof CreateTelegramAgentConnectorRequestMode> = z
+    .nativeEnum(CreateTelegramAgentConnectorRequestMode);
+/** @internal */
+export const CreateTelegramAgentConnectorRequestMode$outboundSchema:
+  z.ZodNativeEnum<typeof CreateTelegramAgentConnectorRequestMode> =
+    CreateTelegramAgentConnectorRequestMode$inboundSchema;
+
+/** @internal */
+export const CreateTelegramAgentConnectorRequestAccess$inboundSchema: z.ZodType<
+  CreateTelegramAgentConnectorRequestAccess,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  mode: CreateTelegramAgentConnectorRequestMode$inboundSchema,
+  chat_ids: z.array(z.number().int()),
+}).transform((v) => {
+  return remap$(v, {
+    "chat_ids": "chatIds",
+  });
+});
+/** @internal */
+export type CreateTelegramAgentConnectorRequestAccess$Outbound = {
+  mode: string;
+  chat_ids: Array<number>;
+};
+
+/** @internal */
+export const CreateTelegramAgentConnectorRequestAccess$outboundSchema:
+  z.ZodType<
+    CreateTelegramAgentConnectorRequestAccess$Outbound,
+    z.ZodTypeDef,
+    CreateTelegramAgentConnectorRequestAccess
+  > = z.object({
+    mode: CreateTelegramAgentConnectorRequestMode$outboundSchema,
+    chatIds: z.array(z.number().int()),
+  }).transform((v) => {
+    return remap$(v, {
+      chatIds: "chat_ids",
+    });
+  });
+
+export function createTelegramAgentConnectorRequestAccessToJSON(
+  createTelegramAgentConnectorRequestAccess:
+    CreateTelegramAgentConnectorRequestAccess,
+): string {
+  return JSON.stringify(
+    CreateTelegramAgentConnectorRequestAccess$outboundSchema.parse(
+      createTelegramAgentConnectorRequestAccess,
+    ),
+  );
+}
+export function createTelegramAgentConnectorRequestAccessFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  CreateTelegramAgentConnectorRequestAccess,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateTelegramAgentConnectorRequestAccess$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'CreateTelegramAgentConnectorRequestAccess' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateTelegramAgentConnectorRequest$inboundSchema: z.ZodType<
+  CreateTelegramAgentConnectorRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  provider: z.literal("telegram"),
+  name: z.string().optional(),
+  credentials: z.lazy(() => Credentials$inboundSchema),
+  access: z.lazy(() => CreateTelegramAgentConnectorRequestAccess$inboundSchema),
+  drop_pending_updates: z.literal(true).default(true),
+}).transform((v) => {
+  return remap$(v, {
+    "drop_pending_updates": "dropPendingUpdates",
+  });
+});
+/** @internal */
+export type CreateTelegramAgentConnectorRequest$Outbound = {
+  provider: "telegram";
+  name?: string | undefined;
+  credentials: Credentials$Outbound;
+  access: CreateTelegramAgentConnectorRequestAccess$Outbound;
+  drop_pending_updates: true;
+};
+
+/** @internal */
+export const CreateTelegramAgentConnectorRequest$outboundSchema: z.ZodType<
+  CreateTelegramAgentConnectorRequest$Outbound,
+  z.ZodTypeDef,
+  CreateTelegramAgentConnectorRequest
+> = z.object({
+  provider: z.literal("telegram"),
+  name: z.string().optional(),
+  credentials: z.lazy(() => Credentials$outboundSchema),
+  access: z.lazy(() =>
+    CreateTelegramAgentConnectorRequestAccess$outboundSchema
+  ),
+  dropPendingUpdates: z.literal(true).default(true as const),
+}).transform((v) => {
+  return remap$(v, {
+    dropPendingUpdates: "drop_pending_updates",
+  });
+});
+
+export function createTelegramAgentConnectorRequestToJSON(
+  createTelegramAgentConnectorRequest: CreateTelegramAgentConnectorRequest,
+): string {
+  return JSON.stringify(
+    CreateTelegramAgentConnectorRequest$outboundSchema.parse(
+      createTelegramAgentConnectorRequest,
+    ),
+  );
+}
+export function createTelegramAgentConnectorRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateTelegramAgentConnectorRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateTelegramAgentConnectorRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateTelegramAgentConnectorRequest' from JSON`,
+  );
+}