ironside 0.1.0

package/src/wrappers/anthropic.ts

@@ -0,0 +1,276 @@
+import type { IronsideClient, TraceHandle } from "../client.js";
+import { errorEndOptions, instrumentAsyncIterable } from "./streaming.js";
+
+// Wraps the Anthropic Node SDK's messages.create() to automatically record
+// a generation. Verified against @anthropic-ai/sdk@0.111.0: usage lives at
+// message.usage.{input_tokens,output_tokens} (snake_case — same field
+// names as OpenAI's Responses API, but this is Anthropic's only call
+// path, unlike OpenAI's Chat-Completions-vs-Responses split). model lives
+// at message.model. client.messages is a plain wrappable instance
+// property; patched in place, same rationale as wrapOpenAI.
+//
+// STREAMING (M9-07) — `create({..., stream: true})` resolves to a Stream
+// of RawMessageStreamEvents. The stream's asyncIterator is patched in
+// place (wrappers/streaming.ts) and the Message is reassembled from the
+// event protocol as the caller iterates: message_start carries the model
+// and input_tokens, content_block_start/content_block_delta carry text
+// and tool_use blocks (tool input arrives as partial_json string
+// fragments), and the final message_delta carries the cumulative
+// output_tokens and stop_reason — so unlike OpenAI (which hides usage
+// behind stream_options.include_usage), a streamed Anthropic call always
+// records full usage. The `messages.stream()` helper is NOT wrapped —
+// it builds its own request path; only create() calls are traced.
+
+export interface WrapAnthropicOptions {
+  /** Attach generations to an existing trace instead of creating a new standalone trace per call. */
+  trace?: TraceHandle;
+}
+
+// Request sampling parameters worth recording as modelParameters — verified
+// against the Messages API request schema (@anthropic-ai/sdk@0.111.0).
+// Only fields actually present on the request are ever recorded.
+interface RequestModelParameters {
+  temperature?: number;
+  top_p?: number;
+  top_k?: number;
+  max_tokens?: number;
+}
+
+function extractModelParameters(
+  body: RequestModelParameters | undefined
+): Record<string, string | number | boolean | null> | undefined {
+  if (!body) return undefined;
+  const entries = (["temperature", "top_p", "top_k", "max_tokens"] as const)
+    .filter((key) => body[key] !== undefined)
+    .map((key) => [key, body[key]] as [string, number]);
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+interface MessageUsage {
+  input_tokens?: number;
+  output_tokens?: number;
+}
+
+interface MessageLike {
+  model?: string;
+  usage?: MessageUsage;
+}
+
+// `never[]` params so the real Anthropic client's overloaded create()
+// satisfies the constraint — same contravariance reasoning as wrapOpenAI.
+interface MessagesLike {
+  create: (...args: never[]) => unknown;
+}
+
+interface AnthropicLike {
+  messages: MessagesLike;
+}
+
+function usageDetailsFrom(usage: MessageUsage | undefined) {
+  if (!usage) return undefined;
+  const details = {
+    ...(usage.input_tokens !== undefined && { input_tokens: usage.input_tokens }),
+    ...(usage.output_tokens !== undefined && { output_tokens: usage.output_tokens })
+  };
+  return Object.keys(details).length > 0 ? details : undefined;
+}
+
+// Streamed event protocol (RawMessageStreamEvent), verified against
+// @anthropic-ai/sdk@0.111.0 + docs.anthropic.com/en/docs/build-with-claude/streaming.
+interface StreamEventLike {
+  type?: string;
+  index?: number;
+  message?: { model?: string; usage?: MessageUsage };
+  content_block?: {
+    type?: string;
+    id?: string;
+    name?: string;
+    text?: string;
+    thinking?: string;
+    signature?: string;
+  };
+  delta?: {
+    type?: string;
+    text?: string;
+    partial_json?: string;
+    thinking?: string;
+    signature?: string;
+    stop_reason?: string;
+  };
+  usage?: MessageUsage;
+}
+
+type AccumulatedBlock =
+  | { type: "text"; text: string }
+  | { type: "tool_use"; id?: string; name?: string; partialJson: string }
+  | { type: "thinking"; thinking: string; signature: string }
+  | { type: string; [key: string]: unknown };
+
+function createEventAccumulator() {
+  const blocks: AccumulatedBlock[] = [];
+  let responseModel: string | undefined;
+  let inputTokens: number | undefined;
+  let outputTokens: number | undefined;
+  let stopReason: string | undefined;
+
+  return {
+    onEvent(raw: unknown) {
+      const event = raw as StreamEventLike;
+      switch (event.type) {
+        case "message_start":
+          responseModel = event.message?.model;
+          inputTokens = event.message?.usage?.input_tokens;
+          outputTokens = event.message?.usage?.output_tokens;
+          break;
+        case "content_block_start": {
+          const block = event.content_block;
+          if (event.index === undefined || !block) break;
+          if (block.type === "text") {
+            blocks[event.index] = { type: "text", text: block.text ?? "" };
+          } else if (block.type === "tool_use") {
+            blocks[event.index] = {
+              type: "tool_use",
+              ...(block.id && { id: block.id }),
+              ...(block.name && { name: block.name }),
+              partialJson: ""
+            };
+          } else if (block.type === "thinking") {
+            // Extended-thinking blocks stream as thinking_delta text plus a
+            // final signature_delta (the signature is required to round-trip
+            // the block in later turns — dropping it would make the recorded
+            // output unusable as a replay input). Review finding, PR #39.
+            blocks[event.index] = {
+              type: "thinking",
+              thinking: block.thinking ?? "",
+              signature: block.signature ?? ""
+            };
+          } else if (block.type) {
+            // Other block kinds (redacted_thinking arrives complete at
+            // start; future API additions) are kept as-is rather than
+            // dropped — deltas for them aren't understood, but the block's
+            // existence is real data.
+            blocks[event.index] = { ...block, type: block.type };
+          }
+          break;
+        }
+        case "content_block_delta": {
+          if (event.index === undefined) break;
+          const block = blocks[event.index];
+          if (!block) break;
+          if (event.delta?.type === "text_delta" && block.type === "text") {
+            (block as { text: string }).text += event.delta.text ?? "";
+          } else if (event.delta?.type === "input_json_delta" && block.type === "tool_use") {
+            (block as { partialJson: string }).partialJson += event.delta.partial_json ?? "";
+          } else if (event.delta?.type === "thinking_delta" && block.type === "thinking") {
+            (block as { thinking: string }).thinking += event.delta.thinking ?? "";
+          } else if (event.delta?.type === "signature_delta" && block.type === "thinking") {
+            (block as { signature: string }).signature = event.delta.signature ?? "";
+          }
+          break;
+        }
+        case "message_delta":
+          if (event.usage?.output_tokens !== undefined) outputTokens = event.usage.output_tokens;
+          if (event.usage?.input_tokens !== undefined) inputTokens = event.usage.input_tokens;
+          if (event.delta?.stop_reason) stopReason = event.delta.stop_reason;
+          break;
+      }
+    },
+    endOptions() {
+      const content = blocks.filter(Boolean).map((block) => {
+        if (block.type === "tool_use" && "partialJson" in block) {
+          const { partialJson, ...rest } = block;
+          const rawJson = typeof partialJson === "string" ? partialJson : "";
+          let input: unknown;
+          try {
+            input = rawJson ? JSON.parse(rawJson) : {};
+          } catch {
+            // Truncated stream (early break mid-tool-call): keep the raw
+            // fragment rather than losing it or throwing in a finalizer.
+            input = { __partial_json: rawJson };
+          }
+          return { ...rest, input };
+        }
+        return block;
+      });
+      const usage = {
+        ...(inputTokens !== undefined && { input_tokens: inputTokens }),
+        ...(outputTokens !== undefined && { output_tokens: outputTokens })
+      };
+      return {
+        output: {
+          role: "assistant",
+          ...(responseModel && { model: responseModel }),
+          content,
+          ...(stopReason && { stop_reason: stopReason })
+        },
+        ...(Object.keys(usage).length > 0 && { usageDetails: usage }),
+        metadata: { streamed: "true" }
+      };
+    }
+  };
+}
+
+/**
+ * Wraps an Anthropic client instance so every messages.create() call —
+ * streaming or not — is automatically recorded as a generation. Mutates
+ * client.messages in place and returns the same client reference.
+ *
+ * Safe to call more than once on the same client — re-wrapping is detected
+ * and is a no-op, rather than nesting a second wrapper around the first
+ * (which would silently double-record every call).
+ */
+export function wrapAnthropic<T extends AnthropicLike>(
+  client: T,
+  ironside: IronsideClient,
+  options: WrapAnthropicOptions = {}
+): T {
+  const messages = client.messages as MessagesLike & { __ironsideWrapped?: boolean };
+  if (messages.__ironsideWrapped) return client;
+
+  const originalCreate = messages.create.bind(messages) as (
+    ...args: unknown[]
+  ) => Promise<unknown>;
+
+  const wrappedCreate = async (...args: unknown[]): Promise<unknown> => {
+    const requestBody = args[0] as
+      | (RequestModelParameters & { model?: string; messages?: unknown; stream?: boolean })
+      | undefined;
+
+    const modelParameters = extractModelParameters(requestBody);
+    const trace = options.trace ?? ironside.trace({ name: "anthropic.messages.create" });
+    const generation = trace.generation({
+      name: "anthropic.messages.create",
+      ...(requestBody?.model && { model: requestBody.model }),
+      ...(modelParameters && { modelParameters }),
+      input: requestBody?.messages
+    });
+
+    try {
+      const result = await originalCreate(...args);
+
+      if (requestBody?.stream) {
+        const accumulator = createEventAccumulator();
+        return instrumentAsyncIterable(result, accumulator.onEvent, ({ error, consumed }) => {
+          if (error) generation.end(errorEndOptions(error));
+          else if (consumed) generation.end(accumulator.endOptions());
+          else generation.end({ metadata: { streamed: "true" } });
+        });
+      }
+
+      const message = result as MessageLike;
+      const usageDetails = usageDetailsFrom(message.usage);
+      generation.end({
+        output: message,
+        ...(usageDetails && { usageDetails })
+      });
+      return result;
+    } catch (error) {
+      generation.end(errorEndOptions(error));
+      throw error;
+    }
+  };
+  messages.create = wrappedCreate as typeof messages.create;
+  Object.defineProperty(messages, "__ironsideWrapped", { value: true, enumerable: false });
+
+  return client;
+}

package/src/wrappers/openai.ts

@@ -0,0 +1,283 @@
+import type { IronsideClient, TraceHandle } from "../client.js";
+import { errorEndOptions, instrumentAsyncIterable } from "./streaming.js";
+
+// Wraps the OpenAI Node SDK's chat.completions.create() to automatically
+// record a generation. Verified against openai@6.46.0: usage lives at
+// completion.usage.{prompt_tokens,completion_tokens} for Chat Completions
+// (the Responses API — client.responses.create — uses a different field
+// vocabulary, input_tokens/output_tokens, and is not wrapped here; only
+// Chat Completions, still the most common call site, is covered in this
+// pass). client.chat.completions is a plain wrappable instance property,
+// not a sealed/frozen internal — this is the same interception pattern
+// OpenInference and Langfuse's own OpenAI integrations use.
+//
+// Patches the passed-in client's create() method in place and returns the
+// SAME reference, rather than shallow-copying the client object. A shallow
+// copy (`{...client}`) would drop every other resource (embeddings,
+// images, ...) and any internal state accessed via `this` inside the SDK's
+// own methods — patch-in-place is what real client instrumentation
+// libraries (OpenInference, Langfuse) do for exactly this reason.
+//
+// STREAMING (M9-07) — `create({..., stream: true})` resolves to a Stream
+// (async iterable of ChatCompletionChunk). The stream's asyncIterator is
+// patched in place (wrappers/streaming.ts) so text deltas, streamed tool
+// calls, and the final usage chunk are accumulated as the CALLER iterates,
+// and the generation ends when iteration finishes (done, early break, or
+// mid-stream error). Usage is only present on the final (empty-choices)
+// chunk when the caller set `stream_options: {include_usage: true}` — the
+// wrapper deliberately does NOT inject that option itself: mutating the
+// wire request can break OpenAI-compatible backends that reject unknown
+// fields, and a tracing wrapper silently changing what's sent to the
+// provider is worse than missing token counts. Without it, the streamed
+// generation records output text but no usageDetails (documented in the
+// README quickstart).
+
+export interface WrapOpenAIOptions {
+  /** Attach generations to an existing trace instead of creating a new standalone trace per call. */
+  trace?: TraceHandle;
+}
+
+// Request sampling parameters worth recording as modelParameters — verified
+// against the Chat Completions request schema (openai@6.46.0). Kept to the
+// common cross-provider set (temperature/top_p/max_tokens/penalties/seed);
+// only fields actually present on the request are ever recorded.
+interface RequestModelParameters {
+  temperature?: number;
+  top_p?: number;
+  max_tokens?: number;
+  max_completion_tokens?: number;
+  presence_penalty?: number;
+  frequency_penalty?: number;
+  seed?: number;
+}
+
+function extractModelParameters(
+  body: RequestModelParameters | undefined
+): Record<string, string | number | boolean | null> | undefined {
+  if (!body) return undefined;
+  const entries = (
+    ["temperature", "top_p", "max_tokens", "max_completion_tokens", "presence_penalty", "frequency_penalty", "seed"] as const
+  )
+    .filter((key) => body[key] !== undefined)
+    .map((key) => [key, body[key]] as [string, number]);
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+interface ChatCompletionUsage {
+  prompt_tokens?: number;
+  completion_tokens?: number;
+}
+
+interface ChatCompletionLike {
+  model?: string;
+  usage?: ChatCompletionUsage;
+}
+
+function usageDetailsFrom(usage: ChatCompletionUsage | undefined) {
+  if (!usage) return undefined;
+  const details = {
+    ...(usage.prompt_tokens !== undefined && { input_tokens: usage.prompt_tokens }),
+    ...(usage.completion_tokens !== undefined && { output_tokens: usage.completion_tokens })
+  };
+  return Object.keys(details).length > 0 ? details : undefined;
+}
+
+// Streamed chunk shape (ChatCompletionChunk): delta carries content and
+// incremental tool_calls (arguments arrive as string fragments to
+// concatenate, keyed by index); usage arrives on a final chunk with empty
+// choices, only under stream_options.include_usage.
+interface ChunkToolCallDelta {
+  index: number;
+  id?: string;
+  type?: string;
+  function?: { name?: string; arguments?: string };
+}
+
+interface ChatCompletionChunkLike {
+  model?: string;
+  usage?: ChatCompletionUsage | null;
+  choices?: Array<{
+    index?: number;
+    delta?: { content?: string | null; tool_calls?: ChunkToolCallDelta[] };
+    finish_reason?: string | null;
+  }>;
+}
+
+interface AccumulatedToolCall {
+  id?: string;
+  type?: string;
+  function: { name?: string; arguments: string };
+}
+
+interface AccumulatedChoice {
+  content: string;
+  sawContent: boolean;
+  toolCalls: AccumulatedToolCall[];
+  finishReason?: string;
+}
+
+function assembleMessage(choice: AccumulatedChoice) {
+  const assembledToolCalls = choice.toolCalls.filter(Boolean);
+  return {
+    role: "assistant",
+    content: choice.sawContent ? choice.content : null,
+    ...(assembledToolCalls.length > 0 && { tool_calls: assembledToolCalls })
+  };
+}
+
+function createChunkAccumulator() {
+  // Keyed by choice.index — an n>1 request streams every choice's deltas
+  // interleaved in the same chunk sequence, so reading only choices[0]
+  // would silently truncate the response to a fraction of one choice
+  // (review finding, PR #39).
+  const choices = new Map<number, AccumulatedChoice>();
+  let usage: ChatCompletionUsage | undefined;
+  let responseModel: string | undefined;
+
+  return {
+    onChunk(raw: unknown) {
+      const chunk = raw as ChatCompletionChunkLike;
+      if (chunk.model) responseModel = chunk.model;
+      if (chunk.usage) usage = chunk.usage;
+      for (const choice of chunk.choices ?? []) {
+        const index = choice.index ?? 0;
+        let slot = choices.get(index);
+        if (!slot) {
+          slot = { content: "", sawContent: false, toolCalls: [] };
+          choices.set(index, slot);
+        }
+        if (choice.finish_reason) slot.finishReason = choice.finish_reason;
+        if (typeof choice.delta?.content === "string") {
+          slot.content += choice.delta.content;
+          slot.sawContent = true;
+        }
+        for (const tc of choice.delta?.tool_calls ?? []) {
+          const toolSlot = (slot.toolCalls[tc.index] ??= { function: { arguments: "" } });
+          if (tc.id) toolSlot.id = tc.id;
+          if (tc.type) toolSlot.type = tc.type;
+          if (tc.function?.name) toolSlot.function.name = tc.function.name;
+          if (tc.function?.arguments) toolSlot.function.arguments += tc.function.arguments;
+        }
+      }
+    },
+    endOptions() {
+      const sorted = [...choices.entries()].sort(([a], [b]) => a - b);
+      const usageDetails = usageDetailsFrom(usage);
+      // Single choice (the overwhelmingly common case): output is the
+      // assistant message itself. n>1: output mirrors the non-streaming
+      // completion's choices array so no choice is dropped.
+      const single =
+        sorted.length === 0
+          ? { content: "", sawContent: false, toolCalls: [] } // empty stream: a bare content-null message
+          : sorted.length === 1
+            ? sorted[0]![1]
+            : undefined;
+      const output = single
+        ? assembleMessage(single)
+        : {
+            choices: sorted.map(([index, choice]) => ({
+              index,
+              message: assembleMessage(choice),
+              ...(choice.finishReason && { finish_reason: choice.finishReason })
+            }))
+          };
+      const finishReason = single?.finishReason;
+      return {
+        output,
+        ...(usageDetails && { usageDetails }),
+        metadata: {
+          streamed: "true",
+          ...(responseModel && { response_model: responseModel }),
+          ...(finishReason && { finish_reason: finishReason })
+        }
+      };
+    }
+  };
+}
+
+// `never[]` parameters make this satisfiable by the real OpenAI client's
+// overloaded create() — a `(...args: unknown[])` signature is
+// contravariantly INCOMPATIBLE with any function taking typed params, so
+// the real SDK class would fail the T constraint (caught by the real-SDK
+// conformance tests, which the fake-client unit tests never exercised).
+interface ChatCompletionsLike {
+  create: (...args: never[]) => unknown;
+}
+
+interface OpenAILike {
+  chat: { completions: ChatCompletionsLike };
+}
+
+/**
+ * Wraps an OpenAI client instance so every chat.completions.create() call
+ * — streaming or not — is automatically recorded as a generation. Mutates
+ * client.chat.completions in place and returns the same client reference
+ * for convenient chaining (`const client = wrapOpenAI(new OpenAI(...), ironside)`).
+ *
+ * Safe to call more than once on the same client — re-wrapping is detected
+ * and is a no-op, rather than nesting a second wrapper around the first
+ * (which would silently double-record every call: two traces, two
+ * generations, per real API call).
+ */
+export function wrapOpenAI<T extends OpenAILike>(
+  client: T,
+  ironside: IronsideClient,
+  options: WrapOpenAIOptions = {}
+): T {
+  const completions = client.chat.completions as ChatCompletionsLike & {
+    __ironsideWrapped?: boolean;
+  };
+  if (completions.__ironsideWrapped) return client;
+
+  const originalCreate = completions.create.bind(completions) as (
+    ...args: unknown[]
+  ) => Promise<unknown>;
+
+  const wrappedCreate = async (...args: unknown[]): Promise<unknown> => {
+    const requestBody = args[0] as
+      | (RequestModelParameters & { model?: string; messages?: unknown; stream?: boolean })
+      | undefined;
+
+    const modelParameters = extractModelParameters(requestBody);
+    const trace = options.trace ?? ironside.trace({ name: "openai.chat.completions.create" });
+    const generation = trace.generation({
+      name: "openai.chat.completions.create",
+      ...(requestBody?.model && { model: requestBody.model }),
+      ...(modelParameters && { modelParameters }),
+      input: requestBody?.messages
+    });
+
+    try {
+      const result = await originalCreate(...args);
+
+      if (requestBody?.stream) {
+        const accumulator = createChunkAccumulator();
+        return instrumentAsyncIterable(result, accumulator.onChunk, ({ error, consumed }) => {
+          if (error) generation.end(errorEndOptions(error));
+          else if (consumed) generation.end(accumulator.endOptions());
+          // !consumed: the result wasn't iterable at all (unexpected SDK
+          // shape) — end with what we know rather than dangle forever.
+          else generation.end({ metadata: { streamed: "true" } });
+        });
+      }
+
+      const completion = result as ChatCompletionLike;
+      const usageDetails = usageDetailsFrom(completion.usage);
+      generation.end({
+        output: completion,
+        ...(usageDetails && { usageDetails })
+      });
+      return result;
+    } catch (error) {
+      generation.end(errorEndOptions(error));
+      throw error;
+    }
+  };
+  completions.create = wrappedCreate as typeof completions.create;
+  Object.defineProperty(completions, "__ironsideWrapped", {
+    value: true,
+    enumerable: false
+  });
+
+  return client;
+}

package/src/wrappers/streaming.ts

@@ -0,0 +1,92 @@
+// Shared machinery for tracing streamed responses (M9-07). Both provider
+// SDKs return a Stream object that is an async iterable with extra API
+// surface (.tee(), .controller, .toReadableStream(), ...). Returning our
+// own wrapper generator would silently break every caller using that
+// surface, so instead the stream's [Symbol.asyncIterator] is patched IN
+// PLACE and the SAME object is returned — identical to how the wrappers
+// patch client.chat.completions.create itself.
+//
+// The generation can only be finalized when the caller actually consumes
+// the stream (that's when the text/usage exists at all). Three exits all
+// funnel into one finalize call: normal completion (done), early break
+// (the iterator's return()), and a mid-stream error (next() rejecting or
+// throw()). A stream the caller never iterates records its start event
+// but never ends — visible in the UI as a dangling in-progress
+// generation, which is the honest representation of what happened.
+//
+// KNOWN LIMIT — .tee(): each branch iterates through the patched
+// asyncIterator, so chunks from both branches feed one accumulator
+// (double-counted text). finalize still fires exactly once. tee'd +
+// wrapped is rare enough that correct-single-stream beats a per-iterator
+// accumulator design that couldn't merge usage sanely anyway.
+
+/**
+ * Patches `stream`'s async iterator in place so every yielded chunk feeds
+ * `onChunk` and exactly one of done/break/error triggers `onFinish`.
+ * Returns the same object. If the value isn't async-iterable at all
+ * (unexpected SDK shape), it is returned untouched and `onFinish` fires
+ * immediately with `{ consumed: false }` so the generation isn't left
+ * dangling by our own bug.
+ */
+export function instrumentAsyncIterable<T>(
+  stream: T,
+  onChunk: (chunk: unknown) => void,
+  onFinish: (outcome: { error?: unknown; consumed: boolean }) => void
+): T {
+  const iterable = stream as T & {
+    [Symbol.asyncIterator]?: () => AsyncIterator<unknown>;
+  };
+  if (typeof iterable?.[Symbol.asyncIterator] !== "function") {
+    onFinish({ consumed: false });
+    return stream;
+  }
+
+  let finished = false;
+  const finishOnce = (outcome: { error?: unknown }) => {
+    if (finished) return;
+    finished = true;
+    onFinish({ ...outcome, consumed: true });
+  };
+
+  const originalFactory = iterable[Symbol.asyncIterator]!.bind(iterable);
+  iterable[Symbol.asyncIterator] = () => {
+    const inner = originalFactory();
+    return {
+      async next(): Promise<IteratorResult<unknown>> {
+        try {
+          const result = await inner.next();
+          if (result.done) finishOnce({});
+          else onChunk(result.value);
+          return result;
+        } catch (error) {
+          finishOnce({ error });
+          throw error;
+        }
+      },
+      // Called on `break`/`return` inside a for-await — the caller chose
+      // to stop early; what accumulated so far is the real output.
+      async return(value?: unknown): Promise<IteratorResult<unknown>> {
+        finishOnce({});
+        if (inner.return) return inner.return(value);
+        return { done: true, value: undefined };
+      },
+      async throw(error?: unknown): Promise<IteratorResult<unknown>> {
+        finishOnce({ error });
+        if (inner.throw) return inner.throw(error);
+        throw error;
+      }
+    };
+  };
+  return stream;
+}
+
+/** Shared error→end mapping so streamed and non-streamed failures record identically. */
+export function errorEndOptions(error: unknown): {
+  level: "error";
+  statusMessage: string;
+} {
+  return {
+    level: "error",
+    statusMessage: error instanceof Error ? error.message : String(error)
+  };
+}