@wingman-ai/gateway 0.1.0

package/dist/types/hooks.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types/hooks.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Hooks System Types
+ *
+ * Following Claude Code's hooks pattern for consistency.
+ * Hooks are user-configurable shell commands that execute at specific lifecycle points.
+ */
+/**
+ * Hook type - currently only "command" is supported
+ */
+export type HookType = "command";
+/**
+ * Individual hook configuration
+ */
+export interface Hook {
+    /** Type of hook - currently only "command" is supported */
+    type: HookType;
+    /** Shell command to execute */
+    command: string;
+    /** Timeout in seconds (default: 60) */
+    timeout?: number;
+}
+/**
+ * Hook matcher for tool-specific hooks (PreToolUse, PostToolUse)
+ * Supports pattern matching to selectively execute hooks
+ */
+export interface HookMatcher {
+    /**
+     * Pattern to match tool names. Supports:
+     * - Pipe-separated tool names: "write_file|edit_file"
+     * - Single tool name: "command_execute"
+     * - Wildcard: "*" or empty string
+     * - Regex patterns: ".*_file"
+     *
+     * Case-sensitive matching
+     */
+    matcher?: string;
+    /** Array of hooks to execute when pattern matches */
+    hooks: Hook[];
+}
+/**
+ * Stop hook configuration (no matcher needed)
+ */
+export interface StopHook {
+    /** Array of hooks to execute when agent stops */
+    hooks: Hook[];
+}
+/**
+ * Complete hooks configuration
+ * Can be defined globally in wingman.config.json or per-agent in agent.json
+ */
+export interface HooksConfig {
+    /** Hooks that fire before tool execution (can block) */
+    PreToolUse?: HookMatcher[];
+    /** Hooks that fire after tool completes successfully (non-blocking) */
+    PostToolUse?: HookMatcher[];
+    /** Hooks that fire when agent completes (non-blocking) */
+    Stop?: StopHook[];
+}
+/**
+ * Hook event names
+ */
+export type HookEventName = "PreToolUse" | "PostToolUse" | "Stop";
+/**
+ * Input data passed to hooks via stdin as JSON
+ * Following Claude Code's HookInput format
+ */
+export interface HookInput {
+    /** Unique session identifier */
+    session_id: string;
+    /** Current working directory */
+    cwd: string;
+    /** Name of the hook event that triggered this hook */
+    hook_event_name: HookEventName;
+    /** Tool name (for PreToolUse/PostToolUse hooks) */
+    tool_name?: string;
+    /** Tool input parameters (for PreToolUse/PostToolUse hooks) */
+    tool_input?: Record<string, unknown>;
+    /** Tool use ID (for PreToolUse/PostToolUse hooks) */
+    tool_use_id?: string;
+    /** Tool output (for PostToolUse hooks only) */
+    tool_output?: unknown;
+}

package/dist/types/mcp.cjs

@@ -0,0 +1,86 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    MCPServerConfigSchema: ()=>MCPServerConfigSchema,
+    MCPStdioConfigSchema: ()=>MCPStdioConfigSchema,
+    validateMCPConfig: ()=>validateMCPConfig,
+    MCPSSEConfigSchema: ()=>MCPSSEConfigSchema,
+    MCPServersConfigSchema: ()=>MCPServersConfigSchema
+});
+const external_zod_namespaceObject = require("zod");
+const MCPStdioConfigSchema = external_zod_namespaceObject.z.object({
+    name: external_zod_namespaceObject.z.string().min(1).describe("Unique server name"),
+    transport: external_zod_namespaceObject.z.literal("stdio"),
+    command: external_zod_namespaceObject.z.string().min(1).describe("Command to execute (e.g., 'node', 'python')"),
+    args: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional().describe("Command arguments"),
+    env: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.string()).optional().describe("Environment variables")
+});
+const MCPSSEConfigSchema = external_zod_namespaceObject.z.object({
+    name: external_zod_namespaceObject.z.string().min(1).describe("Unique server name"),
+    transport: external_zod_namespaceObject.z.literal("sse"),
+    url: external_zod_namespaceObject.z.string().url().describe("Server URL"),
+    headers: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.string()).optional().describe("HTTP headers for authentication")
+});
+const MCPServerConfigSchema = external_zod_namespaceObject.z.union([
+    MCPStdioConfigSchema,
+    MCPSSEConfigSchema
+]);
+const MCPServersConfigSchema = external_zod_namespaceObject.z.object({
+    servers: external_zod_namespaceObject.z.array(MCPServerConfigSchema).optional().describe("List of MCP servers")
+});
+function validateMCPConfig(config) {
+    try {
+        const validated = MCPServersConfigSchema.parse(config);
+        return {
+            success: true,
+            data: validated
+        };
+    } catch (error) {
+        if (error instanceof external_zod_namespaceObject.z.ZodError) return {
+            success: false,
+            error: error.issues.map((e)=>`${e.path.join(".")}: ${e.message}`).join(", ")
+        };
+        return {
+            success: false,
+            error: String(error)
+        };
+    }
+}
+exports.MCPSSEConfigSchema = __webpack_exports__.MCPSSEConfigSchema;
+exports.MCPServerConfigSchema = __webpack_exports__.MCPServerConfigSchema;
+exports.MCPServersConfigSchema = __webpack_exports__.MCPServersConfigSchema;
+exports.MCPStdioConfigSchema = __webpack_exports__.MCPStdioConfigSchema;
+exports.validateMCPConfig = __webpack_exports__.validateMCPConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MCPSSEConfigSchema",
+    "MCPServerConfigSchema",
+    "MCPServersConfigSchema",
+    "MCPStdioConfigSchema",
+    "validateMCPConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types/mcp.d.ts

