@aws-sdk/client-bedrock-runtime 3.864.0 → 3.873.0

package/README.md

@@ -226,6 +226,14 @@ ConverseStream
 
 [Command API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand/) / [Input](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-bedrock-runtime/Interface/ConverseStreamCommandInput/) / [Output](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-bedrock-runtime/Interface/ConverseStreamCommandOutput/)
 
+</details>
+<details>
+<summary>
+CountTokens
+</summary>
+
+[Command API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/CountTokensCommand/) / [Input](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-bedrock-runtime/Interface/CountTokensCommandInput/) / [Output](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-bedrock-runtime/Interface/CountTokensCommandOutput/)
+
 </details>
 <details>
 <summary>

package/dist-cjs/index.js

@@ -57,7 +57,12 @@ __export(index_exports, {
   ConverseStreamRequestFilterSensitiveLog: () => ConverseStreamRequestFilterSensitiveLog,
   ConverseStreamResponseFilterSensitiveLog: () => ConverseStreamResponseFilterSensitiveLog,
   ConverseStreamTraceFilterSensitiveLog: () => ConverseStreamTraceFilterSensitiveLog,
+  ConverseTokensRequestFilterSensitiveLog: () => ConverseTokensRequestFilterSensitiveLog,
   ConverseTraceFilterSensitiveLog: () => ConverseTraceFilterSensitiveLog,
+  CountTokensCommand: () => CountTokensCommand,
+  CountTokensInput: () => CountTokensInput,
+  CountTokensInputFilterSensitiveLog: () => CountTokensInputFilterSensitiveLog,
+  CountTokensRequestFilterSensitiveLog: () => CountTokensRequestFilterSensitiveLog,
   DocumentContentBlock: () => DocumentContentBlock,
   DocumentFormat: () => DocumentFormat,
   DocumentSource: () => DocumentSource,
@@ -117,6 +122,7 @@ __export(index_exports, {
   InvokeModelCommand: () => InvokeModelCommand,
   InvokeModelRequestFilterSensitiveLog: () => InvokeModelRequestFilterSensitiveLog,
   InvokeModelResponseFilterSensitiveLog: () => InvokeModelResponseFilterSensitiveLog,
+  InvokeModelTokensRequestFilterSensitiveLog: () => InvokeModelTokensRequestFilterSensitiveLog,
   InvokeModelWithBidirectionalStreamCommand: () => InvokeModelWithBidirectionalStreamCommand,
   InvokeModelWithBidirectionalStreamInput: () => InvokeModelWithBidirectionalStreamInput,
   InvokeModelWithBidirectionalStreamInputFilterSensitiveLog: () => InvokeModelWithBidirectionalStreamInputFilterSensitiveLog,
@@ -1061,6 +1067,14 @@ var ResponseStream;
     return visitor._(value.$unknown[0], value.$unknown[1]);
   }, "visit");
 })(ResponseStream || (ResponseStream = {}));
+var CountTokensInput;
+((CountTokensInput2) => {
+  CountTokensInput2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.invokeModel !== void 0) return visitor.invokeModel(value.invokeModel);
+    if (value.converse !== void 0) return visitor.converse(value.converse);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(CountTokensInput || (CountTokensInput = {}));
 var GetAsyncInvokeResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
   ...obj.failureMessage && { failureMessage: import_smithy_client.SENSITIVE_STRING },
@@ -1414,6 +1428,25 @@ var InvokeModelWithResponseStreamResponseFilterSensitiveLog = /* @__PURE__ */ __
   ...obj,
   ...obj.body && { body: "STREAMING_CONTENT" }
 }), "InvokeModelWithResponseStreamResponseFilterSensitiveLog");
+var ConverseTokensRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) },
+  ...obj.system && { system: obj.system.map((item) => SystemContentBlockFilterSensitiveLog(item)) }
+}), "ConverseTokensRequestFilterSensitiveLog");
+var InvokeModelTokensRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.body && { body: import_smithy_client.SENSITIVE_STRING }
+}), "InvokeModelTokensRequestFilterSensitiveLog");
+var CountTokensInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.invokeModel !== void 0)
+    return { invokeModel: InvokeModelTokensRequestFilterSensitiveLog(obj.invokeModel) };
+  if (obj.converse !== void 0) return { converse: ConverseTokensRequestFilterSensitiveLog(obj.converse) };
+  if (obj.$unknown !== void 0) return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "CountTokensInputFilterSensitiveLog");
+var CountTokensRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.input && { input: CountTokensInputFilterSensitiveLog(obj.input) }
+}), "CountTokensRequestFilterSensitiveLog");
 
 // src/protocols/Aws_restJson1.ts
 var import_core2 = require("@aws-sdk/core");
@@ -1489,6 +1522,22 @@ var se_ConverseStreamCommand = /* @__PURE__ */ __name(async (input, context) =>
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_ConverseStreamCommand");
+var se_CountTokensCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/model/{modelId}/count-tokens");
+  b.p("modelId", () => input.modelId, "{modelId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      input: /* @__PURE__ */ __name((_) => se_CountTokensInput(_, context), "input")
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CountTokensCommand");
 var se_GetAsyncInvokeCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -1636,6 +1685,20 @@ var de_ConverseStreamCommand = /* @__PURE__ */ __name(async (output, context) =>
   contents.stream = de_ConverseStreamOutput(data, context);
   return contents;
 }, "de_ConverseStreamCommand");
+var de_CountTokensCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    inputTokens: import_smithy_client.expectInt32
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CountTokensCommand");
 var de_GetAsyncInvokeCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -2228,6 +2291,19 @@ var se_ContentBlocks = /* @__PURE__ */ __name((input, context) => {
     return se_ContentBlock(entry, context);
   });
 }, "se_ContentBlocks");
