@wildix/wim-tools-client 0.0.8 → 0.0.10

package/dist-types/models/models_0.d.ts

@@ -1,6 +1,17 @@
 import { ToolsServiceException as __BaseException } from "./ToolsServiceException";
 import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
 import { DocumentType as __DocumentType } from "@smithy/types";
+/**
+ * @public
+ */
+export declare class NotFoundException extends __BaseException {
+    readonly name: "NotFoundException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<NotFoundException, __BaseException>);
+}
 /**
  * @public
  */
@@ -14,137 +25,375 @@ export declare class ValidationException extends __BaseException {
 }
 /**
  * @public
- * @enum
  */
-export declare const ToolType: {
+export declare class AlreadyExistException extends __BaseException {
+    readonly name: "AlreadyExistException";
+    readonly $fault: "client";
     /**
-     * Send email via WNS Email service
+     * @internal
      */
-    readonly EMAIL: "EMAIL";
+    constructor(opts: __ExceptionOptionType<AlreadyExistException, __BaseException>);
+}
+/**
+ * @public
+ */
+export type ToolStringValue = ToolStringValue.StaticMember | ToolStringValue.TemplateMember | ToolStringValue.VariableMember | ToolStringValue.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace ToolStringValue {
+    interface StaticMember {
+        static: string;
+        variable?: never;
+        template?: never;
+        $unknown?: never;
+    }
+    interface VariableMember {
+        static?: never;
+        variable: string;
+        template?: never;
+        $unknown?: never;
+    }
+    interface TemplateMember {
+        static?: never;
+        variable?: never;
+        template: string;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        static?: never;
+        variable?: never;
+        template?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        static: (value: string) => T;
+        variable: (value: string) => T;
+        template: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ToolStringValue, visitor: Visitor<T>) => T;
+}
+/**
+ * @public
+ */
+export interface ToolChannelMessageConfig {
+    channelId: ToolStringValue;
+    text: ToolStringValue;
+}
+/**
+ * @public
+ */
+export interface ToolDirectMessageConfig {
+    memberEmail?: ToolStringValue | undefined;
+    memberPhone?: ToolStringValue | undefined;
+    memberId?: ToolStringValue | undefined;
+    text: ToolStringValue;
+}
+/**
+ * @public
+ */
+export type ToolChatHandler = ToolChatHandler.ChannelMember | ToolChatHandler.DirectMember | ToolChatHandler.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace ToolChatHandler {
+    interface DirectMember {
+        direct: ToolDirectMessageConfig;
+        channel?: never;
+        $unknown?: never;
+    }
+    interface ChannelMember {
+        direct?: never;
+        channel: ToolChannelMessageConfig;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        direct?: never;
+        channel?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        direct: (value: ToolDirectMessageConfig) => T;
+        channel: (value: ToolChannelMessageConfig) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ToolChatHandler, visitor: Visitor<T>) => T;
+}
+/**
+ * @public
+ */
+export interface ToolSmtpConfig {
+    host: string;
+    port: number;
+    username?: string | undefined;
+    password?: string | undefined;
+    secure?: boolean | undefined;
+}
+/**
+ * @public
+ */
+export interface ToolCustomEmailConfig {
+    smtp: ToolSmtpConfig;
+    from: ToolStringValue;
+    to: ToolStringValue;
+    subject: ToolStringValue;
+    text: ToolStringValue;
+    html?: ToolStringValue | undefined;
+    cc?: ToolStringValue | undefined;
+    bcc?: ToolStringValue | undefined;
+    replyTo?: ToolStringValue | undefined;
+}
+/**
+ * @public
+ */
+export interface ToolWnsEmailConfig {
+    to: ToolStringValue;
+    subject: ToolStringValue;
+    text: ToolStringValue;
+}
+/**
+ * @public
+ */
+export type ToolEmailHandler = ToolEmailHandler.CustomMember | ToolEmailHandler.WnsMember | ToolEmailHandler.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace ToolEmailHandler {
+    interface WnsMember {
+        wns: ToolWnsEmailConfig;
+        custom?: never;
+        $unknown?: never;
+    }
+    interface CustomMember {
+        wns?: never;
+        custom: ToolCustomEmailConfig;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        wns?: never;
+        custom?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        wns: (value: ToolWnsEmailConfig) => T;
+        custom: (value: ToolCustomEmailConfig) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ToolEmailHandler, visitor: Visitor<T>) => T;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const ToolAuthorizationType: {
+    readonly API_KEY: "ApiKey";
+    readonly BASIC: "Basic";
+    readonly BEARER: "Bearer";
 };
 /**
  * @public
  */
-export type ToolType = typeof ToolType[keyof typeof ToolType];
+export type ToolAuthorizationType = typeof ToolAuthorizationType[keyof typeof ToolAuthorizationType];
 /**
  * @public
  */
-export interface AddToolInput {
-    /**
-     * Company that owns the tool (optional, derived from auth context)
-     * @public
-     */
-    company?: string | undefined;
-    /**
-     * Tool name for LLM
-     * @public
-     */
+export interface ToolAuthentication {
+    type: ToolAuthorizationType;
+    token: string;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const ToolVariableType: {
+    readonly BOOLEAN: "boolean";
+    readonly NUMBER: "number";
+    readonly NUMBER_ARRAY: "number_array";
+    readonly OBJECT: "object";
+    readonly STRING: "string";
+    readonly STRING_ARRAY: "string_array";
+};
+/**
+ * @public
+ */
+export type ToolVariableType = typeof ToolVariableType[keyof typeof ToolVariableType];
+/**
+ * @public
+ */
+export interface ToolVariable {
     name: string;
-    /**
-     * Tool description
-     * @public
-     */
+    type: ToolVariableType;
     description: string;
-    /**
-     * Tool type
-     * @public
-     */
-    type: ToolType;
-    /**
-     * Tool-specific configuration
-     * @public
-     */
-    config: __DocumentType;
-    /**
-     * JSON Schema for parameters
-     * @public
-     */
-    jsonSchema: __DocumentType;
+    required?: boolean | undefined;
 }
 /**
- * Tool configuration and metadata
  * @public
  */
-export interface Tool {
-    /**
-     * Unique tool identifier
-     * @public
-     */
-    id: string;
-    /**
-     * Company that owns this tool
-     * @public
-     */
-    company: string;
-    /**
-     * Tool name for LLM (e.g., "send_email")
-     * @public
-     */
+export interface ToolInput {
+    variables: (ToolVariable)[];
+}
+/**
+ * @public
+ */
+export interface ToolMcpTool {
+    name: string;
+    input: ToolInput;
+    params: Record<string, ToolStringValue>;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const ToolMcpTransport: {
+    readonly HTTP: "http";
+    readonly SSE: "sse";
+    readonly STDIO: "stdio";
+};
+/**
+ * @public
+ */
+export type ToolMcpTransport = typeof ToolMcpTransport[keyof typeof ToolMcpTransport];
+/**
+ * @public
+ */
+export interface ToolMcpHandler {
+    serverUrl: string;
+    transport: ToolMcpTransport;
+    authentication?: ToolAuthentication | undefined;
+    timeout?: number | undefined;
+    tools: (ToolMcpTool)[];
+}
+/**
+ * @public
+ */
+export interface ToolSmsHandler {
+    serviceUri: ToolStringValue;
+    recipientId?: ToolStringValue | undefined;
+    recipientNumber: ToolStringValue;
+    message: ToolStringValue;
+}
+/**
+ * @public
+ */
+export interface ToolWebhookHandler {
+    url: ToolStringValue;
+    body: ToolStringValue;
+    key?: ToolStringValue | undefined;
+    secret: ToolStringValue;
+    timeout?: number | undefined;
+}
+/**
+ * @public
+ */
+export type ToolHandler = ToolHandler.ChatMember | ToolHandler.EmailMember | ToolHandler.McpMember | ToolHandler.SmsMember | ToolHandler.WebhookMember | ToolHandler.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace ToolHandler {
+    interface EmailMember {
+        email: ToolEmailHandler;
+        sms?: never;
+        chat?: never;
+        webhook?: never;
+        mcp?: never;
+        $unknown?: never;
+    }
+    interface SmsMember {
+        email?: never;
+        sms: ToolSmsHandler;
+        chat?: never;
+        webhook?: never;
+        mcp?: never;
+        $unknown?: never;
+    }
+    interface ChatMember {
+        email?: never;
+        sms?: never;
+        chat: ToolChatHandler;
+        webhook?: never;
+        mcp?: never;
+        $unknown?: never;
+    }
+    interface WebhookMember {
+        email?: never;
+        sms?: never;
+        chat?: never;
+        webhook: ToolWebhookHandler;
+        mcp?: never;
+        $unknown?: never;
+    }
+    interface McpMember {
+        email?: never;
+        sms?: never;
+        chat?: never;
+        webhook?: never;
+        mcp: ToolMcpHandler;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        email?: never;
+        sms?: never;
+        chat?: never;
+        webhook?: never;
+        mcp?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        email: (value: ToolEmailHandler) => T;
+        sms: (value: ToolSmsHandler) => T;
+        chat: (value: ToolChatHandler) => T;
+        webhook: (value: ToolWebhookHandler) => T;
+        mcp: (value: ToolMcpHandler) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ToolHandler, visitor: Visitor<T>) => T;
+}
+/**
+ * @public
+ */
+export interface CreateToolInput {
+    company?: string | undefined;
     name: string;
-    /**
-     * Human-readable description for LLM
-     * @public
-     */
     description: string;
-    /**
-     * Type of tool
-     * @public
-     */
-    type: ToolType;
-    /**
-     * Tool-specific configuration (JSON)
-     * @public
-     */
-    config: __DocumentType;
-    /**
-     * JSON Schema for LLM parameters
-     * @public
-     */
-    jsonSchema: __DocumentType;
-    /**
-     * When the tool was created
-     * @public
-     */
-    createdAt: Date;
-    /**
-     * When the tool was last updated
-     * @public
-     */
-    updatedAt?: Date | undefined;
+    input: ToolInput;
+    handler: ToolHandler;
 }
 /**
  * @public
  */
-export interface AddToolOutput {
-    /**
-     * Created tool
-     * @public
-     */
-    tool: Tool;
+export interface Tool {
+    id: string;
+    company: string;
+    name: string;
+    description?: string | undefined;
+    input: ToolInput;
+    handler: ToolHandler;
 }
 /**
- * Tool already exists error
  * @public
  */
-export declare class ToolAlreadyExistsException extends __BaseException {
-    readonly name: "ToolAlreadyExistsException";
-    readonly $fault: "client";
-    /**
-     * @internal
-     */
-    constructor(opts: __ExceptionOptionType<ToolAlreadyExistsException, __BaseException>);
+export interface CreateToolOutput {
+    tool: Tool;
 }
 /**
- * Tool execution failed error
  * @public
  */
 export declare class ToolExecutionException extends __BaseException {
     readonly name: "ToolExecutionException";
     readonly $fault: "server";
-    /**
-     * Detailed error information
-     * @public
-     */
     details?: __DocumentType | undefined;
     /**
      * @internal
@@ -152,248 +401,106 @@ export declare class ToolExecutionException extends __BaseException {
     constructor(opts: __ExceptionOptionType<ToolExecutionException, __BaseException>);
 }
 /**
- * Tool not found error
  * @public
  */
-export declare class ToolNotFoundException extends __BaseException {
-    readonly name: "ToolNotFoundException";
-    readonly $fault: "client";
-    /**
-     * @internal
-     */
-    constructor(opts: __ExceptionOptionType<ToolNotFoundException, __BaseException>);
+export interface DeleteToolInput {
+    company?: string | undefined;
+    toolId: string;
 }
 /**
  * @public
  */
-export interface DeleteToolInput {
-    /**
-     * Company that owns the tool (optional, derived from auth context)
-     * @public
-     */
+export interface DeleteToolOutput {
+}
+/**
+ * @public
+ */
+export interface DescribeToolsInput {
     company?: string | undefined;
-    /**
-     * Tool identifier
-     * @public
-     */
-    toolId: string;
+    ids: (string)[];
 }
 /**
  * @public
  */
-export interface DeleteToolOutput {
+export interface ToolDescription {
+    id: string;
+    name: string;
+    description: string;
+    variables: (ToolVariable)[];
 }
 /**
- * Tool execution context
  * @public
  */
-export interface ExecutionContext {
-    /**
-     * Company executing the tool
-     * @public
-     */
-    company: string;
-    /**
-     * Session identifier for tracing
-     * @public
-     */
-    sessionId?: string | undefined;
+export interface DescribeToolsOutput {
+    descriptions: (ToolDescription)[];
 }
 /**
  * @public
  */
 export interface ExecuteToolInput {
-    /**
-     * Company executing the tool (optional, derived from auth context)
-     * @public
-     */
     company?: string | undefined;
-    /**
-     * Tool identifier
-     * @public
-     */
-    toolId: string;
-    /**
-     * Parameters from LLM (JSON)
-     * @public
-     */
-    parameters: __DocumentType;
-    /**
-     * Execution context for tracing
-     * @public
-     */
-    context?: ExecutionContext | undefined;
+    id: string;
+    input: __DocumentType;
 }
 /**
- * Tool execution result
  * @public
  */
-export interface ExecutionResult {
-    /**
-     * Whether execution was successful
-     * @public
-     */
-    success: boolean;
-    /**
-     * Result data (JSON)
-     * @public
-     */
-    result?: __DocumentType | undefined;
-    /**
-     * Error message if failed
-     * @public
-     */
-    error?: string | undefined;
-    /**
-     * Execution trace identifier
-     * @public
-     */
-    traceId?: string | undefined;
+export interface ToolExecutionError {
+    message: string;
+}
+/**
+ * @public
+ */
+export interface ToolExecutionResult {
+    statusCode: number;
+    output: __DocumentType;
+    error?: ToolExecutionError | undefined;
 }
 /**
  * @public
  */
 export interface ExecuteToolOutput {
-    /**
-     * Execution result
-     * @public
-     */
-    result: ExecutionResult;
+    result: ToolExecutionResult;
 }
 /**
  * @public
  */
 export interface GetToolInput {
-    /**
-     * Company identifier (optional, derived from auth context)
-     * @public
-     */
     company?: string | undefined;
-    /**
-     * Tool identifier
-     * @public
-     */
     toolId: string;
 }
 /**
  * @public
  */
 export interface GetToolOutput {
-    /**
-     * Tool details
-     * @public
-     */
     tool: Tool;
 }
 /**
  * @public
  */
 export interface ListToolsInput {
-    /**
-     * Company identifier (optional, derived from auth context)
-     * @public
-     */
     company?: string | undefined;
-    /**
-     * Return in LLM-compatible format
-     * @public
-     */
-    format?: string | undefined;
-}
-/**
- * Function definition for LLM
- * @public
- */
-export interface LlmFunctionDefinition {
-    /**
-     * Function name
-     * @public
-     */
-    name: string;
-    /**
-     * Function description
-     * @public
-     */
-    description: string;
-    /**
-     * JSON Schema for parameters
-     * @public
-     */
-    parameters: __DocumentType;
-}
-/**
- * Tool definition in OpenAI-compatible format for LLM
- * @public
- */
-export interface LlmToolDefinition {
-    /**
-     * Tool type (always "function" for OpenAI compatibility)
-     * @public
-     */
-    type: string;
-    /**
-     * Function definition
-     * @public
-     */
-    function: LlmFunctionDefinition;
 }
 /**
  * @public
  */
 export interface ListToolsOutput {
-    /**
-     * List of tools (raw format)
-     * @public
-     */
-    tools?: (Tool)[] | undefined;
-    /**
-     * List of tools in LLM format (if format=llm)
-     * @public
-     */
-    llmTools?: (LlmToolDefinition)[] | undefined;
+    tools: (Tool)[];
 }
 /**
  * @public
  */
 export interface UpdateToolInput {
-    /**
-     * Company that owns the tool (optional, derived from auth context)
-     * @public
-     */
     company?: string | undefined;
-    /**
-     * Tool identifier
-     * @public
-     */
     toolId: string;
-    /**
-     * Updated tool name
-     * @public
-     */
     name: string;
-    /**
-     * Updated description
-     * @public
-     */
     description: string;
-    /**
-     * Updated configuration
-     * @public
-     */
-    config: __DocumentType;
-    /**
-     * Updated JSON Schema
-     * @public
-     */
-    jsonSchema: __DocumentType;
+    input: ToolInput;
+    handler: ToolHandler;
 }
 /**
  * @public
  */
 export interface UpdateToolOutput {
-    /**
-     * Updated tool
-     * @public
-     */
     tool: Tool;
 }