stitchkit 0.70.5 → 0.71.0

package/dist/{index-jw81xr75.js → index-19eet1qx.js}

@@ -30,19 +30,49 @@ var AgentConversationMessagePageSchema = z.object({
   nextCursor: z.string().min(1).optional()
 }).strict();
 
-// src/agent-runtime/store.ts
+// src/agent-runtime/purge.ts
 import { z as z2 } from "zod";
-var AgentStoreConflictSchema = z2.object({
-  outcome: z2.literal("conflict"),
+var AgentConversationPurgeInputSchema = z2.strictObject({
+  conversationId: AgentRecordIdSchema,
+  expectedVersion: AgentRecordVersionSchema.optional()
+});
+var AgentConversationPurgeResultSchema = z2.discriminatedUnion("outcome", [
+  z2.strictObject({ outcome: z2.literal("purged") }),
+  z2.strictObject({ outcome: z2.literal("already_purged") }),
+  z2.strictObject({ outcome: z2.literal("unsupported") }),
+  z2.strictObject({
+    outcome: z2.literal("active"),
+    runIds: z2.array(AgentRecordIdSchema).min(1)
+  }),
+  z2.strictObject({ outcome: z2.literal("conflict"), actualVersion: AgentRecordVersionSchema })
+]);
+
+class AgentConversationPurgedError extends Error {
+  constructor() {
+    super("Agent conversation has been purged; use a new conversation ID");
+    this.name = "AgentConversationPurgedError";
+  }
+}
+async function purgeAgentConversation(store, input) {
+  const parsed = AgentConversationPurgeInputSchema.parse(input);
+  if (!store.purgeConversation)
+    return { outcome: "unsupported" };
+  return AgentConversationPurgeResultSchema.parse(await store.purgeConversation(parsed));
+}
+
+// src/agent-runtime/store.ts
+import { z as z3 } from "zod";
+var AgentStoreConflictSchema = z3.object({
+  outcome: z3.literal("conflict"),
   actualVersion: AgentRecordVersionSchema
 });
-var AgentStoreNotFoundSchema = z2.object({ outcome: z2.literal("not_found") });
-var AgentStoreAppliedSchema = z2.object({
-  outcome: z2.literal("applied"),
+var AgentStoreNotFoundSchema = z3.object({ outcome: z3.literal("not_found") });
+var AgentStoreAppliedSchema = z3.object({
+  outcome: z3.literal("applied"),
   snapshot: AgentSnapshotSchema
 });
-var AgentStoreDuplicateSchema = z2.object({
-  outcome: z2.literal("duplicate"),
+var AgentStoreDuplicateSchema = z3.object({
+  outcome: z3.literal("duplicate"),
   input: AgentMessageSchema,
   inputMessageId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
@@ -51,116 +81,141 @@ var AgentStoreDuplicateSchema = z2.object({
   assistant: AgentMessageSchema.optional(),
   snapshot: AgentSnapshotSchema
 });
-var AgentStoreMutationResultSchema = z2.discriminatedUnion("outcome", [
+var AgentStoreMutationResultSchema = z3.discriminatedUnion("outcome", [
   AgentStoreAppliedSchema,
   AgentStoreDuplicateSchema,
   AgentStoreConflictSchema,
   AgentStoreNotFoundSchema
 ]);
-var AgentRunViewSchema = z2.object({
+var AgentRunViewSchema = z3.object({
   snapshotVersion: AgentRecordVersionSchema,
   run: AgentRunSchema,
   assistant: AgentMessageSchema.optional()
 });
-var AcceptInputAndAssignRunSchema = z2.object({
-  idempotencyKey: z2.string().min(1),
+var AcceptInputAndAssignRunSchema = z3.object({
+  idempotencyKey: z3.string().min(1),
   expectedVersion: AgentRecordVersionSchema.optional(),
   input: AgentMessageSchema,
   run: AgentRunSchema,
   coalesceIntoRunId: AgentRecordIdSchema.optional()
 });
-var AcquireAgentRunSchema = z2.object({
+var AcquireAgentRunSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z2.string().min(1)
+  ownerId: z3.string().min(1)
 });
-var CheckpointRunAssistantSchema = z2.object({
+var CheckpointRunAssistantSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z2.string().min(1),
+  ownerId: z3.string().min(1),
   fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema,
   usage: AgentUsageSchema.optional()
 });
-var CommitRunTerminalSchema = z2.object({
+var CommitRunTerminalSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z2.string().min(1),
+  ownerId: z3.string().min(1),
   fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema,
   reason: AgentTerminalReasonSchema,
-  policyName: z2.string().min(1).optional(),
+  policyName: z3.string().min(1).optional(),
   usage: AgentUsageSchema.optional(),
-  absorb: z2.array(z2.object({
+  absorb: z3.array(z3.object({
     runId: AgentRecordIdSchema,
-    inputMessageIds: z2.array(AgentRecordIdSchema).min(1)
+    inputMessageIds: z3.array(AgentRecordIdSchema).min(1)
   })).min(1).optional()
 });
-var RequestRunInterruptSchema = z2.object({
+var RequestRunInterruptSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema
 });
-var RecoverAgentRunSchema = z2.object({
+var RecoverAgentRunSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  action: z2.enum(["requeue", "abandon"]),
-  replaySafe: z2.boolean().optional()
+  action: z3.enum(["requeue", "abandon"]),
+  replaySafe: z3.boolean().optional()
 });
-var ReplaceCompactedRangeSchema = z2.object({
+var ReplaceCompactedRangeSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   expectedVersion: AgentRecordVersionSchema,
-  replacedMessageIds: z2.array(AgentRecordIdSchema).min(1),
+  replacedMessageIds: z3.array(AgentRecordIdSchema).min(1),
   summary: AgentMessageSchema
 });
-var AgentRecoverableDescriptorSchema = z2.object({
+var AgentRecoverableDescriptorSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   run: AgentRunSchema
 });
-var AgentRecoverablePageSchema = z2.object({
-  items: z2.array(AgentRecoverableDescriptorSchema),
-  nextCursor: z2.string().min(1).optional()
+var AgentRecoverablePageSchema = z3.object({
+  items: z3.array(AgentRecoverableDescriptorSchema),
+  nextCursor: z3.string().min(1).optional()
 });
 
 // src/agent-runtime/store-driver.ts
-import { z as z3 } from "zod";
-var AgentRuntimeHeadSchema = z3.object({
-  schemaVersion: z3.literal(1),
+import { z as z4 } from "zod";
+
+// src/agent-runtime/store-purge.ts
+function createStoreConversationPurge(driver, conversations) {
+  return async (input) => {
+    const { conversationId, expectedVersion } = AgentConversationPurgeInputSchema.parse(input);
+    return driver.transaction(async (transaction) => {
+      if (await conversations.isPurged(transaction, conversationId)) {
+        return { outcome: "already_purged" };
+      }
+      const head = await driver.head.load(transaction, conversationId);
+      const actualVersion = head?.version ?? 0;
+      if (expectedVersion !== undefined && expectedVersion !== actualVersion) {
+        return { outcome: "conflict", actualVersion };
+      }
+      const active = await driver.runs.listActive(transaction, conversationId);
+      if (active.length > 0) {
+        return { outcome: "active", runIds: active.map((record) => record.run.id) };
+      }
+      await conversations.remove(transaction, conversationId);
+      return { outcome: "purged" };
+    });
+  };
+}
+
+// src/agent-runtime/store-driver.ts
+var AgentRuntimeHeadSchema = z4.object({
+  schemaVersion: z4.literal(1),
   conversationId: AgentRecordIdSchema,
   version: AgentRecordVersionSchema
 });
-var AgentStoredRunSchema = z3.object({
-  schemaVersion: z3.literal(1),
+var AgentStoredRunSchema = z4.object({
+  schemaVersion: z4.literal(1),
   run: AgentRunSchema,
   terminalAssistant: AgentMessageSchema.optional()
 });
-var AgentAdmissionReceiptSchema = z3.object({
-  schemaVersion: z3.literal(1),
+var AgentAdmissionReceiptSchema = z4.object({
+  schemaVersion: z4.literal(1),
   conversationId: AgentRecordIdSchema,
-  idempotencyKey: z3.string().min(1),
+  idempotencyKey: z4.string().min(1),
   input: AgentMessageSchema,
   runId: AgentRecordIdSchema,
   assistantMessageId: AgentRecordIdSchema
 });
-var AgentHistoryMutationSchema = z3.discriminatedUnion("type", [
-  z3.object({ type: z3.literal("admit"), input: AgentMessageSchema }),
-  z3.object({
-    type: z3.literal("upsert-assistant"),
+var AgentHistoryMutationSchema = z4.discriminatedUnion("type", [
+  z4.object({ type: z4.literal("admit"), input: AgentMessageSchema }),
+  z4.object({
+    type: z4.literal("upsert-assistant"),
     message: AgentMessageSchema
   }),
-  z3.object({
-    type: z3.literal("replace-compacted-range"),
-    replacedMessageIds: z3.array(AgentRecordIdSchema).min(1),
+  z4.object({
+    type: z4.literal("replace-compacted-range"),
+    replacedMessageIds: z4.array(AgentRecordIdSchema).min(1),
     summary: AgentMessageSchema
   })
 ]);
-var AgentRecoverableScanInputSchema = z3.object({
-  cursor: z3.string().min(1).optional(),
-  limit: z3.number().int().min(1).max(1000)
+var AgentRecoverableScanInputSchema = z4.object({
+  cursor: z4.string().min(1).optional(),
+  limit: z4.number().int().min(1).max(1000)
 });
 function emptyHead(conversationId) {
   return AgentRuntimeHeadSchema.parse({
@@ -264,7 +319,7 @@ function validateSnapshot(head, messages, records) {
     }
   }
 }
-var RecoverableCursorSchema = z3.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
+var RecoverableCursorSchema = z4.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
 function recoverableCursor(input) {
   return JSON.stringify([input.conversationId, input.run.id]);
 }
@@ -622,6 +677,9 @@ function createAgentRuntimeStore(driver) {
   });
   const mutate = (operation) => driver.transaction(async (transaction) => {
     const conversationId = operationConversationId(operation);
+    if (await driver.conversations?.isPurged(transaction, conversationId)) {
+      throw new AgentConversationPurgedError;
+    }
     const operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" ? undefined : operation.input.runId;
     const [stored, messages, activeRecords, operationRecord, duplicateReceipt] = await Promise.all([
       driver.head.load(transaction, conversationId),
@@ -724,6 +782,9 @@ function createAgentRuntimeStore(driver) {
     loadSnapshot,
     loadRun,
     listActiveRuns,
+    ...driver.conversations && {
+      purgeConversation: createStoreConversationPurge(driver, driver.conversations)
+    },
     acceptInputAndAssignRun: (input) => mutate({
       type: "accept",
       input: AcceptInputAndAssignRunSchema.parse(input)
@@ -768,6 +829,7 @@ function cloneHistoryMap(source) {
   ]));
 }
 function createMemoryAgentRuntimeStore() {
+  let purged = new Set;
   let heads = new Map;
   let runs = new Map;
   let admissions = new Map;
@@ -784,6 +846,7 @@ function createMemoryAgentRuntimeStore() {
         return;
       });
       const transaction = {
+        purged: new Set(purged),
         heads: cloneHeadMap(heads),
         runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema.parse(structuredClone(record))),
         admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema.parse(structuredClone(receipt))),
@@ -791,6 +854,7 @@ function createMemoryAgentRuntimeStore() {
       };
       try {
         const result = await work(transaction);
+        purged = transaction.purged;
         heads = transaction.heads;
         runs = transaction.runs;
         admissions = transaction.admissions;
@@ -800,6 +864,18 @@ function createMemoryAgentRuntimeStore() {
         release.resolve();
       }
     },
+    conversations: {
+      async isPurged(transaction, conversationId) {
+        return transaction.purged.has(conversationId);
+      },
+      async remove(transaction, conversationId) {
+        transaction.purged.add(conversationId);
+        transaction.heads.delete(conversationId);
+        transaction.runs.delete(conversationId);
+        transaction.admissions.delete(conversationId);
+        transaction.histories.delete(conversationId);
+      }
+    },
     head: {
       async load(transaction, conversationId) {
         const head = transaction.heads.get(conversationId);
@@ -912,4 +988,4 @@ function createMemoryAgentRuntimeStore() {
   return createAgentRuntimeStore(driver);
 }
 
-export { AgentConversationSummarySchema, AgentConversationPageSchema, AgentConversationMessagePageSchema, AgentStoreConflictSchema, AgentStoreNotFoundSchema, AgentStoreAppliedSchema, AgentStoreDuplicateSchema, AgentStoreMutationResultSchema, AgentRunViewSchema, AcceptInputAndAssignRunSchema, AcquireAgentRunSchema, CheckpointRunAssistantSchema, CommitRunTerminalSchema, RequestRunInterruptSchema, RecoverAgentRunSchema, ReplaceCompactedRangeSchema, AgentRecoverableDescriptorSchema, AgentRecoverablePageSchema, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentHistoryMutationSchema, ACTIVE_AGENT_RUN_STATES, createAgentRuntimeStore, createMemoryAgentRuntimeStore };
+export { AgentConversationSummarySchema, AgentConversationPageSchema, AgentConversationMessagePageSchema, AgentConversationPurgeInputSchema, AgentConversationPurgeResultSchema, AgentConversationPurgedError, purgeAgentConversation, AgentStoreConflictSchema, AgentStoreNotFoundSchema, AgentStoreAppliedSchema, AgentStoreDuplicateSchema, AgentStoreMutationResultSchema, AgentRunViewSchema, AcceptInputAndAssignRunSchema, AcquireAgentRunSchema, CheckpointRunAssistantSchema, CommitRunTerminalSchema, RequestRunInterruptSchema, RecoverAgentRunSchema, ReplaceCompactedRangeSchema, AgentRecoverableDescriptorSchema, AgentRecoverablePageSchema, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentHistoryMutationSchema, ACTIVE_AGENT_RUN_STATES, createAgentRuntimeStore, createMemoryAgentRuntimeStore };

package/dist/{index-ejv31h14.js → index-7qy2ex0m.js}

@@ -1,6 +1,6 @@
 import {
   executeToolMethod
-} from "./index-qm87g51s.js";
+} from "./index-s4c8wy8m.js";
 import {
   assertToolExtensionCompatible,
   mergeSchemas,

package/dist/{index-9sx8tbz2.js → index-cksjz4eg.js}

@@ -8,7 +8,7 @@ import {
   AgentRuntimeHeadSchema,
   AgentStoredRunSchema,
   createAgentRuntimeStore
-} from "./index-jw81xr75.js";
+} from "./index-19eet1qx.js";
 import {
   AgentMessageSchema,
   AgentRunSchema
@@ -16,6 +16,52 @@ import {
 
 // src/agent-runtime/sqlite.ts
 import { z } from "zod";
+
+// src/agent-runtime/sqlite-purge.ts
+var OWNED_TABLES = [
+  "stitchkit_agent_runtime_messages",
+  "stitchkit_agent_runtime_admissions",
+  "stitchkit_agent_runtime_runs",
+  "stitchkit_agent_runtime_heads"
+];
+function initializeSqliteConversationPurge(database) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_purged (
+      conversation_id TEXT PRIMARY KEY
+    );
+  `);
+  for (const table of OWNED_TABLES) {
+    for (const operation of ["INSERT", "UPDATE"]) {
+      database.exec(`
+        CREATE TRIGGER IF NOT EXISTS ${table}_purge_${operation.toLowerCase()}
+        BEFORE ${operation} ON ${table}
+        WHEN EXISTS (
+          SELECT 1 FROM stitchkit_agent_runtime_purged WHERE conversation_id = NEW.conversation_id
+        )
+        BEGIN SELECT RAISE(ABORT, 'Agent conversation has been purged'); END;
+      `);
+    }
+  }
+}
+function sqliteConversationPurge(database) {
+  const table = database.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'stitchkit_agent_runtime_purged'").get();
+  if (table === null || table === undefined)
+    return;
+  return {
+    async isPurged(transaction, conversationId) {
+      const row = transaction.prepare("SELECT conversation_id FROM stitchkit_agent_runtime_purged WHERE conversation_id = ?").get(conversationId);
+      return row !== null && row !== undefined;
+    },
+    async remove(transaction, conversationId) {
+      transaction.prepare("INSERT INTO stitchkit_agent_runtime_purged (conversation_id) VALUES (?)").run(conversationId);
+      for (const table2 of OWNED_TABLES) {
+        transaction.prepare(`DELETE FROM ${table2} WHERE conversation_id = ?`).run(conversationId);
+      }
+    }
+  };
+}
+
+// src/agent-runtime/sqlite.ts
 var HeadRowSchema = z.object({ version: z.number().int().nonnegative() });
 var RunRowSchema = z.object({
   payload: z.string(),
@@ -121,6 +167,7 @@ function initializeAgentRuntimeSqlite(database) {
       if (missingTables.length > 0) {
         throw new Error(`Refusing a partial Stitchkit agent-runtime SQLite schema; missing ${missingTables.join(", ")}`);
       }
+      initializeSqliteConversationPurge(database);
       database.exec("COMMIT");
       return;
     }
@@ -165,6 +212,7 @@ function initializeAgentRuntimeSqlite(database) {
       );
       INSERT INTO stitchkit_agent_runtime_meta (key, value) VALUES ('schema_version', '1');
     `);
+    initializeSqliteConversationPurge(database);
     database.exec("COMMIT");
   } catch (error) {
     database.exec("ROLLBACK");
@@ -197,6 +245,7 @@ function createSqliteAgentRuntimeStore(config) {
     return result;
   };
   const driver = {
+    conversations: sqliteConversationPurge(database),
     transaction: (work) => serial(async () => {
       database.exec("BEGIN IMMEDIATE");
       try {

package/dist/{index-trrf7nch.js → index-ezmn6ac6.js}

@@ -3,15 +3,15 @@ import {
 } from "./index-3xnq72rz.js";
 import {
   collectToolSurface
-} from "./index-hxtm2xr2.js";
+} from "./index-k2zczx1g.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-ejv31h14.js";
+} from "./index-7qy2ex0m.js";
 import {
   isToolExecutionControlError,
   toolResultFromError
-} from "./index-qm87g51s.js";
+} from "./index-s4c8wy8m.js";
 import {
   isRecord
 } from "./index-qyrqwr4c.js";

package/dist/{index-ekkt4gy9.js → index-jqtsc9mj.js}

@@ -1,10 +1,10 @@
 import {
   collectTools,
   createToolRunner
-} from "./index-ejv31h14.js";
+} from "./index-7qy2ex0m.js";
 import {
   toolErrorFromResult
-} from "./index-qm87g51s.js";
+} from "./index-s4c8wy8m.js";
 import {
   assertUniqueToolName
 } from "./index-22by16v6.js";

package/dist/{index-hxtm2xr2.js → index-k2zczx1g.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-wwst0td5.js";
 import {
   contractToolMountable
-} from "./index-ejv31h14.js";
+} from "./index-7qy2ex0m.js";
 import {
   projectToolSurface
 } from "./index-22by16v6.js";

package/dist/{index-35wcrke5.js → index-m668wzyc.js}

@@ -15,7 +15,7 @@ import {
 import {
   ToolExecutionControlError,
   isToolExecutionControlError
-} from "./index-qm87g51s.js";
+} from "./index-s4c8wy8m.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentJsonObjectSchema,
@@ -1418,11 +1418,18 @@ function createRunExecutor(dependencies) {
           ...run.fencingToken !== undefined && { fencingToken: run.fencingToken }
         })
       });
+      let lastPromptTokens = { provenance: "unavailable" };
       const runtimeContext = {
         context: input.context,
         run,
         signal: executionSignal,
-        toolFenceLifecycle
+        toolFenceLifecycle,
+        get contextUsage() {
+          const descriptor = selectedModel?.descriptor;
+          if (!descriptor)
+            return;
+          return { usedTokens: lastPromptTokens, contextWindow: descriptor.contextWindow };
+        }
       };
       selectedModel = await config.models.resolve({
         context: input.context,
@@ -1783,6 +1790,7 @@ function createRunExecutor(dependencies) {
             usage: part.usage,
             providerMetadata: part.providerMetadata
           }) ?? normalizeSdkUsage(part.usage);
+          lastPromptTokens = stepUsage.inputTokens;
           modelUsage = addUsage(modelUsage, stepUsage);
           usage = nonModelUsage ? addUsage(nonModelUsage, modelUsage) : modelUsage;
           config.observe?.emit({
@@ -2182,6 +2190,9 @@ function createAgentRuntime(config) {
         updatedAt: nowIso
       });
       const outerAccepted = Promise.withResolvers();
+      outerAccepted.promise.catch(() => {
+        return;
+      });
       const outerAdmission = Promise.withResolvers();
       outerAdmission.promise.catch(() => {
         return;

package/dist/{index-w9m1wznn.js → index-nemjkxjp.js}

@@ -59,6 +59,123 @@ function parseQueryParams(url) {
   }
   return query;
 }
+var IPV4_RESERVED = [
+  ["0.0.0.0", 8],
+  ["10.0.0.0", 8],
+  ["100.64.0.0", 10],
+  ["127.0.0.0", 8],
+  ["169.254.0.0", 16],
+  ["172.16.0.0", 12],
+  ["192.0.0.0", 24],
+  ["192.0.2.0", 24],
+  ["192.88.99.0", 24],
+  ["192.168.0.0", 16],
+  ["198.18.0.0", 15],
+  ["198.51.100.0", 24],
+  ["203.0.113.0", 24],
+  ["224.0.0.0", 4],
+  ["240.0.0.0", 4]
+];
+function parseIpv4(value) {
+  const parts = value.split(".");
+  if (parts.length !== 4)
+    return;
+  let result = 0;
+  for (const part of parts) {
+    if (!/^(0|[1-9]\d{0,2})$/.test(part))
+      return;
+    const octet = Number(part);
+    if (octet > 255)
+      return;
+    result = result * 256 + octet;
+  }
+  return result;
+}
+function parseIpv6(value) {
+  const address = value.split("%")[0] ?? "";
+  if (!address.includes(":"))
+    return;
+  const halves = address.split("::");
+  if (halves.length > 2)
+    return;
+  const groups = [];
+  const tail = [];
+  const push = (into, text) => {
+    if (text === "")
+      return true;
+    for (const piece of text.split(":")) {
+      if (piece.includes(".")) {
+        const v4 = parseIpv4(piece);
+        if (v4 === undefined)
+          return false;
+        into.push(v4 >>> 16 & 65535, v4 & 65535);
+        continue;
+      }
+      if (!/^[0-9a-fA-F]{1,4}$/.test(piece))
+        return false;
+      into.push(Number.parseInt(piece, 16));
+    }
+    return true;
+  };
+  if (!push(groups, halves[0] ?? ""))
+    return;
+  if (halves.length === 2 && !push(tail, halves[1] ?? ""))
+    return;
+  const missing = 8 - groups.length - tail.length;
+  if (halves.length === 2 ? missing < 0 : missing !== 0)
+    return;
+  const words = [
+    ...groups,
+    ...Array(halves.length === 2 ? missing : 0).fill(0),
+    ...tail
+  ];
+  if (words.length !== 8)
+    return;
+  const bytes = new Uint8Array(16);
+  words.forEach((word, index) => {
+    bytes[index * 2] = word >>> 8 & 255;
+    bytes[index * 2 + 1] = word & 255;
+  });
+  return bytes;
+}
+function hasPrefix(bytes, prefix, bits) {
+  for (let index = 0;index < bits; index += 1) {
+    const byte = bytes[index >> 3] ?? 0;
+    const against = prefix[index >> 3] ?? 0;
+    const mask = 128 >> index % 8;
+    if ((byte & mask) !== (against & mask))
+      return false;
+  }
+  return true;
+}
+function isPublicIp(value) {
+  const address = value.trim();
+  if (!address)
+    return false;
+  const v4 = parseIpv4(address);
+  if (v4 !== undefined) {
+    return !IPV4_RESERVED.some(([network, bits]) => {
+      const base = parseIpv4(network);
+      if (base === undefined)
+        return false;
+      const mask = bits === 0 ? 0 : 4294967295 << 32 - bits >>> 0;
+      return (v4 & mask) >>> 0 === (base & mask) >>> 0;
+    });
+  }
+  const bytes = parseIpv6(address);
+  if (!bytes)
+    return false;
+  if (hasPrefix(bytes, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255], 96)) {
+    return isPublicIp(Array.from(bytes.slice(12)).join("."));
+  }
+  if (!hasPrefix(bytes, [32], 3))
+    return false;
+  if (hasPrefix(bytes, [32, 1, 0, 0], 23))
+    return false;
+  if (hasPrefix(bytes, [32, 1, 13, 184], 32))
+    return false;
+  return true;
+}
 
 // src/observability/context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -114,4 +231,4 @@ function wrapInRequestContext(handler, options = {}) {
   };
 }
 
-export { generateTraceId, resolveTraceId, resolveSocketIp, extractIp, getClientInfo, parseQueryParams, runWithRequestContext, getRequestContext, getTraceId, getUserId, setRequestUser, setRequestEndpoint, setRequestDimensions, setRequestError, wrapInRequestContext };
+export { generateTraceId, resolveTraceId, resolveSocketIp, extractIp, getClientInfo, parseQueryParams, isPublicIp, runWithRequestContext, getRequestContext, getTraceId, getUserId, setRequestUser, setRequestEndpoint, setRequestDimensions, setRequestError, wrapInRequestContext };

package/dist/{index-tnazr5tc.js → index-pz7ytdga.js}

@@ -1,14 +1,14 @@
 import {
   collectToolSurface
-} from "./index-hxtm2xr2.js";
+} from "./index-k2zczx1g.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-ejv31h14.js";
+} from "./index-7qy2ex0m.js";
 import {
   coerceJsonArgs,
   toolResultFromError
-} from "./index-qm87g51s.js";
+} from "./index-s4c8wy8m.js";
 import {
   isWithinDir
 } from "./index-sbdmyz75.js";