@wildix/wim-tools-client 0.0.9 → 0.0.11

package/dist-es/commands/{AddToolCommand.js → CreateToolCommand.js}

@@ -1,17 +1,17 @@
-import { de_AddToolCommand, se_AddToolCommand, } from "../protocols/Aws_restJson1";
+import { de_CreateToolCommand, se_CreateToolCommand, } from "../protocols/Aws_restJson1";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 export { $Command };
-export class AddToolCommand extends $Command.classBuilder()
+export class CreateToolCommand extends $Command.classBuilder()
     .m(function (Command, cs, config, o) {
     return [
         getSerdePlugin(config, this.serialize, this.deserialize),
     ];
 })
-    .s("Tools", "AddTool", {})
-    .n("ToolsClient", "AddToolCommand")
+    .s("Tools", "CreateTool", {})
+    .n("ToolsClient", "CreateToolCommand")
     .f(void 0, void 0)
-    .ser(se_AddToolCommand)
-    .de(de_AddToolCommand)
+    .ser(se_CreateToolCommand)
+    .de(de_CreateToolCommand)
     .build() {
 }

package/dist-es/commands/DescribeToolsCommand.js

@@ -0,0 +1,17 @@
+import { de_DescribeToolsCommand, se_DescribeToolsCommand, } from "../protocols/Aws_restJson1";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+export { $Command };
+export class DescribeToolsCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("Tools", "DescribeTools", {})
+    .n("ToolsClient", "DescribeToolsCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeToolsCommand)
+    .de(de_DescribeToolsCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -1,5 +1,6 @@
-export * from "./AddToolCommand";
+export * from "./CreateToolCommand";
 export * from "./DeleteToolCommand";
+export * from "./DescribeToolsCommand";
 export * from "./ExecuteToolCommand";
 export * from "./GetToolCommand";
 export * from "./ListToolsCommand";

package/dist-es/models/models_0.js

@@ -1,4 +1,16 @@
 import { ToolsServiceException as __BaseException } from "./ToolsServiceException";
+export class NotFoundException extends __BaseException {
+    name = "NotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NotFoundException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, NotFoundException.prototype);
+    }
+}
 export class ValidationException extends __BaseException {
     name = "ValidationException";
     $fault = "client";
@@ -11,21 +23,84 @@ export class ValidationException extends __BaseException {
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
 }
-export const ToolType = {
-    EMAIL: "EMAIL",
-};
-export class ToolAlreadyExistsException extends __BaseException {
-    name = "ToolAlreadyExistsException";
+export class AlreadyExistException extends __BaseException {
+    name = "AlreadyExistException";
     $fault = "client";
     constructor(opts) {
         super({
-            name: "ToolAlreadyExistsException",
+            name: "AlreadyExistException",
             $fault: "client",
             ...opts
         });
-        Object.setPrototypeOf(this, ToolAlreadyExistsException.prototype);
+        Object.setPrototypeOf(this, AlreadyExistException.prototype);
     }
 }
+export var ToolStringValue;
+(function (ToolStringValue) {
+    ToolStringValue.visit = (value, visitor) => {
+        if (value.static !== undefined)
+            return visitor.static(value.static);
+        if (value.variable !== undefined)
+            return visitor.variable(value.variable);
+        if (value.template !== undefined)
+            return visitor.template(value.template);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolStringValue || (ToolStringValue = {}));
+export var ToolChatHandler;
+(function (ToolChatHandler) {
+    ToolChatHandler.visit = (value, visitor) => {
+        if (value.direct !== undefined)
+            return visitor.direct(value.direct);
+        if (value.channel !== undefined)
+            return visitor.channel(value.channel);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolChatHandler || (ToolChatHandler = {}));
+export var ToolEmailHandler;
+(function (ToolEmailHandler) {
+    ToolEmailHandler.visit = (value, visitor) => {
+        if (value.wns !== undefined)
+            return visitor.wns(value.wns);
+        if (value.custom !== undefined)
+            return visitor.custom(value.custom);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolEmailHandler || (ToolEmailHandler = {}));
+export const ToolAuthorizationType = {
+    API_KEY: "ApiKey",
+    BASIC: "Basic",
+    BEARER: "Bearer",
+};
+export const ToolVariableType = {
+    BOOLEAN: "boolean",
+    NUMBER: "number",
+    NUMBER_ARRAY: "number_array",
+    OBJECT: "object",
+    STRING: "string",
+    STRING_ARRAY: "string_array",
+};
+export const ToolMcpTransport = {
+    HTTP: "http",
+    SSE: "sse",
+    STDIO: "stdio",
+};
+export var ToolHandler;
+(function (ToolHandler) {
+    ToolHandler.visit = (value, visitor) => {
+        if (value.email !== undefined)
+            return visitor.email(value.email);
+        if (value.sms !== undefined)
+            return visitor.sms(value.sms);
+        if (value.chat !== undefined)
+            return visitor.chat(value.chat);
+        if (value.webhook !== undefined)
+            return visitor.webhook(value.webhook);
+        if (value.mcp !== undefined)
+            return visitor.mcp(value.mcp);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolHandler || (ToolHandler = {}));
 export class ToolExecutionException extends __BaseException {
     name = "ToolExecutionException";
     $fault = "server";
@@ -40,15 +115,3 @@ export class ToolExecutionException extends __BaseException {
         this.details = opts.details;
     }
 }
-export class ToolNotFoundException extends __BaseException {
-    name = "ToolNotFoundException";
-    $fault = "client";
-    constructor(opts) {
-        super({
-            name: "ToolNotFoundException",
-            $fault: "client",
-            ...opts
-        });
-        Object.setPrototypeOf(this, ToolNotFoundException.prototype);
-    }
-}

package/dist-es/protocols/Aws_restJson1.js

@@ -1,9 +1,9 @@
 import { ToolsServiceException as __BaseException } from "../models/ToolsServiceException";
-import { ToolAlreadyExistsException, ToolExecutionException, ToolNotFoundException, ValidationException, } from "../models/models_0";
+import { AlreadyExistException, NotFoundException, ToolExecutionException, ValidationException, } from "../models/models_0";
 import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
 import { requestBuilder as rb } from "@smithy/core";
-import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, _json, collectBody, isSerializableHeaderValue, map, take, withBaseException, } from "@smithy/smithy-client";
-export const se_AddToolCommand = async (input, context) => {
+import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, _json, collectBody, isSerializableHeaderValue, map, take, withBaseException, } from "@smithy/smithy-client";
+export const se_CreateToolCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         'content-type': 'application/json',
@@ -12,11 +12,10 @@ export const se_AddToolCommand = async (input, context) => {
     b.bp("/v1/tools");
     let body;
     body = JSON.stringify(take(input, {
-        'config': _ => se_Document(_, context),
         'description': [],
-        'jsonSchema': _ => se_Document(_, context),
+        'handler': _ => _json(_),
+        'input': _ => _json(_),
         'name': [],
-        'type': [],
     }));
     b.m("POST")
         .h(headers)
@@ -36,6 +35,22 @@ export const se_DeleteToolCommand = async (input, context) => {
         .b(body);
     return b.build();
 };
+export const se_DescribeToolsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+        [_xci]: input[_c],
+    });
+    b.bp("/v1/tools/describe");
+    let body;
+    body = JSON.stringify(take(input, {
+        'ids': _ => _json(_),
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
 export const se_ExecuteToolCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
@@ -45,9 +60,8 @@ export const se_ExecuteToolCommand = async (input, context) => {
     b.bp("/v1/tools/execute");
     let body;
     body = JSON.stringify(take(input, {
-        'context': _ => _json(_),
-        'parameters': _ => se_Document(_, context),
-        'toolId': [],
+        'id': [],
+        'input': _ => se_Document(_, context),
     }));
     b.m("POST")
         .h(headers)
@@ -71,16 +85,13 @@ export const se_GetToolCommand = async (input, context) => {
 };
 export const se_ListToolsCommand = async (input, context) => {
     const b = rb(input, context);
-    const headers = {};
-    b.bp("/v1/tools");
-    const query = map({
-        [_c]: [, input[_c]],
-        [_f]: [, input[_f]],
+    const headers = map({}, isSerializableHeaderValue, {
+        [_xci]: input[_c],
     });
+    b.bp("/v1/tools");
     let body;
     b.m("GET")
         .h(headers)
-        .q(query)
         .b(body);
     return b.build();
 };
@@ -94,9 +105,9 @@ export const se_UpdateToolCommand = async (input, context) => {
     b.p('toolId', () => input.toolId, '{toolId}', false);
     let body;
     body = JSON.stringify(take(input, {
-        'config': _ => se_Document(_, context),
         'description': [],
-        'jsonSchema': _ => se_Document(_, context),
+        'handler': _ => _json(_),
+        'input': _ => _json(_),
         'name': [],
     }));
     b.m("PUT")
@@ -104,7 +115,7 @@ export const se_UpdateToolCommand = async (input, context) => {
         .b(body);
     return b.build();
 };
-export const de_AddToolCommand = async (output, context) => {
+export const de_CreateToolCommand = async (output, context) => {
     if (output.statusCode !== 201 && output.statusCode >= 300) {
         return de_CommandError(output, context);
     }
@@ -113,7 +124,7 @@ export const de_AddToolCommand = async (output, context) => {
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'tool': _ => de_Tool(_, context),
+        'tool': _json,
     });
     Object.assign(contents, doc);
     return contents;
@@ -128,6 +139,20 @@ export const de_DeleteToolCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
+export const de_DescribeToolsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'descriptions': _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_ExecuteToolCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -137,7 +162,7 @@ export const de_ExecuteToolCommand = async (output, context) => {
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'result': _ => de_ExecutionResult(_, context),
+        'result': _ => de_ToolExecutionResult(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -151,7 +176,7 @@ export const de_GetToolCommand = async (output, context) => {
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'tool': _ => de_Tool(_, context),
+        'tool': _json,
     });
     Object.assign(contents, doc);
     return contents;
@@ -165,8 +190,7 @@ export const de_ListToolsCommand = async (output, context) => {
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'llmTools': _ => de_LlmToolDefinitionsList(_, context),
-        'tools': _ => de_ToolsList(_, context),
+        'tools': _json,
     });
     Object.assign(contents, doc);
     return contents;
@@ -180,7 +204,7 @@ export const de_UpdateToolCommand = async (output, context) => {
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'tool': _ => de_Tool(_, context),
+        'tool': _json,
     });
     Object.assign(contents, doc);
     return contents;
@@ -192,15 +216,15 @@ const de_CommandError = async (output, context) => {
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "ToolAlreadyExistsException":
-        case "wildix.wim.tools#ToolAlreadyExistsException":
-            throw await de_ToolAlreadyExistsExceptionRes(parsedOutput, context);
+        case "AlreadyExistException":
+        case "smithy.framework#AlreadyExistException":
+            throw await de_AlreadyExistExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "smithy.framework#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ToolExecutionException":
         case "wildix.wim.tools#ToolExecutionException":
             throw await de_ToolExecutionExceptionRes(parsedOutput, context);
-        case "ToolNotFoundException":
-        case "wildix.wim.tools#ToolNotFoundException":
-            throw await de_ToolNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "smithy.framework#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
@@ -214,54 +238,54 @@ const de_CommandError = async (output, context) => {
     }
 };
 const throwDefaultError = withBaseException(__BaseException);
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
+const de_AlreadyExistExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     const doc = take(data, {
         'message': __expectString,
     });
     Object.assign(contents, doc);
-    const exception = new ValidationException({
+    const exception = new AlreadyExistException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const de_ToolAlreadyExistsExceptionRes = async (parsedOutput, context) => {
+const de_NotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     const doc = take(data, {
         'message': __expectString,
     });
     Object.assign(contents, doc);
-    const exception = new ToolAlreadyExistsException({
+    const exception = new NotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const de_ToolExecutionExceptionRes = async (parsedOutput, context) => {
+const de_ValidationExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     const doc = take(data, {
-        'details': _ => de_Document(_, context),
         'message': __expectString,
     });
     Object.assign(contents, doc);
-    const exception = new ToolExecutionException({
+    const exception = new ValidationException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const de_ToolNotFoundExceptionRes = async (parsedOutput, context) => {
+const de_ToolExecutionExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     const doc = take(data, {
+        'details': _ => de_Document(_, context),
         'message': __expectString,
     });
     Object.assign(contents, doc);
-    const exception = new ToolNotFoundException({
+    const exception = new ToolExecutionException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents
     });
@@ -273,51 +297,12 @@ const se_Document = (input, context) => {
 const de_Document = (output, context) => {
     return output;
 };
-const de_ExecutionResult = (output, context) => {
-    return take(output, {
-        'error': __expectString,
-        'result': (_) => de_Document(_, context),
-        'success': __expectBoolean,
-        'traceId': __expectString,
-    });
-};
-const de_LlmFunctionDefinition = (output, context) => {
-    return take(output, {
-        'description': __expectString,
-        'name': __expectString,
-        'parameters': (_) => de_Document(_, context),
-    });
-};
-const de_LlmToolDefinition = (output, context) => {
+const de_ToolExecutionResult = (output, context) => {
     return take(output, {
-        'function': (_) => de_LlmFunctionDefinition(_, context),
-        'type': __expectString,
-    });
-};
-const de_LlmToolDefinitionsList = (output, context) => {
-    const retVal = (output || []).filter((e) => e != null).map((entry) => {
-        return de_LlmToolDefinition(entry, context);
-    });
-    return retVal;
-};
-const de_Tool = (output, context) => {
-    return take(output, {
-        'company': __expectString,
-        'config': (_) => de_Document(_, context),
-        'createdAt': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
-        'description': __expectString,
-        'id': __expectString,
-        'jsonSchema': (_) => de_Document(_, context),
-        'name': __expectString,
-        'type': __expectString,
-        'updatedAt': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
-    });
-};
-const de_ToolsList = (output, context) => {
-    const retVal = (output || []).filter((e) => e != null).map((entry) => {
-        return de_Tool(entry, context);
+        'error': _json,
+        'output': (_) => de_Document(_, context),
+        'statusCode': __expectInt32,
     });
-    return retVal;
 };
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
@@ -327,5 +312,4 @@ const deserializeMetadata = (output) => ({
 });
 const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then(body => context.utf8Encoder(body));
 const _c = "company";
-const _f = "format";
 const _xci = "x-company-id";

package/dist-types/Tools.d.ts

@@ -1,6 +1,7 @@
 import { ToolsClient } from "./ToolsClient";
-import { AddToolCommandInput, AddToolCommandOutput } from "./commands/AddToolCommand";
+import { CreateToolCommandInput, CreateToolCommandOutput } from "./commands/CreateToolCommand";
 import { DeleteToolCommandInput, DeleteToolCommandOutput } from "./commands/DeleteToolCommand";
+import { DescribeToolsCommandInput, DescribeToolsCommandOutput } from "./commands/DescribeToolsCommand";
 import { ExecuteToolCommandInput, ExecuteToolCommandOutput } from "./commands/ExecuteToolCommand";
 import { GetToolCommandInput, GetToolCommandOutput } from "./commands/GetToolCommand";
 import { ListToolsCommandInput, ListToolsCommandOutput } from "./commands/ListToolsCommand";
@@ -8,17 +9,23 @@ import { UpdateToolCommandInput, UpdateToolCommandOutput } from "./commands/Upda
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
 export interface Tools {
     /**
-     * @see {@link AddToolCommand}
+     * @see {@link CreateToolCommand}
      */
-    addTool(args: AddToolCommandInput, options?: __HttpHandlerOptions): Promise<AddToolCommandOutput>;
-    addTool(args: AddToolCommandInput, cb: (err: any, data?: AddToolCommandOutput) => void): void;
-    addTool(args: AddToolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AddToolCommandOutput) => void): void;
+    createTool(args: CreateToolCommandInput, options?: __HttpHandlerOptions): Promise<CreateToolCommandOutput>;
+    createTool(args: CreateToolCommandInput, cb: (err: any, data?: CreateToolCommandOutput) => void): void;
+    createTool(args: CreateToolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateToolCommandOutput) => void): void;
     /**
      * @see {@link DeleteToolCommand}
      */
     deleteTool(args: DeleteToolCommandInput, options?: __HttpHandlerOptions): Promise<DeleteToolCommandOutput>;
     deleteTool(args: DeleteToolCommandInput, cb: (err: any, data?: DeleteToolCommandOutput) => void): void;
     deleteTool(args: DeleteToolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteToolCommandOutput) => void): void;
+    /**
+     * @see {@link DescribeToolsCommand}
+     */
+    describeTools(args: DescribeToolsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeToolsCommandOutput>;
+    describeTools(args: DescribeToolsCommandInput, cb: (err: any, data?: DescribeToolsCommandOutput) => void): void;
+    describeTools(args: DescribeToolsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeToolsCommandOutput) => void): void;
     /**
      * @see {@link ExecuteToolCommand}
      */

package/dist-types/ToolsClient.d.ts

@@ -1,5 +1,6 @@
-import { AddToolCommandInput, AddToolCommandOutput } from "./commands/AddToolCommand";
+import { CreateToolCommandInput, CreateToolCommandOutput } from "./commands/CreateToolCommand";
 import { DeleteToolCommandInput, DeleteToolCommandOutput } from "./commands/DeleteToolCommand";
+import { DescribeToolsCommandInput, DescribeToolsCommandOutput } from "./commands/DescribeToolsCommand";
 import { ExecuteToolCommandInput, ExecuteToolCommandOutput } from "./commands/ExecuteToolCommand";
 import { GetToolCommandInput, GetToolCommandOutput } from "./commands/GetToolCommand";
 import { ListToolsCommandInput, ListToolsCommandOutput } from "./commands/ListToolsCommand";
@@ -15,11 +16,11 @@ export { __Client };
 /**
  * @public
  */
-export type ServiceInputTypes = AddToolCommandInput | DeleteToolCommandInput | ExecuteToolCommandInput | GetToolCommandInput | ListToolsCommandInput | UpdateToolCommandInput;
+export type ServiceInputTypes = CreateToolCommandInput | DeleteToolCommandInput | DescribeToolsCommandInput | ExecuteToolCommandInput | GetToolCommandInput | ListToolsCommandInput | UpdateToolCommandInput;
 /**
  * @public
  */
-export type ServiceOutputTypes = AddToolCommandOutput | DeleteToolCommandOutput | ExecuteToolCommandOutput | GetToolCommandOutput | ListToolsCommandOutput | UpdateToolCommandOutput;
+export type ServiceOutputTypes = CreateToolCommandOutput | DeleteToolCommandOutput | DescribeToolsCommandOutput | ExecuteToolCommandOutput | GetToolCommandOutput | ListToolsCommandOutput | UpdateToolCommandOutput;
 /**
  * @public
  */
@@ -119,6 +120,7 @@ export type ToolsClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerO
 export interface ToolsClientConfig extends ToolsClientConfigType {
     env?: 'stage' | 'stable' | 'prod';
     token: TokenProvider;
+    endpoint?: () => Record<string, string>;
 }
 /**
  * @public