+var se_ConverseTokensRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    messages: /* @__PURE__ */ __name((_) => se_Messages(_, context), "messages"),
+    system: /* @__PURE__ */ __name((_) => se_SystemContentBlocks(_, context), "system")
+  });
+}, "se_ConverseTokensRequest");
+var se_CountTokensInput = /* @__PURE__ */ __name((input, context) => {
+  return CountTokensInput.visit(input, {
+    converse: /* @__PURE__ */ __name((value) => ({ converse: se_ConverseTokensRequest(value, context) }), "converse"),
+    invokeModel: /* @__PURE__ */ __name((value) => ({ invokeModel: se_InvokeModelTokensRequest(value, context) }), "invokeModel"),
+    _: /* @__PURE__ */ __name((name, value) => ({ [name]: value }), "_")
+  });
+}, "se_CountTokensInput");
 var se_DocumentBlock = /* @__PURE__ */ __name((input, context) => {
   return (0, import_smithy_client.take)(input, {
     citations: import_smithy_client._json,
@@ -2310,6 +2386,11 @@ var se_InferenceConfiguration = /* @__PURE__ */ __name((input, context) => {
     topP: import_smithy_client.serializeFloat
   });
 }, "se_InferenceConfiguration");
+var se_InvokeModelTokensRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    body: context.base64Encoder
+  });
+}, "se_InvokeModelTokensRequest");
 var se_Message = /* @__PURE__ */ __name((input, context) => {
   return (0, import_smithy_client.take)(input, {
     content: /* @__PURE__ */ __name((_) => se_ContentBlocks(_, context), "content"),
@@ -2997,6 +3078,21 @@ var ConverseStreamCommand = class extends import_smithy_client.Command.classBuil
   }
 };
 
+// src/commands/CountTokensCommand.ts
+
+
+
+var CountTokensCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockFrontendService", "CountTokens", {}).n("BedrockRuntimeClient", "CountTokensCommand").f(CountTokensRequestFilterSensitiveLog, void 0).ser(se_CountTokensCommand).de(de_CountTokensCommand).build() {
+  static {
+    __name(this, "CountTokensCommand");
+  }
+};
+
 // src/commands/GetAsyncInvokeCommand.ts
 
 
@@ -3116,6 +3212,7 @@ var commands = {
   ApplyGuardrailCommand,
   ConverseCommand,
   ConverseStreamCommand,
+  CountTokensCommand,
   GetAsyncInvokeCommand,
   InvokeModelCommand,
   InvokeModelWithBidirectionalStreamCommand,
@@ -3144,6 +3241,7 @@ var paginateListAsyncInvokes = (0, import_core.createPaginator)(BedrockRuntimeCl
   ApplyGuardrailCommand,
   ConverseCommand,
   ConverseStreamCommand,
+  CountTokensCommand,
   GetAsyncInvokeCommand,
   InvokeModelCommand,
   InvokeModelWithBidirectionalStreamCommand,
@@ -3226,6 +3324,7 @@ var paginateListAsyncInvokes = (0, import_core.createPaginator)(BedrockRuntimeCl
   InvokeModelWithBidirectionalStreamInput,
   InvokeModelWithBidirectionalStreamOutput,
   ResponseStream,
+  CountTokensInput,
   GetAsyncInvokeResponseFilterSensitiveLog,
   AsyncInvokeSummaryFilterSensitiveLog,
   ListAsyncInvokesResponseFilterSensitiveLog,
@@ -3281,6 +3380,10 @@ var paginateListAsyncInvokes = (0, import_core.createPaginator)(BedrockRuntimeCl
   InvokeModelWithResponseStreamRequestFilterSensitiveLog,
   PayloadPartFilterSensitiveLog,
   ResponseStreamFilterSensitiveLog,
-  InvokeModelWithResponseStreamResponseFilterSensitiveLog
+  InvokeModelWithResponseStreamResponseFilterSensitiveLog,
+  ConverseTokensRequestFilterSensitiveLog,
+  InvokeModelTokensRequestFilterSensitiveLog,
+  CountTokensInputFilterSensitiveLog,
+  CountTokensRequestFilterSensitiveLog
 });
 

package/dist-es/BedrockRuntime.js

@@ -3,6 +3,7 @@ import { BedrockRuntimeClient } from "./BedrockRuntimeClient";
 import { ApplyGuardrailCommand, } from "./commands/ApplyGuardrailCommand";
 import { ConverseCommand } from "./commands/ConverseCommand";
 import { ConverseStreamCommand, } from "./commands/ConverseStreamCommand";
+import { CountTokensCommand } from "./commands/CountTokensCommand";
 import { GetAsyncInvokeCommand, } from "./commands/GetAsyncInvokeCommand";
 import { InvokeModelCommand } from "./commands/InvokeModelCommand";
 import { InvokeModelWithBidirectionalStreamCommand, } from "./commands/InvokeModelWithBidirectionalStreamCommand";
@@ -13,6 +14,7 @@ const commands = {
     ApplyGuardrailCommand,
     ConverseCommand,
     ConverseStreamCommand,
+    CountTokensCommand,
     GetAsyncInvokeCommand,
     InvokeModelCommand,
     InvokeModelWithBidirectionalStreamCommand,

package/dist-es/commands/CountTokensCommand.js

@@ -0,0 +1,23 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { CountTokensRequestFilterSensitiveLog } from "../models/models_0";
+import { de_CountTokensCommand, se_CountTokensCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CountTokensCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonBedrockFrontendService", "CountTokens", {})
+    .n("BedrockRuntimeClient", "CountTokensCommand")
+    .f(CountTokensRequestFilterSensitiveLog, void 0)
+    .ser(se_CountTokensCommand)
+    .de(de_CountTokensCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -1,6 +1,7 @@
 export * from "./ApplyGuardrailCommand";
 export * from "./ConverseCommand";
 export * from "./ConverseStreamCommand";
+export * from "./CountTokensCommand";
 export * from "./GetAsyncInvokeCommand";
 export * from "./InvokeModelCommand";
 export * from "./InvokeModelWithBidirectionalStreamCommand";

package/dist-es/models/models_0.js

@@ -702,6 +702,16 @@ export var ResponseStream;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(ResponseStream || (ResponseStream = {}));
+export var CountTokensInput;
+(function (CountTokensInput) {
+    CountTokensInput.visit = (value, visitor) => {
+        if (value.invokeModel !== undefined)
+            return visitor.invokeModel(value.invokeModel);
+        if (value.converse !== undefined)
+            return visitor.converse(value.converse);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CountTokensInput || (CountTokensInput = {}));
 export const GetAsyncInvokeResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.failureMessage && { failureMessage: SENSITIVE_STRING }),
@@ -1108,3 +1118,24 @@ export const InvokeModelWithResponseStreamResponseFilterSensitiveLog = (obj) =>
     ...obj,
     ...(obj.body && { body: "STREAMING_CONTENT" }),
 });
+export const ConverseTokensRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) }),
+    ...(obj.system && { system: obj.system.map((item) => SystemContentBlockFilterSensitiveLog(item)) }),
+});
+export const InvokeModelTokensRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.body && { body: SENSITIVE_STRING }),
+});
+export const CountTokensInputFilterSensitiveLog = (obj) => {
+    if (obj.invokeModel !== undefined)
+        return { invokeModel: InvokeModelTokensRequestFilterSensitiveLog(obj.invokeModel) };
+    if (obj.converse !== undefined)
+        return { converse: ConverseTokensRequestFilterSensitiveLog(obj.converse) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CountTokensRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.input && { input: CountTokensInputFilterSensitiveLog(obj.input) }),
+});

package/dist-es/protocols/Aws_restJson1.js

@@ -3,7 +3,7 @@ import { requestBuilder as rb } from "@smithy/core";
 import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, isSerializableHeaderValue, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeDateTime as __serializeDateTime, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { BedrockRuntimeServiceException as __BaseException } from "../models/BedrockRuntimeServiceException";
