From 66399e628fbba543195dc418e44b4d68885abf37 Mon Sep 17 00:00:00 2001 From: Anuraag Agrawal Date: Fri, 28 Mar 2025 12:47:08 +0900 Subject: [PATCH 1/2] Instrument bedrock InvokeModelWithResponseStream --- buildscripts/checkstyle.xml | 22 - .../v2_2/internal/BedrockRuntimeImpl.java | 466 +++++++++++++--- .../v2_2/AbstractAws2BedrockRuntimeTest.java | 524 ++++++++++++++++++ ...vokemodelwithresponsestreamamazonnova.yaml | 292 ++++++++++ ...okemodelwithresponsestreamamazontitan.yaml | 103 ++++ ...odelwithresponsestreamanthropicclaude.yaml | 35 ++ 6 files changed, 1344 insertions(+), 98 deletions(-) create mode 100644 instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamamazonnova.yaml create mode 100644 instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamamazontitan.yaml create mode 100644 instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamanthropicclaude.yaml diff --git a/buildscripts/checkstyle.xml b/buildscripts/checkstyle.xml index 72f15023f18e..93931b701c2d 100644 --- a/buildscripts/checkstyle.xml +++ b/buildscripts/checkstyle.xml @@ -89,28 +89,6 @@ - - - - - - - - - - - - diff --git a/instrumentation/aws-sdk/aws-sdk-2.2/library/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/internal/BedrockRuntimeImpl.java b/instrumentation/aws-sdk/aws-sdk-2.2/library/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/internal/BedrockRuntimeImpl.java index 52e7e854d947..e6bbe5e4353a 100644 --- a/instrumentation/aws-sdk/aws-sdk-2.2/library/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/internal/BedrockRuntimeImpl.java +++ b/instrumentation/aws-sdk/aws-sdk-2.2/library/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/internal/BedrockRuntimeImpl.java @@ -27,6 +27,8 @@ import java.util.Map; import java.util.stream.Collectors; import javax.annotation.Nullable; +import software.amazon.awssdk.awscore.eventstream.EventStreamResponseHandler; +import software.amazon.awssdk.core.SdkBytes; import software.amazon.awssdk.core.SdkRequest; import software.amazon.awssdk.core.SdkResponse; import software.amazon.awssdk.core.async.SdkPublisher; @@ -53,9 +55,14 @@ import software.amazon.awssdk.services.bedrockruntime.model.InferenceConfiguration; import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelRequest; import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelResponse; +import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamRequest; +import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponse; +import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler; import software.amazon.awssdk.services.bedrockruntime.model.Message; import software.amazon.awssdk.services.bedrockruntime.model.MessageStartEvent; import software.amazon.awssdk.services.bedrockruntime.model.MessageStopEvent; +import software.amazon.awssdk.services.bedrockruntime.model.PayloadPart; +import software.amazon.awssdk.services.bedrockruntime.model.ResponseStream; import software.amazon.awssdk.services.bedrockruntime.model.StopReason; import software.amazon.awssdk.services.bedrockruntime.model.TokenUsage; import software.amazon.awssdk.services.bedrockruntime.model.ToolResultContentBlock; @@ -101,6 +108,9 @@ static boolean isBedrockRuntimeRequest(SdkRequest request) { if (request instanceof InvokeModelRequest) { return true; } + if (request instanceof InvokeModelWithResponseStreamRequest) { + return true; + } return false; } @@ -116,9 +126,15 @@ static boolean isBedrockRuntimeResponse(SdkResponse request) { static void maybeParseInvokeModelRequest( ExecutionAttributes executionAttributes, SdkRequest request) { + SdkBytes payload = null; if (request instanceof InvokeModelRequest) { - Document body = - deserializeDocument(((InvokeModelRequest) request).body().asByteArrayUnsafe()); + payload = ((InvokeModelRequest) request).body(); + } + if (request instanceof InvokeModelWithResponseStreamRequest) { + payload = ((InvokeModelWithResponseStreamRequest) request).body(); + } + if (payload != null) { + Document body = deserializeDocument(payload.asByteArrayUnsafe()); executionAttributes.putAttribute(INVOKE_MODEL_REQUEST_BODY, body); } } @@ -144,6 +160,9 @@ static String getModelId(ExecutionAttributes executionAttributes) { if (request instanceof InvokeModelRequest) { return ((InvokeModelRequest) request).modelId(); } + if (request instanceof InvokeModelWithResponseStreamRequest) { + return ((InvokeModelWithResponseStreamRequest) request).modelId(); + } return null; } @@ -157,25 +176,37 @@ static String getOperationName(ExecutionAttributes executionAttributes) { return GenAiOperationNameIncubatingValues.CHAT; } if (request instanceof InvokeModelRequest) { - String modelId = ((InvokeModelRequest) request).modelId(); - if (modelId == null) { - return null; - } - if (modelId.startsWith("amazon.titan")) { - // titan using invoke model is a text completion request - return GenAiOperationNameIncubatingValues.TEXT_COMPLETION; - } - return GenAiOperationNameIncubatingValues.CHAT; + return getOperationNameInvokeModel(((InvokeModelRequest) request).modelId()); + } + if (request instanceof InvokeModelWithResponseStreamRequest) { + return getOperationNameInvokeModel( + ((InvokeModelWithResponseStreamRequest) request).modelId()); } return null; } + @Nullable + private static String getOperationNameInvokeModel(@Nullable String modelId) { + if (modelId == null) { + return null; + } + if (modelId.startsWith("amazon.titan")) { + // titan using invoke model is a text completion request + return GenAiOperationNameIncubatingValues.TEXT_COMPLETION; + } + return GenAiOperationNameIncubatingValues.CHAT; + } + @Nullable static Long getMaxTokens(ExecutionAttributes executionAttributes) { SdkRequest request = executionAttributes.getAttribute(SDK_REQUEST_ATTRIBUTE); if (request instanceof InvokeModelRequest) { - return getMaxTokens(executionAttributes, (InvokeModelRequest) request); + return getMaxTokensInvokeModel(executionAttributes, ((InvokeModelRequest) request).modelId()); + } + if (request instanceof InvokeModelWithResponseStreamRequest) { + return getMaxTokensInvokeModel( + executionAttributes, ((InvokeModelWithResponseStreamRequest) request).modelId()); } InferenceConfiguration config = null; @@ -191,9 +222,8 @@ static Long getMaxTokens(ExecutionAttributes executionAttributes) { } @Nullable - private static Long getMaxTokens( - ExecutionAttributes executionAttributes, InvokeModelRequest request) { - String modelId = request.modelId(); + private static Long getMaxTokensInvokeModel( + ExecutionAttributes executionAttributes, @Nullable String modelId) { if (modelId == null) { return null; } @@ -227,7 +257,12 @@ private static Long getMaxTokens( static Double getTemperature(ExecutionAttributes executionAttributes) { SdkRequest request = executionAttributes.getAttribute(SDK_REQUEST_ATTRIBUTE); if (request instanceof InvokeModelRequest) { - return getTemperature(executionAttributes, (InvokeModelRequest) request); + return getTemperatureInvokeModel( + executionAttributes, ((InvokeModelRequest) request).modelId()); + } + if (request instanceof InvokeModelWithResponseStreamRequest) { + return getTemperatureInvokeModel( + executionAttributes, ((InvokeModelWithResponseStreamRequest) request).modelId()); } InferenceConfiguration config = null; @@ -243,9 +278,8 @@ static Double getTemperature(ExecutionAttributes executionAttributes) { } @Nullable - private static Double getTemperature( - ExecutionAttributes executionAttributes, InvokeModelRequest request) { - String modelId = request.modelId(); + private static Double getTemperatureInvokeModel( + ExecutionAttributes executionAttributes, @Nullable String modelId) { if (modelId == null) { return null; } @@ -279,7 +313,11 @@ private static Double getTemperature( static Double getTopP(ExecutionAttributes executionAttributes) { SdkRequest request = executionAttributes.getAttribute(SDK_REQUEST_ATTRIBUTE); if (request instanceof InvokeModelRequest) { - return getTopP(executionAttributes, (InvokeModelRequest) request); + return getToppInvokeModel(executionAttributes, ((InvokeModelRequest) request).modelId()); + } + if (request instanceof InvokeModelWithResponseStreamRequest) { + return getToppInvokeModel( + executionAttributes, ((InvokeModelWithResponseStreamRequest) request).modelId()); } InferenceConfiguration config = null; @@ -294,9 +332,8 @@ static Double getTopP(ExecutionAttributes executionAttributes) { return null; } - private static Double getTopP( - ExecutionAttributes executionAttributes, InvokeModelRequest request) { - String modelId = request.modelId(); + private static Double getToppInvokeModel( + ExecutionAttributes executionAttributes, @Nullable String modelId) { if (modelId == null) { return null; } @@ -330,7 +367,11 @@ private static Double getTopP( static List getStopSequences(ExecutionAttributes executionAttributes) { SdkRequest request = executionAttributes.getAttribute(SDK_REQUEST_ATTRIBUTE); if (request instanceof InvokeModelRequest) { - return getStopSequences(executionAttributes, (InvokeModelRequest) request); + return getStopSequences(executionAttributes, ((InvokeModelRequest) request).modelId()); + } + if (request instanceof InvokeModelWithResponseStreamRequest) { + return getStopSequences( + executionAttributes, ((InvokeModelWithResponseStreamRequest) request).modelId()); } InferenceConfiguration config = null; @@ -347,8 +388,7 @@ static List getStopSequences(ExecutionAttributes executionAttributes) { @Nullable private static List getStopSequences( - ExecutionAttributes executionAttributes, InvokeModelRequest request) { - String modelId = request.modelId(); + ExecutionAttributes executionAttributes, @Nullable String modelId) { if (modelId == null) { return null; } @@ -396,8 +436,8 @@ static List getStopReasons(ExecutionAttributes executionAttributes, Resp return Collections.singletonList(reason.toString()); } } else { - TracingConverseStreamResponseHandler streamHandler = - TracingConverseStreamResponseHandler.fromContext(response.otelContext()); + BedrockRuntimeStreamResponseHandler streamHandler = + BedrockRuntimeStreamResponseHandler.fromContext(response.otelContext()); if (streamHandler != null) { return streamHandler.stopReasons; } @@ -456,8 +496,8 @@ static Long getUsageInputTokens(ExecutionAttributes executionAttributes, Respons if (sdkResponse instanceof ConverseResponse) { usage = ((ConverseResponse) sdkResponse).usage(); } else { - TracingConverseStreamResponseHandler streamHandler = - TracingConverseStreamResponseHandler.fromContext(response.otelContext()); + BedrockRuntimeStreamResponseHandler streamHandler = + BedrockRuntimeStreamResponseHandler.fromContext(response.otelContext()); if (streamHandler != null) { usage = streamHandler.usage; } @@ -514,8 +554,8 @@ static Long getUsageOutputTokens(ExecutionAttributes executionAttributes, Respon if (sdkResponse instanceof ConverseResponse) { usage = ((ConverseResponse) sdkResponse).usage(); } else { - TracingConverseStreamResponseHandler streamHandler = - TracingConverseStreamResponseHandler.fromContext(response.otelContext()); + BedrockRuntimeStreamResponseHandler streamHandler = + BedrockRuntimeStreamResponseHandler.fromContext(response.otelContext()); if (streamHandler != null) { usage = streamHandler.usage; } @@ -577,10 +617,31 @@ static void recordRequestEvents( ExecutionAttributes executionAttributes, SdkRequest request, boolean captureMessageContent) { + // Good a time as any to store the context for a streaming request. + BedrockRuntimeStreamResponseHandler streamHandler = + BedrockRuntimeStreamResponseHandler.fromContext(otelContext); + if (streamHandler != null) { + streamHandler.setOtelContext(otelContext); + } + if (request instanceof InvokeModelRequest) { Document body = executionAttributes.getAttribute(INVOKE_MODEL_REQUEST_BODY); recordInvokeModelRequestEvents( - otelContext, eventLogger, (InvokeModelRequest) request, body, captureMessageContent); + otelContext, + eventLogger, + ((InvokeModelRequest) request).modelId(), + body, + captureMessageContent); + return; + } + if (request instanceof InvokeModelWithResponseStreamRequest) { + Document body = executionAttributes.getAttribute(INVOKE_MODEL_REQUEST_BODY); + recordInvokeModelRequestEvents( + otelContext, + eventLogger, + ((InvokeModelWithResponseStreamRequest) request).modelId(), + body, + captureMessageContent); return; } if (request instanceof ConverseRequest) { @@ -594,22 +655,18 @@ static void recordRequestEvents( eventLogger, ((ConverseStreamRequest) request).messages(), captureMessageContent); - - // Good a time as any to store the context for a streaming request. - TracingConverseStreamResponseHandler.fromContext(otelContext).setOtelContext(otelContext); } } private static void recordInvokeModelRequestEvents( Context otelContext, Logger eventLogger, - InvokeModelRequest request, + @Nullable String modelId, Document body, boolean captureMessageContent) { if (!body.isMap()) { return; } - String modelId = request.modelId(); if (modelId == null) { return; } @@ -846,6 +903,22 @@ public static BedrockRuntimeAsyncClient wrap( try (Scope ignored = wrapped.makeCurrent()) { return invokeProxyMethod(method, asyncClient, args); } + } else if (method.getName().equals("invokeModelWithResponseStream") + && args.length >= 2 + && args[0] instanceof InvokeModelWithResponseStreamRequest + && args[1] instanceof InvokeModelWithResponseStreamResponseHandler) { + InvokeModelWithResponseStreamRequest request = + (InvokeModelWithResponseStreamRequest) args[0]; + TracingInvokeModelWithResponseStreamResponseHandler wrapped = + new TracingInvokeModelWithResponseStreamResponseHandler( + (InvokeModelWithResponseStreamResponseHandler) args[1], + eventLogger, + captureMessageContent, + request.modelId()); + args[1] = wrapped; + try (Scope ignored = wrapped.makeCurrent()) { + return invokeProxyMethod(method, asyncClient, args); + } } return invokeProxyMethod(method, asyncClient, args); }); @@ -860,54 +933,40 @@ private static Object invokeProxyMethod(Method method, Object target, Object[] a } } - /** - * This class is internal and is hence not for public use. Its APIs are unstable and can change at - * any time. - */ - public static class TracingConverseStreamResponseHandler - implements ConverseStreamResponseHandler, ImplicitContextKeyed { - + abstract static class BedrockRuntimeStreamResponseHandler + implements EventStreamResponseHandler, ImplicitContextKeyed { @Nullable - public static TracingConverseStreamResponseHandler fromContext(Context context) { + public static BedrockRuntimeStreamResponseHandler fromContext(Context context) { return context.get(KEY); } - private static final ContextKey KEY = - ContextKey.named("bedrock-runtime-converse-stream-response-handler"); + private static final ContextKey> KEY = + ContextKey.named("bedrock-runtime-stream-response-handler"); - private final ConverseStreamResponseHandler delegate; - private final Logger eventLogger; - private final boolean captureMessageContent; - - private StringBuilder currentText; + private final EventStreamResponseHandler delegate; // The response handler is created and stored into context before the span, so we need to // also pass the later context in for recording events. While subscribers are called from a // single thread, it is not clear if that is guaranteed to be the same as the execution // interceptor so we use volatile. - private volatile Context otelContext; - - private List tools; - private ToolUseBlock.Builder currentTool; - private StringBuilder currentToolArgs; + volatile Context otelContext; List stopReasons; TokenUsage usage; - TracingConverseStreamResponseHandler( - ConverseStreamResponseHandler delegate, Logger eventLogger, boolean captureMessageContent) { + BedrockRuntimeStreamResponseHandler(EventStreamResponseHandler delegate) { this.delegate = delegate; - this.eventLogger = eventLogger; - this.captureMessageContent = captureMessageContent; } + protected abstract void handleEvent(S event); + @Override - public void responseReceived(ConverseStreamResponse converseStreamResponse) { - delegate.responseReceived(converseStreamResponse); + public final void responseReceived(R response) { + delegate.responseReceived(response); } @Override - public void onEventStream(SdkPublisher sdkPublisher) { + public final void onEventStream(SdkPublisher sdkPublisher) { delegate.onEventStream( sdkPublisher.map( event -> { @@ -916,7 +975,52 @@ public void onEventStream(SdkPublisher sdkPublisher) { })); } - private void handleEvent(ConverseStreamOutput event) { + @Override + public final void exceptionOccurred(Throwable throwable) { + delegate.exceptionOccurred(throwable); + } + + @Override + public final void complete() { + delegate.complete(); + } + + @Override + public final Context storeInContext(Context context) { + return context.with(KEY, this); + } + + final void setOtelContext(Context otelContext) { + this.otelContext = otelContext; + } + } + + /** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ + public static class TracingConverseStreamResponseHandler + extends BedrockRuntimeStreamResponseHandler + implements ConverseStreamResponseHandler { + + private final Logger eventLogger; + private final boolean captureMessageContent; + + private StringBuilder currentText; + + private List tools; + private ToolUseBlock.Builder currentTool; + private StringBuilder currentToolArgs; + + TracingConverseStreamResponseHandler( + ConverseStreamResponseHandler delegate, Logger eventLogger, boolean captureMessageContent) { + super(delegate); + this.eventLogger = eventLogger; + this.captureMessageContent = captureMessageContent; + } + + @Override + protected void handleEvent(ConverseStreamOutput event) { if (captureMessageContent && event instanceof MessageStartEvent) { if (currentText == null) { currentText = new StringBuilder(); @@ -970,24 +1074,234 @@ private void handleEvent(ConverseStreamOutput event) { usage = ((ConverseStreamMetadataEvent) event).usage(); } } + } - @Override - public void exceptionOccurred(Throwable throwable) { - delegate.exceptionOccurred(throwable); + /** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ + public static class TracingInvokeModelWithResponseStreamResponseHandler + extends BedrockRuntimeStreamResponseHandler< + InvokeModelWithResponseStreamResponse, ResponseStream> + implements InvokeModelWithResponseStreamResponseHandler { + + private final Logger eventLogger; + private final boolean captureMessageContent; + private final String requestModel; + + private StringBuilder currentText; + + private int inputTokens; + private int outputTokens; + + TracingInvokeModelWithResponseStreamResponseHandler( + InvokeModelWithResponseStreamResponseHandler delegate, + Logger eventLogger, + boolean captureMessageContent, + String requestModel) { + super(delegate); + this.eventLogger = eventLogger; + this.captureMessageContent = captureMessageContent; + this.requestModel = requestModel; } @Override - public void complete() { - delegate.complete(); + protected void handleEvent(ResponseStream event) { + if (!(event instanceof PayloadPart)) { + return; + } + Document result = deserializeDocument(((PayloadPart) event).bytes().asByteArrayUnsafe()); + if (requestModel.startsWith("amazon.titan")) { + handleEventAmazonTitan(result); + } else if (requestModel.startsWith("amazon.nova")) { + handleEventAmazonNova(result); + } else if (requestModel.startsWith("anthropic.claude")) { + handleEventAnthropicCloud(result); + } } - @Override - public Context storeInContext(Context context) { - return context.with(KEY, this); + private void handleEventAmazonTitan(Document result) { + if (captureMessageContent) { + Document resultText = result.asMap().get("outputText"); + if (resultText != null && resultText.isString()) { + if (currentText == null) { + currentText = new StringBuilder(); + } + currentText.append(resultText.asString()); + } + } + // In practice, first event has the input tokens and last the output. + Document inputTokens = result.asMap().get("inputTextTokenCount"); + if (inputTokens != null && inputTokens.isNumber()) { + this.inputTokens = inputTokens.asNumber().intValue(); + } + Document outputTokens = result.asMap().get("totalOutputTextTokenCount"); + if (outputTokens != null && outputTokens.isNumber()) { + this.outputTokens = outputTokens.asNumber().intValue(); + } + Document stopReasonDoc = result.asMap().get("completionReason"); + if (stopReasonDoc != null && stopReasonDoc.isString()) { + String stopReason = stopReasonDoc.asString(); + if (stopReasons == null) { + stopReasons = new ArrayList<>(); + } + stopReasons.add(stopReason); + // There's no indication of the final event other than completion reason. Emit the event + // and finish up. + newEvent(otelContext, eventLogger) + .setAttribute(EVENT_NAME, "gen_ai.choice") + .setBody(convertMessageData(currentText, null, 0, stopReason, captureMessageContent)) + .emit(); + this.usage = + TokenUsage.builder() + .inputTokens(this.inputTokens) + .outputTokens(this.outputTokens) + .build(); + } } - void setOtelContext(Context otelContext) { - this.otelContext = otelContext; + private void handleEventAmazonNova(Document result) { + if (result.asMap().get("messageStart") != null) { + if (captureMessageContent) { + if (currentText == null) { + currentText = new StringBuilder(); + } + currentText.setLength(0); + } + return; + } + Document contentBlockDelta = result.asMap().get("contentBlockDelta"); + if (contentBlockDelta != null && contentBlockDelta.isMap()) { + Document delta = contentBlockDelta.asMap().get("delta"); + if (delta == null || !delta.isMap()) { + return; + } + if (captureMessageContent) { + Document text = delta.asMap().get("text"); + if (text != null && text.isString()) { + currentText.append(text.asString()); + } + } + return; + } + Document messageStop = result.asMap().get("messageStop"); + if (messageStop != null && messageStop.isMap()) { + Document stopReasonDoc = messageStop.asMap().get("stopReason"); + if (stopReasonDoc == null || !stopReasonDoc.isString()) { + return; + } + if (stopReasons == null) { + stopReasons = new ArrayList<>(); + } + String stopReason = stopReasonDoc.asString(); + stopReasons.add(stopReason); + newEvent(otelContext, eventLogger) + .setAttribute(EVENT_NAME, "gen_ai.choice") + .setBody(convertMessageData(currentText, null, 0, stopReason, captureMessageContent)) + .emit(); + return; + } + Document metadata = result.asMap().get("metadata"); + if (metadata != null && metadata.isMap()) { + Document usage = metadata.asMap().get("usage"); + if (usage == null || !usage.isMap()) { + return; + } + Document inputTokens = usage.asMap().get("inputTokens"); + Document outputTokens = usage.asMap().get("outputTokens"); + if (inputTokens != null + && inputTokens.isNumber() + && outputTokens != null + && outputTokens.isNumber()) { + this.usage = + TokenUsage.builder() + .inputTokens(inputTokens.asNumber().intValue()) + .outputTokens(outputTokens.asNumber().intValue()) + .build(); + } + } + } + + private void handleEventAnthropicCloud(Document result) { + Document type = result.asMap().get("type"); + if (type == null || !type.isString()) { + return; + } + switch (type.asString()) { + case "message_start": + { + if (captureMessageContent) { + if (currentText == null) { + currentText = new StringBuilder(); + } + currentText.setLength(0); + } + Document message = result.asMap().get("message"); + if (message == null || !message.isMap()) { + return; + } + Document usage = message.asMap().get("usage"); + if (usage != null && usage.isMap()) { + Document inputTokens = usage.asMap().get("input_tokens"); + if (inputTokens != null && inputTokens.isNumber()) { + this.inputTokens = inputTokens.asNumber().intValue(); + } + Document outputTokens = usage.asMap().get("output_tokens"); + if (outputTokens != null && outputTokens.isNumber()) { + this.outputTokens = outputTokens.asNumber().intValue(); + } + } + return; + } + case "content_block_delta": + { + Document delta = result.asMap().get("delta"); + if (delta == null || !delta.isMap()) { + return; + } + if (captureMessageContent) { + Document text = delta.asMap().get("text"); + if (text != null && text.isString()) { + currentText.append(text.asString()); + } + } + return; + } + case "message_delta": + { + Document delta = result.asMap().get("delta"); + if (delta != null && delta.isMap()) { + Document stopReasonDoc = delta.asMap().get("stop_reason"); + if (stopReasonDoc != null && stopReasonDoc.isString()) { + String stopReason = stopReasonDoc.asString(); + if (stopReasons == null) { + stopReasons = new ArrayList<>(); + } + stopReasons.add(stopReason); + newEvent(otelContext, eventLogger) + .setAttribute(EVENT_NAME, "gen_ai.choice") + .setBody( + convertMessageData(currentText, null, 0, stopReason, captureMessageContent)) + .emit(); + } + } + Document usage = result.asMap().get("usage"); + if (usage != null && usage.isMap()) { + Document outputTokens = usage.asMap().get("output_tokens"); + if (outputTokens != null && outputTokens.isNumber()) { + this.outputTokens = outputTokens.asNumber().intValue(); + } + } + this.usage = + TokenUsage.builder() + .inputTokens(this.inputTokens) + .outputTokens(this.outputTokens) + .build(); + return; + } + default: + return; + } } } diff --git a/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/AbstractAws2BedrockRuntimeTest.java b/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/AbstractAws2BedrockRuntimeTest.java index a9729c94b3e2..58acde4f5d4e 100644 --- a/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/AbstractAws2BedrockRuntimeTest.java +++ b/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/AbstractAws2BedrockRuntimeTest.java @@ -63,6 +63,8 @@ import software.amazon.awssdk.services.bedrockruntime.model.InferenceConfiguration; import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelRequest; import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelResponse; +import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamRequest; +import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler; import software.amazon.awssdk.services.bedrockruntime.model.Message; import software.amazon.awssdk.services.bedrockruntime.model.Tool; import software.amazon.awssdk.services.bedrockruntime.model.ToolConfiguration; @@ -1574,6 +1576,171 @@ void testInvokeModelAmazonTitan() { Value.of("\nHello! I am a computer program designed to"))))); } + @Test + void testInvokeModelWithResponseStreamAmazonTitan() + throws InterruptedException, ExecutionException { + BedrockRuntimeAsyncClientBuilder builder = BedrockRuntimeAsyncClient.builder(); + builder.overrideConfiguration(createOverrideConfigurationBuilder().build()); + configureClient(builder); + BedrockRuntimeAsyncClient client = configureBedrockRuntimeClient(builder.build()); + + String modelId = "amazon.titan-text-lite-v1"; + + Document requestPayload = + Document.mapBuilder() + // Long output string to trigger multiple chunks. + .putString("inputText", "List out every country in the world") + .putDocument( + "textGenerationConfig", + Document.mapBuilder() + .putNumber("maxTokenCount", 100) + .putNumber("temperature", 0.8f) + .putNumber("topP", 1) + .putList("stopSequences", singletonList(Document.fromString("|"))) + .build()) + .build(); + + SdkJsonGenerator generator = new SdkJsonGenerator(new JsonFactory(), "application/json"); + DocumentTypeJsonMarshaller marshaller = new DocumentTypeJsonMarshaller(generator); + requestPayload.accept(marshaller); + + InvokeModelWithResponseStreamRequest request = + InvokeModelWithResponseStreamRequest.builder() + .modelId(modelId) + .body(SdkBytes.fromByteArray(generator.getBytes())) + .build(); + + StringBuilder text = new StringBuilder(); + + InvokeModelWithResponseStreamResponseHandler responseHandler = + InvokeModelWithResponseStreamResponseHandler.builder() + .subscriber( + InvokeModelWithResponseStreamResponseHandler.Visitor.builder() + .onChunk( + chunk -> { + JsonNode node = JsonNode.parser().parse(chunk.bytes().asByteArray()); + DocumentUnmarshaller unmarshaller = new DocumentUnmarshaller(); + Document result = node.visit(unmarshaller); + text.append(result.asMap().get("outputText").asString()); + }) + .build()) + .build(); + + client.invokeModelWithResponseStream(request, responseHandler).get(); + + assertThat(text.toString()).contains("Here is the list of every country in the world"); + + getTesting() + .waitAndAssertTraces( + trace -> + trace.hasSpansSatisfyingExactly( + span -> + span.hasName("text_completion amazon.titan-text-lite-v1") + .hasKind(SpanKind.CLIENT) + .hasAttributesSatisfying( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes.GenAiOperationNameIncubatingValues + .TEXT_COMPLETION), + equalTo(GEN_AI_REQUEST_MODEL, modelId), + equalTo(GEN_AI_REQUEST_MAX_TOKENS, 100), + satisfies( + GEN_AI_REQUEST_TEMPERATURE, + temp -> temp.isCloseTo(0.8, within(0.0001))), + equalTo(GEN_AI_REQUEST_TOP_P, 1.0), + equalTo(GEN_AI_REQUEST_STOP_SEQUENCES, asList("|")), + equalTo(GEN_AI_USAGE_INPUT_TOKENS, 7), + equalTo(GEN_AI_USAGE_OUTPUT_TOKENS, 100), + equalTo(GEN_AI_RESPONSE_FINISH_REASONS, asList("LENGTH"))))); + + getTesting() + .waitAndAssertMetrics( + INSTRUMENTATION_NAME, + metric -> + metric + .hasName("gen_ai.client.token.usage") + .hasUnit("{token}") + .hasDescription("Measures number of input and output tokens used.") + .hasHistogramSatisfying( + histogram -> + histogram.hasPointsSatisfying( + point -> + point + .hasSum(7) + .hasCount(1) + .hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_TOKEN_TYPE, + GenAiIncubatingAttributes + .GenAiTokenTypeIncubatingValues.INPUT), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes + .GenAiOperationNameIncubatingValues + .TEXT_COMPLETION), + equalTo(GEN_AI_REQUEST_MODEL, modelId)), + point -> + point + .hasSum(100) + .hasCount(1) + .hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_TOKEN_TYPE, + GenAiIncubatingAttributes + .GenAiTokenTypeIncubatingValues.COMPLETION), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes + .GenAiOperationNameIncubatingValues + .TEXT_COMPLETION), + equalTo(GEN_AI_REQUEST_MODEL, modelId)))), + metric -> + metric + .hasName("gen_ai.client.operation.duration") + .hasUnit("s") + .hasDescription("GenAI operation duration.") + .hasHistogramSatisfying( + histogram -> + histogram.hasPointsSatisfying( + point -> + point + .hasSumGreaterThan(0.0) + .hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes + .GenAiOperationNameIncubatingValues + .TEXT_COMPLETION), + equalTo(GEN_AI_REQUEST_MODEL, modelId))))); + + SpanContext spanCtx = getTesting().waitForTraces(1).get(0).get(0).getSpanContext(); + + getTesting() + .waitAndAssertLogRecords( + log -> + log.hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo(EVENT_NAME, "gen_ai.user.message")) + .hasSpanContext(spanCtx) + .hasBody( + Value.of( + KeyValue.of( + "content", Value.of("List out every country in the world")))), + log -> + log.hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), equalTo(EVENT_NAME, "gen_ai.choice")) + .hasSpanContext(spanCtx) + .hasBody( + Value.of( + KeyValue.of("finish_reason", Value.of("LENGTH")), + KeyValue.of("index", Value.of(0)), + KeyValue.of("content", Value.of(text.toString()))))); + } + @Test void testInvokeModelAmazonNova() { BedrockRuntimeClientBuilder builder = BedrockRuntimeClient.builder(); @@ -1743,6 +1910,188 @@ void testInvokeModelAmazonNova() { Value.of("It sounds like you're initiating a test or"))))); } + @Test + void testInvokeModelWithResponseStreamAmazonNova() + throws InterruptedException, ExecutionException { + BedrockRuntimeAsyncClientBuilder builder = BedrockRuntimeAsyncClient.builder(); + builder.overrideConfiguration(createOverrideConfigurationBuilder().build()); + configureClient(builder); + BedrockRuntimeAsyncClient client = configureBedrockRuntimeClient(builder.build()); + + String modelId = "amazon.nova-micro-v1:0"; + + Document requestPayload = + Document.mapBuilder() + .putList( + "messages", + singletonList( + Document.mapBuilder() + .putString("role", "user") + .putList( + "content", + singletonList( + Document.mapBuilder() + // Long output string to trigger multiple chunks. + .putString("text", "List out every country in the world") + .build())) + .build())) + .putDocument( + "inferenceConfig", + Document.mapBuilder() + .putNumber("max_new_tokens", 100) + .putNumber("temperature", 0.8f) + .putNumber("topP", 1) + .putList("stopSequences", singletonList(Document.fromString("|"))) + .build()) + .build(); + + SdkJsonGenerator generator = new SdkJsonGenerator(new JsonFactory(), "application/json"); + DocumentTypeJsonMarshaller marshaller = new DocumentTypeJsonMarshaller(generator); + requestPayload.accept(marshaller); + + InvokeModelWithResponseStreamRequest request = + InvokeModelWithResponseStreamRequest.builder() + .modelId(modelId) + .body(SdkBytes.fromByteArray(generator.getBytes())) + .build(); + + StringBuilder text = new StringBuilder(); + + InvokeModelWithResponseStreamResponseHandler responseHandler = + InvokeModelWithResponseStreamResponseHandler.builder() + .subscriber( + InvokeModelWithResponseStreamResponseHandler.Visitor.builder() + .onChunk( + chunk -> { + JsonNode node = JsonNode.parser().parse(chunk.bytes().asByteArray()); + DocumentUnmarshaller unmarshaller = new DocumentUnmarshaller(); + Document result = node.visit(unmarshaller); + Document block = result.asMap().get("contentBlockDelta"); + if (block == null) { + return; + } + Document delta = block.asMap().get("delta"); + if (delta == null) { + return; + } + text.append(delta.asMap().get("text").asString()); + }) + .build()) + .build(); + + client.invokeModelWithResponseStream(request, responseHandler).get(); + + assertThat(text.toString()) + .contains("Listing every country in the world is a comprehensive task"); + + getTesting() + .waitAndAssertTraces( + trace -> + trace.hasSpansSatisfyingExactly( + span -> + span.hasName("chat amazon.nova-micro-v1:0") + .hasKind(SpanKind.CLIENT) + .hasAttributesSatisfying( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes.GenAiOperationNameIncubatingValues + .CHAT), + equalTo(GEN_AI_REQUEST_MODEL, modelId), + equalTo(GEN_AI_REQUEST_MAX_TOKENS, 100), + satisfies( + GEN_AI_REQUEST_TEMPERATURE, + temp -> temp.isCloseTo(0.8, within(0.0001))), + equalTo(GEN_AI_REQUEST_TOP_P, 1.0), + equalTo(GEN_AI_REQUEST_STOP_SEQUENCES, asList("|")), + equalTo(GEN_AI_USAGE_INPUT_TOKENS, 7), + equalTo(GEN_AI_USAGE_OUTPUT_TOKENS, 100), + equalTo(GEN_AI_RESPONSE_FINISH_REASONS, asList("max_tokens"))))); + + getTesting() + .waitAndAssertMetrics( + INSTRUMENTATION_NAME, + metric -> + metric + .hasName("gen_ai.client.token.usage") + .hasUnit("{token}") + .hasDescription("Measures number of input and output tokens used.") + .hasHistogramSatisfying( + histogram -> + histogram.hasPointsSatisfying( + point -> + point + .hasSum(7) + .hasCount(1) + .hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_TOKEN_TYPE, + GenAiIncubatingAttributes + .GenAiTokenTypeIncubatingValues.INPUT), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes + .GenAiOperationNameIncubatingValues.CHAT), + equalTo(GEN_AI_REQUEST_MODEL, modelId)), + point -> + point + .hasSum(100) + .hasCount(1) + .hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_TOKEN_TYPE, + GenAiIncubatingAttributes + .GenAiTokenTypeIncubatingValues.COMPLETION), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes + .GenAiOperationNameIncubatingValues.CHAT), + equalTo(GEN_AI_REQUEST_MODEL, modelId)))), + metric -> + metric + .hasName("gen_ai.client.operation.duration") + .hasUnit("s") + .hasDescription("GenAI operation duration.") + .hasHistogramSatisfying( + histogram -> + histogram.hasPointsSatisfying( + point -> + point + .hasSumGreaterThan(0.0) + .hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes + .GenAiOperationNameIncubatingValues.CHAT), + equalTo(GEN_AI_REQUEST_MODEL, modelId))))); + + SpanContext spanCtx = getTesting().waitForTraces(1).get(0).get(0).getSpanContext(); + + getTesting() + .waitAndAssertLogRecords( + log -> + log.hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo(EVENT_NAME, "gen_ai.user.message")) + .hasSpanContext(spanCtx) + .hasBody( + Value.of( + KeyValue.of( + "content", Value.of("List out every country in the world")))), + log -> + log.hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), equalTo(EVENT_NAME, "gen_ai.choice")) + .hasSpanContext(spanCtx) + .hasBody( + Value.of( + KeyValue.of("finish_reason", Value.of("max_tokens")), + KeyValue.of("index", Value.of(0)), + KeyValue.of("content", Value.of(text.toString()))))); + } + @Test void testInvokeModelAnthropicClaude() { BedrockRuntimeClientBuilder builder = BedrockRuntimeClient.builder(); @@ -1897,4 +2246,179 @@ void testInvokeModelAnthropicClaude() { KeyValue.of( "content", Value.of("Okay, I just said \"This is a test"))))); } + + @Test + void testInvokeModelWithResponseStreamAnthropicClaude() + throws InterruptedException, ExecutionException { + BedrockRuntimeAsyncClientBuilder builder = BedrockRuntimeAsyncClient.builder(); + builder.overrideConfiguration(createOverrideConfigurationBuilder().build()); + configureClient(builder); + BedrockRuntimeAsyncClient client = configureBedrockRuntimeClient(builder.build()); + + String modelId = "anthropic.claude-v2"; + + Document requestPayload = + Document.mapBuilder() + .putList( + "messages", + singletonList( + Document.mapBuilder() + .putString("role", "user") + .putList( + "content", + singletonList( + Document.mapBuilder() + // Long output string to trigger multiple chunks. + .putString("text", "List out every country in the world") + .putString("type", "text") + .build())) + .build())) + .putString("anthropic_version", "bedrock-2023-05-31") + .putNumber("max_tokens", 10) + .putNumber("temperature", 0.8f) + .putNumber("top_p", 1) + .putList("stop_sequences", singletonList(Document.fromString("|"))) + .build(); + + SdkJsonGenerator generator = new SdkJsonGenerator(new JsonFactory(), "application/json"); + DocumentTypeJsonMarshaller marshaller = new DocumentTypeJsonMarshaller(generator); + requestPayload.accept(marshaller); + + InvokeModelWithResponseStreamRequest request = + InvokeModelWithResponseStreamRequest.builder() + .modelId(modelId) + .body(SdkBytes.fromByteArray(generator.getBytes())) + .build(); + + StringBuilder text = new StringBuilder(); + + InvokeModelWithResponseStreamResponseHandler responseHandler = + InvokeModelWithResponseStreamResponseHandler.builder() + .subscriber( + InvokeModelWithResponseStreamResponseHandler.Visitor.builder() + .onChunk( + chunk -> { + JsonNode node = JsonNode.parser().parse(chunk.bytes().asByteArray()); + DocumentUnmarshaller unmarshaller = new DocumentUnmarshaller(); + Document result = node.visit(unmarshaller); + Document delta = result.asMap().get("delta"); + if (delta == null) { + return; + } + text.append(delta.asMap().get("text").asString()); + }) + .build()) + .build(); + + client.invokeModelWithResponseStream(request, responseHandler).get(); + + assertThat(text.toString()).contains("Unfortunately I do not have a complete list of every"); + + getTesting() + .waitAndAssertTraces( + trace -> + trace.hasSpansSatisfyingExactly( + span -> + span.hasName("chat anthropic.claude-v2") + .hasKind(SpanKind.CLIENT) + .hasAttributesSatisfying( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes.GenAiOperationNameIncubatingValues + .CHAT), + equalTo(GEN_AI_REQUEST_MODEL, modelId), + equalTo(GEN_AI_REQUEST_MAX_TOKENS, 10), + satisfies( + GEN_AI_REQUEST_TEMPERATURE, + temp -> temp.isCloseTo(0.8, within(0.0001))), + equalTo(GEN_AI_REQUEST_TOP_P, 1.0), + equalTo(GEN_AI_REQUEST_STOP_SEQUENCES, asList("|")), + equalTo(GEN_AI_USAGE_INPUT_TOKENS, 16), + equalTo(GEN_AI_USAGE_OUTPUT_TOKENS, 10), + equalTo(GEN_AI_RESPONSE_FINISH_REASONS, asList("max_tokens"))))); + + getTesting() + .waitAndAssertMetrics( + INSTRUMENTATION_NAME, + metric -> + metric + .hasName("gen_ai.client.token.usage") + .hasUnit("{token}") + .hasDescription("Measures number of input and output tokens used.") + .hasHistogramSatisfying( + histogram -> + histogram.hasPointsSatisfying( + point -> + point + .hasSum(16) + .hasCount(1) + .hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_TOKEN_TYPE, + GenAiIncubatingAttributes + .GenAiTokenTypeIncubatingValues.INPUT), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes + .GenAiOperationNameIncubatingValues.CHAT), + equalTo(GEN_AI_REQUEST_MODEL, modelId)), + point -> + point + .hasSum(10) + .hasCount(1) + .hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_TOKEN_TYPE, + GenAiIncubatingAttributes + .GenAiTokenTypeIncubatingValues.COMPLETION), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes + .GenAiOperationNameIncubatingValues.CHAT), + equalTo(GEN_AI_REQUEST_MODEL, modelId)))), + metric -> + metric + .hasName("gen_ai.client.operation.duration") + .hasUnit("s") + .hasDescription("GenAI operation duration.") + .hasHistogramSatisfying( + histogram -> + histogram.hasPointsSatisfying( + point -> + point + .hasSumGreaterThan(0.0) + .hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo( + GEN_AI_OPERATION_NAME, + GenAiIncubatingAttributes + .GenAiOperationNameIncubatingValues.CHAT), + equalTo(GEN_AI_REQUEST_MODEL, modelId))))); + + SpanContext spanCtx = getTesting().waitForTraces(1).get(0).get(0).getSpanContext(); + + getTesting() + .waitAndAssertLogRecords( + log -> + log.hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), + equalTo(EVENT_NAME, "gen_ai.user.message")) + .hasSpanContext(spanCtx) + .hasBody( + Value.of( + KeyValue.of( + "content", Value.of("List out every country in the world")))), + log -> + log.hasAttributesSatisfyingExactly( + equalTo(GEN_AI_SYSTEM, AWS_BEDROCK), equalTo(EVENT_NAME, "gen_ai.choice")) + .hasSpanContext(spanCtx) + .hasBody( + Value.of( + KeyValue.of("finish_reason", Value.of("max_tokens")), + KeyValue.of("index", Value.of(0)), + KeyValue.of("content", Value.of(text.toString()))))); + } } diff --git a/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamamazonnova.yaml b/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamamazonnova.yaml new file mode 100644 index 000000000000..9b85dfdaa39c --- /dev/null +++ b/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamamazonnova.yaml @@ -0,0 +1,292 @@ +--- +id: 673bb5ea-ed38-4158-8dd5-d67cde544eca +name: model_amazonnova-micro-v10_invoke-with-response-stream +request: + url: /model/amazon.nova-micro-v1%3A0/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "messages" : [ { + "role" : "user", + "content" : [ { + "inputText" : "List out every country in the world" + } ] + } ], + "inferenceConfig" : { + "max_new_tokens" : 100, + "temperature" : 0.8, + "topP" : 1, + "stopSequences" : [ "|" ] + } + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 400 + body: "{\"message\":\"Malformed input request: #/messages/0/content/0: required\ + \ key [toolUse] not found, please reformat your input and try again.\"}" + headers: + Date: "Fri, 28 Mar 2025 01:58:41 GMT" + Content-Type: application/json + x-amzn-RequestId: e1e14f20-fc7a-474e-98c1-8a0b73fc8c3f + x-amzn-ErrorType: ValidationException:http://internal.amazon.com/coral/com.amazon.bedrock/ +uuid: 673bb5ea-ed38-4158-8dd5-d67cde544eca +persistent: true +insertionIndex: 34 +--- +id: 272efedf-e8eb-4821-a016-333113a18b6b +name: model_amazonnova-micro-v10_invoke-with-response-stream +request: + url: /model/amazon.nova-micro-v1%3A0/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "messages" : [ { + "role" : "user", + "content" : [ { + "inputText" : "Say this is a test" + } ] + } ], + "inferenceConfig" : { + "max_new_tokens" : 100, + "temperature" : 0.8, + "topP" : 1, + "stopSequences" : [ "|" ] + } + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 400 + body: "{\"message\":\"Malformed input request: #/messages/0/content/0: required\ + \ key [toolUse] not found, please reformat your input and try again.\"}" + headers: + Date: "Fri, 28 Mar 2025 01:59:57 GMT" + Content-Type: application/json + x-amzn-RequestId: e008be22-8a7f-4815-b17d-d8325cb7ee90 + x-amzn-ErrorType: ValidationException:http://internal.amazon.com/coral/com.amazon.bedrock/ +uuid: 272efedf-e8eb-4821-a016-333113a18b6b +persistent: true +insertionIndex: 36 +--- +id: 380cbe37-9195-43df-bd4f-1a51148edb80 +name: model_amazonnova-micro-v10_invoke-with-response-stream +request: + url: /model/amazon.nova-micro-v1%3A0/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "schemaVersion" : "messages-v1", + "messages" : [ { + "role" : "user", + "content" : [ { + "inputText" : "Say this is a test" + } ] + } ], + "inferenceConfig" : { + "max_new_tokens" : 100, + "temperature" : 0.8, + "topP" : 1, + "stopSequences" : [ "|" ] + } + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 400 + body: "{\"message\":\"Malformed input request: #/messages/0/content/0: required\ + \ key [toolUse] not found, please reformat your input and try again.\"}" + headers: + Date: "Fri, 28 Mar 2025 02:01:08 GMT" + Content-Type: application/json + x-amzn-RequestId: 19d4c945-21b0-4ae7-85ec-5d86f3405869 + x-amzn-ErrorType: ValidationException:http://internal.amazon.com/coral/com.amazon.bedrock/ +uuid: 380cbe37-9195-43df-bd4f-1a51148edb80 +persistent: true +insertionIndex: 38 +--- +id: 81d805de-09ed-4384-9202-7b571f447edc +name: model_amazonnova-micro-v10_invoke-with-response-stream +request: + url: /model/amazon.nova-micro-v1%3A0/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "schemaVersion" : "messages-v1", + "system" : [ { + "text" : "Act as an assistant. When the user asks a question, answer it with text." + } ], + "messages" : [ { + "role" : "user", + "content" : [ { + "inputText" : "Say this is a test" + } ] + } ], + "inferenceConfig" : { + "max_new_tokens" : 100, + "temperature" : 0.8, + "topP" : 1, + "stopSequences" : [ "|" ] + } + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 400 + body: "{\"message\":\"Malformed input request: #/messages/0/content/0: required\ + \ key [toolUse] not found, please reformat your input and try again.\"}" + headers: + Date: "Fri, 28 Mar 2025 02:02:34 GMT" + Content-Type: application/json + x-amzn-RequestId: 2eac1d96-1b34-4529-bebf-f466bc241f28 + x-amzn-ErrorType: ValidationException:http://internal.amazon.com/coral/com.amazon.bedrock/ +uuid: 81d805de-09ed-4384-9202-7b571f447edc +persistent: true +insertionIndex: 40 +--- +id: b025de6d-ef1c-4a6b-a55c-b0979b61d481 +name: model_amazonnova-micro-v10_invoke-with-response-stream +request: + url: /model/amazon.nova-micro-v1%3A0/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "messages" : [ { + "role" : "user", + "content" : [ { + "inputText" : "Say this is a test", + "toolUse" : null + } ] + } ], + "inferenceConfig" : { + "max_new_tokens" : 100, + "temperature" : 0.8, + "topP" : 1, + "stopSequences" : [ "|" ] + } + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 400 + body: "{\"message\":\"Malformed input request: #/messages/0/content/0: extraneous\ + \ key [inputText] is not permitted, please reformat your input and try again.\"\ + }" + headers: + Date: "Fri, 28 Mar 2025 02:02:57 GMT" + Content-Type: application/json + x-amzn-RequestId: 828b97e1-6608-4a4b-a3a6-5ebec0238c20 + x-amzn-ErrorType: ValidationException:http://internal.amazon.com/coral/com.amazon.bedrock/ +uuid: b025de6d-ef1c-4a6b-a55c-b0979b61d481 +persistent: true +insertionIndex: 42 +--- +id: e3f0d276-77fe-4987-89a5-6175487d7b72 +name: model_amazonnova-micro-v10_invoke-with-response-stream +request: + url: /model/amazon.nova-micro-v1%3A0/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "messages" : [ { + "role" : "user", + "content" : [ { + "text" : "List out every country in the world" + } ] + } ], + "inferenceConfig" : { + "max_new_tokens" : 100, + "temperature" : 0.8, + "topP" : 1, + "stopSequences" : [ "|" ] + } + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 200 + base64Body: AAAApwAAAEtGKwT3CzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SnRaWE56WVdkbFUzUmhjblFpT25zaWNtOXNaU0k2SW1GemMybHpkR0Z1ZENKOWZRPT0iLCJwIjoiYWJjZGUifZ0S/N0AAADpAAAAS6Ho4t8LOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaVRHbHpkR2x1WnlKOUxDSmpiMjUwWlc1MFFteHZZMnRKYm1SbGVDSTZNSDE5IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QSJ9gNPlpgAAAMYAAABL4nlaCgs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpvd2ZYMD0iLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQiJ9L1a4GAAAAOcAAABLHthcvgs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pSUdWMlpYSjVJbjBzSW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveGZYMD0iLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eSJ916tVmwAAANAAAABLDdk4KAs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveGZYMD0iLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0wifVdswnYAAAEjAAAAS8kRwQALOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaUlHTnZkVzUwY25rZ2FXNGdkR2hsSUhkdmNteGtJR2x6SW4wc0ltTnZiblJsYm5SQ2JHOWphMGx1WkdWNElqb3lmWDA9IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNDU2NzgifafqCBkAAADkAAAAS1l4Jm4LOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydFRkRzl3SWpwN0ltTnZiblJsYm5SQ2JHOWphMGx1WkdWNElqb3lmWDA9IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNDUifZmTaowAAAEFAAAAS4eQG6QLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaUlHRWdZMjl0Y0hKbGFHVnVjMmwyWlNKOUxDSmpiMjUwWlc1MFFteHZZMnRKYm1SbGVDSTZNMzE5IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFEifVF8lCMAAADXAAAAS7/55DgLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydFRkRzl3SWpwN0ltTnZiblJsYm5SQ2JHOWphMGx1WkdWNElqb3pmWDA9IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSUyJ9zyAteAAAAOQAAABLWXgmbgs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pSUhSaGMyc3NJR0oxZENCb1pYSmxJbjBzSW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpvMGZYMD0iLCJwIjoiYWJjZGVmZ2hpaiJ9aCK5gQAAAOIAAABL1jjTzgs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpvMGZYMD0iLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjMifRAx3lQAAAEIAAAAS38A3xULOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaUlHbHpJR0VnYkdsemRDSjlMQ0pqYjI1MFpXNTBRbXh2WTJ0SmJtUmxlQ0k2TlgxOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaMDEifU+e29gAAADTAAAAS0p5QvgLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydFRkRzl3SWpwN0ltTnZiblJsYm5SQ2JHOWphMGx1WkdWNElqbzFmWDA9IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PIn1W+csPAAAA3QAAAEv1SfyZCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lJRzltSUhSb1pTQWlmU3dpWTI5dWRHVnVkRUpzYjJOclNXNWtaWGdpT2paOWZRPT0iLCJwIjoiYWJjZGVmZ2hpamsifRG0ywkAAADCAAAASxf5/MoLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydFRkRzl3SWpwN0ltTnZiblJsYm5SQ2JHOWphMGx1WkdWNElqbzJmWDA9IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eCJ96HwFzQAAAOcAAABLHthcvgs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pTVRrMUluMHNJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam8zZlgwPSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQyJ9jnKQHAAAALAAAABLlOtPZQs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpvM2ZYMD0iLCJwIjoiYWJjZGVmIn3knky8AAAA9AAAAEs5mLHsCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lJSEpsWTI5bmJtbDZaV1FpZlN3aVkyOXVkR1Z1ZEVKc2IyTnJTVzVrWlhnaU9qaDlmUT09IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDRCJ9o+sxxAAAAMMAAABLKpnVegs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpvNGZYMD0iLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eSJ9uHy61wAAAPEAAABL8Xg+nAs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pSUhOdmRtVnlaV2xuYmlKOUxDSmpiMjUwWlc1MFFteHZZMnRKYm1SbGVDSTZPWDE5IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREUiffBLDigAAADnAAAASx7YXL4LOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydFRkRzl3SWpwN0ltTnZiblJsYm5SQ2JHOWphMGx1WkdWNElqbzVmWDA9IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNDU2NzgifdPz5TYAAADpAAAAS6Ho4t8LOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaUlITjBZWFJsY3lKOUxDSmpiMjUwWlc1MFFteHZZMnRKYm1SbGVDSTZNVEI5ZlE9PSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2dyJ9wrvyKAAAAOAAAABLrPiArgs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveE1IMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxIn3+MJnaAAAAzQAAAEuVqWsbCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lJR0Z6SW4wc0ltTnZiblJsYm5SQ2JHOWphMGx1WkdWNElqb3hNWDE5IiwicCI6ImFiYyJ9XftGlAAAANEAAABLMLkRmAs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveE1YMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNIn1riQm+AAAA8wAAAEuLuG38CzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lJRzltSUhSb1pTQnNZWFJsYzNRaWZTd2lZMjl1ZEdWdWRFSnNiMk5yU1c1a1pYZ2lPakV5ZlgwPSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5In04XtgTAAAAwgAAAEsX+fzKCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam94TW4xOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3gifQp/6oQAAAEQAAAASy+QA1YLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaUlIVndaR0YwWlhNNlhHNWNiaUo5TENKamIyNTBaVzUwUW14dlkydEpibVJsZUNJNk1UTjlmUT09IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMSJ92SpV1gAAAL0AAABLbHuL1As6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveE0zMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFycyJ9/WTWCQAAANMAAABLSnlC+As6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pSXlNakluMHNJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam94TkgxOSIsInAiOiJhYmNkZWZnaGkifeYxa/oAAADEAAAAS5i5CWoLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydFRkRzl3SWpwN0ltTnZiblJsYm5SQ2JHOWphMGx1WkdWNElqb3hOSDE5IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6In1SG+hTAAAA8QAAAEvxeD6cCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lJRUZtY21sallTSjlMQ0pqYjI1MFpXNTBRbXh2WTJ0SmJtUmxlQ0k2TVRWOWZRPT0iLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERSJ9QW5cWQAAALEAAABLqYtm1Qs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveE5YMTkiLCJwIjoiYWJjZGVmZyJ91IUwjQAAAOwAAABLaQhtrws6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pWEc0eExpQkJiR2RsY21saEluMHNJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam94Tm4xOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2In3YeR5nAAAAxwAAAEvfGXO6CzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam94Tm4xOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQyJ9+IgyUAAAAOAAAABLrPiArgs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pWEc0eUxpQkJibWR2YkdGY2JqTWlmU3dpWTI5dWRHVnVkRUpzYjJOclNXNWtaWGdpT2pFM2ZYMD0iLCJwIjoiYWJjZGVmIn3CiLVfAAAAyAAAAEtdSeRrCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam94TjMxOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0QifYZ5DZ8AAAEBAAAAS3IQvWQLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaUxpQkNaVzVwYmlKOUxDSmpiMjUwWlc1MFFteHZZMnRKYm1SbGVDSTZNVGg5ZlE9PSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRUlNUVSJ9bPRKWAAAALQAAABLYWvppQs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveE9IMTkiLCJwIjoiYWJjZGVmZ2hpaiJ9pwegCQAAARQAAABL2hCllgs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pWEc0MExpQkNiM1J6ZDJGdVlTSjlMQ0pqYjI1MFpXNTBRbXh2WTJ0SmJtUmxlQ0k2TVRsOWZRPT0iLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NSJ9HkNkOwAAALUAAABLXAvAFQs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveE9YMTkiLCJwIjoiYWJjZGVmZ2hpamsifXWhjIYAAAD4AAAAS/xoXO0LOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaVhHNDFMaUJDZFhKcmFXNWhJbjBzSW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveU1IMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSCJ9dgM5EgAAAMQAAABLmLkJags6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveU1IMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoifS7EZu8AAADQAAAASw3ZOCgLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaUlFWmhjMjhpZlN3aVkyOXVkR1Z1ZEVKc2IyTnJTVzVrWlhnaU9qSXhmWDA9IiwicCI6ImFiIn05JcgtAAAAvwAAAEsWu9i0CzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam95TVgxOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHUifWxuR6sAAAESAAAAS1VQUDYLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaVhHNDJMaUJDZFhKMWJtUnBJbjBzSW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveU1uMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTY3In2b4T3BAAAAwQAAAEtQWYYaCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam95TW4xOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2dyJ9JkDbUQAAAPMAAABLi7ht/As6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pWEc0M0xpQkRZV0p2SW4wc0ltTnZiblJsYm5SQ2JHOWphMGx1WkdWNElqb3lNMzE5IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGRyJ90cHfiwAAAL0AAABLbHuL1As6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveU0zMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFycyJ9y5ZG+gAAAP8AAABLTkiA/Qs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pSUZabGNtUmxJbjBzSW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveU5IMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWVyJ97BKIMgAAALgAAABLpJsEpAs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveU5IMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW4ifbSlRGQAAADeAAAAS7LphkkLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaVhHNDRMaUJEWVcxbGNtOXZiaUo5TENKamIyNTBaVzUwUW14dlkydEpibVJsZUNJNk1qVjlmUT09IiwicCI6ImFiY2QifRBXeFkAAADbAAAAS3oJCTkLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydFRkRzl3SWpwN0ltTnZiblJsYm5SQ2JHOWphMGx1WkdWNElqb3lOWDE5IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSU1RVVlcifcINbIsAAAEGAAAAS8AwYXQLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaVhHNDVMaUJEWlc1MGNtRnNJbjBzSW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveU5uMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWIn2XnKmDAAAAzwAAAEvvaTh7CzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam95Tm4xOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLIn1EbMovAAAA6gAAAEvmSJgPCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lJRUZtY21sallXNGlmU3dpWTI5dWRHVnVkRUpzYjJOclNXNWtaWGdpT2pJM2ZYMD0iLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4In3/kAJSAAAAxQAAAEul2SDaCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam95TjMxOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekEifbrinqEAAAENAAAAS7fgUGULOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaUlGSmxjSFZpYkdsalhHNHhNQ0o5TENKamIyNTBaVzUwUW14dlkydEpibVJsZUNJNk1qaDlmUT09IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWSJ9CG/kCgAAANQAAABL+Fme6As6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpveU9IMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QIn2HTY1KAAAA4QAAAEuRmKkeCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lMaUJEYUdGa0luMHNJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam95T1gxOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzIn2AUaTvAAAA1QAAAEvFObdYCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam95T1gxOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRIn0ZW8CeAAAA9wAAAEt+OMs8CzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lYRzR4TVNKOUxDSmpiMjUwWlc1MFFteHZZMnRKYm1SbGVDSTZNekI5ZlE9PSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OTyJ9V62F2wAAAMIAAABLF/n8ygs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpvek1IMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4In0aLCIEAAABCwAAAEs4oKXFCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lMaUJEYjIxdmNtOXpJbjBzSW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpvek1YMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0In2nhJwaAAAAsQAAAEupi2bVCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam96TVgxOSIsInAiOiJhYmNkZWZnIn2f6Hw6AAAA+wAAAEu7yCY9CzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lYRzR4TWk0Z1EyOXVaMjhpZlN3aVkyOXVkR1Z1ZEVKc2IyTnJTVzVrWlhnaU9qTXlmWDA9IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSksifReSvYkAAAC/AAAASxa72LQLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydFRkRzl3SWpwN0ltTnZiblJsYm5SQ2JHOWphMGx1WkdWNElqb3pNbjE5IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dSJ94L4ZDwAAANQAAABL+Fme6As6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pTENKOUxDSmpiMjUwWlc1MFFteHZZMnRKYm1SbGVDSTZNek45ZlE9PSIsInAiOiJhYmNkZWZnaGlqIn1neFyKAAAA2wAAAEt6CQk5CzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam96TTMxOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXIn382vW/AAABEQAAAEsS8CrmCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lJRVJsYlc5amNtRjBhV01nVW1Wd2RXSnNhV01nYjJZaWZTd2lZMjl1ZEdWdWRFSnNiMk5yU1c1a1pYZ2lPak0wZlgwPSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRIn0wsLpVAAAAuQAAAEuZ+y0UCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam96TkgxOSIsInAiOiJhYmNkZWZnaGlqa2xtbm8ifdGzvwgAAADgAAAAS6z4gK4LOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKamIyNTBaVzUwUW14dlkydEVaV3gwWVNJNmV5SmtaV3gwWVNJNmV5SjBaWGgwSWpvaUlIUm9aU0o5TENKamIyNTBaVzUwUW14dlkydEpibVJsZUNJNk16VjlmUT09IiwicCI6ImFiY2RlZmdoaWprbG1ub3BxciJ9MLMBggAAAL0AAABLbHuL1As6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0VGRHOXdJanA3SW1OdmJuUmxiblJDYkc5amEwbHVaR1Y0SWpvek5YMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFycyJ9NR2kCAAAAPIAAABLtthETAs6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUpqYjI1MFpXNTBRbXh2WTJ0RVpXeDBZU0k2ZXlKa1pXeDBZU0k2ZXlKMFpYaDBJam9pWEc0aWZTd2lZMjl1ZEdWdWRFSnNiMk5yU1c1a1pYZ2lPak0yZlgwPSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OIn3dbbi/AAAA5wAAAEse2Fy+CzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam96Tm4xOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaMDEyMzQ1Njc4In0dKgdrAAAA7QAAAEtUaEQfCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRFWld4MFlTSTZleUprWld4MFlTSTZleUowWlhoMElqb2lNVE11SUVOdmJtZHZMQ0JTWlhCMVlteHBZeUo5TENKamIyNTBaVzUwUW14dlkydEpibVJsZUNJNk16ZDlmUT09IiwicCI6ImFiY2RlZmdoaWprIn2xBkqQAAAA2AAAAEs9qXPpCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SmpiMjUwWlc1MFFteHZZMnRUZEc5d0lqcDdJbU52Ym5SbGJuUkNiRzlqYTBsdVpHVjRJam96TjMxOSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRUlNUIn1JRR6+AAAA5AAAAEtZeCZuCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SnRaWE56WVdkbFUzUnZjQ0k2ZXlKemRHOXdVbVZoYzI5dUlqb2liV0Y0WDNSdmEyVnVjeUo5ZlE9PSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaMDEyMzQ1In00I+xUAAACXwAAAEtzp75gCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SnRaWFJoWkdGMFlTSTZleUoxYzJGblpTSTZleUpwYm5CMWRGUnZhMlZ1Y3lJNk55d2liM1YwY0hWMFZHOXJaVzV6SWpveE1EQXNJbU5oWTJobFVtVmhaRWx1Y0hWMFZHOXJaVzVEYjNWdWRDSTZNQ3dpWTJGamFHVlhjbWwwWlVsdWNIVjBWRzlyWlc1RGIzVnVkQ0k2TUgwc0ltMWxkSEpwWTNNaU9udDlMQ0owY21GalpTSTZlMzE5TENKaGJXRjZiMjR0WW1Wa2NtOWpheTFwYm5adlkyRjBhVzl1VFdWMGNtbGpjeUk2ZXlKcGJuQjFkRlJ2YTJWdVEyOTFiblFpT2pjc0ltOTFkSEIxZEZSdmEyVnVRMjkxYm5RaU9qRXdNQ3dpYVc1MmIyTmhkR2x2Ymt4aGRHVnVZM2tpT2pRNE9Td2labWx5YzNSQ2VYUmxUR0YwWlc1amVTSTZOVE1zSW1OaFkyaGxVbVZoWkVsdWNIVjBWRzlyWlc1RGIzVnVkQ0k2TUN3aVkyRmphR1ZYY21sMFpVbHVjSFYwVkc5clpXNURiM1Z1ZENJNk1IMTkiLCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTY3OCJ9RjQ/Ug== + headers: + Date: "Fri, 28 Mar 2025 02:03:46 GMT" + Content-Type: application/vnd.amazon.eventstream + x-amzn-RequestId: 7807282d-27d0-44cd-be29-878e8e42d9b8 + X-Amzn-Bedrock-Content-Type: application/json +uuid: e3f0d276-77fe-4987-89a5-6175487d7b72 +persistent: true +insertionIndex: 44 +--- +id: 538f5122-e948-4806-b568-5c935e6a4c28 +name: model_amazonnova-micro-v10_invoke-with-response-stream +request: + url: /model/amazon.nova-micro-v1%3A0/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "messages" : [ { + "role" : "user", + "content" : [ { + "text" : "List out every country in the world" + } ] + } ], + "inferenceConfig" : { + "max_new_tokens" : 100, + "temperature" : 0.8, + "topP" : 1, + "stopSequences" : [ "|" ] + } + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 200 + base64Body: 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 + headers: + Date: "Fri, 28 Mar 2025 02:04:21 GMT" + Content-Type: application/vnd.amazon.eventstream + x-amzn-RequestId: 83929b9a-2b7d-48a7-a270-2172da89c69b + X-Amzn-Bedrock-Content-Type: application/json +uuid: 538f5122-e948-4806-b568-5c935e6a4c28 +persistent: true +insertionIndex: 46 +--- +id: 79631f48-2266-4932-9042-ccac8536f8ad +name: model_amazonnova-micro-v10_invoke-with-response-stream +request: + url: /model/amazon.nova-micro-v1%3A0/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "messages" : [ { + "role" : "user", + "content" : [ { + "text" : "List out every country in the world" + } ] + } ], + "inferenceConfig" : { + "max_new_tokens" : 100, + "temperature" : 0.8, + "topP" : 1, + "stopSequences" : [ "|" ] + } + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 200 + base64Body: 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 + headers: + Date: "Fri, 28 Mar 2025 02:06:28 GMT" + Content-Type: application/vnd.amazon.eventstream + x-amzn-RequestId: d877c9dc-e31d-4063-a1a7-f26fd3e6175b + X-Amzn-Bedrock-Content-Type: application/json +uuid: 79631f48-2266-4932-9042-ccac8536f8ad +persistent: true +insertionIndex: 48 diff --git a/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamamazontitan.yaml b/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamamazontitan.yaml new file mode 100644 index 000000000000..f1299c1dea34 --- /dev/null +++ b/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamamazontitan.yaml @@ -0,0 +1,103 @@ +--- +id: 10b1cbb3-d686-4e00-8709-60490f090c00 +name: model_amazontitan-text-lite-v1_invoke-with-response-stream +request: + url: /model/amazon.titan-text-lite-v1/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "inputText" : "List out every country in the world", + "textGenerationConfig" : { } + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 200 + base64Body: AAABmgAAAEvUxqtlCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SnZkWFJ3ZFhSVVpYaDBJam9pWEc1SVpYSmxJR2x6SUdFZ2JHbHpkQ0J2WmlCbGRtVnllU0JqYjNWdWRISjVJR2x1SUhSb1pTQjNiM0pzWkRwY2JqRXVJRUZtWjJoaGJtbHpkR0Z1WEc0eUxpQkJiR0poYm1saFhHNHpMaUJCYkdkbGNtbGhYRzRpTENKcGJtUmxlQ0k2TUN3aWRHOTBZV3hQZFhSd2RYUlVaWGgwVkc5clpXNURiM1Z1ZENJNmJuVnNiQ3dpWTI5dGNHeGxkR2x2YmxKbFlYTnZiaUk2Ym5Wc2JDd2lhVzV3ZFhSVVpYaDBWRzlyWlc1RGIzVnVkQ0k2TjMwPSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUoifaI5xSsAAANjAAAAS9wqOEILOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKdmRYUndkWFJVWlhoMElqb2lOQzRnUVc1a2IzSnlZVnh1TlM0Z1FXNW5iMnhoWEc0MkxpQkJiblJwWjNWaElHRnVaQ0JDWVhKaWRXUmhYRzQzTGlCQmNtZGxiblJwYm1GY2JqZ3VJRUZ5YldWdWFXRmNiamt1SUVGMWMzUnlZV3hwWVZ4dU1UQXVJRUYxYzNSeWFXRmNiakV4TGlCQmVtVnlZbUZwYW1GdVhHNHhNaTRnUW1Gb1lXMWhjMXh1TVRNdUlFSmhhSEpoYVc1Y2JqRTBMaUJDWVc1bmJHRmtaWE5vWEc0eE5TNGdRbUZ5WW1Ga2IzTmNiakUyTGlCQ1pXeGhjblZ6WEc0eE55NGdRbVZzWjJsMWJWeHVNVGd1SUVKbGJHbDZaVnh1TVRrdUlFSmxibWx1WEc0eU1DNGdRbWgxZEdGdVhHNHlNUzRnUW05c2FYWnBZVnh1TWpJdUlFSnZjMjVwWVNCaGJtUWdTR1Z5ZW1WbmIzWnBibUZjYmpJekxpQkNiM1J6ZDJGdVlWeHVNaUlzSW1sdVpHVjRJam93TENKMGIzUmhiRTkxZEhCMWRGUmxlSFJVYjJ0bGJrTnZkVzUwSWpveE1qZ3NJbU52YlhCc1pYUnBiMjVTWldGemIyNGlPaUpNUlU1SFZFZ2lMQ0pwYm5CMWRGUmxlSFJVYjJ0bGJrTnZkVzUwSWpwdWRXeHNMQ0poYldGNmIyNHRZbVZrY205amF5MXBiblp2WTJGMGFXOXVUV1YwY21samN5STZleUpwYm5CMWRGUnZhMlZ1UTI5MWJuUWlPamNzSW05MWRIQjFkRlJ2YTJWdVEyOTFiblFpT2pFeU9Dd2lhVzUyYjJOaGRHbHZia3hoZEdWdVkza2lPak0xT0RVc0ltWnBjbk4wUW5sMFpVeGhkR1Z1WTNraU9qSXlPRFI5ZlE9PSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRUlMifTosKEc= + headers: + Date: "Thu, 27 Mar 2025 05:10:04 GMT" + Content-Type: application/vnd.amazon.eventstream + x-amzn-RequestId: 978fca69-512c-4317-8dbf-d1bf1414b51c + X-Amzn-Bedrock-Content-Type: application/json +uuid: 10b1cbb3-d686-4e00-8709-60490f090c00 +persistent: true +insertionIndex: 26 +--- +id: 62b3c54e-006a-4bb2-99de-a7899500e481 +name: model_amazontitan-text-lite-v1_invoke-with-response-stream +request: + url: /model/amazon.titan-text-lite-v1/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "inputText" : "List out every country in the world" + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 200 + base64Body: AAAC0QAAAEt9cbCTCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SnZkWFJ3ZFhSVVpYaDBJam9pWEc1SVpYSmxJR2x6SUdFZ2JHbHpkQ0J2WmlCbGRtVnllU0JqYjNWdWRISjVJR2x1SUhSb1pTQjNiM0pzWkRwY2JqRXVJRlZ1YVhSbFpDQlRkR0YwWlhOY2JqSXVJRU5vYVc1aFhHNHpMaUJKYm1ScFlWeHVOQzRnU1c1a2IyNWxjMmxoWEc0MUxpQkNjbUY2YVd4Y2JqWXVJRkoxYzNOcFlWeHVOeTRnUTJGdVlXUmhYRzQ0TGlCVmJtbDBaV1FnUzJsdVoyUnZiVnh1T1M0Z1IyVnliV0Z1ZVZ4dU1UQXVJRVp5WVc1alpTSXNJbWx1WkdWNElqb3dMQ0owYjNSaGJFOTFkSEIxZEZSbGVIUlViMnRsYmtOdmRXNTBJam8xTml3aVkyOXRjR3hsZEdsdmJsSmxZWE52YmlJNklrWkpUa2xUU0NJc0ltbHVjSFYwVkdWNGRGUnZhMlZ1UTI5MWJuUWlPamNzSW1GdFlYcHZiaTFpWldSeWIyTnJMV2x1ZG05allYUnBiMjVOWlhSeWFXTnpJanA3SW1sdWNIVjBWRzlyWlc1RGIzVnVkQ0k2Tnl3aWIzVjBjSFYwVkc5clpXNURiM1Z1ZENJNk5UWXNJbWx1ZG05allYUnBiMjVNWVhSbGJtTjVJam95TURneUxDSm1hWEp6ZEVKNWRHVk1ZWFJsYm1ONUlqb3lNRGd4ZlgwPSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaMDEyMzQ1NiJ9Co2+Lw== + headers: + Date: "Thu, 27 Mar 2025 05:41:59 GMT" + Content-Type: application/vnd.amazon.eventstream + x-amzn-RequestId: 836bf587-0584-46f3-a409-3afcbe3f25ec + X-Amzn-Bedrock-Content-Type: application/json +uuid: 62b3c54e-006a-4bb2-99de-a7899500e481 +persistent: true +insertionIndex: 28 +--- +id: 22299a58-5fd6-4778-89c1-99b1bea21cf6 +name: model_amazontitan-text-lite-v1_invoke-with-response-stream +request: + url: /model/amazon.titan-text-lite-v1/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "inputText" : "List out every country in the world" + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 200 + base64Body: AAABrwAAAEu9B5yTCzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SnZkWFJ3ZFhSVVpYaDBJam9pWEc1SVpYSmxJR2x6SUdFZ2JHbHpkQ0J2WmlCaGJHd2dkR2hsSUdOdmRXNTBjbWxsY3lCcGJpQjBhR1VnZDI5eWJHUTZYRzVjYmpFdUlGVnVhWFJsWkNCVGRHRjBaWE1nYjJZZ1FXMWxjbWxqWVZ4dU1pNGdTU0lzSW1sdVpHVjRJam93TENKMGIzUmhiRTkxZEhCMWRGUmxlSFJVYjJ0bGJrTnZkVzUwSWpwdWRXeHNMQ0pqYjIxd2JHVjBhVzl1VW1WaGMyOXVJanB1ZFd4c0xDSnBibkIxZEZSbGVIUlViMnRsYmtOdmRXNTBJam8zZlE9PSIsInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaMDEyMzQifSsPp2gAAAMjAAAAS4TZYAsLOmV2ZW50LXR5cGUHAAVjaHVuaw06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImJ5dGVzIjoiZXlKdmRYUndkWFJVWlhoMElqb2libVJ2Ym1WemFXRmNiak11SUVKeVlYcHBiRnh1TkM0Z1EyaHBibUZjYmpVdUlGSjFjM05wWVZ4dU5pNGdRMkZ1WVdSaFhHNDNMaUJWYm1sMFpXUWdTMmx1WjJSdmJWeHVPQzRnUjJWeWJXRnVlVnh1T1M0Z1JuSmhibU5sWEc0eE1DNGdTWFJoYkhsY2JqRXhMaUJCZFhOMGNtRnNhV0ZjYmpFeUxpQkpibVJwWVZ4dU1UTXVJRXBoY0dGdVhHNHhOQzRnVTNCaGFXNWNiakUxTGlCVWRYSnJaWGxjYmpFMkxpQlFhR2xzYVhCd2FXNWxjMXh1TVRjdUlGWnBaWFJ1WVcxY2JqRTRMaUJGWjNsd2RGeHVNVGt1SUVseVlXNWNiakl3TGlCVGIzVjBhQ0JMYjNKbFlWeHVNakV1SUZSb1lXbHNZVzVrWEc0eU1pNGdUV1Y0YVdOdlhHNHlNeTRnVUdWeWRWeHVNalF1SWl3aWFXNWtaWGdpT2pBc0luUnZkR0ZzVDNWMGNIVjBWR1Y0ZEZSdmEyVnVRMjkxYm5RaU9qRXlPQ3dpWTI5dGNHeGxkR2x2YmxKbFlYTnZiaUk2SWt4RlRrZFVTQ0lzSW1sdWNIVjBWR1Y0ZEZSdmEyVnVRMjkxYm5RaU9tNTFiR3dzSW1GdFlYcHZiaTFpWldSeWIyTnJMV2x1ZG05allYUnBiMjVOWlhSeWFXTnpJanA3SW1sdWNIVjBWRzlyWlc1RGIzVnVkQ0k2Tnl3aWIzVjBjSFYwVkc5clpXNURiM1Z1ZENJNk1USTRMQ0pwYm5adlkyRjBhVzl1VEdGMFpXNWplU0k2TXpreU9Td2labWx5YzNSQ2VYUmxUR0YwWlc1amVTSTZNalF5TVgxOSIsInAiOiJhYmNkZSJ9n2TgQg== + headers: + Date: "Thu, 27 Mar 2025 07:31:42 GMT" + Content-Type: application/vnd.amazon.eventstream + x-amzn-RequestId: fa312770-8231-4acc-a478-b21363af4eb4 + X-Amzn-Bedrock-Content-Type: application/json +uuid: 22299a58-5fd6-4778-89c1-99b1bea21cf6 +persistent: true +insertionIndex: 30 +--- +id: 99dd8812-89f5-48d0-a5b7-09e43bd4a264 +name: model_amazontitan-text-lite-v1_invoke-with-response-stream +request: + url: /model/amazon.titan-text-lite-v1/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "inputText" : "List out every country in the world", + "textGenerationConfig" : { + "maxTokenCount" : 100, + "temperature" : 0.8, + "topP" : 1, + "stopSequences" : [ "|" ] + } + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 200 + base64Body: AAABgQAAAEvD9g32CzpldmVudC10eXBlBwAFY2h1bmsNOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJieXRlcyI6ImV5SnZkWFJ3ZFhSVVpYaDBJam9pWEc1SVpYSmxJR2x6SUhSb1pTQnNhWE4wSUc5bUlHVjJaWEo1SUdOdmRXNTBjbmtnYVc0Z2RHaGxJSGR2Y214a09seHVNUzRnUVdabmFHRnVhWE4wWVc1Y2JqSXVJRUZzWW1GdWFXRmNiak11SUVGc1oyVnlhV0ZjYmlJc0ltbHVaR1Y0SWpvd0xDSjBiM1JoYkU5MWRIQjFkRlJsZUhSVWIydGxia052ZFc1MElqcHVkV3hzTENKamIyMXdiR1YwYVc5dVVtVmhjMjl1SWpwdWRXeHNMQ0pwYm5CMWRGUmxlSFJVYjJ0bGJrTnZkVzUwSWpvM2ZRPT0iLCJwIjoiYWJjZGVmZyJ9uZ/zNgAAAtEAAABLfXGwkws6ZXZlbnQtdHlwZQcABWNodW5rDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiYnl0ZXMiOiJleUp2ZFhSd2RYUlVaWGgwSWpvaU5DNGdRVzVrYjNKeVlWeHVOUzRnUVc1bmIyeGhYRzQyTGlCQmJuUnBaM1ZoSUdGdVpDQkNZWEppZFdSaFhHNDNMaUJCY21kbGJuUnBibUZjYmpndUlFRnliV1Z1YVdGY2Jqa3VJRUYxYzNSeVlXeHBZVnh1TVRBdUlFRjFjM1J5YVdGY2JqRXhMaUJCZW1WeVltRnBhbUZ1WEc0eE1pNGdRbUZvWVcxaGMxeHVNVE11SUVKaGFISmhhVzVjYmpFMExpQkNZVzVuYkdGa1pYTm9YRzR4TlM0Z1FtRnlZbUZrYjNOY2JqRTJMaUJDWld4aGNuVnpYRzR4Tnk0Z1FtVnNaMmwxYlZ4dU1UZ3VJRUpsYkdsNlpWeHVNVGtpTENKcGJtUmxlQ0k2TUN3aWRHOTBZV3hQZFhSd2RYUlVaWGgwVkc5clpXNURiM1Z1ZENJNk1UQXdMQ0pqYjIxd2JHVjBhVzl1VW1WaGMyOXVJam9pVEVWT1IxUklJaXdpYVc1d2RYUlVaWGgwVkc5clpXNURiM1Z1ZENJNmJuVnNiQ3dpWVcxaGVtOXVMV0psWkhKdlkyc3RhVzUyYjJOaGRHbHZiazFsZEhKcFkzTWlPbnNpYVc1d2RYUlViMnRsYmtOdmRXNTBJam8zTENKdmRYUndkWFJVYjJ0bGJrTnZkVzUwSWpveE1EQXNJbWx1ZG05allYUnBiMjVNWVhSbGJtTjVJam95T1RNMUxDSm1hWEp6ZEVKNWRHVk1ZWFJsYm1ONUlqb3lNVGMxZlgwPSIsInAiOiJhYmMifS8psqs= + headers: + Date: "Thu, 27 Mar 2025 07:48:37 GMT" + Content-Type: application/vnd.amazon.eventstream + x-amzn-RequestId: f527236b-19c4-49dd-beed-07d8ac6b3493 + X-Amzn-Bedrock-Content-Type: application/json +uuid: 99dd8812-89f5-48d0-a5b7-09e43bd4a264 +persistent: true +insertionIndex: 32 diff --git a/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamanthropicclaude.yaml b/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamanthropicclaude.yaml new file mode 100644 index 000000000000..8da7f696ac97 --- /dev/null +++ b/instrumentation/aws-sdk/aws-sdk-2.2/testing/src/main/resources/mappings/io.opentelemetry.instrumentation.awssdk.v2_2.abstractaws2bedrockruntimetest.testinvokemodelwithresponsestreamanthropicclaude.yaml @@ -0,0 +1,35 @@ +--- +id: 19285e5a-e4ee-4a69-a081-66e553ee1066 +name: model_anthropicclaude-v2_invoke-with-response-stream +request: + url: /model/anthropic.claude-v2/invoke-with-response-stream + method: POST + bodyPatterns: + - equalToJson: |- + { + "messages" : [ { + "role" : "user", + "content" : [ { + "text" : "List out every country in the world", + "type" : "text" + } ] + } ], + "anthropic_version" : "bedrock-2023-05-31", + "max_tokens" : 10, + "temperature" : 0.8, + "top_p" : 1, + "stop_sequences" : [ "|" ] + } + ignoreArrayOrder: false + ignoreExtraElements: false +response: + status: 200 + base64Body: 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 + headers: + Date: "Fri, 28 Mar 2025 02:49:20 GMT" + Content-Type: application/vnd.amazon.eventstream + x-amzn-RequestId: 2fe45f4c-8936-41bc-b52b-6e4b20902193 + X-Amzn-Bedrock-Content-Type: application/json +uuid: 19285e5a-e4ee-4a69-a081-66e553ee1066 +persistent: true +insertionIndex: 50 From a9cb322f7043175e291329cefb8d8809362c501d Mon Sep 17 00:00:00 2001 From: Anuraag Agrawal Date: Tue, 8 Apr 2025 11:56:16 +0900 Subject: [PATCH 2/2] Fix typo --- .../awssdk/v2_2/internal/BedrockRuntimeImpl.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/instrumentation/aws-sdk/aws-sdk-2.2/library/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/internal/BedrockRuntimeImpl.java b/instrumentation/aws-sdk/aws-sdk-2.2/library/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/internal/BedrockRuntimeImpl.java index e6bbe5e4353a..7e978238908d 100644 --- a/instrumentation/aws-sdk/aws-sdk-2.2/library/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/internal/BedrockRuntimeImpl.java +++ b/instrumentation/aws-sdk/aws-sdk-2.2/library/src/main/java/io/opentelemetry/instrumentation/awssdk/v2_2/internal/BedrockRuntimeImpl.java @@ -1116,7 +1116,7 @@ protected void handleEvent(ResponseStream event) { } else if (requestModel.startsWith("amazon.nova")) { handleEventAmazonNova(result); } else if (requestModel.startsWith("anthropic.claude")) { - handleEventAnthropicCloud(result); + handleEventAnthropicClaude(result); } } @@ -1222,7 +1222,7 @@ private void handleEventAmazonNova(Document result) { } } - private void handleEventAnthropicCloud(Document result) { + private void handleEventAnthropicClaude(Document result) { Document type = result.asMap().get("type"); if (type == null || !type.isString()) { return;