@agentstep/agent-sdk 0.5.1 → 0.5.3

package/dist/chunk-7IYL2O7H.js

@@ -0,0 +1,185 @@
+import {
+  getAgent
+} from "./chunk-M3752GFZ.js";
+import {
+  init_ids,
+  newId
+} from "./chunk-F4WUVOLE.js";
+import {
+  init_clock,
+  nowMs,
+  toIso
+} from "./chunk-HFDLUBWN.js";
+import {
+  getDrizzle,
+  init_drizzle
+} from "./chunk-FILGQF2G.js";
+import {
+  schema_exports
+} from "./chunk-VC5DELR4.js";
+
+// src/db/threads.ts
+init_drizzle();
+import { eq, and, isNull, lt, gt, asc, desc } from "drizzle-orm";
+init_ids();
+init_clock();
+var MAX_THREADS_PER_SESSION = 25;
+function hydrate(row) {
+  const agent = getAgent(row.agent_id, row.agent_version);
+  const agentEmbed = agent ? {
+    type: "agent",
+    id: agent.id,
+    version: agent.version,
+    name: agent.name,
+    description: agent.description,
+    model: agent.model,
+    system: agent.system,
+    tools: agent.tools,
+    mcp_servers: agent.mcp_servers,
+    skills: agent.skills
+  } : {
+    type: "agent",
+    id: row.agent_id,
+    version: row.agent_version,
+    name: "",
+    description: "",
+    model: { id: "" },
+    system: null,
+    tools: [],
+    mcp_servers: [],
+    skills: []
+  };
+  return {
+    type: "session_thread",
+    id: row.id,
+    session_id: row.session_id,
+    status: row.status,
+    agent: agentEmbed,
+    parent_thread_id: row.parent_thread_id ?? null,
+    created_at: toIso(row.created_at),
+    updated_at: toIso(row.updated_at),
+    archived_at: row.archived_at ? toIso(row.archived_at) : null,
+    usage: {
+      input_tokens: row.usage_input_tokens,
+      output_tokens: row.usage_output_tokens,
+      cache_read_input_tokens: row.usage_cache_read_input_tokens,
+      cache_creation: {
+        ephemeral_5m_input_tokens: row.usage_cache_creation_input_tokens,
+        ephemeral_1h_input_tokens: 0
+      }
+    },
+    stop_reason: row.stop_reason ?? null
+  };
+}
+function createThread(opts) {
+  const db = getDrizzle();
+  const existing = db.select({ id: schema_exports.sessionThreads.id }).from(schema_exports.sessionThreads).where(
+    and(
+      eq(schema_exports.sessionThreads.session_id, opts.sessionId),
+      isNull(schema_exports.sessionThreads.archived_at)
+    )
+  ).all();
+  if (existing.length >= MAX_THREADS_PER_SESSION) {
+    throw new Error(`max threads per session reached (${MAX_THREADS_PER_SESSION})`);
+  }
+  const id = newId("sth");
+  const now = nowMs();
+  db.insert(schema_exports.sessionThreads).values({
+    id,
+    session_id: opts.sessionId,
+    agent_id: opts.agentId,
+    agent_version: opts.agentVersion,
+    parent_thread_id: opts.parentThreadId ?? null,
+    status: "idle",
+    usage_input_tokens: 0,
+    usage_output_tokens: 0,
+    usage_cache_read_input_tokens: 0,
+    usage_cache_creation_input_tokens: 0,
+    created_at: now,
+    updated_at: now
+  }).run();
+  return getThread(opts.sessionId, id);
+}
+function getThread(sessionId, threadId) {
+  const db = getDrizzle();
+  const row = db.select().from(schema_exports.sessionThreads).where(
+    and(
+      eq(schema_exports.sessionThreads.id, threadId),
+      eq(schema_exports.sessionThreads.session_id, sessionId)
+    )
+  ).get();
+  if (!row) return void 0;
+  return hydrate(row);
+}
+function listThreads(sessionId, opts) {
+  const db = getDrizzle();
+  const limit = Math.min(Math.max(opts?.limit ?? 50, 1), 100);
+  const orderDir = opts?.order === "asc" ? "asc" : "desc";
+  const conditions = [eq(schema_exports.sessionThreads.session_id, sessionId)];
+  if (opts?.cursor) {
+    conditions.push(
+      orderDir === "desc" ? lt(schema_exports.sessionThreads.id, opts.cursor) : gt(schema_exports.sessionThreads.id, opts.cursor)
+    );
+  }
+  const orderClause = orderDir === "desc" ? desc(schema_exports.sessionThreads.created_at) : asc(schema_exports.sessionThreads.created_at);
+  const rows = db.select().from(schema_exports.sessionThreads).where(and(...conditions)).orderBy(orderClause).limit(limit).all();
+  return rows.map(hydrate);
+}
+function updateThreadStatus(threadId, status, stopReason) {
+  const db = getDrizzle();
+  const now = nowMs();
+  db.update(schema_exports.sessionThreads).set({
+    status,
+    stop_reason: stopReason ?? null,
+    updated_at: now
+  }).where(eq(schema_exports.sessionThreads.id, threadId)).run();
+}
+function updateThreadUsage(threadId, usage) {
+  const db = getDrizzle();
+  const now = nowMs();
+  const row = db.select().from(schema_exports.sessionThreads).where(eq(schema_exports.sessionThreads.id, threadId)).get();
+  if (!row) return;
+  db.update(schema_exports.sessionThreads).set({
+    usage_input_tokens: row.usage_input_tokens + (usage.input_tokens ?? 0),
+    usage_output_tokens: row.usage_output_tokens + (usage.output_tokens ?? 0),
+    usage_cache_read_input_tokens: row.usage_cache_read_input_tokens + (usage.cache_read_input_tokens ?? 0),
+    usage_cache_creation_input_tokens: row.usage_cache_creation_input_tokens + (usage.cache_creation_input_tokens ?? 0),
+    updated_at: now
+  }).where(eq(schema_exports.sessionThreads.id, threadId)).run();
+}
+function archiveThread(sessionId, threadId) {
+  const db = getDrizzle();
+  const row = db.select().from(schema_exports.sessionThreads).where(
+    and(
+      eq(schema_exports.sessionThreads.id, threadId),
+      eq(schema_exports.sessionThreads.session_id, sessionId)
+    )
+  ).get();
+  if (!row) return void 0;
+  if (row.status !== "idle") {
+    throw new Error(`cannot archive thread in status "${row.status}" \u2014 must be idle`);
+  }
+  const now = nowMs();
+  db.update(schema_exports.sessionThreads).set({ archived_at: now, updated_at: now }).where(eq(schema_exports.sessionThreads.id, threadId)).run();
+  return getThread(sessionId, threadId);
+}
+function countActiveThreads(sessionId) {
+  const db = getDrizzle();
+  const rows = db.select({ id: schema_exports.sessionThreads.id }).from(schema_exports.sessionThreads).where(
+    and(
+      eq(schema_exports.sessionThreads.session_id, sessionId),
+      isNull(schema_exports.sessionThreads.archived_at)
+    )
+  ).all();
+  return rows.length;
+}
+
+export {
+  createThread,
+  getThread,
+  listThreads,
+  updateThreadStatus,
+  updateThreadUsage,
+  archiveThread,
+  countActiveThreads
+};

