npm - @ai-sdk/devtools - Versions diffs - 1.0.0-beta.9 → 1.0.0-canary.21 - Mend

@ai-sdk/devtools 1.0.0-beta.9 → 1.0.0-canary.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

package/dist/client/assets/index-B1quREL_.css +1 -0
package/dist/client/assets/index-DYruJ8X0.js +181 -0
package/dist/client/index.html +2 -2
package/dist/index.d.ts +19 -1
package/dist/index.js +342 -3
package/dist/viewer/server.js +42 -5
package/package.json +28 -4
package/src/db.ts +32 -5
package/src/index.ts +1 -0
package/src/integration.ts +509 -0
package/src/middleware.ts +5 -5
package/src/viewer/client/app.tsx +97 -1878
package/src/viewer/client/components/message-components.tsx +342 -0
package/src/viewer/client/components/output-components.tsx +145 -0
package/src/viewer/client/components/shared-components.tsx +691 -0
package/src/viewer/client/components/step-card.tsx +472 -0
package/src/viewer/client/components/trace-timeline.tsx +529 -0
package/src/viewer/client/components/ui/badge.tsx +0 -1
package/src/viewer/client/components/ui/button.tsx +0 -1
package/src/viewer/client/types.ts +183 -0
package/src/viewer/client/utils.ts +708 -0
package/src/viewer/server.ts +49 -5
package/dist/client/assets/index-BkyOIjbt.css +0 -1
package/dist/client/assets/index-BwqXGbSV.js +0 -176

package/dist/client/index.html CHANGED Viewed

@@ -10,8 +10,8 @@
       href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600;700&family=Geist+Mono:wght@400;500;600;700&display=swap"
       rel="stylesheet"
     />
-    <script type="module" crossorigin src="/assets/index-BwqXGbSV.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BkyOIjbt.css">
+    <script type="module" crossorigin src="/assets/index-DYruJ8X0.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B1quREL_.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/index.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import { LanguageModelV4Middleware } from '@ai-sdk/provider';
+import { Telemetry } from 'ai';
 /**
  * Factory function that creates a devtools middleware instance.
@@ -18,4 +19,21 @@ import { LanguageModelV4Middleware } from '@ai-sdk/provider';
  */
 declare const devToolsMiddleware: () => LanguageModelV4Middleware;
-export { devToolsMiddleware };
+/**
+ * Creates a devtools telemetry integration that logs all AI SDK operations
+ * to the devtools viewer.
+ *
+ * Usage:
+ * ```ts
+ * import { registerTelemetry } from 'ai';
+ * import { DevToolsTelemetry } from '@ai-sdk/devtools';
+ *
+ * registerTelemetry(DevToolsTelemetry());
+ * ```
+ *
+ * Telemetry is enabled by default — no need to set `telemetry`
+ * unless you want to configure `functionId`, `recordInputs`, or `recordOutputs`.
+ */
+declare function DevToolsTelemetry(): Telemetry;
+export { DevToolsTelemetry, devToolsMiddleware };

package/dist/index.js CHANGED Viewed

@@ -12,7 +12,7 @@ var notifyServerAsync = async (event) => {
     await fetch(`http://localhost:${DEVTOOLS_PORT}/api/notify`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ event, timestamp: Date.now() })
+      body: JSON.stringify({ event, timestamp: Date.now(), dbPath: DB_PATH })
     });
   } catch {
   }
@@ -64,14 +64,20 @@ var saveDb = (db) => {
   dbCache = db;
   writeDb(db);
 };
-var createRun = async (id) => {
+var createRun = async (id, parent, functionId) => {
   const db = getDb();
   const started_at = (/* @__PURE__ */ new Date()).toISOString();
   const existing = db.runs.find((r) => r.id === id);
   if (existing) {
     return existing;
   }
-  const run = { id, started_at };
+  const run = {
+    id,
+    started_at,
+    parent_run_id: parent?.runId ?? null,
+    parent_step_id: parent?.stepId ?? null,
+    function_id: functionId ?? null
+  };
   db.runs.push(run);
   saveDb(db);
   notifyServer("run");
@@ -379,6 +385,339 @@ var devToolsMiddleware = () => {
     }
   };
 };