-import { AccessDeniedException, ConflictException, ContentBlock, DocumentSource, GuardrailContentBlock, GuardrailConverseContentBlock, GuardrailConverseImageSource, GuardrailImageSource, ImageSource, InternalServerException, InvokeModelWithBidirectionalStreamInput, ModelErrorException, ModelNotReadyException, ModelStreamErrorException, ModelTimeoutException, ReasoningContentBlock, ResourceNotFoundException, ServiceQuotaExceededException, ServiceUnavailableException, SystemContentBlock, ThrottlingException, Tool, ToolInputSchema, ToolResultContentBlock, ValidationException, VideoSource, } from "../models/models_0";
+import { AccessDeniedException, ConflictException, ContentBlock, CountTokensInput, DocumentSource, GuardrailContentBlock, GuardrailConverseContentBlock, GuardrailConverseImageSource, GuardrailImageSource, ImageSource, InternalServerException, InvokeModelWithBidirectionalStreamInput, ModelErrorException, ModelNotReadyException, ModelStreamErrorException, ModelTimeoutException, ReasoningContentBlock, ResourceNotFoundException, ServiceQuotaExceededException, ServiceUnavailableException, SystemContentBlock, ThrottlingException, Tool, ToolInputSchema, ToolResultContentBlock, ValidationException, VideoSource, } from "../models/models_0";
 export const se_ApplyGuardrailCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -67,6 +67,20 @@ export const se_ConverseStreamCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_CountTokensCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/model/{modelId}/count-tokens");
+    b.p("modelId", () => input.modelId, "{modelId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        input: (_) => se_CountTokensInput(_, context),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_GetAsyncInvokeCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -212,6 +226,20 @@ export const de_ConverseStreamCommand = async (output, context) => {
     contents.stream = de_ConverseStreamOutput(data, context);
     return contents;
 };
+export const de_CountTokensCommand = 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, {
+        inputTokens: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_GetAsyncInvokeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -788,6 +816,19 @@ const se_ContentBlocks = (input, context) => {
         return se_ContentBlock(entry, context);
     });
 };
