@telemetry-dev/bedrock 0.1.0

package/src/converse.ts

@@ -0,0 +1,390 @@
+import type { SpanFields } from "@telemetry-dev/sdk";
+
+import {
+  arrayValue,
+  awsMetadataFields,
+  isRecord,
+  mergeFields,
+  modeledStreamError,
+  numberValue,
+  omitUndefined,
+  parseJson,
+  PROVIDER,
+  stringValue,
+  type StreamState,
+} from "./internal.ts";
+
+export type MessagePart = Record<string, unknown>;
+export interface NormalizedMessage {
+  role: string | undefined;
+  parts: MessagePart[];
+  finish_reason?: string;
+}
+
+export function converseRequestFields(input: Record<string, unknown>): SpanFields {
+  const inference = isRecord(input.inferenceConfig) ? input.inferenceConfig : {};
+  const guardrail = isRecord(input.guardrailConfig) ? input.guardrailConfig : undefined;
+  return omitUndefined({
+    provider: PROVIDER,
+    model: stringValue(input.modelId),
+    input: normalizeMessages(input.messages),
+    systemInstructions: normalizeSystem(input.system),
+    temperature: numberValue(inference.temperature),
+    topP: numberValue(inference.topP),
+    maxTokens: numberValue(inference.maxTokens),
+    stopSequences: arrayValue<string>(inference.stopSequences),
+    metadata: guardrail
+      ? omitUndefined({
+          guardrail_id: stringValue(guardrail.guardrailIdentifier),
+          guardrail_version: stringValue(guardrail.guardrailVersion),
+        })
+      : undefined,
+  });
+}
+
+export function converseResponseFields(output: unknown): SpanFields {
+  const result = isRecord(output) ? output : {};
+  const usage = usageFromConverse(result.usage);
+  const metrics = isRecord(result.metrics) ? result.metrics : undefined;
+  const trace = isRecord(result.trace) ? result.trace : undefined;
+  const promptRouter = isRecord(trace?.promptRouter) ? trace?.promptRouter : undefined;
+  const guardrail = isRecord(trace?.guardrail) ? trace?.guardrail : undefined;
+  const stopReason = stringValue(result.stopReason);
+  const message = isRecord(result.output) ? result.output.message : undefined;
+  return mergeFields(awsMetadataFields(result.$metadata), {
+    output: normalizeOutputMessage(message, stopReason),
+    usage,
+    finishReason: stopReason,
+    responseModel: stringValue(promptRouter?.invokedModelId),
+    metadata: omitUndefined({
+      server_latency_ms: numberValue(metrics?.latencyMs),
+      guardrail_action: stringValue(result.guardrailAction) ?? stringValue(guardrail?.action),
+      guardrail_action_reason: stringValue(guardrail?.actionReason),
+    }),
+  });
+}
+
+export function usageFromConverse(value: unknown): SpanFields["usage"] | undefined {
+  if (!isRecord(value)) return undefined;
+  return omitUndefined({
+    inputTokens: numberValue(value.inputTokens),
+    outputTokens: numberValue(value.outputTokens),
+    totalTokens: numberValue(value.totalTokens),
+    cacheReadInputTokens: numberValue(value.cacheReadInputTokens),
+    cacheCreationInputTokens: numberValue(value.cacheWriteInputTokens),
+  });
+}
+
+export function normalizeMessages(value: unknown): NormalizedMessage[] | undefined {
+  const messages = arrayValue<Record<string, unknown>>(value);
+  if (!messages) return undefined;
+  return messages.map((message) => ({
+    role: stringValue(message.role),
+    parts: normalizeContentList(message.content),
+  }));
+}
+
+export function normalizeOutputMessage(
+  value: unknown,
+  finishReason?: string,
+): NormalizedMessage[] | undefined {
+  if (!isRecord(value)) return undefined;
+  return [
+    omitUndefined({
+      role: stringValue(value.role),
+      parts: normalizeContentList(value.content),
+      finish_reason: finishReason,
+    }) as NormalizedMessage,
+  ];
+}
+
+export function normalizeSystem(value: unknown): MessagePart[] | undefined {
+  const blocks = arrayValue<Record<string, unknown>>(value);
+  if (!blocks) return undefined;
+  const parts = blocks.flatMap((block) => normalizeContentBlock(block));
+  return parts.length > 0 ? parts : undefined;
+}
+
+function normalizeContentList(value: unknown): MessagePart[] {
+  const blocks = arrayValue<Record<string, unknown>>(value);
+  if (!blocks) return [];
+  return blocks.flatMap((block) => normalizeContentBlock(block));
+}
+
+function normalizeContentBlock(block: Record<string, unknown>): MessagePart[] {
+  const text = stringValue(block.text);
+  if (text !== undefined)
+    return [
+      omitUndefined({
+        type: "text",
+        content: text,
+        citations: arrayValue<unknown>(block.citations),
+      }),
+    ];
+
+  const toolUse = isRecord(block.toolUse) ? block.toolUse : undefined;
+  if (toolUse) {
+    return [
+      omitUndefined({
+        type: "tool_call",
+        id: stringValue(toolUse.toolUseId),
+        name: stringValue(toolUse.name),
+        arguments: toolUse.input,
+      }),
+    ];
+  }
+
+  const toolResult = isRecord(block.toolResult) ? block.toolResult : undefined;
+  if (toolResult) {
+    return [
+      omitUndefined({
+        type: "tool_call_response",
+        id: stringValue(toolResult.toolUseId),
+        response: simplifyToolResult(toolResult.content),
+      }),
+    ];
+  }
+
+  const reasoning = isRecord(block.reasoningContent) ? block.reasoningContent : undefined;
+  if (reasoning) {
+    const reasoningText = isRecord(reasoning.reasoningText) ? reasoning.reasoningText : undefined;
+    return [
+      {
+        type: "reasoning",
+        content:
+          stringValue(reasoningText?.text) ?? (reasoning.redactedContent ? "[redacted]" : ""),
+      },
+    ];
+  }
+
+  for (const modality of ["image", "document", "video", "audio"] as const) {
+    const media = isRecord(block[modality]) ? block[modality] : undefined;
+    if (!media) continue;
+    const format = stringValue(media.format);
+    const source = isRecord(media.source) ? media.source : undefined;
+    if (source?.bytes !== undefined) {
+      return [
+        omitUndefined({
+          type: "blob",
+          modality,
+          mime_type: format ? `${modality}/${format}` : undefined,
+        }),
+      ];
+    }
+    const s3 = isRecord(source?.s3Location) ? source?.s3Location : undefined;
+    const uri = stringValue(source?.uri) ?? stringValue(s3?.uri) ?? s3Uri(s3);
+    if (uri) return [omitUndefined({ type: "uri", uri, modality, mime_type: format })];
+  }
+
+  const citationsContent = isRecord(block.citationsContent) ? block.citationsContent : undefined;
+  if (citationsContent) {
+    const contentBlocks = arrayValue<Record<string, unknown>>(citationsContent.content) ?? [];
+    const citations = arrayValue<unknown>(citationsContent.citations);
+    return contentBlocks.flatMap((contentBlock) =>
+      normalizeContentBlock(citations ? { ...contentBlock, citations } : contentBlock),
+    );
+  }
+
+  const guardContent = isRecord(block.guardContent) ? block.guardContent : undefined;
+  if (guardContent) {
+    const guardText = isRecord(guardContent.text) ? guardContent.text : undefined;
+    const content = stringValue(guardText?.text) ?? stringValue(guardContent.text);
+    if (content) return [{ type: "text", content }];
+  }
+
+  try {
+    return [{ type: "text", content: JSON.stringify(block) }];
+  } catch {
+    return [{ type: "text", content: "[unsupported content block]" }];
+  }
+}
+
+function simplifyToolResult(content: unknown): unknown {
+  const blocks = arrayValue<Record<string, unknown>>(content);
+  if (!blocks) return content;
+  if (blocks.length === 1 && typeof blocks[0]?.text === "string") return blocks[0].text;
+  return blocks.flatMap((block) => normalizeContentBlock(block));
+}
+
+function s3Uri(value: Record<string, unknown> | undefined): string | undefined {
+  const bucket = stringValue(value?.bucket);
+  const key = stringValue(value?.key);
+  return bucket && key ? `s3://${bucket}/${key}` : undefined;
+}
+
+interface StreamBlock {
+  kind: "text" | "tool" | "reasoning" | "content";
+  text?: string;
+  toolUseId?: string;
+  name?: string;
+  input?: string;
+  content?: Record<string, unknown>;
+  citations?: unknown[];
+}
+
+export class ConverseStreamState implements StreamState {
+  private role = "assistant";
+  private readonly blocks = new Map<number, StreamBlock>();
+  private stopReason: string | undefined;
+  private usage: SpanFields["usage"];
+  private metadata: Record<string, unknown> = {};
+  private responseModel: string | undefined;
+  private error: Error | undefined;
+  private errorFields: SpanFields | undefined;
+
+  feed(event: unknown): void {
+    if (!isRecord(event)) return;
+    const streamError = modeledStreamError(event);
+    if (streamError) {
+      this.error = streamError.error;
+      this.errorFields = streamError.fields;
+      return;
+    }
+    const messageStart = isRecord(event.messageStart) ? event.messageStart : undefined;
+    if (messageStart) this.role = stringValue(messageStart.role) ?? this.role;
+
+    const blockStart = isRecord(event.contentBlockStart) ? event.contentBlockStart : undefined;
+    if (blockStart) {
+      const index = numberValue(blockStart.contentBlockIndex) ?? this.blocks.size;
+      const start = isRecord(blockStart.start) ? blockStart.start : undefined;
+      const toolUse = isRecord(start?.toolUse) ? start?.toolUse : undefined;
+      const toolResult = isRecord(start?.toolResult) ? start?.toolResult : undefined;
+      const image = isRecord(start?.image) ? start?.image : undefined;
+      this.blocks.set(
+        index,
+        toolUse
+          ? {
+              kind: "tool",
+              toolUseId: stringValue(toolUse.toolUseId),
+              name: stringValue(toolUse.name),
+              input: "",
+            }
+          : toolResult
+            ? {
+                kind: "content",
+                content: {
+                  toolResult: omitUndefined({
+                    toolUseId: stringValue(toolResult.toolUseId),
+                    status: stringValue(toolResult.status),
+                    content: [],
+                  }),
+                },
+              }
+            : image
+              ? { kind: "content", content: { image } }
+              : { kind: "text", text: "" },
+      );
+    }
+
+    const deltaEvent = isRecord(event.contentBlockDelta) ? event.contentBlockDelta : undefined;
+    if (deltaEvent) {
+      const index = numberValue(deltaEvent.contentBlockIndex) ?? 0;
+      const delta = isRecord(deltaEvent.delta) ? deltaEvent.delta : {};
+      const block = this.blocks.get(index) ?? { kind: "text", text: "" };
+      if (typeof delta.text === "string") {
+        block.kind = "text";
+        block.text = `${block.text ?? ""}${delta.text}`;
+      }
+      const toolUse = isRecord(delta.toolUse) ? delta.toolUse : undefined;
+      if (toolUse && typeof toolUse.input === "string") {
+        block.kind = "tool";
+        block.input = `${block.input ?? ""}${toolUse.input}`;
+      }
+      const reasoning = isRecord(delta.reasoningContent) ? delta.reasoningContent : undefined;
+      if (reasoning) {
+        block.kind = "reasoning";
+        block.text = `${block.text ?? ""}${stringValue(reasoning.text) ?? (reasoning.redactedContent ? "[redacted]" : "")}`;
+      }
+      const image = isRecord(delta.image) ? delta.image : undefined;
+      if (image) {
+        const content = isRecord(block.content) ? block.content : {};
+        const current = isRecord(content.image) ? content.image : {};
+        block.kind = "content";
+        block.content = { image: { ...current, ...image } };
+      }
+      const toolResult = arrayValue<Record<string, unknown>>(delta.toolResult);
+      if (toolResult) {
+        const content = isRecord(block.content) ? block.content : {};
+        const current = isRecord(content.toolResult) ? content.toolResult : {};
+        const currentContent = arrayValue<unknown>(current.content) ?? [];
+        block.kind = "content";
+        block.content = {
+          toolResult: {
+            ...current,
+            content: [...currentContent, ...toolResult],
+          },
+        };
+      }
+      if (isRecord(delta.citation)) {
+        block.citations = [...(block.citations ?? []), delta.citation];
+      }
+      this.blocks.set(index, block);
+    }
+
+    const stop = isRecord(event.messageStop) ? event.messageStop : undefined;
+    if (stop) this.stopReason = stringValue(stop.stopReason) ?? this.stopReason;
+
+    const metadata = isRecord(event.metadata) ? event.metadata : undefined;
+    if (metadata) {
+      this.usage = usageFromConverse(metadata.usage) ?? this.usage;
+      const metrics = isRecord(metadata.metrics) ? metadata.metrics : undefined;
+      const trace = isRecord(metadata.trace) ? metadata.trace : undefined;
+      const promptRouter = isRecord(trace?.promptRouter) ? trace?.promptRouter : undefined;
+      const guardrail = isRecord(trace?.guardrail) ? trace?.guardrail : undefined;
+      this.responseModel = stringValue(promptRouter?.invokedModelId) ?? this.responseModel;
+      this.metadata = {
+        ...this.metadata,
+        ...omitUndefined({
+          server_latency_ms: numberValue(metrics?.latencyMs),
+          guardrail_action: stringValue(guardrail?.action),
+          guardrail_action_reason: stringValue(guardrail?.actionReason),
+        }),
+      };
+    }
+  }
+
+  finish(partial: boolean): SpanFields {
+    const parts = [...this.blocks.entries()]
+      .sort(([left], [right]) => left - right)
+      .map(([, block]) => blockToPart(block));
+    return mergeFields(
+      omitUndefined({
+        output:
+          parts.length > 0
+            ? [
+                omitUndefined({
+                  role: this.role,
+                  parts,
+                  finish_reason: partial ? undefined : this.stopReason,
+                }),
+              ]
+            : undefined,
+        finishReason: partial ? undefined : this.stopReason,
+        usage: this.usage,
+        responseModel: this.responseModel,
+        metadata: Object.keys(this.metadata).length > 0 ? this.metadata : undefined,
+        error: this.error,
+      }),
+      this.errorFields,
+    );
+  }
+}
+
+function blockToPart(block: StreamBlock): MessagePart {
+  if (block.kind === "tool") {
+    return omitUndefined({
+      type: "tool_call",
+      id: block.toolUseId,
+      name: block.name,
+      arguments: parseJson(block.input) ?? block.input ?? "",
+    });
+  }
+  if (block.kind === "reasoning") return { type: "reasoning", content: block.text ?? "" };
+  if (block.kind === "content" && block.content)
+    return normalizeContentBlock(block.content)[0] ?? {};
+  return omitUndefined({
+    type: "text",
+    content: block.text ?? "",
+    citations: block.citations && block.citations.length > 0 ? block.citations : undefined,
+  });
+}