package/dist/{chunk-KGBKIJPF.js → chunk-7JAUY5SG.js}

@@ -10,14 +10,14 @@ import {
 import {
   getDrizzle,
   init_drizzle
-} from "./chunk-PZNAQBHQ.js";
+} from "./chunk-FILGQF2G.js";
 import {
   schema_exports
-} from "./chunk-ILHIHMO3.js";
+} from "./chunk-VC5DELR4.js";
 import {
   getDb,
   init_client
-} from "./chunk-W3JMIUHV.js";
+} from "./chunk-KQTTKYZY.js";
 
 // src/db/events.ts
 init_client();

package/dist/{chunk-T7BHW3CP.js → chunk-7JWW4ZQI.js}

@@ -1,6 +1,15 @@
 import {
   parseNDJSONLines
 } from "./chunk-PJZ5TQYW.js";
+import {
+  incrementRetry,
+  resetRetry,
+  retryDelay,
+  shouldRetry
+} from "./chunk-72BKGVBE.js";
+import {
+  loadSessionSecrets
+} from "./chunk-4A4F4L4H.js";
 import {
   childSpan,
   newTrace
@@ -13,32 +22,23 @@ import {
 import {
   injectMcpAuthHeaders
 } from "./chunk-DBFPJSOY.js";
-import {
-  incrementRetry,
-  resetRetry,
-  retryDelay,
-  shouldRetry
-} from "./chunk-72BKGVBE.js";
-import {
-  loadSessionSecrets
-} from "./chunk-HMOSAXVZ.js";
 import {
   isProxied
-} from "./chunk-5U5LRAFJ.js";
+} from "./chunk-MTLM36QD.js";
 import {
   acquireForFirstTurn,
   installSkills,
   provisionResources,
   wrapProviderWithSecrets
-} from "./chunk-ZY2U24QP.js";
+} from "./chunk-75XURMV5.js";
 import {
   BLOCKED_ENV_KEYS,
   resolveVaultSecrets
-} from "./chunk-T3HMVHDG.js";
+} from "./chunk-O2X4XBU7.js";
 import {
   appendEvent,
   appendEventsBatch
-} from "./chunk-5MERXOLJ.js";
+} from "./chunk-NRX5WHHN.js";
 import {
   bumpSessionStats,
   getOutcomeCriteria,
@@ -49,26 +49,26 @@ import {
   setOutcomeCriteria,
   updateSessionMutable,
   updateSessionStatus
-} from "./chunk-KUWJJD6O.js";
+} from "./chunk-TSR33JMZ.js";
 import {
   listEvents,
   markUserEventProcessed
-} from "./chunk-KGBKIJPF.js";
+} from "./chunk-7JAUY5SG.js";
 import {
   getBySession
 } from "./chunk-EFOIR7R3.js";
 import {
   resolveContainerProvider
-} from "./chunk-JRQB3SHR.js";
+} from "./chunk-LT5PRO54.js";
 import {
   getEnvironment
-} from "./chunk-H6OT5GUL.js";
+} from "./chunk-7APAOJIZ.js";
 import {
   getAgent
-} from "./chunk-BCIFFAGW.js";
+} from "./chunk-M3752GFZ.js";
 import {
   resolveBackend
-} from "./chunk-IMPLRDOV.js";
+} from "./chunk-Q2JYAAJO.js";
 import {
   PERMISSION_BRIDGE_PENDING_PATH,
   PERMISSION_BRIDGE_REQUEST_PATH,
@@ -84,7 +84,7 @@ import {
 } from "./chunk-XBHDQK4Z.js";
 import {
   getConfig
-} from "./chunk-GQYSSSVA.js";
+} from "./chunk-UGH5JDXX.js";
 import {
   init_clock,
   nowMs
@@ -266,13 +266,36 @@ async function runTurn(sessionId, inputs, _depth = 0, parentTrace) {
     content: i.content
   }));
   const agentForTurn = injectMcpAuthHeaders(agent, vaultEntries);
