autotel-cloudflare 2.19.0 → 3.1.0

package/src/agents/types.ts

@@ -2,159 +2,53 @@
  * Type definitions for Cloudflare Agents SDK observability integration
  */
 
-import type { ConfigurationOption } from 'autotel-edge';
 import type { Attributes } from '@opentelemetry/api';
+import type { ConfigurationOption } from 'autotel-edge';
+import type { AgentObservabilityEvent } from './agent';
+import type { BaseEvent } from './base';
+import type { MCPObservabilityEvent } from './mcp';
+import type {
+  ChannelEventMap,
+  Observability,
+  ObservabilityEvent,
+} from './observability';
 
-/**
- * Base event structure from Agents SDK (mirrors agents/src/observability/base.ts)
- */
-export interface BaseAgentEvent<
-  T extends string,
-  Payload extends Record<string, unknown> = Record<string, unknown>
-> {
-  type: T;
-  /** Unique identifier for the event */
-  id: string;
-  /** Human-readable message for logging */
-  displayMessage: string;
-  /** Event payload with type-specific data */
-  payload: Payload & Record<string, unknown>;
-  /** Timestamp in milliseconds since epoch */
-  timestamp: number;
-}
-
-/**
- * Agent-specific observability events
- */
-export type AgentObservabilityEvent =
-  | BaseAgentEvent<'state:update', Record<string, unknown>>
-  | BaseAgentEvent<
-      'rpc',
-      {
-        method: string;
-        streaming?: boolean;
-      }
-    >
-  | BaseAgentEvent<'message:request' | 'message:response', Record<string, unknown>>
-  | BaseAgentEvent<'message:clear'>
-  | BaseAgentEvent<
-      'schedule:create' | 'schedule:execute' | 'schedule:cancel',
-      {
-        callback: string;
-        id: string;
-      }
-    >
-  | BaseAgentEvent<'destroy'>
-  | BaseAgentEvent<
-      'connect',
-      {
-        connectionId: string;
-      }
-    >;
-
-/**
- * MCP-specific observability events
- */
-export type MCPObservabilityEvent =
-  | BaseAgentEvent<'mcp:client:preconnect', { serverId: string }>
-  | BaseAgentEvent<
-      'mcp:client:connect',
-      { url: string; transport: string; state: string; error?: string }
-    >
-  | BaseAgentEvent<
-      'mcp:client:authorize',
-      {
-        serverId: string;
-        authUrl: string;
-        clientId?: string;
-      }
-    >
-  | BaseAgentEvent<'mcp:client:discover', Record<string, unknown>>;
+export type { BaseEvent, AgentObservabilityEvent, MCPObservabilityEvent };
+export type { Observability, ObservabilityEvent, ChannelEventMap };
 
-/**
- * Union of all observability event types
- */
-export type ObservabilityEvent = AgentObservabilityEvent | MCPObservabilityEvent;
-
-/**
- * Observability interface from Agents SDK
- */
-export interface Observability {
-  /**
-   * Emit an event for the Agent's observability implementation to handle.
-   * @param event - The event to emit
-   * @param ctx - The execution context of the invocation (optional)
-   */
-  emit(event: ObservabilityEvent, ctx?: DurableObjectState): void;
-}
+export type ObservabilityExecutionContext = DurableObjectState | ExecutionContext;
 
-/**
- * Agent-specific instrumentation options
- */
 export interface AgentInstrumentationOptions {
-  /**
-   * Whether to create spans for RPC calls
-   * @default true
-   */
   traceRpc?: boolean;
-
-  /**
-   * Whether to create spans for schedule operations
-   * @default true
-   */
   traceSchedule?: boolean;
-
-  /**
-   * Whether to create spans for MCP operations
-   * @default true
-   */
+  traceQueue?: boolean;
+  traceSubmissions?: boolean;
   traceMcp?: boolean;
-
-  /**
-   * Whether to create spans for state updates
-   * @default false (can be noisy)
-   */
   traceStateUpdates?: boolean;
-
-  /**
-   * Whether to create spans for message events
-   * @default true
-   */
   traceMessages?: boolean;
-
-  /**
-   * Whether to create spans for connect/destroy lifecycle events
-   * @default true
-   */
   traceLifecycle?: boolean;
-
-  /**
-   * Custom attribute extractor for events
-   */
+  traceChat?: boolean;
+  traceTranscripts?: boolean;
+  traceFibers?: boolean;
+  traceToolRecovery?: boolean;
+  traceWorkflow?: boolean;
+  traceEmail?: boolean;
   attributeExtractor?: (event: ObservabilityEvent) => Attributes;
-
-  /**
-   * Custom span name formatter
-   */
   spanNameFormatter?: (event: ObservabilityEvent) => string;
 }
 