+// src/integration.ts
+var activeSteps2 = /* @__PURE__ */ new Map();
+var signalHandlersRegistered2 = false;
+var registerSignalHandlers2 = () => {
+  if (signalHandlersRegistered2) return;
+  signalHandlersRegistered2 = true;
+  const cleanup = async () => {
+    if (activeSteps2.size === 0) return;
+    const promises = Array.from(activeSteps2.entries()).map(
+      async ([stepId, data]) => {
+        const durationMs = Date.now() - data.startTime;
+        await updateStepResult(stepId, {
+          duration_ms: durationMs,
+          output: null,
+          usage: null,
+          error: "Request aborted",
+          raw_request: null,
+          raw_response: null,
+          raw_chunks: null
+        });
+      }
+    );
+    await Promise.all(promises);
+    await notifyServerAsync("step-update");
+  };
+  process.on("SIGINT", () => {
+    cleanup().then(() => process.exit(130));
+  });
+  process.on("SIGTERM", () => {
+    cleanup().then(() => process.exit(143));
+  });
+};
+var generateRunId2 = () => {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString().replace(/[-:T.Z]/g, "").slice(0, 17);
+  const uniqueId = crypto.randomUUID().slice(0, 8);
+  return `${timestamp}-${uniqueId}`;
+};
+function getOperationType(operationId) {
+  if (operationId === "ai.streamText" || operationId === "ai.streamObject") {
+    return "stream";
+  }
+  return "generate";
+}
+function DevToolsTelemetry() {
+  if (process.env.NODE_ENV === "production") {
+    throw new Error(
+      "@ai-sdk/devtools should not be used in production. Remove DevToolsTelemetry from your telemetry configuration for production builds."
+    );
+  }
+  registerSignalHandlers2();
+  const callStates = /* @__PURE__ */ new Map();
+  const toolContextMap = /* @__PURE__ */ new Map();
+  let currentToolCallId = null;
+  function resolveParentInfo() {
+    if (!currentToolCallId) return void 0;
+    const ctx = toolContextMap.get(currentToolCallId);
+    if (!ctx) return void 0;
+    const parentState = callStates.get(ctx.parentCallId);
+    if (!parentState) return void 0;
+    let latestStepId;
+    let latestStepNumber = -1;
+    for (const [stepNumber, stepState] of parentState.stepStates) {
+      if (stepNumber > latestStepNumber) {
+        latestStepNumber = stepNumber;
+        latestStepId = stepState.stepId;
+      }
+    }
+    if (!latestStepId) return void 0;
+    return { runId: parentState.runId, stepId: latestStepId };
+  }
+  function getOrCreateCallState(callId, operationId, event) {
+    let state = callStates.get(callId);
+    if (state) return state;
+    state = {
+      runId: generateRunId2(),
+      operationType: getOperationType(operationId),
+      functionId: event.functionId,
+      settings: {
+        maxOutputTokens: event.maxOutputTokens,
+        temperature: event.temperature,
+        topP: event.topP,
+        topK: event.topK,
+        presencePenalty: event.presencePenalty,
+        frequencyPenalty: event.frequencyPenalty,
+        seed: event.seed
+      },
+      stepStates: /* @__PURE__ */ new Map()
+    };
+    callStates.set(callId, state);
+    return state;
+  }
+  const integration = {
+    onStart: async (event) => {
+      const operationId = event.operationId;
+      if (operationId === "ai.embed" || operationId === "ai.embedMany" || operationId === "ai.rerank") {
+        return;
+      }
+      const startEvent = event;
+      const parentInfo = resolveParentInfo();
+      const state = getOrCreateCallState(
+        startEvent.callId,
+        operationId,
+        startEvent
+      );
+      await createRun(state.runId, parentInfo, state.functionId);
+    },
+    onStepStart: async (event) => {
+      const stepStartEvent = event;
+      const state = callStates.get(stepStartEvent.callId);
+      if (!state) return;
+      const stepId = crypto.randomUUID();
+      const startTime = Date.now();
+      const stepState = {
+        stepId,
+        startTime,
+        streamChunks: [],
+        rawStreamChunks: []
+      };
+      const stepNumber = stepStartEvent.steps.length;
+      state.stepStates.set(stepNumber, stepState);
+      activeSteps2.set(stepId, stepState);
+      const prompt = stepStartEvent.promptMessages ?? stepStartEvent.messages;
+      await createStep({
+        id: stepId,
+        run_id: state.runId,
+        step_number: stepNumber + 1,
+        type: state.operationType,
+        model_id: stepStartEvent.modelId,
+        provider: stepStartEvent.provider ?? null,
+        started_at: (/* @__PURE__ */ new Date()).toISOString(),
+        input: JSON.stringify({
+          prompt,
+          tools: stepStartEvent.tools ? Object.entries(stepStartEvent.tools).map(([name, tool]) => ({
+            name,
+            description: tool.description,
+            parameters: tool.parameters
+          })) : void 0,
+          toolChoice: stepStartEvent.toolChoice,
+          maxOutputTokens: state.settings.maxOutputTokens,
+          temperature: state.settings.temperature,
+          topP: state.settings.topP,
+          topK: state.settings.topK,
+          presencePenalty: state.settings.presencePenalty,
+          frequencyPenalty: state.settings.frequencyPenalty,
+          seed: state.settings.seed
+        }),
+        provider_options: stepStartEvent.providerOptions ? JSON.stringify(stepStartEvent.providerOptions) : null
+      });
+    },
+    onObjectStepStart: async (event) => {
+      const stepStartEvent = event;
+      const state = callStates.get(stepStartEvent.callId);
+      if (!state) return;
+      const stepId = crypto.randomUUID();
+      const startTime = Date.now();
+      const stepState = {
+        stepId,
+        startTime,
+        streamChunks: [],
+        rawStreamChunks: []
+      };
+      state.stepStates.set(stepStartEvent.stepNumber, stepState);
+      activeSteps2.set(stepId, stepState);
+      await createStep({
+        id: stepId,
+        run_id: state.runId,
+        step_number: stepStartEvent.stepNumber + 1,
+        type: state.operationType,
+        model_id: stepStartEvent.modelId,
+        provider: stepStartEvent.provider ?? null,
+        started_at: (/* @__PURE__ */ new Date()).toISOString(),
+        input: JSON.stringify({
+          prompt: stepStartEvent.promptMessages,
+          maxOutputTokens: state.settings.maxOutputTokens,
+          temperature: state.settings.temperature,
+          topP: state.settings.topP,
+          topK: state.settings.topK,
+          presencePenalty: state.settings.presencePenalty,
+          frequencyPenalty: state.settings.frequencyPenalty,
+          seed: state.settings.seed
+        }),
+        provider_options: stepStartEvent.providerOptions ? JSON.stringify(stepStartEvent.providerOptions) : null
+      });
+    },
+    onChunk: async (event) => {
+      const { chunk } = event;
+      if (chunk.type === "raw") {
+        const rawValue = chunk.rawValue;
+        for (const [, state] of callStates) {
+          let latestStepState;
+          let latestStepNumber = -1;
+          for (const [stepNumber, ss] of state.stepStates) {
+            if (stepNumber > latestStepNumber) {
+              latestStepNumber = stepNumber;
+              latestStepState = ss;
+            }
+          }
+          if (latestStepState) {
+            latestStepState.rawStreamChunks.push(rawValue);
+            return;
+          }
+        }
+        return;
+      }
+      if ("callId" in chunk && "stepNumber" in chunk) {
+        const typed = chunk;
+        const state = callStates.get(typed.callId);
+        if (!state) return;
+        const stepState = state.stepStates.get(typed.stepNumber);
+        if (!stepState) return;
+        stepState.streamChunks.push(chunk);
+        return;
+      }
+      for (const [, state] of callStates) {
+        let latestStepState;
+        let latestStepNumber = -1;
+        for (const [stepNumber, ss] of state.stepStates) {
+          if (stepNumber > latestStepNumber) {
+            latestStepNumber = stepNumber;
+            latestStepState = ss;
+          }
+        }
+        if (latestStepState) {
+          latestStepState.streamChunks.push(chunk);
+          return;
+        }
+      }
+    },
+    onStepFinish: async (event) => {
+      const stepResult = event;
+      const state = callStates.get(stepResult.callId);
+      if (!state) return;
+      const stepState = state.stepStates.get(stepResult.stepNumber);
+      if (!stepState) return;
+      activeSteps2.delete(stepState.stepId);
+      const durationMs = Date.now() - stepState.startTime;
+      const output = {
+        content: stepResult.content,
+        finishReason: stepResult.finishReason,
+        response: {
+          id: stepResult.response.id,
+          modelId: stepResult.response.modelId,
+          timestamp: stepResult.response.timestamp,
+          messages: stepResult.response.messages
+        }
+      };
+      const hasStreamChunks = stepState.streamChunks.length > 0;
+      const hasRawStreamChunks = stepState.rawStreamChunks.length > 0;
+      await updateStepResult(stepState.stepId, {
+        duration_ms: durationMs,
+        output: JSON.stringify(output),
+        usage: stepResult.usage ? JSON.stringify(stepResult.usage) : null,
+        error: null,
+        raw_request: stepResult.request?.body ? JSON.stringify(stepResult.request.body) : null,
+        raw_response: stepResult.response?.body ? JSON.stringify(stepResult.response.body) : hasStreamChunks ? JSON.stringify(stepState.streamChunks) : null,
+        raw_chunks: hasRawStreamChunks ? JSON.stringify(stepState.rawStreamChunks) : null
+      });
+      state.stepStates.delete(stepResult.stepNumber);
+    },
+    onObjectStepFinish: async (event) => {
+      const stepResult = event;
+      const state = callStates.get(stepResult.callId);
+      if (!state) return;
+      const stepState = state.stepStates.get(stepResult.stepNumber);
+      if (!stepState) return;
+      activeSteps2.delete(stepState.stepId);
+      const durationMs = Date.now() - stepState.startTime;
+      const output = {
+        finishReason: stepResult.finishReason,
+        objectText: stepResult.objectText,
+        response: {
+          id: stepResult.response.id,
+          modelId: stepResult.response.modelId,
+          timestamp: stepResult.response.timestamp
+        }
+      };
+      await updateStepResult(stepState.stepId, {
+        duration_ms: durationMs,
+        output: JSON.stringify(output),
+        usage: stepResult.usage ? JSON.stringify(stepResult.usage) : null,
+        error: null,
+        raw_request: stepResult.request?.body ? JSON.stringify(stepResult.request.body) : null,
+        raw_response: stepResult.response?.body ? JSON.stringify(stepResult.response.body) : null
+      });
+      state.stepStates.delete(stepResult.stepNumber);
+    },
+    onFinish: async (event) => {
+      const finishEvent = event;
+      callStates.delete(finishEvent.callId);
+    },
+    onError: async (error) => {
+      const errorObj = error;
+      const callId = errorObj?.callId;
+      if (!callId) return;
+      const state = callStates.get(callId);
+      if (!state) return;
+      const cause = errorObj?.error ?? error;
+      const errorMessage = cause instanceof Error ? cause.message : String(cause);
+      for (const [, stepState] of state.stepStates) {
+        activeSteps2.delete(stepState.stepId);
+        const durationMs = Date.now() - stepState.startTime;
+        await updateStepResult(stepState.stepId, {
+          duration_ms: durationMs,
+          output: null,
+          usage: null,
+          error: errorMessage,
+          raw_request: null,
+          raw_response: null,
+          raw_chunks: null
+        });
+      }
+      callStates.delete(callId);
+    },
+    executeTool: async ({ callId, toolCallId, execute }) => {
+      toolContextMap.set(toolCallId, {
+        parentCallId: callId,
+        parentToolCallId: toolCallId
+      });
+      const previousToolCallId = currentToolCallId;
+      currentToolCallId = toolCallId;
+      try {
+        return await execute();
+      } finally {
+        currentToolCallId = previousToolCallId;
+        toolContextMap.delete(toolCallId);
+      }
+    }
+  };
+  return integration;
+}
 export {
+  DevToolsTelemetry,
   devToolsMiddleware
 };

