type SecretInput,

} from "openclaw/plugin-sdk/secret-input";

import { z } from "openclaw/plugin-sdk/zod";

import { TtsAutoSchema, TtsConfigSchema, TtsModeSchema, TtsProviderSchema } from "../api.js";

import { TtsConfigSchema } from "../api.js";

import { deepMergeDefined } from "./deep-merge.js";

import { DEFAULT_VOICE_CALL_REALTIME_INSTRUCTIONS } from "./realtime-defaults.js";

export { DEFAULT_VOICE_CALL_REALTIME_INSTRUCTIONS } from "./realtime-defaults.js";

// -----------------------------------------------------------------------------

// Phone Number Validation

// -----------------------------------------------------------------------------

* E.164 phone number format: +[country code][number]

* Examples use 555 prefix (reserved for fictional numbers)

*/

export const E164Schema = z

const E164Schema = z

.string()

.regex(/^\+[1-9]\d{1,14}$/, "Expected E.164 format, e.g. +15550001234");

* - "pairing": Unknown callers can request pairing (future)

* - "open": Accept all inbound calls (dangerous!)

*/

export const InboundPolicySchema = z.enum(["disabled", "allowlist", "pairing", "open"]);

const InboundPolicySchema = z.enum(["disabled", "allowlist", "pairing", "open"]);

// -----------------------------------------------------------------------------

// Provider-Specific Configuration

// -----------------------------------------------------------------------------

const SecretInputSchema = buildSecretInputSchema();

export const TelnyxConfigSchema = z

const TelnyxConfigSchema = z

.object({

/** Telnyx API v2 key */

apiKey: z.string().min(1).optional(),

.strict();

export type TelnyxConfig = z.infer<typeof TelnyxConfigSchema>;

export const TwilioConfigSchema = z

const TwilioConfigSchema = z

.object({

/** Twilio Account SID */

accountSid: z.string().min(1).optional(),

})

.strict();

export const PlivoConfigSchema = z

const PlivoConfigSchema = z

.object({

/** Plivo Auth ID (starts with MA/SA) */

authId: z.string().min(1).optional(),

.strict();

export type PlivoConfig = z.infer<typeof PlivoConfigSchema>;

export { TtsAutoSchema, TtsConfigSchema, TtsModeSchema, TtsProviderSchema };

export type VoiceCallTtsConfig = z.infer<typeof TtsConfigSchema>;

// -----------------------------------------------------------------------------

// Webhook Server Configuration

// -----------------------------------------------------------------------------

export const VoiceCallServeConfigSchema = z

const VoiceCallServeConfigSchema = z

.object({

/** Port to listen on */

port: z.number().int().positive().default(3334),

.strict()

.default({ port: 3334, bind: "127.0.0.1", path: "/voice/webhook" });

export const VoiceCallTailscaleConfigSchema = z

const VoiceCallTailscaleConfigSchema = z

.object({

/**

* Tailscale exposure mode:

// Tunnel Configuration (unified ngrok/tailscale)

// -----------------------------------------------------------------------------

export const VoiceCallTunnelConfigSchema = z

const VoiceCallTunnelConfigSchema = z

.object({

/**

* Tunnel provider:

// Webhook Security Configuration

// -----------------------------------------------------------------------------

export const VoiceCallWebhookSecurityConfigSchema = z

const VoiceCallWebhookSecurityConfigSchema = z

.object({

/**

* Allowed hostnames for webhook URL reconstruction.

* - "notify": Deliver message and auto-hangup after delay (one-way notification)

* - "conversation": Stay open for back-and-forth until explicit end or timeout

*/

export const CallModeSchema = z.enum(["notify", "conversation"]);

const CallModeSchema = z.enum(["notify", "conversation"]);

export type CallMode = z.infer<typeof CallModeSchema>;

export const OutboundConfigSchema = z

const OutboundConfigSchema = z

.object({

/** Default call mode for outbound calls */

defaultMode: CallModeSchema.default("notify"),

// Realtime Voice Configuration

// -----------------------------------------------------------------------------

export const RealtimeToolSchema = z

const RealtimeToolSchema = z

.object({

type: z.literal("function"),

name: z.string().min(1),

}),

})

.strict();

export type RealtimeToolConfig = z.infer<typeof RealtimeToolSchema>;

type RealtimeToolConfig = z.infer<typeof RealtimeToolSchema>;

export const VoiceCallRealtimeProvidersConfigSchema = z

const VoiceCallRealtimeProvidersConfigSchema = z

.record(z.string(), z.record(z.string(), z.unknown()))

.default({});

export const VoiceCallRealtimeToolPolicySchema = z.enum(REALTIME_VOICE_AGENT_CONSULT_TOOL_POLICIES);

const VoiceCallRealtimeToolPolicySchema = z.enum(REALTIME_VOICE_AGENT_CONSULT_TOOL_POLICIES);

export const VoiceCallRealtimeFastContextSourceSchema = z.enum(["memory", "sessions"]);

const VoiceCallRealtimeFastContextSourceSchema = z.enum(["memory", "sessions"]);

export const VoiceCallRealtimeFastContextConfigSchema = z

const VoiceCallRealtimeFastContextConfigSchema = z

.object({

/** Enable bounded memory/session lookup before the full consult agent. */

enabled: z.boolean().default(false),

typeof VoiceCallRealtimeFastContextConfigSchema

>;

export const VoiceCallStreamingProvidersConfigSchema = z

const VoiceCallStreamingProvidersConfigSchema = z

.record(z.string(), z.record(z.string(), z.unknown()))

.default({});

export const VoiceCallRealtimeConfigSchema = z

const VoiceCallRealtimeConfigSchema = z

.object({

/** Enable realtime voice-to-voice mode. */

enabled: z.boolean().default(false),

// Streaming Configuration (Realtime Transcription)

// -----------------------------------------------------------------------------

export const VoiceCallStreamingConfigSchema = z

const VoiceCallStreamingConfigSchema = z

.object({

/** Enable real-time audio streaming (requires WebSocket support) */

enabled: z.boolean().default(false),