+const se_ConverseTokensRequest = (input, context) => {
+    return take(input, {
+        messages: (_) => se_Messages(_, context),
+        system: (_) => se_SystemContentBlocks(_, context),
+    });
+};
+const se_CountTokensInput = (input, context) => {
+    return CountTokensInput.visit(input, {
+        converse: (value) => ({ converse: se_ConverseTokensRequest(value, context) }),
+        invokeModel: (value) => ({ invokeModel: se_InvokeModelTokensRequest(value, context) }),
+        _: (name, value) => ({ [name]: value }),
+    });
+};
 const se_DocumentBlock = (input, context) => {
     return take(input, {
         citations: _json,
@@ -872,6 +913,11 @@ const se_InferenceConfiguration = (input, context) => {
         topP: __serializeFloat,
     });
 };
+const se_InvokeModelTokensRequest = (input, context) => {
+    return take(input, {
+        body: context.base64Encoder,
+    });
+};
 const se_Message = (input, context) => {
     return take(input, {
         content: (_) => se_ContentBlocks(_, context),

package/dist-types/BedrockRuntime.d.ts

@@ -3,6 +3,7 @@ import { BedrockRuntimeClient } from "./BedrockRuntimeClient";
 import { ApplyGuardrailCommandInput, ApplyGuardrailCommandOutput } from "./commands/ApplyGuardrailCommand";
 import { ConverseCommandInput, ConverseCommandOutput } from "./commands/ConverseCommand";
 import { ConverseStreamCommandInput, ConverseStreamCommandOutput } from "./commands/ConverseStreamCommand";
+import { CountTokensCommandInput, CountTokensCommandOutput } from "./commands/CountTokensCommand";
 import { GetAsyncInvokeCommandInput, GetAsyncInvokeCommandOutput } from "./commands/GetAsyncInvokeCommand";
 import { InvokeModelCommandInput, InvokeModelCommandOutput } from "./commands/InvokeModelCommand";
 import { InvokeModelWithBidirectionalStreamCommandInput, InvokeModelWithBidirectionalStreamCommandOutput } from "./commands/InvokeModelWithBidirectionalStreamCommand";
@@ -28,6 +29,12 @@ export interface BedrockRuntime {
     converseStream(args: ConverseStreamCommandInput, options?: __HttpHandlerOptions): Promise<ConverseStreamCommandOutput>;
     converseStream(args: ConverseStreamCommandInput, cb: (err: any, data?: ConverseStreamCommandOutput) => void): void;
     converseStream(args: ConverseStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ConverseStreamCommandOutput) => void): void;
+    /**
+     * @see {@link CountTokensCommand}
+     */
+    countTokens(args: CountTokensCommandInput, options?: __HttpHandlerOptions): Promise<CountTokensCommandOutput>;
+    countTokens(args: CountTokensCommandInput, cb: (err: any, data?: CountTokensCommandOutput) => void): void;
+    countTokens(args: CountTokensCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CountTokensCommandOutput) => void): void;
     /**
      * @see {@link GetAsyncInvokeCommand}
      */

package/dist-types/BedrockRuntimeClient.d.ts

@@ -14,6 +14,7 @@ import { HttpAuthSchemeInputConfig, HttpAuthSchemeResolvedConfig } from "./auth/
 import { ApplyGuardrailCommandInput, ApplyGuardrailCommandOutput } from "./commands/ApplyGuardrailCommand";
 import { ConverseCommandInput, ConverseCommandOutput } from "./commands/ConverseCommand";
 import { ConverseStreamCommandInput, ConverseStreamCommandOutput } from "./commands/ConverseStreamCommand";
+import { CountTokensCommandInput, CountTokensCommandOutput } from "./commands/CountTokensCommand";
 import { GetAsyncInvokeCommandInput, GetAsyncInvokeCommandOutput } from "./commands/GetAsyncInvokeCommand";
 import { InvokeModelCommandInput, InvokeModelCommandOutput } from "./commands/InvokeModelCommand";
 import { InvokeModelWithBidirectionalStreamCommandInput, InvokeModelWithBidirectionalStreamCommandOutput } from "./commands/InvokeModelWithBidirectionalStreamCommand";
@@ -26,11 +27,11 @@ export { __Client };
 /**
  * @public
  */
-export type ServiceInputTypes = ApplyGuardrailCommandInput | ConverseCommandInput | ConverseStreamCommandInput | GetAsyncInvokeCommandInput | InvokeModelCommandInput | InvokeModelWithBidirectionalStreamCommandInput | InvokeModelWithResponseStreamCommandInput | ListAsyncInvokesCommandInput | StartAsyncInvokeCommandInput;
+export type ServiceInputTypes = ApplyGuardrailCommandInput | ConverseCommandInput | ConverseStreamCommandInput | CountTokensCommandInput | GetAsyncInvokeCommandInput | InvokeModelCommandInput | InvokeModelWithBidirectionalStreamCommandInput | InvokeModelWithResponseStreamCommandInput | ListAsyncInvokesCommandInput | StartAsyncInvokeCommandInput;
 /**
  * @public
  */
-export type ServiceOutputTypes = ApplyGuardrailCommandOutput | ConverseCommandOutput | ConverseStreamCommandOutput | GetAsyncInvokeCommandOutput | InvokeModelCommandOutput | InvokeModelWithBidirectionalStreamCommandOutput | InvokeModelWithResponseStreamCommandOutput | ListAsyncInvokesCommandOutput | StartAsyncInvokeCommandOutput;
+export type ServiceOutputTypes = ApplyGuardrailCommandOutput | ConverseCommandOutput | ConverseStreamCommandOutput | CountTokensCommandOutput | GetAsyncInvokeCommandOutput | InvokeModelCommandOutput | InvokeModelWithBidirectionalStreamCommandOutput | InvokeModelWithResponseStreamCommandOutput | ListAsyncInvokesCommandOutput | StartAsyncInvokeCommandOutput;
 /**
  * @public
  */

package/dist-types/commands/CountTokensCommand.d.ts

@@ -0,0 +1,281 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { BedrockRuntimeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BedrockRuntimeClient";
+import { CountTokensRequest, CountTokensResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link CountTokensCommand}.
+ */
+export interface CountTokensCommandInput extends CountTokensRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link CountTokensCommand}.
+ */
+export interface CountTokensCommandOutput extends CountTokensResponse, __MetadataBearer {
+}
+declare const CountTokensCommand_base: {
+    new (input: CountTokensCommandInput): import("@smithy/smithy-client").CommandImpl<CountTokensCommandInput, CountTokensCommandOutput, BedrockRuntimeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: CountTokensCommandInput): import("@smithy/smithy-client").CommandImpl<CountTokensCommandInput, CountTokensCommandOutput, BedrockRuntimeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Returns the token count for a given inference request. This operation helps you estimate token usage before sending requests to foundation models by returning the token count that would be used if the same input were sent to the model in an inference request.</p> <p>Token counting is model-specific because different models use different tokenization strategies. The token count returned by this operation will match the token count that would be charged if the same input were sent to the model in an <code>InvokeModel</code> or <code>Converse</code> request.</p> <p>You can use this operation to:</p> <ul> <li> <p>Estimate costs before sending inference requests.</p> </li> <li> <p>Optimize prompts to fit within token limits.</p> </li> <li> <p>Plan for token usage in your applications.</p> </li> </ul> <p>This operation accepts the same input formats as <code>InvokeModel</code> and <code>Converse</code>, allowing you to count tokens for both raw text inputs and structured conversation formats.</p> <p>The following operations are related to <code>CountTokens</code>:</p> <ul> <li> <p> <a href="https://docs.aws.amazon.com/bedrock/latest/API/API_runtime_InvokeModel.html">InvokeModel</a> - Sends inference requests to foundation models</p> </li> <li> <p> <a href="https://docs.aws.amazon.com/bedrock/latest/API/API_runtime_Converse.html">Converse</a> - Sends conversation-based inference requests to foundation models</p> </li> </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BedrockRuntimeClient, CountTokensCommand } from "@aws-sdk/client-bedrock-runtime"; // ES Modules import
+ * // const { BedrockRuntimeClient, CountTokensCommand } = require("@aws-sdk/client-bedrock-runtime"); // CommonJS import
+ * const client = new BedrockRuntimeClient(config);
+ * const input = { // CountTokensRequest
+ *   modelId: "STRING_VALUE", // required
+ *   input: { // CountTokensInput Union: only one key present
+ *     invokeModel: { // InvokeModelTokensRequest
+ *       body: new Uint8Array(), // e.g. Buffer.from("") or new TextEncoder().encode("")       // required
+ *     },
+ *     converse: { // ConverseTokensRequest
+ *       messages: [ // Messages
+ *         { // Message
+ *           role: "user" || "assistant", // required
+ *           content: [ // ContentBlocks // required
+ *             { // ContentBlock Union: only one key present
+ *               text: "STRING_VALUE",
+ *               image: { // ImageBlock
+ *                 format: "png" || "jpeg" || "gif" || "webp", // required
+ *                 source: { // ImageSource Union: only one key present
+ *                   bytes: new Uint8Array(), // e.g. Buffer.from("") or new TextEncoder().encode("")
+ *                   s3Location: { // S3Location
+ *                     uri: "STRING_VALUE", // required
+ *                     bucketOwner: "STRING_VALUE",
+ *                   },
+ *                 },
+ *               },
+ *               document: { // DocumentBlock
+ *                 format: "pdf" || "csv" || "doc" || "docx" || "xls" || "xlsx" || "html" || "txt" || "md",
+ *                 name: "STRING_VALUE", // required
+ *                 source: { // DocumentSource Union: only one key present
+ *                   bytes: new Uint8Array(), // e.g. Buffer.from("") or new TextEncoder().encode("")
+ *                   s3Location: {
+ *                     uri: "STRING_VALUE", // required
+ *                     bucketOwner: "STRING_VALUE",
+ *                   },
+ *                   text: "STRING_VALUE",
+ *                   content: [ // DocumentContentBlocks
+ *                     { // DocumentContentBlock Union: only one key present
+ *                       text: "STRING_VALUE",
+ *                     },
+ *                   ],
+ *                 },
+ *                 context: "STRING_VALUE",
+ *                 citations: { // CitationsConfig
+ *                   enabled: true || false, // required
+ *                 },
+ *               },
+ *               video: { // VideoBlock
+ *                 format: "mkv" || "mov" || "mp4" || "webm" || "flv" || "mpeg" || "mpg" || "wmv" || "three_gp", // required
+ *                 source: { // VideoSource Union: only one key present
+ *                   bytes: new Uint8Array(), // e.g. Buffer.from("") or new TextEncoder().encode("")
+ *                   s3Location: {
+ *                     uri: "STRING_VALUE", // required
+ *                     bucketOwner: "STRING_VALUE",
+ *                   },
+ *                 },
+ *               },
+ *               toolUse: { // ToolUseBlock
+ *                 toolUseId: "STRING_VALUE", // required
+ *                 name: "STRING_VALUE", // required
+ *                 input: "DOCUMENT_VALUE", // required
+ *               },
+ *               toolResult: { // ToolResultBlock
+ *                 toolUseId: "STRING_VALUE", // required
+ *                 content: [ // ToolResultContentBlocks // required
+ *                   { // ToolResultContentBlock Union: only one key present
+ *                     json: "DOCUMENT_VALUE",
+ *                     text: "STRING_VALUE",
+ *                     image: {
+ *                       format: "png" || "jpeg" || "gif" || "webp", // required
+ *                       source: {//  Union: only one key present
+ *                         bytes: new Uint8Array(), // e.g. Buffer.from("") or new TextEncoder().encode("")
+ *                         s3Location: {
+ *                           uri: "STRING_VALUE", // required
+ *                           bucketOwner: "STRING_VALUE",
+ *                         },
+ *                       },
+ *                     },
+ *                     document: {
+ *                       format: "pdf" || "csv" || "doc" || "docx" || "xls" || "xlsx" || "html" || "txt" || "md",
+ *                       name: "STRING_VALUE", // required
+ *                       source: {//  Union: only one key present
+ *                         bytes: new Uint8Array(), // e.g. Buffer.from("") or new TextEncoder().encode("")
+ *                         s3Location: {
+ *                           uri: "STRING_VALUE", // required
+ *                           bucketOwner: "STRING_VALUE",
+ *                         },
+ *                         text: "STRING_VALUE",
+ *                         content: [
+ *                           {//  Union: only one key present
+ *                             text: "STRING_VALUE",
+ *                           },
+ *                         ],
+ *                       },
+ *                       context: "STRING_VALUE",
+ *                       citations: {
+ *                         enabled: true || false, // required
+ *                       },
+ *                     },
+ *                     video: {
+ *                       format: "mkv" || "mov" || "mp4" || "webm" || "flv" || "mpeg" || "mpg" || "wmv" || "three_gp", // required
+ *                       source: {//  Union: only one key present
+ *                         bytes: new Uint8Array(), // e.g. Buffer.from("") or new TextEncoder().encode("")
+ *                         s3Location: "<S3Location>",
+ *                       },
+ *                     },
+ *                   },
+ *                 ],
+ *                 status: "success" || "error",
+ *               },
+ *               guardContent: { // GuardrailConverseContentBlock Union: only one key present
+ *                 text: { // GuardrailConverseTextBlock
+ *                   text: "STRING_VALUE", // required
+ *                   qualifiers: [ // GuardrailConverseContentQualifierList
+ *                     "grounding_source" || "query" || "guard_content",
+ *                   ],
+ *                 },
+ *                 image: { // GuardrailConverseImageBlock
+ *                   format: "png" || "jpeg", // required
+ *                   source: { // GuardrailConverseImageSource Union: only one key present
+ *                     bytes: new Uint8Array(), // e.g. Buffer.from("") or new TextEncoder().encode("")
+ *                   },
+ *                 },
+ *               },
+ *               cachePoint: { // CachePointBlock
+ *                 type: "default", // required
+ *               },
+ *               reasoningContent: { // ReasoningContentBlock Union: only one key present
+ *                 reasoningText: { // ReasoningTextBlock
+ *                   text: "STRING_VALUE", // required
+ *                   signature: "STRING_VALUE",
+ *                 },
+ *                 redactedContent: new Uint8Array(), // e.g. Buffer.from("") or new TextEncoder().encode("")
+ *               },
+ *               citationsContent: { // CitationsContentBlock
+ *                 content: [ // CitationGeneratedContentList
+ *                   { // CitationGeneratedContent Union: only one key present
+ *                     text: "STRING_VALUE",
+ *                   },
+ *                 ],
+ *                 citations: [ // Citations
+ *                   { // Citation
+ *                     title: "STRING_VALUE",
+ *                     sourceContent: [ // CitationSourceContentList
+ *                       { // CitationSourceContent Union: only one key present
+ *                         text: "STRING_VALUE",
+ *                       },
+ *                     ],
+ *                     location: { // CitationLocation Union: only one key present
+ *                       documentChar: { // DocumentCharLocation
+ *                         documentIndex: Number("int"),
+ *                         start: Number("int"),
+ *                         end: Number("int"),
+ *                       },
+ *                       documentPage: { // DocumentPageLocation
+ *                         documentIndex: Number("int"),
+ *                         start: Number("int"),
+ *                         end: Number("int"),
+ *                       },
+ *                       documentChunk: { // DocumentChunkLocation
+ *                         documentIndex: Number("int"),
+ *                         start: Number("int"),
+ *                         end: Number("int"),
+ *                       },
+ *                     },
+ *                   },
+ *                 ],
+ *               },
+ *             },
+ *           ],
+ *         },
+ *       ],
+ *       system: [ // SystemContentBlocks
+ *         { // SystemContentBlock Union: only one key present
+ *           text: "STRING_VALUE",
+ *           guardContent: {//  Union: only one key present
+ *             text: {
+ *               text: "STRING_VALUE", // required
+ *               qualifiers: [
+ *                 "grounding_source" || "query" || "guard_content",
+ *               ],
+ *             },
+ *             image: {
+ *               format: "png" || "jpeg", // required
+ *               source: {//  Union: only one key present
+ *                 bytes: new Uint8Array(), // e.g. Buffer.from("") or new TextEncoder().encode("")
+ *               },
+ *             },
+ *           },
+ *           cachePoint: {
+ *             type: "default", // required
+ *           },
+ *         },
+ *       ],
+ *     },
+ *   },
+ * };
+ * const command = new CountTokensCommand(input);
+ * const response = await client.send(command);
+ * // { // CountTokensResponse
+ * //   inputTokens: Number("int"), // required
+ * // };
+ *
+ * ```
+ *
+ * @param CountTokensCommandInput - {@link CountTokensCommandInput}
+ * @returns {@link CountTokensCommandOutput}
+ * @see {@link CountTokensCommandInput} for command's `input` shape.
+ * @see {@link CountTokensCommandOutput} for command's `response` shape.
+ * @see {@link BedrockRuntimeClientResolvedConfig | config} for BedrockRuntimeClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>The request is denied because you do not have sufficient permissions to perform the requested action. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-access-denied">AccessDeniedException</a> in the Amazon Bedrock User Guide</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>An internal server error occurred. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-internal-failure">InternalFailure</a> in the Amazon Bedrock User Guide</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The specified resource ARN was not found. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-resource-not-found">ResourceNotFound</a> in the Amazon Bedrock User Guide</p>
+ *
+ * @throws {@link ServiceUnavailableException} (server fault)
+ *  <p>The service isn't currently available. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-service-unavailable">ServiceUnavailable</a> in the Amazon Bedrock User Guide</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>Your request was denied due to exceeding the account quotas for <i>Amazon Bedrock</i>. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-throttling-exception">ThrottlingException</a> in the Amazon Bedrock User Guide</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>The input fails to satisfy the constraints specified by <i>Amazon Bedrock</i>. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-validation-error">ValidationError</a> in the Amazon Bedrock User Guide</p>
+ *
+ * @throws {@link BedrockRuntimeServiceException}
+ * <p>Base exception class for all service exceptions from BedrockRuntime service.</p>
+ *
+ *
+ * @public
+ */
+export declare class CountTokensCommand extends CountTokensCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: CountTokensRequest;
+            output: CountTokensResponse;
+        };
+        sdk: {
+            input: CountTokensCommandInput;
+            output: CountTokensCommandOutput;
+        };
+    };
+}

package/dist-types/commands/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./ApplyGuardrailCommand";
 export * from "./ConverseCommand";
 export * from "./ConverseStreamCommand";
+export * from "./CountTokensCommand";
 export * from "./GetAsyncInvokeCommand";
 export * from "./InvokeModelCommand";
 export * from "./InvokeModelWithBidirectionalStreamCommand";

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

@@ -862,7 +862,7 @@ export type GuardrailAutomatedReasoningFinding = GuardrailAutomatedReasoningFind
  */
 export declare namespace GuardrailAutomatedReasoningFinding {
     /**
-     * <p>Indicates that the claims are definitively true and logically implied by the premises, with no possible alternative interpretations.</p>
+     * <p>Contains the result when the automated reasoning evaluation determines that the claims in the input are logically valid and definitively true based on the provided premises and policy rules.</p>
      * @public
      */
     interface ValidMember {
@@ -876,7 +876,7 @@ export declare namespace GuardrailAutomatedReasoningFinding {
         $unknown?: never;
     }
     /**
-     * <p>Indicates that the claims are logically false and contradictory to the established rules or premises.</p>
+     * <p>Contains the result when the automated reasoning evaluation determines that the claims in the input are logically invalid and contradict the established premises or policy rules.</p>
      * @public
      */
     interface InvalidMember {
@@ -890,7 +890,7 @@ export declare namespace GuardrailAutomatedReasoningFinding {
         $unknown?: never;
     }
     /**
-     * <p>Indicates that the claims could be either true or false depending on additional assumptions not provided in the input.</p>
+     * <p>Contains the result when the automated reasoning evaluation determines that the claims in the input could be either true or false depending on additional assumptions not provided in the input context.</p>
      * @public
      */
     interface SatisfiableMember {
@@ -904,7 +904,7 @@ export declare namespace GuardrailAutomatedReasoningFinding {
         $unknown?: never;
     }
     /**
-     * <p>Indicates that no valid claims can be made due to logical contradictions in the premises or rules.</p>
+     * <p>Contains the result when the automated reasoning evaluation determines that no valid logical conclusions can be drawn due to contradictions in the premises or policy rules themselves.</p>
      * @public
      */
     interface ImpossibleMember {
@@ -918,7 +918,7 @@ export declare namespace GuardrailAutomatedReasoningFinding {
         $unknown?: never;
     }
     /**
-     * <p>Indicates that the input has multiple valid logical interpretations, requiring additional context or clarification.</p>
+     * <p>Contains the result when the automated reasoning evaluation detects that the input has multiple valid logical interpretations, requiring additional context or clarification to proceed with validation.</p>
      * @public
      */
     interface TranslationAmbiguousMember {
@@ -932,7 +932,7 @@ export declare namespace GuardrailAutomatedReasoningFinding {
         $unknown?: never;
     }
     /**
-     * <p>Indicates that the input exceeds the processing capacity due to the volume or complexity of the logical information.</p>
+     * <p>Contains the result when the automated reasoning evaluation cannot process the input due to its complexity or volume exceeding the system's processing capacity for logical analysis.</p>
      * @public
      */
     interface TooComplexMember {
@@ -946,7 +946,7 @@ export declare namespace GuardrailAutomatedReasoningFinding {
         $unknown?: never;
     }
     /**
-     * <p>Indicates that no relevant logical information could be extracted from the input for validation.</p>
+     * <p>Contains the result when the automated reasoning evaluation cannot extract any relevant logical information from the input that can be validated against the policy rules.</p>
      * @public
      */
     interface NoTranslationsMember {
@@ -4624,6 +4624,100 @@ export interface InvokeModelWithResponseStreamResponse {
      */
     performanceConfigLatency?: PerformanceConfigLatency | undefined;
 }
+/**
+ * <p>The inputs from a <code>Converse</code> API request for token counting.</p> <p>This structure mirrors the input format for the <code>Converse</code> operation, allowing you to count tokens for conversation-based inference requests.</p>
+ * @public
+ */
+export interface ConverseTokensRequest {
+    /**
+     * <p>An array of messages to count tokens for.</p>
+     * @public
+     */
+    messages?: Message[] | undefined;
+    /**
+     * <p>The system content blocks to count tokens for. System content provides instructions or context to the model about how it should behave or respond. The token count will include any system content provided.</p>
+     * @public
+     */
+    system?: SystemContentBlock[] | undefined;
+}
+/**
+ * <p>The body of an <code>InvokeModel</code> API request for token counting. This structure mirrors the input format for the <code>InvokeModel</code> operation, allowing you to count tokens for raw text inference requests.</p>
+ * @public
+ */
+export interface InvokeModelTokensRequest {
+    /**
+     * <p>The request body to count tokens for, formatted according to the model's expected input format. To learn about the input format for different models, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html">Model inference parameters and responses</a>.</p>
+     * @public
+     */
+    body: Uint8Array | undefined;
+}
+/**
+ * <p>The input value for token counting. The value should be either an <code>InvokeModel</code> or <code>Converse</code> request body. </p>
+ * @public
+ */
+export type CountTokensInput = CountTokensInput.ConverseMember | CountTokensInput.InvokeModelMember | CountTokensInput.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace CountTokensInput {
+    /**
+     * <p>An <code>InvokeModel</code> request for which to count tokens. Use this field when you want to count tokens for a raw text input that would be sent to the <code>InvokeModel</code> operation.</p>
+     * @public
+     */
+    interface InvokeModelMember {
+        invokeModel: InvokeModelTokensRequest;
+        converse?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>A <code>Converse</code> request for which to count tokens. Use this field when you want to count tokens for a conversation-based input that would be sent to the <code>Converse</code> operation.</p>
+     * @public
+     */
+    interface ConverseMember {
+        invokeModel?: never;
+        converse: ConverseTokensRequest;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        invokeModel?: never;
+        converse?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        invokeModel: (value: InvokeModelTokensRequest) => T;
+        converse: (value: ConverseTokensRequest) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: CountTokensInput, visitor: Visitor<T>) => T;
+}
+/**
+ * @public
+ */
+export interface CountTokensRequest {
+    /**
+     * <p>The unique identifier or ARN of the foundation model to use for token counting. Each model processes tokens differently, so the token count is specific to the model you specify.</p>
+     * @public
+     */
+    modelId: string | undefined;
+    /**
+     * <p>The input for which to count tokens. The structure of this parameter depends on whether you're counting tokens for an <code>InvokeModel</code> or <code>Converse</code> request:</p> <ul> <li> <p>For <code>InvokeModel</code> requests, provide the request body in the <code>invokeModel</code> field</p> </li> <li> <p>For <code>Converse</code> requests, provide the messages and system content in the <code>converse</code> field</p> </li> </ul> <p>The input format must be compatible with the model specified in the <code>modelId</code> parameter.</p>
+     * @public
+     */
+    input: CountTokensInput | undefined;
+}
+/**
+ * @public
+ */
+export interface CountTokensResponse {
+    /**
+     * <p>The number of tokens in the provided input according to the specified model's tokenization rules. This count represents the number of input tokens that would be processed if the same input were sent to the model in an inference request. Use this value to estimate costs and ensure your inputs stay within model token limits.</p>
+     * @public
+     */
+    inputTokens: number | undefined;
+}
 /**
  * @internal
  */
@@ -4848,3 +4942,19 @@ export declare const ResponseStreamFilterSensitiveLog: (obj: ResponseStream) =>
  * @internal
  */
 export declare const InvokeModelWithResponseStreamResponseFilterSensitiveLog: (obj: InvokeModelWithResponseStreamResponse) => any;
+/**
+ * @internal
+ */
+export declare const ConverseTokensRequestFilterSensitiveLog: (obj: ConverseTokensRequest) => any;
+/**
+ * @internal
+ */
+export declare const InvokeModelTokensRequestFilterSensitiveLog: (obj: InvokeModelTokensRequest) => any;
+/**
+ * @internal
+ */
+export declare const CountTokensInputFilterSensitiveLog: (obj: CountTokensInput) => any;
+/**
+ * @internal
+ */
+export declare const CountTokensRequestFilterSensitiveLog: (obj: CountTokensRequest) => any;

package/dist-types/protocols/Aws_restJson1.d.ts

@@ -3,6 +3,7 @@ import { EventStreamSerdeContext as __EventStreamSerdeContext, SerdeContext as _
 import { ApplyGuardrailCommandInput, ApplyGuardrailCommandOutput } from "../commands/ApplyGuardrailCommand";
 import { ConverseCommandInput, ConverseCommandOutput } from "../commands/ConverseCommand";
 import { ConverseStreamCommandInput, ConverseStreamCommandOutput } from "../commands/ConverseStreamCommand";
+import { CountTokensCommandInput, CountTokensCommandOutput } from "../commands/CountTokensCommand";
 import { GetAsyncInvokeCommandInput, GetAsyncInvokeCommandOutput } from "../commands/GetAsyncInvokeCommand";
 import { InvokeModelCommandInput, InvokeModelCommandOutput } from "../commands/InvokeModelCommand";
 import { InvokeModelWithBidirectionalStreamCommandInput, InvokeModelWithBidirectionalStreamCommandOutput } from "../commands/InvokeModelWithBidirectionalStreamCommand";
@@ -21,6 +22,10 @@ export declare const se_ConverseCommand: (input: ConverseCommandInput, context:
  * serializeAws_restJson1ConverseStreamCommand
  */
 export declare const se_ConverseStreamCommand: (input: ConverseStreamCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+/**
+ * serializeAws_restJson1CountTokensCommand
+ */
+export declare const se_CountTokensCommand: (input: CountTokensCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 /**
  * serializeAws_restJson1GetAsyncInvokeCommand
  */
@@ -57,6 +62,10 @@ export declare const de_ConverseCommand: (output: __HttpResponse, context: __Ser
  * deserializeAws_restJson1ConverseStreamCommand
  */
 export declare const de_ConverseStreamCommand: (output: __HttpResponse, context: __SerdeContext & __EventStreamSerdeContext) => Promise<ConverseStreamCommandOutput>;
+/**
+ * deserializeAws_restJson1CountTokensCommand
+ */
+export declare const de_CountTokensCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<CountTokensCommandOutput>;
 /**
  * deserializeAws_restJson1GetAsyncInvokeCommand
  */

package/dist-types/ts3.4/BedrockRuntime.d.ts

@@ -12,6 +12,10 @@ import {
   ConverseStreamCommandInput,
   ConverseStreamCommandOutput,
 } from "./commands/ConverseStreamCommand";
+import {
+  CountTokensCommandInput,
+  CountTokensCommandOutput,
+} from "./commands/CountTokensCommand";
 import {
   GetAsyncInvokeCommandInput,
   GetAsyncInvokeCommandOutput,
@@ -76,6 +80,19 @@ export interface BedrockRuntime {
     options: __HttpHandlerOptions,
     cb: (err: any, data?: ConverseStreamCommandOutput) => void
   ): void;
+  countTokens(
+    args: CountTokensCommandInput,
+    options?: __HttpHandlerOptions
+  ): Promise<CountTokensCommandOutput>;
+  countTokens(
+    args: CountTokensCommandInput,
+    cb: (err: any, data?: CountTokensCommandOutput) => void
+  ): void;
+  countTokens(
+    args: CountTokensCommandInput,
+    options: __HttpHandlerOptions,
+    cb: (err: any, data?: CountTokensCommandOutput) => void
+  ): void;
   getAsyncInvoke(
     args: GetAsyncInvokeCommandInput,
     options?: __HttpHandlerOptions

package/dist-types/ts3.4/BedrockRuntimeClient.d.ts

@@ -71,6 +71,10 @@ import {
   ConverseStreamCommandInput,
   ConverseStreamCommandOutput,
 } from "./commands/ConverseStreamCommand";
+import {
+  CountTokensCommandInput,
+  CountTokensCommandOutput,
+} from "./commands/CountTokensCommand";
 import {
   GetAsyncInvokeCommandInput,
   GetAsyncInvokeCommandOutput,
@@ -106,6 +110,7 @@ export type ServiceInputTypes =
   | ApplyGuardrailCommandInput
   | ConverseCommandInput
   | ConverseStreamCommandInput
+  | CountTokensCommandInput
   | GetAsyncInvokeCommandInput
   | InvokeModelCommandInput
   | InvokeModelWithBidirectionalStreamCommandInput
@@ -116,6 +121,7 @@ export type ServiceOutputTypes =
   | ApplyGuardrailCommandOutput
   | ConverseCommandOutput
   | ConverseStreamCommandOutput
+  | CountTokensCommandOutput
   | GetAsyncInvokeCommandOutput
   | InvokeModelCommandOutput
   | InvokeModelWithBidirectionalStreamCommandOutput

package/dist-types/ts3.4/commands/CountTokensCommand.d.ts

@@ -0,0 +1,47 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import {
+  BedrockRuntimeClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../BedrockRuntimeClient";
+import { CountTokensRequest, CountTokensResponse } from "../models/models_0";
+export { __MetadataBearer };
+export { $Command };
+export interface CountTokensCommandInput extends CountTokensRequest {}
+export interface CountTokensCommandOutput
+  extends CountTokensResponse,
+    __MetadataBearer {}
+declare const CountTokensCommand_base: {
+  new (
+    input: CountTokensCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CountTokensCommandInput,
+    CountTokensCommandOutput,
+    BedrockRuntimeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  new (
+    input: CountTokensCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CountTokensCommandInput,
+    CountTokensCommandOutput,
+    BedrockRuntimeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CountTokensCommand extends CountTokensCommand_base {
+  protected static __types: {
+    api: {
+      input: CountTokensRequest;
+      output: CountTokensResponse;
+    };
+    sdk: {
+      input: CountTokensCommandInput;
+      output: CountTokensCommandOutput;
+    };
+  };
+}

package/dist-types/ts3.4/commands/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./ApplyGuardrailCommand";
 export * from "./ConverseCommand";
 export * from "./ConverseStreamCommand";
+export * from "./CountTokensCommand";
 export * from "./GetAsyncInvokeCommand";
 export * from "./InvokeModelCommand";
 export * from "./InvokeModelWithBidirectionalStreamCommand";

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

@@ -2236,6 +2236,47 @@ export interface InvokeModelWithResponseStreamResponse {
   contentType: string | undefined;
   performanceConfigLatency?: PerformanceConfigLatency | undefined;
 }
+export interface ConverseTokensRequest {
+  messages?: Message[] | undefined;
+  system?: SystemContentBlock[] | undefined;
+}
+export interface InvokeModelTokensRequest {
+  body: Uint8Array | undefined;
+}
+export type CountTokensInput =
+  | CountTokensInput.ConverseMember
+  | CountTokensInput.InvokeModelMember
+  | CountTokensInput.$UnknownMember;
+export declare namespace CountTokensInput {
+  interface InvokeModelMember {
+    invokeModel: InvokeModelTokensRequest;
+    converse?: never;
+    $unknown?: never;
+  }
+  interface ConverseMember {
+    invokeModel?: never;
+    converse: ConverseTokensRequest;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    invokeModel?: never;
+    converse?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    invokeModel: (value: InvokeModelTokensRequest) => T;
+    converse: (value: ConverseTokensRequest) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: CountTokensInput, visitor: Visitor<T>) => T;
+}
+export interface CountTokensRequest {
+  modelId: string | undefined;
+  input: CountTokensInput | undefined;
+}
+export interface CountTokensResponse {
+  inputTokens: number | undefined;
+}
 export declare const GetAsyncInvokeResponseFilterSensitiveLog: (
   obj: GetAsyncInvokeResponse
 ) => any;
@@ -2398,3 +2439,15 @@ export declare const ResponseStreamFilterSensitiveLog: (
 export declare const InvokeModelWithResponseStreamResponseFilterSensitiveLog: (
   obj: InvokeModelWithResponseStreamResponse
 ) => any;
+export declare const ConverseTokensRequestFilterSensitiveLog: (
+  obj: ConverseTokensRequest
+) => any;
+export declare const InvokeModelTokensRequestFilterSensitiveLog: (
+  obj: InvokeModelTokensRequest
+) => any;
+export declare const CountTokensInputFilterSensitiveLog: (
+  obj: CountTokensInput
+) => any;
+export declare const CountTokensRequestFilterSensitiveLog: (
+  obj: CountTokensRequest
+) => any;

package/dist-types/ts3.4/protocols/Aws_restJson1.d.ts

@@ -18,6 +18,10 @@ import {
   ConverseStreamCommandInput,
   ConverseStreamCommandOutput,
 } from "../commands/ConverseStreamCommand";
+import {
+  CountTokensCommandInput,
+  CountTokensCommandOutput,
+} from "../commands/CountTokensCommand";
 import {
   GetAsyncInvokeCommandInput,
   GetAsyncInvokeCommandOutput,
@@ -54,6 +58,10 @@ export declare const se_ConverseStreamCommand: (
   input: ConverseStreamCommandInput,
   context: __SerdeContext
 ) => Promise<__HttpRequest>;
+export declare const se_CountTokensCommand: (
+  input: CountTokensCommandInput,
+  context: __SerdeContext
+) => Promise<__HttpRequest>;
 export declare const se_GetAsyncInvokeCommand: (
   input: GetAsyncInvokeCommandInput,
   context: __SerdeContext
@@ -90,6 +98,10 @@ export declare const de_ConverseStreamCommand: (
   output: __HttpResponse,
   context: __SerdeContext & __EventStreamSerdeContext
 ) => Promise<ConverseStreamCommandOutput>;
+export declare const de_CountTokensCommand: (
+  output: __HttpResponse,
+  context: __SerdeContext
+) => Promise<CountTokensCommandOutput>;
 export declare const de_GetAsyncInvokeCommand: (
   output: __HttpResponse,
   context: __SerdeContext

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-bedrock-runtime",
   "description": "AWS SDK for JavaScript Bedrock Runtime Client for Node.js, Browser and React Native",
-  "version": "3.864.0",
+  "version": "3.873.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "node ../../scripts/compilation/inline client-bedrock-runtime",
@@ -20,21 +20,21 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "5.2.0",
     "@aws-crypto/sha256-js": "5.2.0",
-    "@aws-sdk/core": "3.864.0",
-    "@aws-sdk/credential-provider-node": "3.864.0",
-    "@aws-sdk/eventstream-handler-node": "3.862.0",
-    "@aws-sdk/middleware-eventstream": "3.862.0",
-    "@aws-sdk/middleware-host-header": "3.862.0",
-    "@aws-sdk/middleware-logger": "3.862.0",
-    "@aws-sdk/middleware-recursion-detection": "3.862.0",
-    "@aws-sdk/middleware-user-agent": "3.864.0",
-    "@aws-sdk/middleware-websocket": "3.862.0",
-    "@aws-sdk/region-config-resolver": "3.862.0",
-    "@aws-sdk/token-providers": "3.864.0",
+    "@aws-sdk/core": "3.873.0",
+    "@aws-sdk/credential-provider-node": "3.873.0",
+    "@aws-sdk/eventstream-handler-node": "3.873.0",
+    "@aws-sdk/middleware-eventstream": "3.873.0",
+    "@aws-sdk/middleware-host-header": "3.873.0",
+    "@aws-sdk/middleware-logger": "3.873.0",
+    "@aws-sdk/middleware-recursion-detection": "3.873.0",
+    "@aws-sdk/middleware-user-agent": "3.873.0",
+    "@aws-sdk/middleware-websocket": "3.873.0",
+    "@aws-sdk/region-config-resolver": "3.873.0",
+    "@aws-sdk/token-providers": "3.873.0",
     "@aws-sdk/types": "3.862.0",
-    "@aws-sdk/util-endpoints": "3.862.0",
-    "@aws-sdk/util-user-agent-browser": "3.862.0",
-    "@aws-sdk/util-user-agent-node": "3.864.0",
+    "@aws-sdk/util-endpoints": "3.873.0",
+    "@aws-sdk/util-user-agent-browser": "3.873.0",
+    "@aws-sdk/util-user-agent-node": "3.873.0",
     "@smithy/config-resolver": "^4.1.5",
     "@smithy/core": "^3.8.0",
     "@smithy/eventstream-serde-browser": "^4.0.5",