@letrquan/book 0.2.0

package/dist/sdk.js

@@ -0,0 +1,665 @@
+import {
+  collectWithheldProjectNotices,
+  connectMcpServers,
+  disconnectMcpServers,
+  runHeadless
+} from "./chunk-J7MIZ5CA.js";
+import {
+  SessionStore,
+  createAgentSessionSnapshot,
+  reduceAgentSessionSnapshot,
+  resolveSessionBootstrap
+} from "./chunk-V4BOYR52.js";
+import {
+  AgentManager,
+  SessionRuntime,
+  SkillRegistry,
+  SkillRegistryError,
+  createDefaultRegistry,
+  createRegistry,
+  createToolSurface,
+  freezeAgentConfig,
+  loadConfig
+} from "./chunk-XIFFTATU.js";
+import {
+  buildSkillReport,
+  resolvePermissionMode
+} from "./chunk-A7JLBK2Y.js";
+import {
+  applySkillOverrides,
+  buildSkillListing,
+  discoverSkills,
+  explicitSkillMentions,
+  generateSkillListing,
+  loadSkillBody,
+  skillRoots
+} from "./chunk-KWHQ2XXL.js";
+import "./chunk-VZQXX3WW.js";
+import "./chunk-E75IPST5.js";
+import "./chunk-5KLVH3PY.js";
+import {
+  resolveMcpServerList
+} from "./chunk-3U5IBM24.js";
+import {
+  mcpServersToRecord,
+  partitionMcpServersByApproval
+} from "./chunk-URLQAXTR.js";
+import "./chunk-MAQXCUR4.js";
+import {
+  toolFailure,
+  toolSuccess
+} from "./chunk-5GDZ22YP.js";
+import "./chunk-EYGD6X2T.js";
+import {
+  DEFAULT_LOCAL_DATA_RETENTION_DAYS,
+  cleanupDebugLogs,
+  getDebugLogPath
+} from "./chunk-GTVB4HEM.js";
+import "./chunk-S4XL7HOM.js";
+import "./chunk-7N4J557C.js";
+import "./chunk-BTZZUCLI.js";
+import "./chunk-WKBO5R4O.js";
+import "./chunk-ANSJPYGI.js";
+import "./chunk-DGMQEI6Y.js";
+import "./chunk-5RDRAO4B.js";
+import "./chunk-CAGOB2N4.js";
+import "./chunk-574C6MQR.js";
+import {
+  resolveBookHome
+} from "./chunk-24AXE6SP.js";
+
+// src/sdk.ts
+import { join } from "path";
+
+// src/skill-evaluation.ts
+import { createHash } from "crypto";
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+var SKILL_EVALUATION_CATEGORIES = [
+  "direct",
+  "indirect",
+  "negative",
+  "ambiguous",
+  "conflicting",
+  "disabled",
+  "invalid",
+  "missing-body",
+  "missing-resource"
+];
+var DEFAULT_SKILL_EVALUATION_THRESHOLDS = {
+  minimumPrecision: 0.95,
+  minimumRecall: 0.8,
+  maximumFalseActivations: 0,
+  maximumUnnecessaryPermissionPrompts: 0,
+  maximumSkillToolFailures: 0
+};
+var DEFAULT_SKILL_EVALUATION_FIXTURES = [
+  {
+    id: "direct-review",
+    category: "direct",
+    prompt: "$review inspect the current change",
+    expectedSkills: ["review"]
+  },
+  {
+    id: "indirect-review",
+    category: "indirect",
+    prompt: "Inspect this diff for correctness regressions and missing tests",
+    expectedSkills: ["review"]
+  },
+  {
+    id: "negative-general-question",
+    category: "negative",
+    prompt: "Explain what this function returns",
+    expectedSkills: []
+  },
+  {
+    id: "ambiguous-review-word",
+    category: "ambiguous",
+    prompt: "Review the available deployment choices with me",
+    expectedSkills: []
+  },
+  {
+    id: "conflicting-tool-ceilings",
+    category: "conflicting",
+    prompt: "$read-review $write-review inspect the change",
+    expectedSkills: ["read-review"],
+    expectedBlockedCodes: ["skill_tool_intersection_empty"]
+  },
+  {
+    id: "disabled-skill",
+    category: "disabled",
+    prompt: "$disabled-skill run the workflow",
+    expectedSkills: [],
+    expectedBlockedCodes: ["skill_disabled"]
+  },
+  {
+    id: "invalid-skill",
+    category: "invalid",
+    prompt: "$invalid-skill run the workflow",
+    expectedSkills: [],
+    expectedBlockedCodes: ["skill_invalid"]
+  },
+  {
+    id: "missing-body",
+    category: "missing-body",
+    prompt: "$missing-body run the workflow",
+    expectedSkills: [],
+    expectedBlockedCodes: ["skill_load_failed"]
+  },
+  {
+    id: "missing-resource",
+    category: "missing-resource",
+    prompt: "$missing-resource load references/checklist.md",
+    expectedSkills: ["missing-resource"],
+    expectedBlockedCodes: ["skill_resource_unreadable"]
+  }
+];
+function numberDetail(event, key) {
+  const value = event.details?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function median(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((left, right) => left - right);
+  return sorted[Math.floor(sorted.length / 2)] ?? 0;
+}
+function percentile(values, fraction) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((left, right) => left - right);
+  const index = Math.min(sorted.length - 1, Math.ceil(sorted.length * fraction) - 1);
+  return sorted[index] ?? 0;
+}
+function observeSkillEvaluation(fixture, events, outcome = {}) {
+  const applied = events.filter(
+    (event) => event.type === "skill_activation_applied" && event.skill
+  );
+  const activatedSkills = [...new Set(applied.map((event) => event.skill))];
+  const expected = new Set(fixture.expectedSkills);
+  const falseActivations = applied.filter((event) => event.skill && !expected.has(event.skill));
+  const consentEvents = events.filter((event) => event.type === "skill_consent_requested");
+  const blockedCodes = events.filter(
+    (event) => event.type === "skill_activation_blocked" || event.type === "skill_resource_blocked"
+  ).map((event) => event.details?.code).filter((code) => typeof code === "string");
+  const expectedBlockedCodes = fixture.expectedBlockedCodes ?? [];
+  const promptChars = outcome.promptChars ?? 0;
+  const bodyBytes = applied.reduce(
+    (total, event) => total + numberDetail(event, "bodyByteSize"),
+    0
+  );
+  return {
+    ...fixture,
+    expectedSkills: [...fixture.expectedSkills],
+    activatedSkills,
+    expectedBlockedCodes: [...expectedBlockedCodes],
+    blockedCodes,
+    promptChars,
+    promptTokens: outcome.promptTokens ?? Math.ceil(promptChars / 4),
+    bodyBytes,
+    bodyTokens: outcome.bodyTokens ?? Math.ceil(bodyBytes / 4),
+    falseActivationBytes: falseActivations.reduce(
+      (total, event) => total + numberDetail(event, "bodyByteSize"),
+      0
+    ),
+    activationLatencyMs: applied.map((event) => numberDetail(event, "activationLatencyMs")),
+    consentRequests: consentEvents.length,
+    unnecessaryPermissionPrompts: consentEvents.filter(
+      (event) => !event.skill || !expected.has(event.skill)
+    ).length,
+    taskCompleted: outcome.taskCompleted,
+    userCorrections: outcome.userCorrections ?? 0,
+    skillToolFailures: outcome.skillToolFailures ?? 0,
+    blockingMismatch: expectedBlockedCodes.some((code) => !blockedCodes.includes(code)) || blockedCodes.some((code) => !expectedBlockedCodes.includes(code)),
+    exposure: outcome.exposure,
+    activationTurns: outcome.activationTurns
+  };
+}
+function evaluateSkillActivation(observations, thresholds = DEFAULT_SKILL_EVALUATION_THRESHOLDS) {
+  const categoryCounts = Object.fromEntries(
+    SKILL_EVALUATION_CATEGORIES.map((category) => [
+      category,
+      observations.filter((observation) => observation.category === category).length
+    ])
+  );
+  let truePositives = 0;
+  let falsePositives = 0;
+  let falseNegatives = 0;
+  for (const observation of observations) {
+    const expected = new Set(observation.expectedSkills);
+    const activated = new Set(observation.activatedSkills);
+    truePositives += [...activated].filter((skill) => expected.has(skill)).length;
+    falsePositives += [...activated].filter((skill) => !expected.has(skill)).length;
+    falseNegatives += [...expected].filter((skill) => !activated.has(skill)).length;
+  }
+  const precision = truePositives + falsePositives === 0 ? 1 : truePositives / (truePositives + falsePositives);
+  const recall = truePositives + falseNegatives === 0 ? 1 : truePositives / (truePositives + falseNegatives);
+  const completed = observations.filter(
+    (observation) => observation.taskCompleted !== void 0
+  );
+  const exposure = Object.fromEntries(
+    ["eager", "deferred"].map((mode) => {
+      const samples = observations.filter((observation) => observation.exposure === mode);
+      return [
+        mode,
+        {
+          samples: samples.length,
+          activationRate: samples.length === 0 ? 0 : samples.filter((observation) => observation.activatedSkills.length > 0).length / samples.length,
+          medianActivationTurns: median(
+            samples.map((observation) => observation.activationTurns ?? 0)
+          )
+        }
+      ];
+    })
+  );
+  const reasons = [];
+  const missingCategories = SKILL_EVALUATION_CATEGORIES.filter(
+    (category) => categoryCounts[category] === 0
+  );
+  if (missingCategories.length)
+    reasons.push(`Missing fixture categories: ${missingCategories.join(", ")}.`);
+  if (precision < thresholds.minimumPrecision) {
+    reasons.push(
+      `Activation precision ${precision.toFixed(3)} is below ${thresholds.minimumPrecision}.`
+    );
+  }
+  if (recall < thresholds.minimumRecall) {
+    reasons.push(`Activation recall ${recall.toFixed(3)} is below ${thresholds.minimumRecall}.`);
+  }
+  if (falsePositives > thresholds.maximumFalseActivations) {
+    reasons.push(
+      `False activations ${falsePositives} exceed ${thresholds.maximumFalseActivations}.`
+    );
+  }
+  const unnecessaryPermissionPrompts = observations.reduce(
+    (total, observation) => total + observation.unnecessaryPermissionPrompts,
+    0
+  );
+  if (unnecessaryPermissionPrompts > thresholds.maximumUnnecessaryPermissionPrompts) {
+    reasons.push(
+      `Unnecessary permission prompts ${unnecessaryPermissionPrompts} exceed ${thresholds.maximumUnnecessaryPermissionPrompts}.`
+    );
+  }
+  const skillToolFailures = observations.reduce(
+    (total, observation) => total + observation.skillToolFailures,
+    0
+  );
+  if (skillToolFailures > thresholds.maximumSkillToolFailures) {
+    reasons.push(
+      `Skill-caused tool failures ${skillToolFailures} exceed ${thresholds.maximumSkillToolFailures}.`
+    );
+  }
+  const blockingMismatches = observations.filter(
+    (observation) => observation.blockingMismatch
+  ).length;
+  if (blockingMismatches > 0) {
+    reasons.push(`${blockingMismatches} fixture(s) had unexpected or missing block outcomes.`);
+  }
+  const latencies = observations.flatMap((observation) => observation.activationLatencyMs);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fixtureCount: observations.length,
+    categoryCounts,
+    truePositives,
+    falsePositives,
+    falseNegatives,
+    precision,
+    recall,
+    falseActivationBytes: observations.reduce(
+      (total, observation) => total + observation.falseActivationBytes,
+      0
+    ),
+    promptChars: {
+      total: observations.reduce((total, observation) => total + observation.promptChars, 0),
+      median: median(observations.map((observation) => observation.promptChars))
+    },
+    promptTokens: {
+      total: observations.reduce((total, observation) => total + observation.promptTokens, 0),
+      median: median(observations.map((observation) => observation.promptTokens))
+    },
+    bodyBytes: {
+      total: observations.reduce((total, observation) => total + observation.bodyBytes, 0),
+      median: median(observations.map((observation) => observation.bodyBytes))
+    },
+    bodyTokens: {
+      total: observations.reduce((total, observation) => total + observation.bodyTokens, 0),
+      median: median(observations.map((observation) => observation.bodyTokens))
+    },
+    activationLatencyMs: { median: median(latencies), p95: percentile(latencies, 0.95) },
+    consentRequests: observations.reduce(
+      (total, observation) => total + observation.consentRequests,
+      0
+    ),
+    unnecessaryPermissionPrompts,
+    taskCompletionRate: completed.length === 0 ? void 0 : completed.filter((observation) => observation.taskCompleted).length / completed.length,
+    userCorrections: observations.reduce(
+      (total, observation) => total + observation.userCorrections,
+      0
+    ),
+    skillToolFailures,
+    blockingMismatches,
+    exposure,
+    thresholds: { ...thresholds },
+    rolloutReady: reasons.length === 0,
+    reasons,
+    observations: observations.map((observation) => ({
+      ...observation,
+      expectedSkills: [...observation.expectedSkills],
+      expectedBlockedCodes: observation.expectedBlockedCodes ? [...observation.expectedBlockedCodes] : void 0,
+      activatedSkills: [...observation.activatedSkills],
+      blockedCodes: [...observation.blockedCodes],
+      activationLatencyMs: [...observation.activationLatencyMs]
+    }))
+  };
+}
+async function runSkillActivationEvaluation(fixtures, execute, thresholds = DEFAULT_SKILL_EVALUATION_THRESHOLDS) {
+  const observations = [];
+  for (const fixture of fixtures) {
+    const result = await execute(fixture);
+    observations.push(
+      observeSkillEvaluation(
+        {
+          id: fixture.id,
+          category: fixture.category,
+          promptHash: createHash("sha256").update(fixture.prompt).digest("hex"),
+          expectedSkills: [...fixture.expectedSkills],
+          expectedBlockedCodes: fixture.expectedBlockedCodes ? [...fixture.expectedBlockedCodes] : void 0
+        },
+        result.events,
+        result.outcome
+      )
+    );
+  }
+  return evaluateSkillActivation(observations, thresholds);
+}
+function renderSkillEvaluationReport(report) {
+  const categories = SKILL_EVALUATION_CATEGORIES.map(
+    (category) => `- ${category}: ${report.categoryCounts[category]}`
+  ).join("\n");
+  return [
+    "# Skill Activation Evaluation",
+    "",
+    `Generated: ${report.generatedAt}`,
+    `Rollout ready: ${report.rolloutReady ? "yes" : "no"}`,
+    `Precision: ${report.precision.toFixed(3)}`,
+    `Recall: ${report.recall.toFixed(3)}`,
+    `False activations: ${report.falsePositives}`,
+    `False-activation body bytes: ${report.falseActivationBytes}`,
+    `Median prompt tokens: ${report.promptTokens.median}`,
+    `Median activated body tokens: ${report.bodyTokens.median}`,
+    `Median activation latency: ${report.activationLatencyMs.median} ms`,
+    `Unnecessary permission prompts: ${report.unnecessaryPermissionPrompts}`,
+    `Skill-caused tool failures: ${report.skillToolFailures}`,
+    `Blocking mismatches: ${report.blockingMismatches}`,
+    ...report.evaluation ? [
+      `Evidence kind: ${report.evaluation.evidenceKind}`,
+      `Provider run eligibility: ${report.evaluation.providerRunEligibility}`,
+      `Evaluation date: ${report.evaluation.controls.evaluationDate}`,
+      `Evaluation seed: ${report.evaluation.controls.randomSeed}`,
+      `Runtime revision: ${report.evaluation.controls.runtimeRevision}`,
+      `Fixture revision: ${report.evaluation.controls.fixtureRevision} (${report.evaluation.controls.fixtureRevisionStatus})`
+    ] : [],
+    "",
+    "## Fixture Coverage",
+    "",
+    categories,
+    "",
+    "## Gate",
+    "",
+    ...report.reasons.length ? report.reasons.map((reason) => `- ${reason}`) : ["- All thresholds passed."],
+    ""
+  ].join("\n");
+}
+function writeSkillEvaluationReport(report, jsonPath, markdownPath) {
+  mkdirSync(dirname(jsonPath), { recursive: true });
+  writeFileSync(jsonPath, `${JSON.stringify(report, null, 2)}
+`, "utf8");
+  if (markdownPath) {
+    mkdirSync(dirname(markdownPath), { recursive: true });
+    writeFileSync(markdownPath, renderSkillEvaluationReport(report), "utf8");
+  }
+}
+
+// src/agents/evaluation.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+async function runPairedEvaluation(fixtures, execute, outputPath) {
+  const metrics = [];
+  for (const fixture of fixtures) {
+    for (const mode of ["off", "adaptive"]) {
+      const result = await execute(fixture, mode);
+      metrics.push({
+        fixtureId: fixture.id,
+        promptHash: createHash2("sha256").update(fixture.prompt).digest("hex"),
+        cohort: fixture.cohort,
+        mode,
+        ...result
+      });
+    }
+  }
+  mkdirSync2(dirname2(outputPath), { recursive: true });
+  writeFileSync2(
+    outputPath,
+    `${metrics.map((metric) => JSON.stringify(metric)).join("\n")}
+`,
+    "utf8"
+  );
+  return metrics;
+}
+function evaluateSuccess(metrics) {
+  const reasons = [];
+  const byMode = (cohorts, mode) => metrics.filter((metric) => cohorts.includes(metric.cohort) && metric.mode === mode);
+  const rate = (items) => items.length === 0 ? 0 : items.filter((item) => item.passed).length / items.length;
+  const median2 = (values) => {
+    if (values.length === 0) return 0;
+    const sorted = [...values].sort((left, right) => left - right);
+    return sorted[Math.floor(sorted.length / 2)];
+  };
+  const treatment = byMode(["decomposable", "ambiguous"], "adaptive");
+  const control = byMode(["decomposable", "ambiguous"], "off");
+  const passGain = rate(treatment) - rate(control);
+  const treatmentWall = median2(treatment.map((item) => item.wallTimeMs));
+  const controlWall = median2(control.map((item) => item.wallTimeMs));
+  if (passGain < 0.05 && !(passGain >= 0 && treatmentWall <= controlWall * 0.8)) {
+    reasons.push("Decomposable/ambiguous cohort missed the pass-rate or wall-time target.");
+  }
+  const sequentialTreatment = byMode(["sequential"], "adaptive");
+  const sequentialControl = byMode(["sequential"], "off");
+  if (rate(sequentialTreatment) < rate(sequentialControl) - 0.02) {
+    reasons.push("Sequential cohort regressed by more than two pass-rate points.");
+  }
+  const adaptiveTokens = median2(
+    metrics.filter((item) => item.mode === "adaptive").map((item) => item.totalTokens ?? 0)
+  );
+  const controlTokens = median2(
+    metrics.filter((item) => item.mode === "off").map((item) => item.totalTokens ?? 0)
+  );
+  if (controlTokens > 0 && adaptiveTokens >= controlTokens * 3) {
+    reasons.push("Median adaptive token overhead is not below 3x.");
+  }
+  if (metrics.some((item) => (item.unvalidatedApplications ?? 0) > 0)) {
+    reasons.push("At least one unvalidated patch was applied.");
+  }
+  return { successful: reasons.length === 0, reasons };
+}
+
+// src/sdk.ts
+var AsyncEventQueue = class {
+  values = [];
+  waiters = [];
+  closed = false;
+  push(value) {
+    if (this.closed) return;
+    const waiter = this.waiters.shift();
+    if (waiter) waiter(value);
+    else this.values.push(value);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const waiter of this.waiters.splice(0)) waiter(void 0);
+  }
+  next() {
+    const value = this.values.shift();
+    if (value !== void 0) return Promise.resolve(value);
+    if (this.closed) return Promise.resolve(void 0);
+    return new Promise((resolve) => this.waiters.push(resolve));
+  }
+};
+async function* query(prompt, options = {}) {
+  const workspace = options.workspace || process.cwd();
+  const loadedConfig = loadConfig(workspace, {
+    settingsOverridePath: options.settingsPath,
+    noSettings: options.noSettings,
+    runMigrations: !options.noSettings
+  });
+  const config = freezeAgentConfig({
+    ...loadedConfig,
+    ...options.model ? { model: options.model } : {},
+    ...options.maxTurns ? { maxTurns: options.maxTurns } : {},
+    ...options.agents ? {
+      settings: {
+        ...loadedConfig.settings,
+        agents: { ...loadedConfig.settings.agents, mode: options.agents }
+      }
+    } : {}
+  });
+  const controller = new AbortController();
+  const abortFromCaller = () => controller.abort(options.signal?.reason);
+  if (options.signal?.aborted) abortFromCaller();
+  else options.signal?.addEventListener("abort", abortFromCaller, { once: true });
+  const persistSession = options.persistSession !== false;
+  const sessionStore = persistSession ? options.sessionStore ?? new SessionStore(join(resolveBookHome(), "sessions")) : void 0;
+  const bootstrap = resolveSessionBootstrap(sessionStore, {
+    cwd: config.workspace,
+    sessionId: options.sessionId
+  });
+  if (persistSession && !options.sessionStore && sessionStore) {
+    cleanupDebugLogs(DEFAULT_LOCAL_DATA_RETENTION_DAYS, getDebugLogPath());
+    sessionStore.cleanup(DEFAULT_LOCAL_DATA_RETENTION_DAYS, /* @__PURE__ */ new Set([bootstrap.sessionId]));
+  }
+  const queue = new AsyncEventQueue();
+  let connections = [];
+  queue.push({ type: "system", model: config.model, cwd: config.workspace });
+  queue.push({ type: "session", sessionId: bootstrap.sessionId });
+  const running = (async () => {
+    try {
+      for (const notice of collectWithheldProjectNotices({
+        workspace: config.workspace,
+        settings: config.settings,
+        settingsEnabled: !options.noSettings
+      })) {
+        console.warn(notice);
+      }
+      const declaredMcpServers = resolveMcpServerList(config.workspace);
+      const mcpPartition = partitionMcpServersByApproval(declaredMcpServers, config.settings);
+      for (const server of mcpPartition.pending) {
+        console.warn(
+          `\u26A0  Skipping MCP server "${server.name}" (${server.path}): project-declared servers require one-time approval. Approve it in an interactive session first.`
+        );
+      }
+      const mcp = await connectMcpServers(config.workspace, {
+        signal: controller.signal,
+        servers: mcpServersToRecord(mcpPartition.allowed),
+        onElicit: options.onElicit
+      });
+      connections = mcp.connections;
+      const registry = createDefaultRegistry({ agents: config.settings.agents.mode !== "off" });
+      if (mcp.tools.length > 0) registry.registerAll(mcp.tools);
+      const result = await runHeadless(config, registry, {
+        prompt,
+        inputFormat: "text",
+        outputFormat: "text",
+        history: bootstrap.history,
+        transcript: bootstrap.transcript,
+        compactBoundaries: bootstrap.compactBoundaries,
+        mode: resolvePermissionMode(config.settings, options.permissionMode),
+        maxTurns: options.maxTurns,
+        persistSession,
+        sessionStore,
+        sessionId: bootstrap.sessionId,
+        sessionCreated: bootstrap.created,
+        runSource: "sdk",
+        signal: controller.signal,
+        onUserQuestionRequired: options.onUserQuestionRequired,
+        forwardSubagentText: options.forwardSubagentText,
+        stdout: { write: () => true },
+        onAgentEvent: (event) => {
+          if (event.type !== "system" && event.type !== "session" && event.type !== "result" && event.type !== "done" && (event.type !== "agent_text_delta" || options.forwardSubagentText === true)) {
+            queue.push(event);
+          }
+        }
+      });
+      queue.push({
+        type: "result",
+        messages: result.messages,
+        usage: result.usage,
+        sessionId: bootstrap.sessionId,
+        outcome: result.outcome,
+        runs: result.runs,
+        // `stdout` above is a discard sink, so this is the only way an SDK
+        // caller sees a slash command the host performed on its behalf.
+        commandResults: result.commandResults
+      });
+    } catch (error) {
+      if (!controller.signal.aborted) {
+        queue.push({
+          type: "error",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    } finally {
+      await disconnectMcpServers(connections);
+      queue.push({ type: "done" });
+      queue.close();
+    }
+  })();
+  try {
+    while (true) {
+      const event = await queue.next();
+      if (!event) break;
+      yield event;
+    }
+  } finally {
+    controller.abort(new Error("SDK event consumer stopped"));
+    options.signal?.removeEventListener("abort", abortFromCaller);
+    await running;
+  }
+}
+function createAgentManager(config) {
+  return new AgentManager(config, createDefaultRegistry({ agents: true }).getDefinitions());
+}
+export {
+  AgentManager,
+  DEFAULT_SKILL_EVALUATION_FIXTURES,
+  DEFAULT_SKILL_EVALUATION_THRESHOLDS,
+  SKILL_EVALUATION_CATEGORIES,
+  SessionRuntime,
+  SkillRegistry,
+  SkillRegistryError,
+  applySkillOverrides,
+  buildSkillListing,
+  buildSkillReport,
+  createAgentManager,
+  createAgentSessionSnapshot,
+  createDefaultRegistry,
+  createRegistry,
+  createToolSurface,
+  discoverSkills,
+  evaluateSkillActivation,
+  evaluateSuccess,
+  explicitSkillMentions,
+  generateSkillListing,
+  loadConfig,
+  loadSkillBody,
+  observeSkillEvaluation,
+  query,
+  reduceAgentSessionSnapshot,
+  renderSkillEvaluationReport,
+  runPairedEvaluation,
+  runSkillActivationEvaluation,
+  skillRoots,
+  toolFailure,
+  toolSuccess,
+  writeSkillEvaluationReport
+};
+//# sourceMappingURL=sdk.js.map