@@ -0,0 +1,107 @@
+import { z } from "zod";
+/**
+ * Transport type for MCP server connection
+ */
+export type MCPTransport = "stdio" | "sse";
+/**
+ * Base MCP server configuration
+ */
+export interface MCPServerConfig {
+    /** Unique server identifier/name */
+    name: string;
+    /** Transport protocol */
+    transport: MCPTransport;
+}
+/**
+ * Stdio transport configuration (for local subprocess)
+ */
+export interface MCPStdioConfig extends MCPServerConfig {
+    transport: "stdio";
+    /** Command to execute (e.g., "node", "python") */
+    command: string;
+    /** Command arguments (e.g., ["/path/to/server.js"]) */
+    args?: string[];
+    /** Environment variables for the subprocess */
+    env?: Record<string, string>;
+}
+/**
+ * SSE transport configuration (for HTTP/remote servers)
+ */
+export interface MCPSSEConfig extends MCPServerConfig {
+    transport: "sse";
+    /** Server URL (e.g., "http://localhost:8000/mcp") */
+    url: string;
+    /** Optional headers for authentication */
+    headers?: Record<string, string>;
+}
+/**
+ * Union type for all MCP server configurations
+ */
+export type MCPServerConfiguration = MCPStdioConfig | MCPSSEConfig;
+/**
+ * Container for multiple MCP servers
+ */
+export interface MCPServersConfig {
+    /** List of MCP server configurations */
+    servers?: MCPServerConfiguration[];
+}
+/**
+ * Zod schema for Stdio transport configuration
+ */
+export declare const MCPStdioConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodLiteral<"stdio">;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for SSE transport configuration
+ */
+export declare const MCPSSEConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodLiteral<"sse">;
+    url: z.ZodString;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for MCP server configuration (discriminated union)
+ */
+export declare const MCPServerConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodLiteral<"stdio">;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodLiteral<"sse">;
+    url: z.ZodString;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>]>;
+/**
+ * Zod schema for MCP servers configuration container
+ */
+export declare const MCPServersConfigSchema: z.ZodObject<{
+    servers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        name: z.ZodString;
+        transport: z.ZodLiteral<"stdio">;
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+        transport: z.ZodLiteral<"sse">;
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>]>>>;
+}, z.core.$strip>;
+export type MCPServersConfigType = z.infer<typeof MCPServersConfigSchema>;
+/**
+ * Validate MCP server configuration
+ */
+export declare function validateMCPConfig(config: unknown): {
+    success: boolean;
+    data?: MCPServersConfigType;
+    error?: string;
+};

package/dist/types/mcp.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+const MCPStdioConfigSchema = z.object({
+    name: z.string().min(1).describe("Unique server name"),
+    transport: z.literal("stdio"),
+    command: z.string().min(1).describe("Command to execute (e.g., 'node', 'python')"),
+    args: z.array(z.string()).optional().describe("Command arguments"),
+    env: z.record(z.string(), z.string()).optional().describe("Environment variables")
+});
+const MCPSSEConfigSchema = z.object({
+    name: z.string().min(1).describe("Unique server name"),
+    transport: z.literal("sse"),
+    url: z.string().url().describe("Server URL"),
+    headers: z.record(z.string(), z.string()).optional().describe("HTTP headers for authentication")
+});
+const MCPServerConfigSchema = z.union([
+    MCPStdioConfigSchema,
+    MCPSSEConfigSchema
+]);
+const MCPServersConfigSchema = z.object({
+    servers: z.array(MCPServerConfigSchema).optional().describe("List of MCP servers")
+});
+function validateMCPConfig(config) {
+    try {
+        const validated = MCPServersConfigSchema.parse(config);
+        return {
+            success: true,
+            data: validated
+        };
+    } catch (error) {
+        if (error instanceof z.ZodError) return {
+            success: false,
+            error: error.issues.map((e)=>`${e.path.join(".")}: ${e.message}`).join(", ")
+        };
+        return {
+            success: false,
+            error: String(error)
+        };
+    }
+}
+export { MCPSSEConfigSchema, MCPServerConfigSchema, MCPServersConfigSchema, MCPStdioConfigSchema, validateMCPConfig };

