agentv 4.35.1 → 4.36.0-next.1

package/dist/{chunk-INOKS5LF.js → chunk-7KZ2AF26.js}

@@ -13,12 +13,14 @@ import {
   resolveRunIndexPath,
   resolveRunManifestPath,
   resolveWorkspaceOrFilePath,
-  toSnakeCaseDeep,
+  toSnakeCaseDeep as toSnakeCaseDeep2,
   writeArtifactsFromResults,
   writeInitialBenchmarkArtifact
-} from "./chunk-KJGYL3M3.js";
+} from "./chunk-HVBAVOAH.js";
 import {
   RunBudgetTracker,
+  buildWipBranchName,
+  deleteWipBranch,
   deriveCategory,
   directPushResults,
   directorySizeBytes,
@@ -29,9 +31,12 @@ import {
   loadTsConfig,
   materializeGitRun,
   normalizeResultsConfig,
+  pushWipCheckpoint,
   resolveResultsRepoRunsDir,
-  syncResultsRepoForProject
-} from "./chunk-KNF3AGCI.js";
+  setupWipWorktree,
+  syncResultsRepoForProject,
+  traceFromTranscriptJsonLines
+} from "./chunk-P5JONEWJ.js";
 import {
   CLI_PLACEHOLDERS,
   COMMON_TARGET_SETTINGS,
@@ -42,6 +47,7 @@ import {
   ResponseCache,
   buildDirectoryChain,
   buildSearchRoots,
+  buildTraceFromMessages,
   ensureVSCodeSubagents,
   findDeprecatedCamelCaseTargetWarnings,
   findGitRoot,
@@ -66,8 +72,9 @@ import {
   subscribeToCopilotCliLogEntries,
   subscribeToCopilotSdkLogEntries,
   subscribeToPiLogEntries,
-  toCamelCaseDeep
-} from "./chunk-6QEIZ33V.js";
+  toCamelCaseDeep,
+  toSnakeCaseDeep
+} from "./chunk-TUTURE2B.js";
 
 // src/commands/eval/shared.ts
 import { constants } from "node:fs";
@@ -183,7 +190,7 @@ async function findRepoRoot(start) {
 // package.json
 var package_default = {
   name: "agentv",
-  version: "4.35.1",
+  version: "4.36.0-next.1",
   description: "CLI entry point for AgentV",
   type: "module",
   repository: {
@@ -574,18 +581,31 @@ function hydrateInput(baseDir, record) {
   return messages.length > 0 ? messages : [{ role: "user", content: inputText.trimEnd() }];
 }
 function hydrateOutput(baseDir, record) {
-  const responseText = readOptionalText(baseDir, record.output_path ?? record.response_path);
+  const responseText = readOptionalText(
+    baseDir,
+    record.output_path ?? record.answer_path ?? record.response_path
+  );
   if (!responseText) {
     return void 0;
   }
-  const messages = parseMarkdownMessages(responseText);
-  if (messages.length > 0) {
-    return messages.map((message) => ({
-      role: message.role,
-      content: message.content
-    }));
+  return responseText.trimEnd();
+}
+function hydrateTrace(baseDir, record) {
+  const transcriptText = readOptionalText(baseDir, record.transcript_path);
+  if (transcriptText) {
+    try {
+      return traceFromTranscriptJsonLines(parseJsonlLines(transcriptText));
+    } catch {
+    }
   }
-  return [{ role: "assistant", content: responseText.trimEnd() }];
+  const output = hydrateOutput(baseDir, record) ?? "";
+  return buildTraceFromMessages({
+    input: hydrateInput(baseDir, record),
+    output: output ? [{ role: "assistant", content: output }] : [],
+    finalOutput: output,
+    target: record.target,
+    testId: record.test_id
+  });
 }
 function hydrateManifestRecord(baseDir, record) {
   const grading = readOptionalJson(baseDir, record.grading_path);
@@ -630,7 +650,8 @@ function hydrateManifestRecord(baseDir, record) {
     durationMs: timing?.duration_ms ?? record.duration_ms,
     costUsd: record.cost_usd,
     input: hydrateInput(baseDir, record),
-    output: hydrateOutput(baseDir, record),
+    output: hydrateOutput(baseDir, record) ?? "",
+    trace: hydrateTrace(baseDir, record),
     metadata: record.metadata
   };
 }
@@ -756,6 +777,7 @@ function toRawResult(result) {
     end_time: result.endTime,
     input: result.input,
     output: result.output,
+    trace: toSnakeCaseDeep(result.trace),
     file_changes: result.fileChanges
   };
 }
@@ -1336,25 +1358,33 @@ function deleteRemoteRunTags(repoDir, manifestPath) {
 // src/commands/results/remote.ts
 var gitRunsCache = /* @__PURE__ */ new Map();
 var GIT_RUNS_CACHE_TTL_MS = 6e4;
-function cachedListGitRuns(repoDir) {
+function getResultsStorageRef(config) {
+  return config.branch ? `origin/${config.branch}` : void 0;
+}
+function cachedListGitRuns(repoDir, ref) {
   const now = Date.now();
-  const cached = gitRunsCache.get(repoDir);
+  const cacheKey = `${repoDir}\0${ref ?? ""}`;
+  const cached = gitRunsCache.get(cacheKey);
   if (cached && cached.expiresAt > now) {
     return cached.data;
   }
-  const promise = listGitRuns(repoDir);
-  gitRunsCache.set(repoDir, { data: promise, expiresAt: now + GIT_RUNS_CACHE_TTL_MS });
+  const promise = ref ? listGitRuns(repoDir, ref) : listGitRuns(repoDir);
+  gitRunsCache.set(cacheKey, { data: promise, expiresAt: now + GIT_RUNS_CACHE_TTL_MS });
   promise.catch(() => {
   }).finally(() => {
-    const entry = gitRunsCache.get(repoDir);
+    const entry = gitRunsCache.get(cacheKey);
     if (entry && entry.expiresAt <= Date.now()) {
-      gitRunsCache.delete(repoDir);
+      gitRunsCache.delete(cacheKey);
     }
   });
   return promise;
 }
 function invalidateGitRunsCache(repoDir) {
-  gitRunsCache.delete(repoDir);
+  for (const key of gitRunsCache.keys()) {
+    if (key.startsWith(`${repoDir}\0`)) {
+      gitRunsCache.delete(key);
+    }
+  }
 }
 var REMOTE_RUN_PREFIX = "remote::";
 var SIZE_WARNING_BYTES = 10 * 1024 * 1024;
@@ -1391,6 +1421,7 @@ async function loadNormalizedResultsConfig(cwd, projectId) {
   const projectResults = project?.results ? {
     mode: "github",
     repo: project.results.repoUrl,
+    branch: project.results.branch,
     path: project.results.path,
     auto_push: project.results.sync?.autoPush,
     branch_prefix: project.results.branchPrefix
@@ -1420,9 +1451,11 @@ async function getRemoteRunCount(config, status) {
   let runCount = 0;
   if (config && status.available) {
     try {
-      runCount = (await cachedListGitRuns(config.path)).length;
+      runCount = (await cachedListGitRuns(config.path, getResultsStorageRef(config))).length;
     } catch {
-      runCount = listResultFilesFromRunsDir(resolveResultsRepoRunsDir(config)).length;
+      if (!config.branch) {
+        runCount = listResultFilesFromRunsDir(resolveResultsRepoRunsDir(config)).length;
+      }
     }
   }
   return runCount;
@@ -1482,7 +1515,7 @@ async function listMergedResultFiles(cwd, limit, projectId) {
   let remoteRuns = [];
   if (config.mode === "github") {
     try {
-      const gitRuns = await cachedListGitRuns(config.path);
+      const gitRuns = await cachedListGitRuns(config.path, getResultsStorageRef(config));
       remoteRuns = gitRuns.map((r) => ({
         filename: encodeRemoteRunId(r.run_id),
         raw_filename: r.run_id,
@@ -1496,15 +1529,19 @@ async function listMergedResultFiles(cwd, limit, projectId) {
         sizeBytes: r.size_bytes || 0
       }));
     } catch (error) {
-      console.error("git-native listing failed, falling back", error);
-      remoteRuns = listResultFilesFromRunsDir(resolveResultsRepoRunsDir(config)).map(
-        (meta) => ({
-          ...meta,
-          filename: encodeRemoteRunId(meta.filename),
-          raw_filename: meta.filename,
-          source: "remote"
-        })
-      );
+      if (config.branch) {
+        console.error("git-native listing failed for configured results branch", error);
+      } else {
+        console.error("git-native listing failed, falling back", error);
+        remoteRuns = listResultFilesFromRunsDir(resolveResultsRepoRunsDir(config)).map(
+          (meta) => ({
+            ...meta,
+            filename: encodeRemoteRunId(meta.filename),
+            raw_filename: meta.filename,
+            source: "remote"
+          })
+        );
+      }
     }
   } else {
     remoteRuns = listResultFilesFromRunsDir(resolveResultsRepoRunsDir(config)).map(
@@ -1544,7 +1581,7 @@ async function ensureRemoteRunAvailable(cwd, meta, projectId) {
     ".agentv/results/runs",
     path7.posix.dirname(relativeManifestPath)
   );
-  await materializeGitRun(config.path, relativeRunPath);
+  await materializeGitRun(config.path, relativeRunPath, getResultsStorageRef(config));
 }
 async function readRemoteRunTagState(cwd, meta, projectId) {
   if (meta.source !== "remote") return void 0;
@@ -1581,7 +1618,7 @@ async function clearRemoteRunTags(cwd, meta, projectId) {
 async function maybeAutoExportRunArtifacts(payload) {
   const config = await loadNormalizedResultsConfig(payload.cwd);
   if (!config?.auto_push) {
-    return;
+    return "disabled";
   }
   try {
     await maybeWarnLargeArtifact(payload.run_dir);
@@ -1595,12 +1632,14 @@ async function maybeAutoExportRunArtifacts(payload) {
     });
     if (!pushed) {
       console.warn("Warning: results export produced no git changes. Skipping push.");
-      return;
+      return "already_published";
     }
     console.log(`Results pushed to ${config.repo} (${config.path}/${relativeRunPath})`);
+    return "published";
   } catch (error) {
     console.warn(`Warning: skipping results export: ${getStatusMessage(error)}`);
     console.warn("Warning: Run 'gh auth login' if GitHub authentication is missing.");
+    return "failed";
   }
 }
 
@@ -1906,7 +1945,7 @@ var JsonlWriter = class _JsonlWriter {
       if (this.closed) {
         throw new Error("Cannot write to closed JSONL writer");
       }
-      const snakeCaseRecord = toSnakeCaseDeep(record);
+      const snakeCaseRecord = toSnakeCaseDeep2(record);
       const line = `${JSON.stringify(snakeCaseRecord)}
 `;
       if (!this.stream.write(line)) {
@@ -3425,6 +3464,14 @@ var MOCK_SETTINGS = /* @__PURE__ */ new Set([
   "trace"
   // For testing tool-trajectory evaluator
 ]);
+var REPLAY_SETTINGS = /* @__PURE__ */ new Set([
+  ...COMMON_SETTINGS,
+  "fixtures",
+  "source_target",
+  "suite",
+  "eval_path",
+  "variant"
+]);
 var CLAUDE_SETTINGS = /* @__PURE__ */ new Set([
   ...COMMON_SETTINGS,
   "executable",
@@ -3480,6 +3527,8 @@ function getKnownSettings(provider) {
       return VSCODE_SETTINGS;
     case "mock":
       return MOCK_SETTINGS;
+    case "replay":
+      return REPLAY_SETTINGS;
     case "cli":
       return null;
     default:
@@ -3761,6 +3810,24 @@ async function validateTargetsFile(filePath) {
     if (providerValue === "cli") {
       validateCliSettings(target, absolutePath, location, errors);
     }
+    if (providerValue === "replay") {
+      if (!isNonEmptyString(target.fixtures)) {
+        errors.push({
+          severity: "error",
+          filePath: absolutePath,
+          location: `${location}.fixtures`,
+          message: "Replay provider requires 'fixtures' as a non-empty string"
+        });
+      }
+      if (!isNonEmptyString(target.source_target)) {
+        errors.push({
+          severity: "error",
+          filePath: absolutePath,
+          location: `${location}.source_target`,
+          message: "Replay provider requires 'source_target' as a non-empty string"
+        });
+      }
+    }
     if (typeof provider === "string" && !isTemplated) {
       validateUnknownSettings(target, provider, absolutePath, location, errors);
     }
@@ -4005,6 +4072,14 @@ function validateProjectResultsConfig(errors, filePath, rawResults, location) {
     }
   }
   validateGitRemoteUrl(errors, filePath, resultsRecord.repo_url, `${location}.repo_url`);
+  if (resultsRecord.branch !== void 0 && (typeof resultsRecord.branch !== "string" || resultsRecord.branch.trim().length === 0)) {
+    errors.push({
+      severity: "error",
+      filePath,
+      location: `${location}.branch`,
+      message: `Field '${location}.branch' must be a non-empty string`
+    });
+  }
   if (resultsRecord.path !== void 0) {
     if (typeof resultsRecord.path !== "string" || resultsRecord.path.trim().length === 0) {
       errors.push({
@@ -4074,6 +4149,14 @@ function validateResultsConfig(errors, filePath, rawResults, location) {
     });
   }
   validateRequiredString(errors, filePath, resultsRecord.repo, `${location}.repo`);
+  if (resultsRecord.branch !== void 0 && (typeof resultsRecord.branch !== "string" || resultsRecord.branch.trim().length === 0)) {
+    errors.push({
+      severity: "error",
+      filePath,
+      location: `${location}.branch`,
+      message: `Field '${location}.branch' must be a non-empty string`
+    });
+  }
   if (resultsRecord.path !== void 0) {
     if (typeof resultsRecord.path !== "string" || resultsRecord.path.trim().length === 0) {
       errors.push({
@@ -4582,6 +4665,94 @@ Errors in ${targetsFilePath}:`);
   return results;
 }
 
+// src/commands/eval/wip-checkpoint.ts
+var WIP_CHECKPOINT_INTERVAL_MS = 3e4;
+var defaultDependencies = {
+  buildWipBranchName,
+  deleteWipBranch,
+  pushWipCheckpoint,
+  setupWipWorktree
+};
+function warnCheckpointError(context, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(`WIP checkpoint: ${context}: ${message}`);
+}
+var WipCheckpointLoop = class {
+  wipBranch;
+  config;
+  runDir;
+  destinationPath;
+  intervalMs;
+  deps;
+  handle;
+  timer;
+  checkpointInFlight;
+  active = false;
+  constructor(params) {
+    this.config = params.config;
+    this.runDir = params.runDir;
+    this.destinationPath = params.destinationPath;
+    this.intervalMs = params.intervalMs ?? WIP_CHECKPOINT_INTERVAL_MS;
+    this.deps = params.dependencies ?? defaultDependencies;
+    this.wipBranch = this.deps.buildWipBranchName(params.runDir);
+  }
+  async start() {
+    try {
+      this.handle = await this.deps.setupWipWorktree({
+        config: this.config,
+        wipBranch: this.wipBranch
+      });
+    } catch (err) {
+      warnCheckpointError("failed to set up WIP worktree", err);
+      return;
+    }
+    this.active = true;
+    this.timer = setInterval(() => {
+      this.runCheckpointIfIdle();
+    }, this.intervalMs);
+    this.timer.unref?.();
+  }
+  runCheckpointIfIdle() {
+    if (!this.active || this.checkpointInFlight) return;
+    this.checkpointInFlight = this.checkpoint().catch((err) => warnCheckpointError("push failed", err)).finally(() => {
+      this.checkpointInFlight = void 0;
+    });
+  }
+  async checkpoint() {
+    if (!this.handle) return;
+    await this.deps.pushWipCheckpoint({
+      handle: this.handle,
+      sourceDir: this.runDir,
+      destinationPath: this.destinationPath
+    });
+  }
+  /** Stop the loop and clean up the local worktree. Does NOT delete the remote WIP branch. */
+  async stop() {
+    this.active = false;
+    if (this.timer !== void 0) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    await this.checkpointInFlight;
+    if (this.handle) {
+      await this.handle.cleanup().catch((err) => warnCheckpointError("worktree cleanup failed", err));
+      this.handle = void 0;
+    }
+  }
+  /**
+   * Stop the loop and delete the remote WIP branch.
+   * Call after a successful run to keep the results repo tidy.
+   */
+  async stopAndDeleteWipBranch() {
+    await this.stop();
+    try {
+      await this.deps.deleteWipBranch({ config: this.config, wipBranch: this.wipBranch });
+    } catch (err) {
+      warnCheckpointError(`failed to delete remote branch ${this.wipBranch}`, err);
+    }
+  }
+};
+
 // src/commands/eval/run-eval.ts
 var DEFAULT_WORKERS = 3;
 function shouldSkipExistingResultForResume(result, rerunFailed) {
@@ -4722,17 +4893,8 @@ function normalizeOutputMessages(cliValue) {
   }
   return parsed;
 }
-function trimOutputMessages(output, outputMessages) {
-  const messages = output ?? [];
-  if (outputMessages === "all") {
-    return messages.map((m) => ({ role: m.role, content: m.content }));
-  }
-  if (outputMessages === 1) {
-    const lastAssistant = messages.filter((m) => m.role === "assistant").at(-1);
-    return lastAssistant ? [{ role: lastAssistant.role, content: lastAssistant.content }] : [];
-  }
-  const sliced = messages.slice(-outputMessages);
-  return sliced.map((m) => ({ role: m.role, content: m.content }));
+function trimOutputMessages(output, _outputMessages) {
+  return output;
 }
 function normalizeOptions(rawOptions, config, yamlExecution) {
   const cliWorkers = normalizeOptionalNumber(rawOptions.workers);
@@ -4819,6 +4981,8 @@ function normalizeOptions(rawOptions, config, yamlExecution) {
     tags: normalizeStringArray(rawOptions.tag),
     excludeTags: normalizeStringArray(rawOptions.excludeTag),
     transcript: normalizeString(rawOptions.transcript),
+    recordReplay: normalizeString(rawOptions.recordReplay),
+    recordReplayVariant: normalizeString(rawOptions.recordReplayVariant),
     experiment: normalizeString(rawOptions.experiment),
     budgetUsd: normalizeOptionalNumber(rawOptions.budgetUsd),
     sourceMetadataByEvalFile: normalizeSourceMetadataByEvalFile(
@@ -5115,6 +5279,11 @@ async function runSingleEvalFile(params) {
     providerFactory
   } = params;
   const targetName = selection.targetName;
+  const replayRecording = options.recordReplay ? {
+    fixturesPath: path12.resolve(options.recordReplay),
+    sourceTarget: targetName,
+    variant: options.recordReplayVariant
+  } : void 0;
   await ensureFileExists(testFilePath, "Test file");
   const resolvedTargetSelection = applyVerboseOverride(selection, options.verbose);
   const providerLabel = options.dryRun ? `${resolvedTargetSelection.resolvedTarget.kind} (dry-run)` : resolvedTargetSelection.resolvedTarget.kind;
@@ -5191,6 +5360,7 @@ async function runSingleEvalFile(params) {
     model: options.model,
     threshold: options.threshold,
     targetHooks: resolvedTargetSelection.targetHooks,
+    replayRecording,
     providerFactory,
     streamCallbacks: streamingObserver?.getStreamCallbacks(),
     onResult: async (result) => {
@@ -5381,7 +5551,7 @@ async function runEvalCommand(input) {
   const useFileExport = !!options.otelFile;
   if (options.exportOtel || useFileExport) {
     try {
-      const { OtelTraceExporter, OTEL_BACKEND_PRESETS } = await import("./dist-M4B77IW4.js");
+      const { OtelTraceExporter, OTEL_BACKEND_PRESETS } = await import("./dist-BSFUYS54.js");
       let endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
       let headers = {};
       if (options.otelBackend) {
@@ -5480,6 +5650,9 @@ async function runEvalCommand(input) {
   if (cache) {
     console.log(`Response cache: enabled (${cache.cachePath})`);
   }
+  if (options.recordReplay) {
+    console.log(`Replay recording: ${path12.resolve(options.recordReplay)}`);
+  }
   const yamlThreshold = firstMeta?.threshold;
   const resolvedThreshold = options.threshold ?? yamlThreshold;
   if (resolvedThreshold !== void 0 && (resolvedThreshold < 0 || resolvedThreshold > 1)) {
@@ -5574,7 +5747,7 @@ async function runEvalCommand(input) {
   const activeTestFiles = resolvedTestFiles.filter((f) => fileMetadata.has(f));
   let transcriptProviderFactory;
   if (options.transcript) {
-    const { TranscriptProvider } = await import("./dist-M4B77IW4.js");
+    const { TranscriptProvider } = await import("./dist-BSFUYS54.js");
     const transcriptProvider = await TranscriptProvider.fromFile(options.transcript);
     const totalTests = [...fileMetadata.values()].reduce(
       (sum, meta) => sum + meta.testCases.length,
@@ -5598,6 +5771,20 @@ async function runEvalCommand(input) {
       experiment: normalizeExperimentName(options.experiment)
     });
   }
+  let wipLoop;
+  let wipCleanedUp = false;
+  let finalExportStatus = "disabled";
+  {
+    const wipConfig = await loadNormalizedResultsConfig(cwd).catch(() => void 0);
+    if (wipConfig?.auto_push) {
+      wipLoop = new WipCheckpointLoop({
+        config: wipConfig,
+        runDir,
+        destinationPath: getRelativeRunPath(cwd, runDir)
+      });
+      await wipLoop.start();
+    }
+  }
   try {
     for (const testFilePath of activeTestFiles) {
       if (runBudgetTracker?.isExceeded()) {
@@ -5612,7 +5799,16 @@ async function runEvalCommand(input) {
             testId: testCase.id,
             score: 0,
             assertions: [],
-            output: [],
+            output: budgetMsg,
+            trace: buildTraceFromMessages({
+              input: testCase.input,
+              output: [{ role: "assistant", content: budgetMsg }],
+              finalOutput: budgetMsg,
+              target: selection.targetName,
+              testId: testCase.id,
+              conversationId: testCase.conversation_id,
+              error: budgetMsg
+            }),
             error: budgetMsg,
             budgetExceeded: true,
             executionStatus: "execution_error",
@@ -5702,7 +5898,16 @@ async function runEvalCommand(input) {
                   testId: testCase.id,
                   score: 0,
                   assertions: [],
-                  output: [],
+                  output: message,
+                  trace: buildTraceFromMessages({
+                    input: testCase.input,
+                    output: [{ role: "assistant", content: message }],
+                    finalOutput: message,
+                    target: selection.targetName,
+                    testId: testCase.id,
+                    conversationId: testCase.conversation_id,
+                    error: message
+                  }),
                   scores: [],
                   error: message,
                   executionStatus: "execution_error",
@@ -5758,7 +5963,7 @@ async function runEvalCommand(input) {
       );
       const taskBundleTargets = buildTaskBundleTargetSelections(activeTestFiles, fileMetadata);
       if (isResumeAppend) {
-        const { writePerTestArtifacts } = await import("./artifact-writer-G57MG52C.js");
+        const { writePerTestArtifacts } = await import("./artifact-writer-3YRN6YTA.js");
         await writePerTestArtifacts(allResults, runDir, {
           experiment: normalizeExperimentName(options.experiment),
           cwd,
@@ -5815,7 +6020,7 @@ async function runEvalCommand(input) {
       console.log(`
 Results written to: ${outputPath}`);
       await saveRunCache(cwd, outputPath).catch(() => void 0);
-      await maybeAutoExportRunArtifacts({
+      finalExportStatus = await maybeAutoExportRunArtifacts({
         cwd,
         run_dir: runDir,
         test_files: activeTestFiles,
@@ -5851,6 +6056,10 @@ Tip: ${summary.executionErrorCount} execution error(s) detected. Re-run failed t
 \u26A0 Run budget exceeded: $${runBudgetTracker?.currentCostUsd.toFixed(4)} spent of $${runBudgetTracker?.budgetCapUsd.toFixed(4)} cap`
       );
     }
+    if (wipLoop && (finalExportStatus === "published" || finalExportStatus === "already_published")) {
+      wipCleanedUp = true;
+      await wipLoop.stopAndDeleteWipBranch();
+    }
     return {
       executionErrorCount: summary.executionErrorCount,
       outputPath,
@@ -5861,6 +6070,9 @@ Tip: ${summary.executionErrorCount} execution error(s) detected. Re-run failed t
       budgetExceeded: runBudgetExceeded || void 0
     };
   } finally {
+    if (wipLoop && !wipCleanedUp) {
+      await wipLoop.stop().catch(() => void 0);
+    }
     unsubscribeCodexLogs();
     unsubscribePiLogs();
     unsubscribeCopilotSdkLogs();
@@ -5986,4 +6198,4 @@ export {
   getCategories,
   filterByCategory
 };
-//# sourceMappingURL=chunk-INOKS5LF.js.map
+//# sourceMappingURL=chunk-7KZ2AF26.js.map