package/src/index.ts

@@ -0,0 +1,69 @@
+import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
+
+import { RUNTIME_HANDLERS } from "./internal-handlers.ts";
+import {
+  createInstrumentedSend,
+  type BedrockInstrumentationOptions,
+  type SendFn,
+} from "./internal.ts";
+
+export type { BedrockInstrumentationOptions } from "./internal.ts";
+
+export interface WrappableBedrockClient {
+  send: (...args: never[]) => unknown;
+}
+
+const WRAPPED = new WeakSet<object>();
+let ORIGINAL: { proto: object; hadOwn: boolean; value: unknown; wrapper: SendFn } | undefined;
+
+export function wrapBedrock<T extends WrappableBedrockClient>(
+  client: T,
+  options: BedrockInstrumentationOptions = {},
+): T {
+  if (WRAPPED.has(client as object)) return client;
+  const original = client.send as SendFn;
+  Object.defineProperty(client, "send", {
+    value: createInstrumentedSend(original, options, RUNTIME_HANDLERS),
+    configurable: true,
+    writable: true,
+  });
+  WRAPPED.add(client as object);
+  return client;
+}
+
+export function instrumentBedrock(options: BedrockInstrumentationOptions = {}): void {
+  if (ORIGINAL) return;
+  const proto = BedrockRuntimeClient.prototype as unknown as { send: SendFn };
+  const hadOwn = Object.prototype.hasOwnProperty.call(proto, "send");
+  const original = proto.send;
+  const instrumentedSend = createInstrumentedSend(original, options, RUNTIME_HANDLERS);
+  const wrapper = function telemetryDevBedrockSend(
+    this: WrappableBedrockClient,
+    ...args: unknown[]
+  ) {
+    if (WRAPPED.has(this as object)) return original.apply(this, args);
+    return instrumentedSend.apply(this, args);
+  };
+  ORIGINAL = { proto, hadOwn, value: original, wrapper };
+  Object.defineProperty(proto, "send", {
+    configurable: true,
+    writable: true,
+    value: wrapper,
+  });
+}
+
+export function uninstrumentBedrock(): void {
+  const original = ORIGINAL;
+  if (!original) return;
+  if (Object.getOwnPropertyDescriptor(original.proto, "send")?.value !== original.wrapper) return;
+  ORIGINAL = undefined;
+  if (original.hadOwn) {
+    Object.defineProperty(original.proto, "send", {
+      configurable: true,
+      writable: true,
+      value: original.value,
+    });
+  } else {
+    Reflect.deleteProperty(original.proto, "send");
+  }
+}