package/dist/types/voice.cjs

@@ -0,0 +1,103 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    WebSpeechOptionsSchema: ()=>WebSpeechOptionsSchema,
+    AgentVoiceConfigSchema: ()=>AgentVoiceConfigSchema,
+    VoiceConfigSchema: ()=>VoiceConfigSchema,
+    VoiceConfigUpdateSchema: ()=>VoiceConfigUpdateSchema,
+    VoicePolicySchema: ()=>VoicePolicySchema,
+    VoiceProviderSchema: ()=>VoiceProviderSchema,
+    ElevenLabsOptionsSchema: ()=>ElevenLabsOptionsSchema
+});
+const external_zod_namespaceObject = require("zod");
+const VoiceProviderSchema = external_zod_namespaceObject.z["enum"]([
+    "web_speech",
+    "elevenlabs"
+]);
+const VoicePolicySchema = external_zod_namespaceObject.z["enum"]([
+    "off",
+    "manual",
+    "auto"
+]);
+const WebSpeechOptionsSchema = external_zod_namespaceObject.z.object({
+    voiceName: external_zod_namespaceObject.z.string().optional(),
+    lang: external_zod_namespaceObject.z.string().optional(),
+    rate: external_zod_namespaceObject.z.number().min(0.1).max(4).optional(),
+    pitch: external_zod_namespaceObject.z.number().min(0).max(2).optional(),
+    volume: external_zod_namespaceObject.z.number().min(0).max(1).optional()
+});
+const ElevenLabsOptionsSchema = external_zod_namespaceObject.z.object({
+    voiceId: external_zod_namespaceObject.z.string().optional(),
+    modelId: external_zod_namespaceObject.z.string().optional(),
+    stability: external_zod_namespaceObject.z.number().min(0).max(1).optional(),
+    similarityBoost: external_zod_namespaceObject.z.number().min(0).max(1).optional(),
+    style: external_zod_namespaceObject.z.number().min(0).max(1).optional(),
+    speakerBoost: external_zod_namespaceObject.z.boolean().optional(),
+    speed: external_zod_namespaceObject.z.number().min(0.25).max(4).optional(),
+    outputFormat: external_zod_namespaceObject.z.string().optional(),
+    optimizeStreamingLatency: external_zod_namespaceObject.z.number().min(0).max(4).optional()
+});
+const VoiceConfigSchema = external_zod_namespaceObject.z.object({
+    provider: VoiceProviderSchema.default("web_speech"),
+    defaultPolicy: VoicePolicySchema.default("off"),
+    webSpeech: WebSpeechOptionsSchema.optional().default({}),
+    elevenlabs: ElevenLabsOptionsSchema.optional().default({})
+}).default({
+    provider: "web_speech",
+    defaultPolicy: "off",
+    webSpeech: {},
+    elevenlabs: {}
+});
+const AgentVoiceConfigSchema = external_zod_namespaceObject.z.object({
+    provider: VoiceProviderSchema.optional(),
+    webSpeech: WebSpeechOptionsSchema.optional(),
+    elevenlabs: ElevenLabsOptionsSchema.optional()
+});
+const VoiceConfigUpdateSchema = external_zod_namespaceObject.z.object({
+    provider: VoiceProviderSchema.optional(),
+    defaultPolicy: VoicePolicySchema.optional(),
+    webSpeech: WebSpeechOptionsSchema.optional(),
+    elevenlabs: ElevenLabsOptionsSchema.optional()
+});
+exports.AgentVoiceConfigSchema = __webpack_exports__.AgentVoiceConfigSchema;
+exports.ElevenLabsOptionsSchema = __webpack_exports__.ElevenLabsOptionsSchema;
+exports.VoiceConfigSchema = __webpack_exports__.VoiceConfigSchema;
+exports.VoiceConfigUpdateSchema = __webpack_exports__.VoiceConfigUpdateSchema;
+exports.VoicePolicySchema = __webpack_exports__.VoicePolicySchema;
+exports.VoiceProviderSchema = __webpack_exports__.VoiceProviderSchema;
+exports.WebSpeechOptionsSchema = __webpack_exports__.WebSpeechOptionsSchema;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AgentVoiceConfigSchema",
+    "ElevenLabsOptionsSchema",
+    "VoiceConfigSchema",
+    "VoiceConfigUpdateSchema",
+    "VoicePolicySchema",
+    "VoiceProviderSchema",
+    "WebSpeechOptionsSchema"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types/voice.d.ts