+  let mountedMemoryStores;
+  try {
+    const { listResources: listSessionResources } = await import("./db/session-resources.js");
+    const { getMemoryStore } = await import("./db/memory.js");
+    const sessionResources = listSessionResources(sessionId);
+    const memStoreResources = sessionResources.filter((r) => r.type === "memory_store" && r.memory_store_id);
+    if (memStoreResources.length > 0) {
+      mountedMemoryStores = [];
+      for (const r of memStoreResources) {
+        const store = getMemoryStore(r.memory_store_id);
+        if (store) {
+          mountedMemoryStores.push({
+            name: store.name,
+            access: r.access ?? "read_write",
+            description: store.description,
+            instructions: r.instructions
+          });
+        }
+      }
+    }
+  } catch {
+  }
   let turnBuild;
   try {
     turnBuild = backend.buildTurn({
       agent: agentForTurn,
       backendSessionId: getSessionRow(sessionId)?.claude_session_id ?? null,
       promptText,
-      toolResults
+      toolResults,
+      memoryStores: mountedMemoryStores
     });
   } catch (err) {
     const msg = err instanceof ApiError ? err.message : err instanceof Error ? err.message : String(err);
@@ -613,6 +636,17 @@ ${turnBuild.stdin}`;
     } catch (err) {
       console.warn("[driver] container file sync failed:", err?.stack ?? err);
     }
+    try {
+      const { syncMemoryStores } = await import("./sync/memory-sync.js");
+      await syncMemoryStores({
+        sessionId,
+        sandboxName: sessionRowForSync.sandbox_name,
+        provider,
+        secrets
+      });
+    } catch (err) {
+      console.warn("[driver] memory store sync failed:", err?.stack ?? err);
+    }
   }
   const now = nowMs();
   const stopReason = result?.stopReason ?? "end_turn";
@@ -670,11 +704,12 @@ ${turnBuild.stdin}`;
   setIdleSince(sessionId, now);
   if (stopReason === "end_turn") {
     const criteria = getOutcomeCriteria(sessionId);
-    if (criteria?.rubric) {
+    if (criteria?.rubric && criteria?.status === "running") {
       try {
         const { runGraderEvaluation } = await import("./sessions/grader.js");
         const maxIter = criteria.max_iterations ?? 3;
         const iteration = criteria.grader_iteration ?? 0;
+        const outcomeId = criteria.outcome_id ?? null;
         const recentEvents = listEvents(sessionId, { limit: 50, order: "desc" });
         let lastAgentText = "";
         for (const evt of recentEvents) {
@@ -687,7 +722,7 @@ ${turnBuild.stdin}`;
             }
           }
         }
-        emit("span.outcome_evaluation_start", { iteration });
+        emit("span.outcome_evaluation_start", { outcome_id: outcomeId, iteration });
         const evaluation = await runGraderEvaluation(
           criteria.rubric,
           lastAgentText,
@@ -706,10 +741,21 @@ ${turnBuild.stdin}`;
         });
         const finalResult = iteration + 1 >= maxIter && evaluation.result === "needs_revision" ? "max_iterations_reached" : evaluation.result;
         emit("span.outcome_evaluation_end", {
+          outcome_id: outcomeId,
           result: finalResult,
+          explanation: evaluation.feedback,
           iteration,
-          feedback: evaluation.feedback
+          usage: evaluation.usage
         });
+        if (finalResult === "satisfied" || finalResult === "max_iterations_reached" || finalResult === "failed") {
+          setOutcomeCriteria(sessionId, {
+            ...criteria,
+            grader_iteration: iteration + 1,
+            status: finalResult,
+            completed_at: new Date(nowMs()).toISOString(),
+            explanation: evaluation.feedback
+          });
+        }
         if (evaluation.result === "needs_revision" && iteration + 1 < maxIter) {
           await runTurn(sessionId, [{
             kind: "text",

package/dist/{chunk-YZZHDZ7B.js → chunk-7XIAKW75.js}

@@ -1,6 +1,6 @@
 import {
   getConfig
-} from "./chunk-GQYSSSVA.js";
+} from "./chunk-UGH5JDXX.js";
 
 // src/backends/factory/auth.ts
 function buildFactoryAuthEnv() {

package/dist/{chunk-USIMPXUH.js → chunk-A2W3USEZ.js}

@@ -1,6 +1,6 @@
 import {
   getConfig
-} from "./chunk-GQYSSSVA.js";
+} from "./chunk-UGH5JDXX.js";
 import {
   ApiError
 } from "./chunk-EZYKRG4W.js";

package/dist/{chunk-WU74DV5R.js → chunk-A7AXD5AM.js}

@@ -1,11 +1,11 @@
 import {
   BatchError,
   executeBatch
-} from "./chunk-MCWCRZM4.js";
+} from "./chunk-BLTCDZ3O.js";
 import {
   jsonOk,
   routeWrap
-} from "./chunk-T3IGOI6Z.js";
+} from "./chunk-DTQ7J35Q.js";
 import {
   badRequest
 } from "./chunk-EZYKRG4W.js";

package/dist/chunk-ACPP4KN7.js

@@ -0,0 +1,164 @@
+import {
+  DREAMING_SYSTEM_PROMPT,
+  UPDATE_MEMORIES_TOOL
+} from "./chunk-3LUY2POB.js";
+import {
+  createOrUpsertMemory,
+  deleteMemory,
+  getMemoryByPath,
+  getMemoryStore,
+  listMemories
+} from "./chunk-GBLR2CPP.js";
+import {
+  listSessions
+} from "./chunk-TSR33JMZ.js";
+import {
+  listEvents
+} from "./chunk-7JAUY5SG.js";
+import {
+  init_clock,
+  nowMs
+} from "./chunk-HFDLUBWN.js";
+
+// src/dreaming/review.ts
+init_clock();
+var MAX_SESSIONS = 20;
+var MAX_EVENTS_PER_SESSION = 50;
+var RELEVANT_EVENT_TYPES = ["user.message", "agent.message", "session.error"];
+function extractSessionSummary(sessionId, title, events) {
+  const parts = [];
+  const errors = [];
+  for (const evt of events) {
+    let payload;
+    try {
+      payload = JSON.parse(evt.payload_json);
+    } catch {
+      continue;
+    }
+    if (evt.type === "user.message") {
+      const content = payload.content;
+      if (Array.isArray(content)) {
+        const text = content.filter((b) => b.type === "text").map((b) => b.text ?? "").join(" ");
+        if (text) parts.push(`[User] ${text.slice(0, 500)}`);
+      } else if (typeof content === "string") {
+        parts.push(`[User] ${content.slice(0, 500)}`);
+      }
+    } else if (evt.type === "agent.message") {
+      const content = payload.content;
+      if (Array.isArray(content)) {
+        const text = content.filter((b) => b.type === "text").map((b) => b.text ?? "").join(" ");
+        if (text) parts.push(`[Agent] ${text.slice(0, 500)}`);
+      } else if (typeof content === "string") {
+        parts.push(`[Agent] ${content.slice(0, 500)}`);
+      }
+    } else if (evt.type === "session.error") {
+      const msg = payload.message ?? payload.error ?? JSON.stringify(payload);
+      errors.push(msg.slice(0, 200));
+    }
+  }
+  const header = `Session ${sessionId}${title ? ` (${title})` : ""}:`;
+  const body = parts.join("\n");
+  const errorSection = errors.length ? `
+Errors: ${errors.join("; ")}` : "";
+  return `${header}
+${body}${errorSection}`;
+}
+async function reviewSessions(opts) {
+  const { storeId, lookbackMs, dryRun } = opts;
+  const store = getMemoryStore(storeId);
+  if (!store) {
+    throw new Error(`Memory store not found: ${storeId}`);
+  }
+  const apiKey = opts.apiKey || process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error("No Anthropic API key provided. Use --api-key or set ANTHROPIC_API_KEY.");
+  }
+  const cutoff = nowMs() - lookbackMs;
+  const sessions = listSessions({
+    statuses: ["idle", "terminated"],
+    createdGt: cutoff,
+    limit: MAX_SESSIONS,
+    order: "desc"
+  });
+  if (sessions.length === 0) {
+    return { sessionCount: 0, proposedChanges: [], applied: false };
+  }
+  const summaries = [];
+  for (const session of sessions) {
+    const events = listEvents(session.id, {
+      limit: MAX_EVENTS_PER_SESSION,
+      order: "asc"
+    });
+    const relevant = events.filter((e) => RELEVANT_EVENT_TYPES.includes(e.type));
+    if (relevant.length === 0) continue;
+    const summary = extractSessionSummary(session.id, session.title ?? null, relevant);
+    summaries.push(summary);
+  }
+  if (summaries.length === 0) {
+    return { sessionCount: sessions.length, proposedChanges: [], applied: false };
+  }
+  const memories = listMemories(storeId);
+  const memorySection = memories.length > 0 ? `## Current Memory Store Contents
+
+${memories.map((m) => `### ${m.path}
+${m.content}`).join("\n\n")}` : "## Current Memory Store Contents\n\n(empty \u2014 no memories yet)";
+  const sessionSection = `## Recent Sessions (${summaries.length})
+
+${summaries.join("\n\n---\n\n")}`;
+  const userMessage = `${sessionSection}
+
+${memorySection}
+
+Analyze the sessions above and propose memory changes using the update_memories tool.`;
+  const maxChars = 2e5;
+  const truncatedMessage = userMessage.length > maxChars ? userMessage.slice(0, maxChars) + "\n\n[... truncated for context limits]" : userMessage;
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 4096,
+      system: DREAMING_SYSTEM_PROMPT,
+      tools: [UPDATE_MEMORIES_TOOL],
+      tool_choice: { type: "tool", name: "update_memories" },
+      messages: [{ role: "user", content: truncatedMessage }]
+    })
+  });
+  if (!response.ok) {
+    const errText = await response.text().catch(() => "");
+    throw new Error(`Anthropic API error (${response.status}): ${errText}`);
+  }
+  const data = await response.json();
+  const toolUse = data.content.find(
+    (b) => b.type === "tool_use" && b.name === "update_memories"
+  );
+  const changes = toolUse?.input?.changes ?? [];
+  if (!dryRun && changes.length > 0) {
+    for (const change of changes) {
+      if (change.operation === "create" || change.operation === "update") {
+        if (change.content) {
+          createOrUpsertMemory(storeId, change.path, change.content, "dream");
+        }
+      } else if (change.operation === "delete") {
+        const existing = getMemoryByPath(storeId, change.path);
+        if (existing) {
+          deleteMemory(existing.id, "dream");
+        }
+      }
+    }
+  }
+  return {
+    sessionCount: sessions.length,
+    proposedChanges: changes,
+    applied: !dryRun && changes.length > 0
+  };
+}
+
+export {
+  extractSessionSummary,
+  reviewSessions
+};