package/src/internal-handlers.ts

@@ -0,0 +1,230 @@
+import type { OpHandler } from "./internal.ts";
+import {
+  AgentStreamState,
+  FlowStreamState,
+  RagStreamState,
+  agentRequestFields,
+  flowName,
+  flowRequestFields,
+  inlineAgentRequestFields,
+  ragName,
+  ragRequestFields,
+  ragResponseFields,
+  retrieveRequestFields,
+  retrieveResponseFields,
+} from "./agent-handlers.ts";
+import { ConverseStreamState, converseRequestFields, converseResponseFields } from "./converse.ts";
+import {
+  invokeModelRequestFields,
+  invokeModelResponseFields,
+  invokeModelSpanName,
+  InvokeModelStreamState,
+  isEmbeddingModel,
+} from "./invoke-model.ts";
+import {
+  awsMetadataFields,
+  mergeFields,
+  omitUndefined,
+  PROVIDER,
+  stringValue,
+  wrapAsyncIterable,
+  endSpan,
+  type BedrockInstrumentationOptions,
+} from "./internal.ts";
+
+export const RUNTIME_HANDLERS: Record<string, OpHandler> = {
+  ConverseCommand: {
+    spanName: (input) => `chat ${stringValue(input.modelId) ?? "unknown"}`,
+    spanType: () => "generation",
+    requestFields: converseRequestFields,
+    onResult(result, span) {
+      endSpan(span, converseResponseFields(result));
+      return result;
+    },
+  },
+  ConverseStreamCommand: {
+    spanName: (input) => `chat ${stringValue(input.modelId) ?? "unknown"}`,
+    spanType: () => "generation",
+    requestFields: converseRequestFields,
+    onResult(result, span, t0) {
+      const response = result as { stream?: unknown; $metadata?: unknown };
+      if (!response.stream) {
+        endSpan(span, awsMetadataFields(response.$metadata));
+        return result;
+      }
+      return {
+        ...response,
+        stream: wrapAsyncIterable(
+          response.stream,
+          new ConverseStreamState(),
+          span,
+          t0,
+          awsMetadataFields(response.$metadata),
+        ),
+      };
+    },
+  },
+  InvokeModelCommand: {
+    spanName: invokeModelSpanName,
+    spanType: (input) => (isEmbeddingModel(input.modelId) ? "embedding" : "generation"),
+    requestFields: invokeModelRequestFields,
+    onResult(result, span, _t0, input) {
+      endSpan(span, invokeModelResponseFields(input, result));
+      return result;
+    },
+  },
+  InvokeModelWithResponseStreamCommand: {
+    spanName: invokeModelSpanName,
+    spanType: (input) => (isEmbeddingModel(input.modelId) ? "embedding" : "generation"),
+    requestFields: invokeModelRequestFields,
+    onResult(result, span, t0) {
+      const response = result as { body?: unknown; $metadata?: unknown };
+      if (!response.body) {
+        endSpan(span, awsMetadataFields(response.$metadata));
+        return result;
+      }
+      return {
+        ...response,
+        body: wrapAsyncIterable(
+          response.body,
+          new InvokeModelStreamState(),
+          span,
+          t0,
+          awsMetadataFields(response.$metadata),
+        ),
+      };
+    },
+  },
+  ApplyGuardrailCommand: {
+    spanName: (input) => `apply_guardrail ${stringValue(input.guardrailIdentifier) ?? "unknown"}`,
+    spanType: () => "span",
+    requestFields: (input) => ({
+      provider: PROVIDER,
+      input: omitUndefined({
+        source: input.source,
+        content: input.content,
+        guardrailIdentifier: input.guardrailIdentifier,
+        guardrailVersion: input.guardrailVersion,
+      }),
+    }),
+    onResult(result, span) {
+      const response = result as Record<string, unknown>;
+      endSpan(
+        span,
+        mergeFields(awsMetadataFields(response.$metadata), {
+          output: omitUndefined({ outputs: response.outputs, assessments: response.assessments }),
+          metadata: omitUndefined({
+            guardrail_action: stringValue(response.action),
+            guardrail_action_reason: stringValue(response.actionReason),
+          }),
+        }),
+      );
+      return result;
+    },
+  },
+};
+
+export const AGENT_HANDLERS: Record<string, OpHandler> = {
+  InvokeAgentCommand: {
+    spanName: (input) => `invoke_agent ${stringValue(input.agentId) ?? "unknown"}`,
+    spanType: () => "agent",
+    requestFields: agentRequestFields,
+    onResult: streamAgentResult("completion"),
+  },
+  InvokeInlineAgentCommand: {
+    spanName: (input) => `invoke_agent ${stringValue(input.agentName) ?? "inline-agent"}`,
+    spanType: () => "agent",
+    requestFields: inlineAgentRequestFields,
+    onResult: streamAgentResult("completion"),
+  },
+  RetrieveCommand: {
+    spanName: (input) => `retrieve ${stringValue(input.knowledgeBaseId) ?? "unknown"}`,
+    spanType: () => "span",
+    requestFields: retrieveRequestFields,
+    onResult(result, span) {
+      endSpan(span, retrieveResponseFields(result));
+      return result;
+    },
+  },
+  RetrieveAndGenerateCommand: {
+    spanName: ragName,
+    spanType: () => "generation",
+    requestFields: ragRequestFields,
+    onResult(result, span) {
+      endSpan(span, ragResponseFields(result));
+      return result;
+    },
+  },
+  RetrieveAndGenerateStreamCommand: {
+    spanName: ragName,
+    spanType: () => "generation",
+    requestFields: ragRequestFields,
+    onResult(result, span, t0) {
+      const response = result as { stream?: unknown; $metadata?: unknown; sessionId?: string };
+      const base = mergeFields(awsMetadataFields(response.$metadata), {
+        metadata: omitUndefined({ bedrock_session_id: stringValue(response.sessionId) }),
+      });
+      if (!response.stream) {
+        endSpan(span, base);
+        return result;
+      }
+      return {
+        ...response,
+        stream: wrapAsyncIterable(response.stream, new RagStreamState(), span, t0, base),
+      };
+    },
+  },
+  InvokeFlowCommand: {
+    spanName: flowName,
+    spanType: () => "agent",
+    requestFields: flowRequestFields,
+    onResult(result, span, t0) {
+      const response = result as { responseStream?: unknown; $metadata?: unknown };
+      if (!response.responseStream) {
+        endSpan(span, awsMetadataFields(response.$metadata));
+        return result;
+      }
+      return {
+        ...response,
+        responseStream: wrapAsyncIterable(
+          response.responseStream,
+          new FlowStreamState(),
+          span,
+          t0,
+          awsMetadataFields(response.$metadata),
+        ),
+      };
+    },
+  },
+};
+
+function streamAgentResult(key: "completion") {
+  return (
+    result: unknown,
+    span: Parameters<OpHandler["onResult"]>[1],
+    t0: number,
+    _input: Record<string, unknown>,
+    options: BedrockInstrumentationOptions,
+  ): unknown => {
+    const response = result as {
+      completion?: unknown;
+      $metadata?: unknown;
+      sessionId?: string;
+      memoryId?: string;
+    };
+    const base = mergeFields(awsMetadataFields(response.$metadata), {
+      metadata: omitUndefined({
+        bedrock_session_id: stringValue(response.sessionId),
+        bedrock_memory_id: stringValue(response.memoryId),
+      }),
+    });
+    if (!response[key]) {
+      endSpan(span, base);
+      return result;
+    }
+    return {
+      ...response,
+      [key]: wrapAsyncIterable(response[key], new AgentStreamState(options), span, t0, base),
+    };
+  };
+}