@@ -0,0 +1,117 @@
+import { z } from "zod";
+export declare const VoiceProviderSchema: z.ZodEnum<{
+    web_speech: "web_speech";
+    elevenlabs: "elevenlabs";
+}>;
+export type VoiceProvider = z.infer<typeof VoiceProviderSchema>;
+export declare const VoicePolicySchema: z.ZodEnum<{
+    off: "off";
+    manual: "manual";
+    auto: "auto";
+}>;
+export type VoicePolicy = z.infer<typeof VoicePolicySchema>;
+export declare const WebSpeechOptionsSchema: z.ZodObject<{
+    voiceName: z.ZodOptional<z.ZodString>;
+    lang: z.ZodOptional<z.ZodString>;
+    rate: z.ZodOptional<z.ZodNumber>;
+    pitch: z.ZodOptional<z.ZodNumber>;
+    volume: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type WebSpeechOptions = z.infer<typeof WebSpeechOptionsSchema>;
+export declare const ElevenLabsOptionsSchema: z.ZodObject<{
+    voiceId: z.ZodOptional<z.ZodString>;
+    modelId: z.ZodOptional<z.ZodString>;
+    stability: z.ZodOptional<z.ZodNumber>;
+    similarityBoost: z.ZodOptional<z.ZodNumber>;
+    style: z.ZodOptional<z.ZodNumber>;
+    speakerBoost: z.ZodOptional<z.ZodBoolean>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    outputFormat: z.ZodOptional<z.ZodString>;
+    optimizeStreamingLatency: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ElevenLabsOptions = z.infer<typeof ElevenLabsOptionsSchema>;
+export declare const VoiceConfigSchema: z.ZodDefault<z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        web_speech: "web_speech";
+        elevenlabs: "elevenlabs";
+    }>>;
+    defaultPolicy: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        manual: "manual";
+        auto: "auto";
+    }>>;
+    webSpeech: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        voiceName: z.ZodOptional<z.ZodString>;
+        lang: z.ZodOptional<z.ZodString>;
+        rate: z.ZodOptional<z.ZodNumber>;
+        pitch: z.ZodOptional<z.ZodNumber>;
+        volume: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    elevenlabs: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        voiceId: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        stability: z.ZodOptional<z.ZodNumber>;
+        similarityBoost: z.ZodOptional<z.ZodNumber>;
+        style: z.ZodOptional<z.ZodNumber>;
+        speakerBoost: z.ZodOptional<z.ZodBoolean>;
+        speed: z.ZodOptional<z.ZodNumber>;
+        outputFormat: z.ZodOptional<z.ZodString>;
+        optimizeStreamingLatency: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>>;
+export type VoiceConfig = z.infer<typeof VoiceConfigSchema>;
+export declare const AgentVoiceConfigSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<{
+        web_speech: "web_speech";
+        elevenlabs: "elevenlabs";
+    }>>;
+    webSpeech: z.ZodOptional<z.ZodObject<{
+        voiceName: z.ZodOptional<z.ZodString>;
+        lang: z.ZodOptional<z.ZodString>;
+        rate: z.ZodOptional<z.ZodNumber>;
+        pitch: z.ZodOptional<z.ZodNumber>;
+        volume: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    elevenlabs: z.ZodOptional<z.ZodObject<{
+        voiceId: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        stability: z.ZodOptional<z.ZodNumber>;
+        similarityBoost: z.ZodOptional<z.ZodNumber>;
+        style: z.ZodOptional<z.ZodNumber>;
+        speakerBoost: z.ZodOptional<z.ZodBoolean>;
+        speed: z.ZodOptional<z.ZodNumber>;
+        outputFormat: z.ZodOptional<z.ZodString>;
+        optimizeStreamingLatency: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentVoiceConfig = z.infer<typeof AgentVoiceConfigSchema>;
+export declare const VoiceConfigUpdateSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<{
+        web_speech: "web_speech";
+        elevenlabs: "elevenlabs";
+    }>>;
+    defaultPolicy: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        manual: "manual";
+        auto: "auto";
+    }>>;
+    webSpeech: z.ZodOptional<z.ZodObject<{
+        voiceName: z.ZodOptional<z.ZodString>;
+        lang: z.ZodOptional<z.ZodString>;
+        rate: z.ZodOptional<z.ZodNumber>;
+        pitch: z.ZodOptional<z.ZodNumber>;
+        volume: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    elevenlabs: z.ZodOptional<z.ZodObject<{
+        voiceId: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        stability: z.ZodOptional<z.ZodNumber>;
+        similarityBoost: z.ZodOptional<z.ZodNumber>;
+        style: z.ZodOptional<z.ZodNumber>;
+        speakerBoost: z.ZodOptional<z.ZodBoolean>;
+        speed: z.ZodOptional<z.ZodNumber>;
+        outputFormat: z.ZodOptional<z.ZodString>;
+        optimizeStreamingLatency: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type VoiceConfigUpdate = z.infer<typeof VoiceConfigUpdateSchema>;

package/dist/types/voice.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+const VoiceProviderSchema = z["enum"]([
+    "web_speech",
+    "elevenlabs"
+]);
+const VoicePolicySchema = z["enum"]([
+    "off",
+    "manual",
+    "auto"
+]);
+const WebSpeechOptionsSchema = z.object({
+    voiceName: z.string().optional(),
+    lang: z.string().optional(),
+    rate: z.number().min(0.1).max(4).optional(),
+    pitch: z.number().min(0).max(2).optional(),
+    volume: z.number().min(0).max(1).optional()
+});
+const ElevenLabsOptionsSchema = z.object({
+    voiceId: z.string().optional(),
+    modelId: z.string().optional(),
+    stability: z.number().min(0).max(1).optional(),
+    similarityBoost: z.number().min(0).max(1).optional(),
+    style: z.number().min(0).max(1).optional(),
+    speakerBoost: z.boolean().optional(),
+    speed: z.number().min(0.25).max(4).optional(),
+    outputFormat: z.string().optional(),
+    optimizeStreamingLatency: z.number().min(0).max(4).optional()
+});
+const VoiceConfigSchema = z.object({
+    provider: VoiceProviderSchema.default("web_speech"),
+    defaultPolicy: VoicePolicySchema.default("off"),
+    webSpeech: WebSpeechOptionsSchema.optional().default({}),
+    elevenlabs: ElevenLabsOptionsSchema.optional().default({})
+}).default({
+    provider: "web_speech",
+    defaultPolicy: "off",
+    webSpeech: {},
+    elevenlabs: {}
+});
+const AgentVoiceConfigSchema = z.object({
+    provider: VoiceProviderSchema.optional(),
+    webSpeech: WebSpeechOptionsSchema.optional(),
+    elevenlabs: ElevenLabsOptionsSchema.optional()
+});
+const VoiceConfigUpdateSchema = z.object({
+    provider: VoiceProviderSchema.optional(),
+    defaultPolicy: VoicePolicySchema.optional(),
+    webSpeech: WebSpeechOptionsSchema.optional(),
+    elevenlabs: ElevenLabsOptionsSchema.optional()
+});
+export { AgentVoiceConfigSchema, ElevenLabsOptionsSchema, VoiceConfigSchema, VoiceConfigUpdateSchema, VoicePolicySchema, VoiceProviderSchema, WebSpeechOptionsSchema };

package/dist/utils/attachments.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    extractImageFiles: ()=>extractImageFiles
+});
+function extractImageFiles(items) {
+    const files = [];
+    if (!items) return files;
+    for(let i = 0; i < items.length; i += 1){
+        const item = items[i];
+        if (!item || "file" !== item.kind || !item.type.startsWith("image/")) continue;
+        const file = item.getAsFile?.();
+        if (file) files.push(file);
+    }
+    return files;
+}
+exports.extractImageFiles = __webpack_exports__.extractImageFiles;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "extractImageFiles"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/attachments.d.ts

@@ -0,0 +1,7 @@
+type ClipboardItemLike = {
+    kind: string;
+    type: string;
+    getAsFile?: () => File | null;
+};
+export declare function extractImageFiles(items?: ArrayLike<ClipboardItemLike> | null): File[];
+export {};

package/dist/utils/attachments.js

@@ -0,0 +1,12 @@
+function extractImageFiles(items) {
+    const files = [];
+    if (!items) return files;
+    for(let i = 0; i < items.length; i += 1){
+        const item = items[i];
+        if (!item || "file" !== item.kind || !item.type.startsWith("image/")) continue;
+        const file = item.getAsFile?.();
+        if (file) files.push(file);
+    }
+    return files;
+}
+export { extractImageFiles };