-/**
- * Configuration for OtelObservability
- */
 export type OtelObservabilityConfig = ConfigurationOption & {
-  /**
-   * Agent-specific instrumentation options
-   */
   agents?: AgentInstrumentationOptions;
 };
 
-/**
- * Semantic attributes for Agent spans
- */
 export interface AgentSpanAttributes {
   'agent.event.type': string;
-  'agent.event.id': string;
+  'agent.event.id'?: string;
+  'agent.class'?: string;
+  'agent.instance.name'?: string;
+  'agent.display_message'?: string;
+  'agent.framework'?: string;
+  'gen_ai.agent.name'?: string;
   'agent.rpc.method'?: string;
   'agent.rpc.streaming'?: boolean;
   'agent.schedule.callback'?: string;

package/src/agents.ts

@@ -47,12 +47,20 @@
  * const observability = createOtelObservability({
  *   service: { name: 'my-agent' },
  *   agents: {
- *     traceRpc: true,           // Trace RPC calls (default: true)
- *     traceSchedule: true,      // Trace scheduled tasks (default: true)
- *     traceMcp: true,           // Trace MCP operations (default: true)
- *     traceStateUpdates: false, // Skip state updates (default: false, can be noisy)
- *     traceMessages: true,      // Trace message events (default: true)
- *     traceLifecycle: true,     // Trace connect/destroy (default: true)
+ *     traceRpc: true,            // RPC and rpc:error
+ *     traceSchedule: true,       // schedule:* events
+ *     traceQueue: true,          // queue:* events
+ *     traceSubmissions: true,    // submission:* events
+ *     traceMcp: true,            // mcp:* events
+ *     traceStateUpdates: false,  // state:update (off by default; noisy)
+ *     traceMessages: true,       // message:* and tool:* events
+ *     traceChat: true,           // chat:* recovery/stream/context events
+ *     traceTranscripts: true,    // chat:transcript:* events
+ *     traceFibers: true,         // fiber:* events
+ *     traceToolRecovery: true,   // agent_tool:* recovery events
+ *     traceWorkflow: true,       // workflow:* events
+ *     traceEmail: true,          // email:* events
+ *     traceLifecycle: true,      // connect/disconnect/destroy
  *   }
  * })
  * ```
@@ -65,12 +73,15 @@ export {
   createOtelObservabilityFromEnv,
   OtelObservability,
 } from './agents/otel-observability';
+export { channels, genericObservability, subscribe } from './agents/observability';
 export type {
+  BaseEvent,
   OtelObservabilityConfig,
   AgentObservabilityEvent,
   MCPObservabilityEvent,
   ObservabilityEvent,
   Observability,
+  ChannelEventMap,
   AgentInstrumentationOptions,
   AgentSpanAttributes,
 } from './agents/types';

package/src/index.ts

@@ -81,3 +81,11 @@ export {
 
 // Global instrumentations
 export { instrumentGlobalFetch, instrumentGlobalCache } from './global';
+
+// Cloudflare native tracing helpers (auto-wired by the handler wrappers;
+// exported for manual detection). `enterSpan` is re-exported from autotel-edge
+// above via `export * from 'autotel-edge'`.
+export {
+  isNativeTracingAvailable,
+  getNativeTracerFromCtx,
+} from './native/native-tracing';

package/src/native/native-tracing.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  isNativeTracingAvailable,
+  getNativeTracerFromCtx,
+} from './native-tracing';
+
+function ctxWithTracing() {
+  const enterSpan = vi.fn((_name: string, cb: (s: any) => unknown) =>
+    cb({ isTraced: true, setAttribute: vi.fn() }),
+  );
+  return { tracing: { enterSpan }, waitUntil() {}, passThroughOnException() {} };
+}
+
+describe('isNativeTracingAvailable', () => {
+  it('is true when ctx.tracing.enterSpan is a function', () => {
+    expect(isNativeTracingAvailable(ctxWithTracing())).toBe(true);
+  });
+
+  it('is false for a plain ExecutionContext (tracing disabled / old runtime)', () => {
+    expect(isNativeTracingAvailable({ waitUntil() {} })).toBe(false);
+  });
+
+  it('is false for null/undefined or malformed tracing', () => {
+    expect(isNativeTracingAvailable(undefined)).toBe(false);
+    expect(isNativeTracingAvailable(null)).toBe(false);
+    expect(isNativeTracingAvailable({ tracing: {} })).toBe(false);
+    expect(isNativeTracingAvailable({ tracing: { enterSpan: 123 } })).toBe(false);
+  });
+});
+
+describe('getNativeTracerFromCtx', () => {
+  it('returns null when native tracing is unavailable', () => {
+    expect(getNativeTracerFromCtx({ waitUntil() {} })).toBeNull();
+  });
+
+  it('wraps ctx.tracing.enterSpan as a NativeTracer', () => {
+    const ctx = ctxWithTracing();
+    const tracer = getNativeTracerFromCtx(ctx);
+    expect(tracer).not.toBeNull();
+
+    const result = tracer!.enterSpan('work', (span) => {
+      span.setAttribute('k', 'v');
+      return 7;
+    });
+
+    expect(result).toBe(7);
+    expect(ctx.tracing.enterSpan).toHaveBeenCalledWith('work', expect.any(Function));
+  });
+
+  it('attaches the supplied correlation id to the tracer', () => {
+    const tracer = getNativeTracerFromCtx(ctxWithTracing(), 'ray-xyz');
+    expect(tracer?.correlationId).toBe('ray-xyz');
+  });
+});

package/src/native/native-tracing.ts

@@ -0,0 +1,83 @@
+/**
+ * Cloudflare native tracing adapter
+ *
+ * Bridges Cloudflare Workers' built-in custom-span API
+ * (`ctx.tracing.enterSpan()` / `import { tracing } from "cloudflare:workers"`)
+ * to autotel-edge's runtime-agnostic {@link NativeTracer} seam.
+ *
+ * When a Worker has tracing enabled (`observability.traces.enabled = true` in
+ * Wrangler) the runtime exposes `ctx.tracing`. The handler wrappers detect it,
+ * wrap it as a {@link NativeTracer}, and install it into the active context with
+ * `withNativeTracer()`. From then on every autotel `span()` / `trace()` /
+ * `enterSpan()` call — including deep inside utility functions and libraries —
+ * automatically routes to Cloudflare's native tracer and nests inside the
+ * platform's trace waterfall (fetch / KV / R2 / D1 / handler spans), exported
+ * by Cloudflare to whichever destination is configured in Wrangler.
+ *
+ * No `cloudflare:workers` import is required here: the native tracer travels
+ * through autotel's AsyncLocalStorage context, so code without access to `ctx`
+ * still picks it up via `getActiveNativeTracer()`.
+ */
+
+import type { NativeTracer, NativeSpanHandle } from 'autotel-edge';
+
+/**
+ * Cloudflare's native custom-span surface. Declared locally because it is not
+ * yet present in `@cloudflare/workers-types`. Structurally compatible with
+ * autotel-edge's {@link NativeSpanHandle}.
+ */
+interface CloudflareSpan {
+  readonly isTraced: boolean;
+  setAttribute(key: string, value: string | number | boolean | undefined): void;
+}
+
+/**
+ * Cloudflare's `tracing` object, available as `ctx.tracing` on the
+ * ExecutionContext and as the `tracing` export of `cloudflare:workers`.
+ */
+interface CloudflareTracing {
+  enterSpan<T, A extends unknown[]>(
+    name: string,
+    callback: (span: CloudflareSpan, ...args: A) => T,
+    ...args: A
+  ): T;
+}
+
+type MaybeTracingCarrier = { tracing?: CloudflareTracing } | null | undefined;
+
+function readTracing(carrier: unknown): CloudflareTracing | undefined {
+  const tracing = (carrier as MaybeTracingCarrier)?.tracing;
+  return typeof tracing?.enterSpan === 'function' ? tracing : undefined;
+}
+
+/**
+ * Returns `true` when Cloudflare native custom-span tracing is available on the
+ * given ExecutionContext (i.e. tracing is enabled for this Worker).
+ */
+export function isNativeTracingAvailable(ctx: unknown): boolean {
+  return readTracing(ctx) !== undefined;
+}
+
+/**
+ * Wrap Cloudflare's `ctx.tracing` as an autotel {@link NativeTracer}, or return
+ * `null` when native tracing is unavailable on this context.
+ *
+ * @param correlationId Optional per-request id (e.g. the `cf-ray` header)
+ * surfaced as `ctx.correlationId` and a `correlation.id` span attribute, so
+ * logs, custom spans, and the Cloudflare dashboard share one queryable key
+ * today — before Cloudflare exposes in-code trace/span ids.
+ */
+export function getNativeTracerFromCtx(
+  ctx: unknown,
+  correlationId?: string,
+): NativeTracer | null {
+  const tracing = readTracing(ctx);
+  if (!tracing) {
+    return null;
+  }
+  return {
+    correlationId,
+    enterSpan: <T>(name: string, callback: (span: NativeSpanHandle) => T): T =>
+      tracing.enterSpan(name, callback as (span: CloudflareSpan) => T),
+  };
+}

package/src/native.ts

@@ -0,0 +1,12 @@
+/**
+ * autotel-cloudflare/native
+ *
+ * Cloudflare native tracing helpers. Most users never need this entry point —
+ * the handler wrappers (`instrument`, `wrapModule`, `defineWorkerFetch`,
+ * `wrapDurableObject`) auto-detect and wire up native tracing for you. Import
+ * from here only when you want to detect native tracing yourself.
+ */
+export {
+  isNativeTracingAvailable,
+  getNativeTracerFromCtx,
+} from './native/native-tracing';

package/src/wrappers/instrument.ts

@@ -41,10 +41,14 @@ import {
   getActiveConfig,
   getServiceForPath,
   shouldInstrumentPath,
+  withNativeTracer,
+  ensureGlobalContextManager,
   type Initialiser,
+  type NativeTracer,
   WorkerTracerProvider,
   WorkerTracer,
 } from 'autotel-edge';
+import { getNativeTracerFromCtx } from '../native/native-tracing';
 import { proxyExecutionContext, unwrap, wrap, type PromiseTracker } from '../bindings/common';
 import { instrumentGlobalFetch } from '../global/fetch';
 import { instrumentGlobalCache } from '../global/cache';
@@ -528,6 +532,68 @@ function createHandlerFlow<T extends Trigger, E, R>(
   };
 }
 
+let warnedMissingNative = false;
+
+/**
+ * Resolve whether this invocation should use Cloudflare's native tracer.
+ *
+ * - `nativeTracing: 'off'` → never use native (always autotel's OTLP pipeline).
+ * - `nativeTracing: 'on'`  → require native; warn once and fall back if absent.
+ * - `nativeTracing: 'auto'` (default) → use native when `ctx.tracing` exists.
+ */
+function resolveNativeTracer(
+  config: ResolvedEdgeConfig,
+  ctx: ExecutionContext,
+  trigger: Trigger,
+): NativeTracer | null {
+  const mode = config.nativeTracing ?? 'auto';
+  if (mode === 'off') {
+    return null;
+  }
+  // Correlation id: prefer Cloudflare's ray id (also stamped on the native root
+  // span + carried by the workers logger), so logs/spans/dashboard share a key.
+  // Fall back to a per-invocation uuid for non-fetch triggers.
+  const rayId = trigger instanceof Request ? trigger.headers.get('cf-ray') : null;
+  const correlationId = rayId ?? crypto.randomUUID();
+  const nativeTracer = getNativeTracerFromCtx(ctx, correlationId);
+  if (!nativeTracer && mode === 'on' && !warnedMissingNative) {
+    warnedMissingNative = true;
+    console.warn(
+      "[autotel-cloudflare] nativeTracing is 'on' but Cloudflare native tracing was not detected. " +
+        'Enable observability.traces in your Wrangler config (and use a recent compatibility_date). ' +
+        'Falling back to the autotel OTLP exporter.',
+    );
+  }
+  return nativeTracer;
+}
+
+/**
+ * Run a handler in native-tracing mode.
+ *
+ * Cloudflare already creates the root handler span and instruments platform
+ * operations (fetch / KV / R2 / D1 / DO), so autotel defers entirely: no
+ * binding proxies (avoids duplicate spans), no provider/exporter, no manual
+ * flush. We install the native tracer into the active context so that the
+ * user's `span()` / `trace()` / `enterSpan()` calls nest inside Cloudflare's
+ * native waterfall and are exported by the platform.
+ */
+function runWithNativeTracing<T extends Trigger, E, R>(
+  handlerFn: (trigger: T, env: E, ctx: ExecutionContext) => R | Promise<R>,
+  trigger: T,
+  env: E,
+  ctx: ExecutionContext,
+  config: ResolvedEdgeConfig,
+  nativeTracer: NativeTracer,
+): R | Promise<R> {
+  // Register the context manager (we skip initProvider in native mode) so the
+  // native tracer propagates through OTel context into span()/trace() — without
+  // it, getActiveNativeTracer() returns null and custom spans never route to
+  // enterSpan. Bindings are NOT proxied: Cloudflare instruments them natively.
+  ensureGlobalContextManager();
+  const nativeContext = withNativeTracer(nativeTracer, setConfig(config));
+  return api_context.with(nativeContext, () => handlerFn(trigger, env, ctx));
+}
+
 /**
  * Create handler proxy
  */
@@ -539,16 +605,22 @@ function createHandlerProxy<T extends Trigger, E, R>(
 ): (trigger: T, env: E, ctx: ExecutionContext) => ReturnType<typeof handlerFn> {
   return (trigger: T, env: E, ctx: ExecutionContext) => {
     const config = initialiser(env, trigger);
-    
+
     // Check if instrumentation is disabled (useful for local dev)
     if (config.instrumentation.disabled) {
       // Return handler as-is without instrumentation
       return handlerFn(trigger, env, ctx);
     }
-    
+
+    // Prefer Cloudflare native tracing when available — defer to the platform.
+    const nativeTracer = resolveNativeTracer(config, ctx, trigger);
+    if (nativeTracer) {
+      return runWithNativeTracing(handlerFn, trigger, env, ctx, config, nativeTracer);
+    }
+
     // Auto-instrument Cloudflare bindings in the environment
     const instrumentedEnv = instrumentBindings(env as Record<string, any>) as E;
-    
+
     const configContext = setConfig(config);
 
     // Initialize provider on first call
@@ -593,10 +665,16 @@ function createHandlerProxyWithConfig<T extends Trigger, E, R>(
         return handlerFn(trigger, env, ctx) as ReturnType<typeof handlerFn>;
       }
     }
-    
+
+    // Prefer Cloudflare native tracing when available — defer to the platform.
+    const nativeTracer = resolveNativeTracer(config, ctx, trigger);
+    if (nativeTracer) {
+      return runWithNativeTracing(handlerFn, trigger, env, ctx, config, nativeTracer) as ReturnType<typeof handlerFn>;
+    }
+
     // Auto-instrument Cloudflare bindings in the environment
     const instrumentedEnv = instrumentBindings(env as Record<string, any>) as E;
-    
+
     const configContext = setConfig(config);
 
     // Initialize provider on first call

package/src/wrappers/native-instrument.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect, vi } from 'vitest';
+import { instrument } from './instrument';
+import { span } from 'autotel-edge';
+import { isWrapped } from '../bindings/common';
+
+/**
+ * A KV-shaped binding so instrumentBindings() would proxy it in the OTLP path.
+ * In native mode we must NOT proxy it (Cloudflare traces KV natively) — these
+ * tests assert that the handler receives the original, unwrapped binding and
+ * that user spans route to ctx.tracing.enterSpan instead of the OTel pipeline.
+ */
+function fakeKv() {
+  return {
+    get: vi.fn(async () => 'value'),
+    put: vi.fn(async () => {}),
+    delete: vi.fn(async () => {}),
+    list: vi.fn(async () => ({ keys: [] })),
+  };
+}
+
+function nativeCtx() {
+  const enteredSpans: string[] = [];
+  const waitUntil = vi.fn();
+  const ctx = {
+    waitUntil,
+    passThroughOnException() {},
+    tracing: {
+      enterSpan: vi.fn((name: string, cb: (s: any) => unknown) => {
+        enteredSpans.push(name);
+        return cb({ isTraced: true, setAttribute: vi.fn() });
+      }),
+    },
+  };
+  return { ctx, enteredSpans, waitUntil };
+}
+
+const baseConfig = {
+  service: { name: 'native-test' },
+  exporter: { url: 'http://localhost:4318/v1/traces' },
+} as const;
+
+describe('instrument() with Cloudflare native tracing (auto)', () => {
+  it('defers binding instrumentation to the platform (no proxy wrapping)', async () => {
+    const { ctx } = nativeCtx();
+    const kv = fakeKv();
+    let seenBinding: unknown;
+
+    const handler = instrument(
+      {
+        async fetch(_req, env: { MY_KV: ReturnType<typeof fakeKv> }) {
+          seenBinding = env.MY_KV;
+          await env.MY_KV.get('k');
+          return new Response('ok');
+        },
+      },
+      baseConfig,
+    );
+
+    await handler.fetch!(new Request('https://x/'), { MY_KV: kv }, ctx as never);
+
+    // Handler received the ORIGINAL binding, not an autotel proxy.
+    expect(seenBinding).toBe(kv);
+    expect(isWrapped(seenBinding)).toBe(false);
+    // No "KV ...: get" span was created via the native tracer.
+    expect(
+      ctx.tracing.enterSpan.mock.calls.some(([name]) =>
+        String(name).startsWith('KV '),
+      ),
+    ).toBe(false);
+  });
+
+  it('surfaces the cf-ray header as a correlation.id span attribute', async () => {
+    const attrs: Record<string, unknown> = {};
+    const ctx = {
+      waitUntil() {},
+      passThroughOnException() {},
+      tracing: {
+        enterSpan: vi.fn((_name: string, cb: (s: any) => unknown) =>
+          cb({
+            isTraced: true,
+            setAttribute(k: string, v: unknown) {
+              attrs[k] = v;
+            },
+          }),
+        ),
+      },
+    };
+
+    const handler = instrument(
+      { async fetch() { return span('work', () => new Response('ok')); } },
+      baseConfig,
+    );
+
+    const req = new Request('https://x/', { headers: { 'cf-ray': 'ray-7f' } });
+    await handler.fetch!(req, {}, ctx as never);
+    expect(attrs['correlation.id']).toBe('ray-7f');
+  });
+
+  it('routes user span() calls to ctx.tracing.enterSpan', async () => {
+    const { ctx, enteredSpans } = nativeCtx();
+
+    const handler = instrument(
+      {
+        async fetch() {
+          return span('user.work', (s) => {
+            s.setAttribute('ok', true);
+            return new Response('done');
+          });
+        },
+      },
+      baseConfig,
+    );
+
+    const res = await handler.fetch!(new Request('https://x/'), {}, ctx as never);
+    expect(await res.text()).toBe('done');
+    expect(enteredSpans).toContain('user.work');
+  });
+
+  it('does not run the OTLP export flow (no waitUntil) in native mode', async () => {
+    const { ctx, waitUntil } = nativeCtx();
+    const handler = instrument(
+      { async fetch() { return new Response('ok'); } },
+      baseConfig,
+    );
+    await handler.fetch!(new Request('https://x/'), {}, ctx as never);
+    expect(waitUntil).not.toHaveBeenCalled();
+  });
+});
+
+describe('instrument() with nativeTracing: "off"', () => {
+  it('ignores ctx.tracing and uses the autotel pipeline (proxies bindings)', async () => {
+    const { ctx } = nativeCtx();
+    const kv = fakeKv();
+    let seenBinding: unknown;
+
+    const handler = instrument(
+      {
+        async fetch(_req, env: { MY_KV: ReturnType<typeof fakeKv> }) {
+          seenBinding = env.MY_KV;
+          return new Response('ok');
+        },
+      },
+      { ...baseConfig, nativeTracing: 'off' },
+    );
+
+    await handler.fetch!(new Request('https://x/'), { MY_KV: kv }, ctx as never);
+
+    // OTLP path proxies the binding, so the handler sees a wrapped object.
+    expect(isWrapped(seenBinding)).toBe(true);
+    // Native tracer was never used.
+    expect(ctx.tracing.enterSpan).not.toHaveBeenCalled();
+  });
+});