package/dist/{chunk-22OUZJAV.js → chunk-AESA3ARX.js}

@@ -5,14 +5,14 @@ import {
 import {
   getDrizzle,
   init_drizzle
-} from "./chunk-PZNAQBHQ.js";
+} from "./chunk-FILGQF2G.js";
 import {
   schema_exports
-} from "./chunk-ILHIHMO3.js";
+} from "./chunk-VC5DELR4.js";
 import {
   getDb,
   init_client
-} from "./chunk-W3JMIUHV.js";
+} from "./chunk-KQTTKYZY.js";
 
 // src/db/sync.ts
 init_drizzle();

package/dist/{chunk-37C5BNVV.js → chunk-AIAF5ZZA.js}

@@ -1,6 +1,6 @@
 import {
   getConfig
-} from "./chunk-GQYSSSVA.js";
+} from "./chunk-UGH5JDXX.js";
 import {
   serverBusy
 } from "./chunk-EZYKRG4W.js";

package/dist/{chunk-YYMUSVUI.js → chunk-ANS2TQYT.js}

@@ -1,12 +1,12 @@
 import {
   withGatewayPreamble
-} from "./chunk-FVBDEOTZ.js";
+} from "./chunk-YE2RMJY7.js";
 import {
   resolveToolset
 } from "./chunk-XBHDQK4Z.js";
 import {
   getConfig
-} from "./chunk-GQYSSSVA.js";
+} from "./chunk-UGH5JDXX.js";
 
 // src/backends/claude/args.ts
 function buildClaudeArgs(input) {
@@ -28,7 +28,7 @@ function buildClaudeArgs(input) {
     argv.push("--resume", input.claudeSessionId);
   }
   const tools = resolveToolset(input.agent.tools);
-  let systemPrompt = withGatewayPreamble(input.agent.system);
+  let systemPrompt = withGatewayPreamble(input.agent.system, input.memoryStores);
   if (tools.customToolNames.size > 0) {
     const toolList = Array.from(tools.customToolNames).map((name) => `mcp__tool-bridge__${name}`).join(", ");
     systemPrompt += `

package/dist/{chunk-T3FQPTOA.js → chunk-BCBDHUFY.js}

@@ -9,10 +9,10 @@ import {
 import {
   getDrizzle,
   init_drizzle
-} from "./chunk-PZNAQBHQ.js";
+} from "./chunk-FILGQF2G.js";
 import {
   schema_exports
-} from "./chunk-ILHIHMO3.js";
+} from "./chunk-VC5DELR4.js";
 
 // src/db/api_keys.ts
 init_drizzle();

package/dist/{chunk-COZG53R3.js → chunk-BCBRLP33.js}

@@ -4,11 +4,11 @@ import {
   getSources,
   getStats,
   searchSkills
-} from "./chunk-74E7GKUG.js";
+} from "./chunk-TE6KCRPP.js";
 import {
   jsonOk,
   routeWrap
-} from "./chunk-T3IGOI6Z.js";
+} from "./chunk-DTQ7J35Q.js";
 
 // src/handlers/skills.ts
 async function handleGetSkillsCatalog(request) {