@agent-inspect/ai-sdk 1.7.0 → 1.8.0

package/dist/index.mjs

@@ -37,6 +37,12 @@ function countRecordKeys(value) {
   }
   return Object.keys(value).length;
 }
+function normalizeMaxPreviewChars(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return void 0;
+  }
+  return Math.floor(value);
+}
 function summarizeUnknown(value) {
   if (value === null) return { type: "null" };
   if (Array.isArray(value)) return { type: "array", itemCount: value.length };
@@ -100,264 +106,375 @@ function summarizeFinishReason(finishReason) {
 var AgentInspectAiSdkTelemetryIntegration = class {
   constructor(options) {
     this.options = options;
+    this.requestedCapture = options.capture ?? "metadata-only";
     this.writer = options.writer ?? (options.traceDir ? fileWriter({ dir: options.traceDir }) : void 0);
+    this.recordCaptureOptionWarnings();
   }
   options;
   writer;
+  requestedCapture;
+  effectiveCapture = "metadata-only";
   diagnostics = {
-    writeFailures: 0
+    writeFailures: 0,
+    lifecycleWarnings: 0,
+    flushFailures: 0,
+    closeFailures: 0
   };
   activeRun;
+  suspendedReason;
   getDiagnostics() {
     return { ...this.diagnostics };
   }
   async onStart(event) {
-    const startedAt = nowIso();
-    const runId = createId("ai_sdk_run");
-    const eventId = createId("event");
-    const name = this.options.runName ?? event.functionId ?? event.model.modelId ?? "ai-sdk-generation";
-    this.activeRun = {
-      runId,
-      eventId,
-      name,
-      startedAt,
-      model: event.model,
-      steps: /* @__PURE__ */ new Map(),
-      tools: /* @__PURE__ */ new Map()
-    };
-    await this.write({
-      schemaVersion: "0.2",
-      eventId,
-      runId,
-      kind: "RUN",
-      name,
-      status: "running",
-      timestamp: startedAt,
-      startedAt,
-      confidence: "explicit",
-      source: AI_SDK_SOURCE,
-      attributes: {
-        ...summarizeModel(event.model),
-        functionId: event.functionId,
-        capture: this.options.capture ?? "metadata-only",
-        recordInputsRequired: false,
-        recordOutputsRequired: false,
-        toolCount: countRecordKeys(event.tools),
-        hasPrompt: event.prompt !== void 0,
-        hasMessages: event.messages !== void 0,
-        metadataKeyCount: countRecordKeys(event.metadata)
+    await this.handleLifecycle("onStart", async () => {
+      if (this.activeRun || this.suspendedReason) {
+        this.activeRun = void 0;
+        this.suspendedReason = "Overlapping AI SDK generation ignored; create one agentInspect() integration per concurrent generation.";
+        this.recordLifecycleWarning(this.suspendedReason);
+        return;
       }
+      const startedAt = nowIso();
+      const runId = createId("ai_sdk_run");
+      const eventId = createId("event");
+      const name = this.options.runName ?? event.functionId ?? event.model.modelId ?? "ai-sdk-generation";
+      this.activeRun = {
+        runId,
+        eventId,
+        name,
+        startedAt,
+        model: event.model,
+        steps: /* @__PURE__ */ new Map(),
+        tools: /* @__PURE__ */ new Map()
+      };
+      await this.write({
+        schemaVersion: "0.2",
+        eventId,
+        runId,
+        kind: "RUN",
+        name,
+        status: "running",
+        timestamp: startedAt,
+        startedAt,
+        confidence: "explicit",
+        source: AI_SDK_SOURCE,
+        attributes: {
+          legacyEvent: "run_started",
+          ...summarizeModel(event.model),
+          functionId: event.functionId,
+          capture: this.effectiveCapture,
+          requestedCapture: this.requestedCapture === this.effectiveCapture ? void 0 : this.requestedCapture,
+          previewCaptureSupported: this.requestedCapture === "preview" ? false : void 0,
+          redactionProfile: this.options.redactionProfile,
+          maxPreviewChars: normalizeMaxPreviewChars(this.options.maxPreviewChars),
+          recordInputsRequired: false,
+          recordOutputsRequired: false,
+          toolCount: countRecordKeys(event.tools),
+          hasPrompt: event.prompt !== void 0,
+          hasMessages: event.messages !== void 0,
+          metadataKeyCount: countRecordKeys(event.metadata)
+        }
+      });
     });
   }
   async onStepStart(event) {
-    const run = this.ensureRun(event.model, event.functionId);
-    const startedAt = nowIso();
-    const stepEventId = createId("event");
-    run.steps.set(event.stepNumber, {
-      eventId: stepEventId,
-      startedAt
-    });
-    await this.write({
-      schemaVersion: "0.2",
-      eventId: stepEventId,
-      runId: run.runId,
-      parentId: run.eventId,
-      kind: "LLM",
-      name: `ai-sdk-step-${event.stepNumber}`,
-      status: "running",
-      timestamp: startedAt,
-      startedAt,
-      confidence: "explicit",
-      source: AI_SDK_SOURCE,
-      attributes: {
-        ...summarizeModel(event.model),
-        functionId: event.functionId,
-        stepNumber: event.stepNumber,
-        priorStepCount: event.steps.length,
-        activeToolCount: event.activeTools?.length,
-        toolCount: countRecordKeys(event.tools),
-        messageCount: event.messages.length,
-        metadataKeyCount: countRecordKeys(event.metadata)
-      }
+    await this.handleLifecycle("onStepStart", async () => {
+      const run = this.getActiveRun("onStepStart");
+      if (!run) return;
+      const startedAt = nowIso();
+      const stepEventId = createId("event");
+      run.steps.set(event.stepNumber, {
+        eventId: stepEventId,
+        parentId: run.eventId,
+        startedAt
+      });
+      await this.write({
+        schemaVersion: "0.2",
+        eventId: stepEventId,
+        runId: run.runId,
+        parentId: run.eventId,
+        kind: "LLM",
+        name: `ai-sdk-step-${event.stepNumber}`,
+        status: "running",
+        timestamp: startedAt,
+        startedAt,
+        confidence: "explicit",
+        source: AI_SDK_SOURCE,
+        attributes: {
+          legacyEvent: "step_started",
+          stepId: stepEventId,
+          ...summarizeModel(event.model),
+          functionId: event.functionId,
+          stepNumber: event.stepNumber,
+          priorStepCount: event.steps.length,
+          activeToolCount: event.activeTools?.length,
+          toolCount: countRecordKeys(event.tools),
+          messageCount: event.messages.length,
+          metadataKeyCount: countRecordKeys(event.metadata)
+        }
+      });
     });
   }
   async onStepFinish(event) {
-    const run = this.ensureRun(event.model, event.functionId);
-    const endedAt = nowIso();
-    const activeStep = run.steps.get(event.stepNumber) ?? {
-      eventId: createId("event"),
-      startedAt: endedAt
-    };
-    await this.write({
-      schemaVersion: "0.2",
-      eventId: createId("event"),
-      runId: run.runId,
-      parentId: activeStep.eventId,
-      kind: "LLM",
-      name: `ai-sdk-step-${event.stepNumber}`,
-      status: "ok",
-      timestamp: endedAt,
-      startedAt: activeStep.startedAt,
-      endedAt,
-      durationMs: durationMs(activeStep.startedAt, endedAt),
-      confidence: "explicit",
-      source: AI_SDK_SOURCE,
-      attributes: {
-        ...summarizeModel(event.model),
-        functionId: event.functionId,
-        stepNumber: event.stepNumber,
-        ...summarizeFinishReason(event.finishReason),
-        warningCount: event.warnings?.length ?? 0,
-        contentPartCount: event.content.length,
-        toolCallCount: event.toolCalls.length,
-        toolResultCount: event.toolResults.length,
-        responseId: event.response.id,
-        responseModelId: event.response.modelId,
-        responseTimestamp: event.response.timestamp?.toISOString(),
-        metadataKeyCount: countRecordKeys(event.metadata)
-      },
-      tokenUsage: summarizeUsage(event.usage),
-      outputSummary: {
-        contentPartCount: event.content.length,
-        textLength: event.text.length,
-        reasoningPartCount: event.reasoning.length,
-        fileCount: event.files.length,
-        sourceCount: event.sources.length
+    await this.handleLifecycle("onStepFinish", async () => {
+      const run = this.getActiveRun("onStepFinish");
+      if (!run) return;
+      const endedAt = nowIso();
+      const activeStep = run.steps.get(event.stepNumber);
+      if (!activeStep) {
+        this.recordLifecycleWarning(
+          `onStepFinish ignored because step ${event.stepNumber} has no matching start callback.`
+        );
+        return;
       }
+      await this.write({
+        schemaVersion: "0.2",
+        eventId: activeStep.eventId,
+        runId: run.runId,
+        parentId: activeStep.parentId,
+        kind: "LLM",
+        name: `ai-sdk-step-${event.stepNumber}`,
+        status: "ok",
+        timestamp: endedAt,
+        startedAt: activeStep.startedAt,
+        endedAt,
+        durationMs: durationMs(activeStep.startedAt, endedAt),
+        confidence: "explicit",
+        source: AI_SDK_SOURCE,
+        attributes: {
+          legacyEvent: "step_completed",
+          stepId: activeStep.eventId,
+          ...summarizeModel(event.model),
+          functionId: event.functionId,
+          stepNumber: event.stepNumber,
+          ...summarizeFinishReason(event.finishReason),
+          warningCount: event.warnings?.length ?? 0,
+          contentPartCount: event.content.length,
+          toolCallCount: event.toolCalls.length,
+          toolResultCount: event.toolResults.length,
+          responseId: event.response.id,
+          responseModelId: event.response.modelId,
+          responseTimestamp: event.response.timestamp?.toISOString(),
+          metadataKeyCount: countRecordKeys(event.metadata)
+        },
+        tokenUsage: summarizeUsage(event.usage),
+        outputSummary: {
+          contentPartCount: event.content.length,
+          textLength: event.text.length,
+          reasoningPartCount: event.reasoning.length,
+          fileCount: event.files.length,
+          sourceCount: event.sources.length
+        }
+      });
     });
   }
   async onToolCallStart(event) {
-    const run = this.ensureRun(event.model, event.functionId);
-    const startedAt = nowIso();
-    const eventId = createId("event");
-    const toolCall = event.toolCall;
-    run.tools.set(toolCall.toolCallId, {
-      eventId,
-      startedAt,
-      toolName: toolCall.toolName
-    });
-    const step = event.stepNumber === void 0 ? void 0 : run.steps.get(event.stepNumber);
-    await this.write({
-      schemaVersion: "0.2",
-      eventId,
-      runId: run.runId,
-      parentId: step?.eventId ?? run.eventId,
-      kind: "TOOL",
-      name: toolCall.toolName,
-      status: "running",
-      timestamp: startedAt,
-      startedAt,
-      confidence: "explicit",
-      source: AI_SDK_SOURCE,
-      attributes: {
-        ...summarizeModel(event.model),
-        functionId: event.functionId,
-        stepNumber: event.stepNumber,
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        dynamic: toolCall.dynamic === true,
-        invalid: toolCall.invalid === true,
-        providerExecuted: toolCall.providerExecuted === true,
-        messageCount: event.messages.length,
-        metadataKeyCount: countRecordKeys(event.metadata),
-        providerMetadataKeyCount: countRecordKeys(toolCall.providerMetadata),
-        toolMetadataKeyCount: countRecordKeys(toolCall.toolMetadata)
-      },
-      inputSummary: summarizeUnknown(toolCall.input),
-      error: toolCall.invalid ? summarizeError(toolCall.error) : void 0
+    await this.handleLifecycle("onToolCallStart", async () => {
+      const run = this.getActiveRun("onToolCallStart");
+      if (!run) return;
+      const startedAt = nowIso();
+      const eventId = createId("event");
+      const toolCall = event.toolCall;
+      const step = event.stepNumber === void 0 ? void 0 : run.steps.get(event.stepNumber);
+      const parentId = step?.eventId ?? run.eventId;
+      if (event.stepNumber === void 0 || !step) {
+        this.recordLifecycleWarning(
+          "onToolCallStart attached tool to run because the AI SDK callback did not expose a matching active step."
+        );
+      }
+      run.tools.set(toolCall.toolCallId, {
+        eventId,
+        parentId,
+        startedAt,
+        toolName: toolCall.toolName
+      });
+      await this.write({
+        schemaVersion: "0.2",
+        eventId,
+        runId: run.runId,
+        parentId,
+        kind: "TOOL",
+        name: toolCall.toolName,
+        status: "running",
+        timestamp: startedAt,
+        startedAt,
+        confidence: "explicit",
+        source: AI_SDK_SOURCE,
+        attributes: {
+          legacyEvent: "step_started",
+          stepId: eventId,
+          ...summarizeModel(event.model),
+          functionId: event.functionId,
+          stepNumber: event.stepNumber,
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          dynamic: toolCall.dynamic === true,
+          invalid: toolCall.invalid === true,
+          providerExecuted: toolCall.providerExecuted === true,
+          messageCount: event.messages.length,
+          metadataKeyCount: countRecordKeys(event.metadata),
+          providerMetadataKeyCount: countRecordKeys(toolCall.providerMetadata),
+          toolMetadataKeyCount: countRecordKeys(toolCall.toolMetadata)
+        },
+        inputSummary: summarizeUnknown(toolCall.input),
+        error: toolCall.invalid ? summarizeError(toolCall.error) : void 0
+      });
     });
   }
   async onToolCallFinish(event) {
-    const run = this.ensureRun(event.model, event.functionId);
-    const endedAt = nowIso();
-    const toolCall = event.toolCall;
-    const activeTool = run.tools.get(toolCall.toolCallId) ?? {
-      eventId: createId("event"),
-      startedAt: endedAt,
-      toolName: toolCall.toolName
-    };
-    await this.write({
-      schemaVersion: "0.2",
-      eventId: createId("event"),
-      runId: run.runId,
-      parentId: activeTool.eventId,
-      kind: "TOOL",
-      name: activeTool.toolName,
-      status: event.success ? "ok" : "error",
-      timestamp: endedAt,
-      startedAt: activeTool.startedAt,
-      endedAt,
-      durationMs: event.durationMs,
-      confidence: "explicit",
-      source: AI_SDK_SOURCE,
-      attributes: {
-        ...summarizeModel(event.model),
-        functionId: event.functionId,
-        stepNumber: event.stepNumber,
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        dynamic: toolCall.dynamic === true,
-        invalid: toolCall.invalid === true,
-        providerExecuted: toolCall.providerExecuted === true,
-        messageCount: event.messages.length,
-        metadataKeyCount: countRecordKeys(event.metadata),
-        providerMetadataKeyCount: countRecordKeys(toolCall.providerMetadata),
-        toolMetadataKeyCount: countRecordKeys(toolCall.toolMetadata)
-      },
-      outputSummary: event.success ? summarizeUnknown(event.output) : void 0,
-      error: event.success ? void 0 : summarizeError(event.error)
+    await this.handleLifecycle("onToolCallFinish", async () => {
+      const run = this.getActiveRun("onToolCallFinish");
+      if (!run) return;
+      const endedAt = nowIso();
+      const toolCall = event.toolCall;
+      const activeTool = run.tools.get(toolCall.toolCallId);
+      if (!activeTool) {
+        this.recordLifecycleWarning(
+          `onToolCallFinish ignored because tool call ${toolCall.toolCallId} has no matching start callback.`
+        );
+        return;
+      }
+      await this.write({
+        schemaVersion: "0.2",
+        eventId: activeTool.eventId,
+        runId: run.runId,
+        parentId: activeTool.parentId,
+        kind: "TOOL",
+        name: activeTool.toolName,
+        status: event.success ? "ok" : "error",
+        timestamp: endedAt,
+        startedAt: activeTool.startedAt,
+        endedAt,
+        durationMs: event.durationMs,
+        confidence: "explicit",
+        source: AI_SDK_SOURCE,
+        attributes: {
+          legacyEvent: "step_completed",
+          stepId: activeTool.eventId,
+          ...summarizeModel(event.model),
+          functionId: event.functionId,
+          stepNumber: event.stepNumber,
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          dynamic: toolCall.dynamic === true,
+          invalid: toolCall.invalid === true,
+          providerExecuted: toolCall.providerExecuted === true,
+          messageCount: event.messages.length,
+          metadataKeyCount: countRecordKeys(event.metadata),
+          providerMetadataKeyCount: countRecordKeys(toolCall.providerMetadata),
+          toolMetadataKeyCount: countRecordKeys(toolCall.toolMetadata)
+        },
+        outputSummary: event.success ? summarizeUnknown(event.output) : void 0,
+        error: event.success ? void 0 : summarizeError(event.error)
+      });
     });
   }
   async onFinish(event) {
-    const run = this.ensureRun(event.model, event.functionId);
-    const endedAt = nowIso();
-    await this.write({
-      schemaVersion: "0.2",
-      eventId: createId("event"),
-      runId: run.runId,
-      kind: "RUN",
-      name: run.name,
-      status: "ok",
-      timestamp: endedAt,
-      startedAt: run.startedAt,
-      endedAt,
-      durationMs: durationMs(run.startedAt, endedAt),
-      confidence: "explicit",
-      source: AI_SDK_SOURCE,
-      attributes: {
-        ...summarizeModel(event.model ?? run.model),
-        functionId: event.functionId,
-        ...summarizeFinishReason(event.finishReason),
-        stepCount: event.steps.length,
-        warningCount: event.warnings?.length ?? 0,
-        toolCallCount: event.toolCalls.length,
-        toolResultCount: event.toolResults.length,
-        metadataKeyCount: countRecordKeys(event.metadata)
-      },
-      tokenUsage: summarizeUsage(event.totalUsage),
-      outputSummary: {
-        contentPartCount: event.content.length,
-        textLength: event.text.length,
-        reasoningPartCount: event.reasoning.length,
-        fileCount: event.files.length,
-        sourceCount: event.sources.length
+    await this.handleLifecycle("onFinish", async () => {
+      if (this.suspendedReason) {
+        this.suspendedReason = void 0;
+        return;
       }
+      const run = this.getActiveRun("onFinish");
+      if (!run) return;
+      const endedAt = nowIso();
+      await this.write({
+        schemaVersion: "0.2",
+        eventId: run.eventId,
+        runId: run.runId,
+        kind: "RUN",
+        name: run.name,
+        status: "ok",
+        timestamp: endedAt,
+        startedAt: run.startedAt,
+        endedAt,
+        durationMs: durationMs(run.startedAt, endedAt),
+        confidence: "explicit",
+        source: AI_SDK_SOURCE,
+        attributes: {
+          legacyEvent: "run_completed",
+          ...summarizeModel(event.model ?? run.model),
+          functionId: event.functionId,
+          ...summarizeFinishReason(event.finishReason),
+          stepCount: event.steps.length,
+          warningCount: event.warnings?.length ?? 0,
+          toolCallCount: event.toolCalls.length,
+          toolResultCount: event.toolResults.length,
+          metadataKeyCount: countRecordKeys(event.metadata)
+        },
+        tokenUsage: summarizeUsage(event.totalUsage),
+        outputSummary: {
+          contentPartCount: event.content.length,
+          textLength: event.text.length,
+          reasoningPartCount: event.reasoning.length,
+          fileCount: event.files.length,
+          sourceCount: event.sources.length
+        }
+      });
+      this.activeRun = void 0;
     });
-    this.activeRun = void 0;
   }
-  ensureRun(model, functionId) {
+  getWriterStats() {
+    return this.writer?.getStats?.();
+  }
+  async flush() {
+    try {
+      await this.writer?.flush?.();
+    } catch (error) {
+      this.diagnostics.flushFailures += 1;
+      this.diagnostics.lastError = normalizeError(error);
+    }
+  }
+  async close() {
+    try {
+      await this.writer?.close?.();
+    } catch (error) {
+      this.diagnostics.closeFailures += 1;
+      this.diagnostics.lastError = normalizeError(error);
+    } finally {
+      this.activeRun = void 0;
+      this.suspendedReason = void 0;
+    }
+  }
+  getActiveRun(callbackName) {
+    if (this.suspendedReason) {
+      this.recordLifecycleWarning(
+        `${callbackName} ignored while integration is suspended: ${this.suspendedReason}`
+      );
+      return void 0;
+    }
     if (this.activeRun) return this.activeRun;
-    const startedAt = nowIso();
-    this.activeRun = {
-      runId: createId("ai_sdk_run"),
-      eventId: createId("event"),
-      name: this.options.runName ?? functionId ?? model?.modelId ?? "ai-sdk-generation",
-      startedAt,
-      model,
-      steps: /* @__PURE__ */ new Map(),
-      tools: /* @__PURE__ */ new Map()
-    };
-    return this.activeRun;
+    this.recordLifecycleWarning(
+      `${callbackName} ignored because no active AI SDK generation was started.`
+    );
+    return void 0;
+  }
+  async handleLifecycle(callbackName, run) {
+    try {
+      await run();
+    } catch (error) {
+      this.recordLifecycleWarning(`${callbackName}: ${normalizeError(error)}`);
+    }
+  }
+  recordLifecycleWarning(message) {
+    this.diagnostics.lifecycleWarnings += 1;
+    this.diagnostics.lastWarning = message;
+  }
+  recordCaptureOptionWarnings() {
+    const previewOnlyOptions = [];
+    if (this.requestedCapture === "preview") previewOnlyOptions.push("capture");
+    if (this.options.redactionProfile !== void 0) previewOnlyOptions.push("redactionProfile");
+    if (this.options.maxPreviewChars !== void 0) previewOnlyOptions.push("maxPreviewChars");
+    if (this.requestedCapture === "preview") {
+      this.recordLifecycleWarning(
+        `AI SDK preview capture is not supported yet; falling back to metadata-only capture. Unsupported options: ${previewOnlyOptions.join(", ")}.`
+      );
+      return;
+    }
+    if (previewOnlyOptions.length > 0) {
+      this.recordLifecycleWarning(
+        `AI SDK preview-only options have no effect in metadata-only capture: ${previewOnlyOptions.join(", ")}.`
+      );
+    }
   }
   async write(event) {
     if (!this.writer) return;
@@ -373,7 +490,10 @@ function agentInspect(options = {}) {
   const integration = new AgentInspectAiSdkTelemetryIntegration(options);
   return {
     ...bindTelemetryIntegration(integration),
-    getDiagnostics: () => integration.getDiagnostics()
+    getDiagnostics: () => integration.getDiagnostics(),
+    getWriterStats: () => integration.getWriterStats(),
+    flush: () => integration.flush(),
+    close: () => integration.close()
   };
 }