package/dist/viewer/server.js CHANGED Viewed

@@ -22,7 +22,7 @@ var notifyServerAsync = async (event) => {
     await fetch(`http://localhost:${DEVTOOLS_PORT}/api/notify`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ event, timestamp: Date.now() })
+      body: JSON.stringify({ event, timestamp: Date.now(), dbPath: DB_PATH })
     });
   } catch {
   }
@@ -74,7 +74,17 @@ var saveDb = (db) => {
   dbCache = db;
   writeDb(db);
 };
-var reloadDb = async () => {
+var reloadDb = async (remoteDbPath2) => {
+  if (remoteDbPath2) {
+    try {
+      if (fs.existsSync(remoteDbPath2)) {
+        const content = fs.readFileSync(remoteDbPath2, "utf-8");
+        dbCache = JSON.parse(content);
+        return;
+      }
+    } catch {
+    }
+  }
   dbCache = readDb();
 };
 var getRuns = async () => {
@@ -120,12 +130,15 @@ var devEnv = process.env.AI_SDK_DEVTOOLS_DEV;
 var isDevMode = devEnv !== void 0 && devEnv !== "false" && devEnv !== "0";
 var projectRoot = path2.resolve(__dirname, "../..");
 var clientDir = path2.join(projectRoot, "dist/client");
+var remoteDbPath;
 var app = new Hono();
 app.use("/*", cors());
 app.get("/api/runs", async (c) => {
+  await reloadDb(remoteDbPath);
   const runs = await getRuns();
+  const rootRuns = runs.filter((r) => !r.parent_run_id);
   const runsWithMeta = await Promise.all(
-    runs.map(async (run) => {
+    rootRuns.map(async (run) => {
       const steps = await getStepsForRun(run.id);
       let firstMessage = "No user message";
       let hasError = false;
@@ -159,14 +172,35 @@ app.get("/api/runs", async (c) => {
   return c.json(runsWithMeta);
 });
 app.get("/api/runs/:id", async (c) => {
+  await reloadDb(remoteDbPath);
   const data = await getRunWithSteps(c.req.param("id"));
   if (!data) {
     return c.json({ error: "Run not found" }, 404);
   }
   const isInProgress = data.steps.some((s) => s.duration_ms === null && !s.error);
+  const allRuns = await getRuns();
+  async function getDescendantRuns(parentRunId) {
+    const children = allRuns.filter((r) => r.parent_run_id === parentRunId);
+    return Promise.all(
+      children.map(async (childRun) => {
+        const childSteps = await getStepsForRun(childRun.id);
+        const childIsInProgress = childSteps.some(
+          (s) => s.duration_ms === null && !s.error
+        );
+        const grandchildren = await getDescendantRuns(childRun.id);
+        return {
+          run: { ...childRun, isInProgress: childIsInProgress },
+          steps: childSteps,
+          childRuns: grandchildren
+        };
+      })
+    );
+  }
+  const childRuns = await getDescendantRuns(data.run.id);
   return c.json({
     run: { ...data.run, isInProgress },
-    steps: data.steps
+    steps: data.steps,
+    childRuns
   });
 });
 app.post("/api/clear", async (c) => {
@@ -224,7 +258,10 @@ app.get("/api/events", (c) => {
 });
 app.post("/api/notify", async (c) => {
   const body = await c.req.json();
-  await reloadDb();
+  if (body.dbPath) {
+    remoteDbPath = body.dbPath;
+  }
+  await reloadDb(remoteDbPath);
   broadcastToClients("update", body);
   return c.json({ success: true });
 });

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/devtools",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-canary.21",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -27,7 +27,7 @@
   "dependencies": {
     "@hono/node-server": "^1.13.7",
     "hono": "^4.6.14",
-    "@ai-sdk/provider": "4.0.0-beta.9"
+    "@ai-sdk/provider": "4.0.0-canary.16"
   },
   "devDependencies": {
     "@radix-ui/react-collapsible": "^1.1.12",
@@ -49,14 +49,36 @@
     "tailwind-merge": "^3.4.0",
     "tailwindcss": "^4.1.17",
     "tsup": "^8",
+    "vitest": "^4.1.5",
     "tsx": "^4.19.2",
     "tw-animate-css": "^1.4.0",
     "typescript": "5.8.3",
     "vaul": "^1.1.2",
     "vite": "^6.0.3",
     "zod": "3.25.76",
-    "ai": "7.0.0-beta.74"
+    "ai": "7.0.0-canary.120"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "homepage": "https://ai-sdk.dev/docs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vercel/ai",
+    "directory": "packages/devtools"
+  },
+  "bugs": {
+    "url": "https://github.com/vercel/ai/issues"
+  },
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "ai"
+  ],
   "scripts": {
     "dev": "concurrently -k \"pnpm dev:api\" \"pnpm dev:client\"",
     "dev:api": "AI_SDK_DEVTOOLS_DEV=true tsx src/viewer/server.ts",
@@ -65,6 +87,8 @@
     "start": "node dist/viewer/server.js",
     "build": "pnpm build:client && pnpm build:server",
     "build:client": "vite build",
-    "build:server": "tsup"
+    "build:server": "tsup --tsconfig tsconfig.build.json",
+    "test": "vitest --config vitest.node.config.js --run",
+    "test:watch": "vitest --config vitest.node.config.js"
   }
 }

package/src/db.ts CHANGED Viewed

@@ -26,7 +26,7 @@ export const notifyServerAsync = async (
     await fetch(`http://localhost:${DEVTOOLS_PORT}/api/notify`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ event, timestamp: Date.now() }),
+      body: JSON.stringify({ event, timestamp: Date.now(), dbPath: DB_PATH }),
     });
   } catch {
     // Ignore errors - server might not be running
@@ -36,6 +36,9 @@ export const notifyServerAsync = async (
 export interface Run {
   id: string;
   started_at: string;
+  parent_run_id: string | null;
+  parent_step_id: string | null;
+  function_id: string | null;
 }
 export interface Step {
@@ -139,13 +142,31 @@ const saveDb = (db: Database): void => {
 /**
  * Reload the database from disk.
- * Used by the viewer server to pick up changes made by the middleware.
+ * Used by the viewer server to pick up changes made by the middleware/integration.
+ * When a remote dbPath is provided (from a notify POST), reads from that path
+ * instead of the local CWD-based path, so the viewer works regardless of where
+ * it was started.
  */
-export const reloadDb = async (): Promise<void> => {
+export const reloadDb = async (remoteDbPath?: string): Promise<void> => {
+  if (remoteDbPath) {
+    try {
+      if (fs.existsSync(remoteDbPath)) {
+        const content = fs.readFileSync(remoteDbPath, 'utf-8');
+        dbCache = JSON.parse(content);
+        return;
+      }
+    } catch {
+      // Fall through to default
+    }
+  }
   dbCache = readDb();
 };
-export const createRun = async (id: string): Promise<Run> => {
+export const createRun = async (
+  id: string,
+  parent?: { runId: string; stepId: string },
+  functionId?: string,
+): Promise<Run> => {
   const db = getDb();
   const started_at = new Date().toISOString();
@@ -155,7 +176,13 @@ export const createRun = async (id: string): Promise<Run> => {
     return existing;
   }
-  const run: Run = { id, started_at };
+  const run: Run = {
+    id,
+    started_at,
+    parent_run_id: parent?.runId ?? null,
+    parent_step_id: parent?.stepId ?? null,
+    function_id: functionId ?? null,
+  };
   db.runs.push(run);
   saveDb(db);
   notifyServer('run');

package/src/index.ts CHANGED Viewed

	@@ -1 +1,2 @@
1 1	export { devToolsMiddleware } from './middleware.js';
2	+ export { DevToolsTelemetry } from './integration.js';