stitchkit 0.116.0 → 0.117.0

package/dist/index-qezhmp51.js

@@ -0,0 +1,242 @@
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
+
+// src/primitives/decimal.ts
+import { z } from "zod";
+var DECIMAL_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+function parseDecimal(value) {
+  if (!DECIMAL_PATTERN.test(value))
+    throw new TypeError(`invalid decimal value "${value}"`);
+  const negative = value.startsWith("-");
+  const unsigned = negative ? value.slice(1) : value;
+  const [whole = "0", fraction = ""] = unsigned.split(".");
+  const coefficient = BigInt(`${negative ? "-" : ""}${whole}${fraction}`);
+  return normalizeDecimal({ coefficient, scale: fraction.length });
+}
+function normalizeDecimal(parts) {
+  let coefficient = parts.coefficient;
+  let scale = parts.scale;
+  while (scale > 0 && coefficient % 10n === 0n) {
+    coefficient /= 10n;
+    scale -= 1;
+  }
+  return { coefficient, scale };
+}
+function formatDecimal(parts) {
+  const normalized = normalizeDecimal(parts);
+  const negative = normalized.coefficient < 0n;
+  const digits = (negative ? -normalized.coefficient : normalized.coefficient).toString();
+  if (normalized.scale === 0)
+    return `${negative ? "-" : ""}${digits}`;
+  const padded = digits.padStart(normalized.scale + 1, "0");
+  const point = padded.length - normalized.scale;
+  return `${negative ? "-" : ""}${padded.slice(0, point)}.${padded.slice(point)}`;
+}
+function addDecimal(left, right) {
+  const scale = Math.max(left.scale, right.scale);
+  const leftCoefficient = left.coefficient * 10n ** BigInt(scale - left.scale);
+  const rightCoefficient = right.coefficient * 10n ** BigInt(scale - right.scale);
+  return normalizeDecimal({ coefficient: leftCoefficient + rightCoefficient, scale });
+}
+function multiplyDecimalRatio(value, numerator, denominator) {
+  if (denominator <= 0n)
+    throw new RangeError("conversion denominator must be positive");
+  let coefficient = value.coefficient * numerator;
+  let scale = value.scale;
+  for (let extraScale = 0;extraScale <= 18; extraScale += 1) {
+    if (coefficient % denominator === 0n) {
+      return normalizeDecimal({ coefficient: coefficient / denominator, scale });
+    }
+    coefficient *= 10n;
+    scale += 1;
+  }
+  throw new RangeError("conversion does not have a finite decimal representation");
+}
+var DecimalStringSchema2 = z.string().refine((value) => {
+  try {
+    return formatDecimal(parseDecimal(value)) === value;
+  } catch {
+    return false;
+  }
+}, "expected a canonical decimal string");
+var DecimalInputSchema2 = z.string().regex(DECIMAL_PATTERN, "expected a decimal string").transform((value) => formatDecimal(parseDecimal(value)));
+
+// src/primitives/rounding.ts
+import { z as z2 } from "zod";
+var RoundingModeSchema2 = z2.enum(["half-up", "half-even", "up", "down"]);
+function isPositive(value) {
+  return DecimalStringSchema2.safeParse(value).success && parseDecimal(value).coefficient > 0n;
+}
+function compareParts(left, right) {
+  const scale = BigInt(Math.max(left.scale, right.scale));
+  const a = left.coefficient * 10n ** (scale - BigInt(left.scale));
+  const b = right.coefficient * 10n ** (scale - BigInt(right.scale));
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+var RoundingTierSchema = z2.object({
+  below: z2.string().refine(isPositive, "expected a positive decimal").optional(),
+  step: z2.string().refine(isPositive, "expected a positive decimal")
+});
+var RoundingPolicySchema2 = z2.object({ mode: RoundingModeSchema2, tiers: z2.array(RoundingTierSchema).min(1) }).superRefine(({ tiers }, context) => {
+  const bounds = tiers.map((tier) => tier.below);
+  if (bounds.at(-1) !== undefined || bounds.slice(0, -1).includes(undefined)) {
+    context.addIssue({ code: "custom", message: 'only the last tier omits "below"' });
+  }
+  const ordered = bounds.flatMap((bound) => bound !== undefined && isPositive(bound) ? [parseDecimal(bound)] : []);
+  for (const [index, bound] of ordered.entries()) {
+    const next = ordered[index + 1];
+    if (next !== undefined && compareParts(bound, next) >= 0) {
+      context.addIssue({ code: "custom", message: '"below" must ascend' });
+    }
+  }
+});
+function defineRoundingPolicy2(policy) {
+  const { mode, tiers } = RoundingPolicySchema2.parse(policy);
+  return Object.freeze({ mode, tiers: tiers.map((tier) => Object.freeze(tier)) });
+}
+function absolute(value) {
+  return value < 0n ? -value : value;
+}
+function roundRatio(numerator, denominator, mode) {
+  const magnitude = absolute(numerator);
+  const quotient = magnitude / denominator;
+  const remainder = magnitude % denominator;
+  const twice = remainder * 2n;
+  const away = remainder !== 0n && (mode === "up" || mode === "half-up" && twice >= denominator || mode === "half-even" && (twice > denominator || twice === denominator && quotient % 2n === 1n));
+  const rounded = away ? quotient + 1n : quotient;
+  return numerator < 0n ? -rounded : rounded;
+}
+function stepFor(value, policy) {
+  const magnitude = { ...value, coefficient: absolute(value.coefficient) };
+  const tier = policy.tiers.find(({ below }) => below === undefined || compareParts(magnitude, parseDecimal(below)) < 0);
+  if (tier === undefined)
+    throw new TypeError("a rounding policy needs a last tier");
+  return parseDecimal(tier.step);
+}
+function hasWholeSteps(policy) {
+  return policy.tiers.every(({ step }) => parseDecimal(step).scale === 0);
+}
+function roundParts(value, policy) {
+  const step = stepFor(value, policy);
+  const steps = roundRatio(value.coefficient * 10n ** BigInt(step.scale), step.coefficient * 10n ** BigInt(value.scale), policy.mode);
+  return { coefficient: steps * step.coefficient, scale: step.scale };
+}
+function multiplyAndRound(left, right, policy) {
+  return roundParts({ coefficient: left.coefficient * right.coefficient, scale: left.scale + right.scale }, policy);
+}
+function roundDecimal2(value, policy) {
+  return formatDecimal(roundParts(parseDecimal(DecimalInputSchema2.parse(value)), policy));
+}
+
+// src/primitives/money.ts
+import { z as z3 } from "zod";
+var IntegerStringSchema = z3.string().regex(/^-?(?:0|[1-9]\d*)$/);
+function createMoneySchema2(currency) {
+  return z3.object({
+    minor: IntegerStringSchema,
+    currency: z3.literal(currency)
+  });
+}
+function parseMinor(value) {
+  return BigInt(IntegerStringSchema.parse(value.minor));
+}
+function assertSameCurrency(left, right) {
+  if (left.currency !== right.currency) {
+    throw new TypeError(`cannot combine "${left.currency}" and "${right.currency}"`);
+  }
+}
+function money(minor, currency) {
+  return Object.freeze({ minor: minor.toString(), currency });
+}
+function addMoney2(left, right) {
+  assertSameCurrency(left, right);
+  return money(parseMinor(left) + parseMinor(right), left.currency);
+}
+function subtractMoney2(left, right) {
+  assertSameCurrency(left, right);
+  return money(parseMinor(left) - parseMinor(right), left.currency);
+}
+function multiplyMoney2(value, quantity) {
+  if (typeof quantity === "number" && !Number.isSafeInteger(quantity)) {
+    throw new RangeError("quantity must be a safe integer");
+  }
+  const multiplier = typeof quantity === "bigint" ? quantity : BigInt(quantity);
+  return money(parseMinor(value) * multiplier, value.currency);
+}
+var ScaleSchema = z3.number().int().min(0).max(18);
+function moneyFromDecimal2(currency, value, scale) {
+  const places = ScaleSchema.parse(scale);
+  const parts = parseDecimal(DecimalInputSchema2.parse(value));
+  if (parts.scale > places) {
+    throw new RangeError(`"${value}" is finer than ${places} decimal places`);
+  }
+  return money(parts.coefficient * 10n ** BigInt(places - parts.scale), currency);
+}
+function moneyToDecimal2(value, scale) {
+  const places = ScaleSchema.parse(scale);
+  const minor = parseMinor(value);
+  const whole = formatDecimal({ coefficient: minor, scale: places });
+  if (places === 0)
+    return whole;
+  const [integer = "0", fraction = ""] = whole.split(".");
+  return `${integer}.${fraction.padEnd(places, "0")}`;
+}
+function assertMinorSteps(policy) {
+  if (!hasWholeSteps(policy)) {
+    throw new RangeError("a money rounding step must be a whole number of minor units");
+  }
+}
+function roundMoney2(value, policy) {
+  assertMinorSteps(policy);
+  const rounded = roundParts({ coefficient: parseMinor(value), scale: 0 }, policy);
+  return money(rounded.coefficient, value.currency);
+}
+function multiplyMoneyByDecimal2(value, factor, policy) {
+  assertMinorSteps(policy);
+  const rounded = multiplyAndRound({ coefficient: parseMinor(value), scale: 0 }, parseDecimal(DecimalInputSchema2.parse(factor)), policy);
+  return money(rounded.coefficient, value.currency);
+}
+function shareMoney2(value, numerator, denominator) {
+  if (denominator <= 0n)
+    throw new RangeError("denominator must be positive");
+  if (numerator < 0n)
+    throw new RangeError("numerator must be non-negative");
+  const scaled = parseMinor(value) * numerator;
+  return Object.freeze({
+    amount: money(scaled / denominator, value.currency),
+    remainder: Object.freeze({
+      numerator: (scaled % denominator).toString(),
+      denominator: denominator.toString(),
+      currency: value.currency
+    })
+  });
+}
+function splitMoney2(value, count) {
+  assertPositiveSafeInteger("count", count, RangeError);
+  const divisor = BigInt(count);
+  const total = parseMinor(value);
+  return Object.freeze({
+    part: money(total / divisor, value.currency),
+    count,
+    remainder: money(total % divisor, value.currency)
+  });
+}
+function defineMoney2(currency) {
+  const schema = createMoneySchema2(currency);
+  return Object.freeze({
+    currency,
+    schema,
+    create(minor) {
+      const parsed = schema.parse({ minor: minor.toString(), currency });
+      return Object.freeze(parsed);
+    },
+    add: addMoney2,
+    subtract: subtractMoney2,
+    multiply: multiplyMoney2,
+    share: shareMoney2,
+    split: splitMoney2
+  });
+}
+
+export { parseDecimal, formatDecimal, addDecimal, multiplyDecimalRatio, DecimalStringSchema2, DecimalInputSchema2, RoundingModeSchema2, RoundingPolicySchema2, defineRoundingPolicy2, roundDecimal2, createMoneySchema2, addMoney2, subtractMoney2, multiplyMoney2, moneyFromDecimal2, moneyToDecimal2, roundMoney2, multiplyMoneyByDecimal2, shareMoney2, splitMoney2, defineMoney2 };

package/dist/index-vv1sch8a.js

@@ -0,0 +1,94 @@
+// src/tracking/beacon.ts
+function sendUnloadBeacon2(url, body, sender = typeof navigator === "undefined" ? undefined : navigator) {
+  if (!sender || typeof sender.sendBeacon !== "function")
+    return false;
+  return sender.sendBeacon(url, body);
+}
+
+// src/tracking/privacy.ts
+var MASK = "[masked]";
+var MAX_REDACTED_CHARS = 16384;
+var TELEGRAM_SIGNED_FIELD = "tgwebappdata";
+var PASSWORD_FIELD = /^(?:current|new|old|confirm|repeat|repeated)?(?:password|passwd|pwd)(?:confirmation)?$/;
+var CREDENTIAL_FIELDS = new Set([
+  "token",
+  "accesstoken",
+  "idtoken",
+  "refreshtoken",
+  "authtoken",
+  "sessiontoken",
+  "csrftoken",
+  "resettoken",
+  "magictoken",
+  "secret",
+  "clientsecret",
+  "apikey",
+  "privatekey",
+  "authorization",
+  "signature",
+  "xamzsignature"
+]);
+var OAUTH_FIELDS = new Set(["code", "state", "sessionstate"]);
+var SIGNED_LOGIN_FIELDS = new Set(["hash"]);
+var PARAMETER = /([?&#])([^=&#?\s]+)=([^&#\s]*)/g;
+var URL_PASSWORD = /(https?:\/\/[^\s/:@]+:)[^\s/@]+(@)/gi;
+var BEARER = /\b(bearer\s+)[^\s,;]+/gi;
+var ASSIGNMENT = /(^|[^\w?&#/-])("[^"\n]+"|'[^'\n]+'|[\w.$[\]-]+)(\s*[:=]\s*)("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,;}]+)/g;
+function fieldName(key) {
+  const field = key.replace(/^amp;/, "").split(/[.[\]]/).filter((part) => part !== "" && !/^\d+$/.test(part)).at(-1) ?? "";
+  return field.replace(/[-_\s]/g, "").toLowerCase();
+}
+function isSecretField(key, context) {
+  const field = fieldName(key);
+  if (PASSWORD_FIELD.test(field) || CREDENTIAL_FIELDS.has(field))
+    return true;
+  if (field === TELEGRAM_SIGNED_FIELD)
+    return true;
+  if (context?.oauth && OAUTH_FIELDS.has(field))
+    return true;
+  return Boolean(context?.signedLogin && SIGNED_LOGIN_FIELDS.has(field));
+}
+function decodeKey(key) {
+  try {
+    return decodeURIComponent(key.replace(/\+/g, " "));
+  } catch {
+    return key;
+  }
+}
+function secretContextOf(input) {
+  const names = new Set(Array.from(input.matchAll(PARAMETER), (match) => fieldName(decodeKey(match[2] ?? ""))));
+  return {
+    oauth: names.has("state") && names.has("code"),
+    signedLogin: names.has("authdate")
+  };
+}
+function redactTrackingText2(input) {
+  const text = input.slice(0, MAX_REDACTED_CHARS);
+  const context = secretContextOf(text);
+  return text.replace(URL_PASSWORD, `$1${MASK}$2`).replace(BEARER, `$1${MASK}`).replace(PARAMETER, (whole, separator, key, value) => {
+    try {
+      if (isSecretField(decodeKey(key), context))
+        return `${separator}${key}=${MASK}`;
+      const decoded = decodeURIComponent(value.replace(/\+/g, " "));
+      const redacted = redactTrackingText2(decoded);
+      return redacted === decoded ? whole : `${separator}${key}=${encodeURIComponent(redacted)}`;
+    } catch {
+      return whole;
+    }
+  }).replace(ASSIGNMENT, (whole, prefix, key, assignment) => isSecretField(key.replace(/^["']|["']$/g, "")) ? `${prefix}${key}${assignment}${MASK}` : whole);
+}
+function redactTrackingValue2(value) {
+  if (typeof value === "string")
+    return redactTrackingText2(value);
+  if (Array.isArray(value))
+    return value.map(redactTrackingValue2);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+      key,
+      isSecretField(key) ? MASK : redactTrackingValue2(item)
+    ]));
+  }
+  return value;
+}
+
+export { sendUnloadBeacon2, redactTrackingText2, redactTrackingValue2 };

package/dist/{index-fggxgbrk.js → index-xx1j310k.js}

@@ -374,158 +374,221 @@ function assistantStatus(reason) {
   return "failed";
 }
 
+// src/agent-runtime/store-driver-contract.ts
+import { z as z4 } from "zod";
+var AgentRuntimeHeadSchema2 = z4.object({
+  schemaVersion: z4.literal(1),
+  conversationId: AgentRecordIdSchema2,
+  version: AgentRecordVersionSchema2
+});
+var AgentStoredRunSchema2 = z4.object({
+  schemaVersion: z4.literal(1),
+  run: AgentRunSchema2,
+  terminalAssistant: AgentMessageSchema2.optional()
+});
+var AgentAdmissionReceiptSchema2 = z4.object({
+  schemaVersion: z4.literal(1),
+  conversationId: AgentRecordIdSchema2,
+  idempotencyKey: z4.string().min(1),
+  input: AgentMessageSchema2,
+  runId: AgentRecordIdSchema2,
+  assistantMessageId: AgentRecordIdSchema2
+});
+var AgentSeedReceiptSchema2 = z4.object({
+  schemaVersion: z4.literal(1),
+  conversationId: AgentRecordIdSchema2,
+  seedKey: z4.string().min(1),
+  messageIds: z4.array(AgentRecordIdSchema2).min(1)
+});
+var AgentHistoryMutationSchema2 = z4.discriminatedUnion("type", [
+  z4.object({ type: z4.literal("admit"), input: AgentMessageSchema2 }),
+  z4.object({
+    type: z4.literal("upsert-assistant"),
+    message: AgentMessageSchema2
+  }),
+  z4.object({
+    type: z4.literal("replace-compacted-range"),
+    replacedMessageIds: z4.array(AgentRecordIdSchema2).min(1),
+    summary: AgentMessageSchema2
+  }),
+  z4.object({
+    type: z4.literal("seed"),
+    message: AgentMessageSchema2
+  }),
+  z4.object({
+    type: z4.literal("insert"),
+    message: AgentMessageSchema2,
+    beforeMessageId: AgentRecordIdSchema2.optional()
+  })
+]);
+var ACTIVE_AGENT_RUN_STATES2 = [
+  "queued",
+  "running",
+  "interrupt_requested"
+];
+function isActiveRunState(state) {
+  return ACTIVE_AGENT_RUN_STATES2.includes(state);
+}
+function emptyHead(conversationId) {
+  return AgentRuntimeHeadSchema2.parse({
+    schemaVersion: 1,
+    conversationId,
+    version: 0
+  });
+}
+
 // src/agent-runtime/provider-journal.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/agent-runtime/provider-content.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var ProviderJournalOptions = {
-  providerOptions: z4.record(z4.string(), z4.record(z4.string(), z4.json())).optional()
+  providerOptions: z5.record(z5.string(), z5.record(z5.string(), z5.json())).optional()
 };
 var Options = ProviderJournalOptions;
-var Reference = z4.record(z4.string(), z4.string()).refine((value) => !("type" in value), "Provider reference cannot contain a file discriminator");
-var Binary = z4.object({
-  binary: z4.literal(true),
-  sha256: z4.string().regex(/^[a-f0-9]{64}$/),
-  bytes: z4.int().nonnegative()
+var Reference = z5.record(z5.string(), z5.string()).refine((value) => !("type" in value), "Provider reference cannot contain a file discriminator");
+var Binary = z5.object({
+  binary: z5.literal(true),
+  sha256: z5.string().regex(/^[a-f0-9]{64}$/),
+  bytes: z5.int().nonnegative()
 }).strict();
-var Inline = z4.union([z4.string(), Binary]);
-var TaggedBinary = z4.object({ type: z4.literal("data"), data: Inline }).strict();
-var TaggedUrl = z4.object({ type: z4.literal("url"), url: z4.string() }).strict();
-var FileData = z4.union([
+var Inline = z5.union([z5.string(), Binary]);
+var TaggedBinary = z5.object({ type: z5.literal("data"), data: Inline }).strict();
+var TaggedUrl = z5.object({ type: z5.literal("url"), url: z5.string() }).strict();
+var FileData = z5.union([
   TaggedBinary,
   TaggedUrl,
-  z4.object({ type: z4.literal("reference"), reference: Reference }).strict(),
-  z4.object({ type: z4.literal("text"), text: z4.string() }).strict()
+  z5.object({ type: z5.literal("reference"), reference: Reference }).strict(),
+  z5.object({ type: z5.literal("text"), text: z5.string() }).strict()
 ]);
-var File = z4.object({
-  type: z4.literal("file"),
-  data: z4.union([FileData, Inline, Reference]),
-  mediaType: z4.string(),
-  filename: z4.string().optional(),
+var File = z5.object({
+  type: z5.literal("file"),
+  data: z5.union([FileData, Inline, Reference]),
+  mediaType: z5.string(),
+  filename: z5.string().optional(),
   ...Options
 }).strict();
-var Text = z4.object({ type: z4.literal("text"), text: z4.string(), ...Options }).strict();
-var Output = z4.discriminatedUnion("type", [
-  z4.object({ type: z4.enum(["text", "error-text"]), value: z4.string(), ...Options }).strict(),
-  z4.object({ type: z4.enum(["json", "error-json"]), value: z4.json(), ...Options }).strict(),
-  z4.object({ type: z4.literal("execution-denied"), reason: z4.string().optional(), ...Options }).strict(),
-  z4.object({
-    type: z4.literal("content"),
-    value: z4.array(z4.union([
+var Text = z5.object({ type: z5.literal("text"), text: z5.string(), ...Options }).strict();
+var Output = z5.discriminatedUnion("type", [
+  z5.object({ type: z5.enum(["text", "error-text"]), value: z5.string(), ...Options }).strict(),
+  z5.object({ type: z5.enum(["json", "error-json"]), value: z5.json(), ...Options }).strict(),
+  z5.object({ type: z5.literal("execution-denied"), reason: z5.string().optional(), ...Options }).strict(),
+  z5.object({
+    type: z5.literal("content"),
+    value: z5.array(z5.union([
       Text,
-      z4.object({
-        type: z4.literal("file"),
+      z5.object({
+        type: z5.literal("file"),
         data: FileData,
-        mediaType: z4.string(),
-        filename: z4.string().optional(),
+        mediaType: z5.string(),
+        filename: z5.string().optional(),
         ...Options
       }).strict(),
-      z4.object({
-        type: z4.literal("file-data"),
-        data: z4.string(),
-        mediaType: z4.string(),
-        filename: z4.string().optional(),
+      z5.object({
+        type: z5.literal("file-data"),
+        data: z5.string(),
+        mediaType: z5.string(),
+        filename: z5.string().optional(),
         ...Options
       }).strict(),
-      z4.object({
-        type: z4.literal("image-data"),
-        data: z4.string(),
-        mediaType: z4.string(),
+      z5.object({
+        type: z5.literal("image-data"),
+        data: z5.string(),
+        mediaType: z5.string(),
         ...Options
       }).strict(),
-      z4.object({
-        type: z4.literal("file-url"),
-        url: z4.string(),
-        mediaType: z4.string().optional(),
+      z5.object({
+        type: z5.literal("file-url"),
+        url: z5.string(),
+        mediaType: z5.string().optional(),
         ...Options
       }).strict(),
-      z4.object({ type: z4.literal("image-url"), url: z4.string(), ...Options }).strict(),
-      z4.object({
-        type: z4.enum(["file-id", "image-file-id"]),
-        fileId: z4.union([z4.string(), Reference]),
+      z5.object({ type: z5.literal("image-url"), url: z5.string(), ...Options }).strict(),
+      z5.object({
+        type: z5.enum(["file-id", "image-file-id"]),
+        fileId: z5.union([z5.string(), Reference]),
         ...Options
       }).strict(),
-      z4.object({
-        type: z4.enum(["file-reference", "image-file-reference"]),
+      z5.object({
+        type: z5.enum(["file-reference", "image-file-reference"]),
         providerReference: Reference,
         ...Options
       }).strict(),
-      z4.object({ type: z4.literal("custom"), ...Options }).strict()
+      z5.object({ type: z5.literal("custom"), ...Options }).strict()
     ]))
   }).strict()
 ]);
-var ProviderJournalContentSchema = z4.union([
+var ProviderJournalContentSchema = z5.union([
   Text,
   File,
-  z4.object({ type: z4.literal("reasoning"), text: z4.string(), ...Options }).strict(),
-  z4.object({ type: z4.literal("custom"), kind: z4.string(), ...Options }).strict(),
-  z4.object({
-    type: z4.literal("reasoning-file"),
-    data: z4.union([TaggedBinary, TaggedUrl, Inline]),
-    mediaType: z4.string(),
+  z5.object({ type: z5.literal("reasoning"), text: z5.string(), ...Options }).strict(),
+  z5.object({ type: z5.literal("custom"), kind: z5.string(), ...Options }).strict(),
+  z5.object({
+    type: z5.literal("reasoning-file"),
+    data: z5.union([TaggedBinary, TaggedUrl, Inline]),
+    mediaType: z5.string(),
     ...Options
   }).strict(),
-  z4.object({
-    type: z4.literal("image"),
-    image: z4.union([Inline, Reference]),
-    mediaType: z4.string().optional(),
+  z5.object({
+    type: z5.literal("image"),
+    image: z5.union([Inline, Reference]),
+    mediaType: z5.string().optional(),
     ...Options
   }).strict(),
-  z4.object({
-    type: z4.literal("tool-call"),
-    toolCallId: z4.string(),
-    toolName: z4.string(),
-    input: z4.json(),
-    providerExecuted: z4.boolean().optional(),
+  z5.object({
+    type: z5.literal("tool-call"),
+    toolCallId: z5.string(),
+    toolName: z5.string(),
+    input: z5.json(),
+    providerExecuted: z5.boolean().optional(),
     ...Options
   }).strict(),
-  z4.object({
-    type: z4.literal("tool-result"),
-    toolCallId: z4.string(),
-    toolName: z4.string(),
+  z5.object({
+    type: z5.literal("tool-result"),
+    toolCallId: z5.string(),
+    toolName: z5.string(),
     output: Output,
     ...Options
   }).strict(),
-  z4.object({
-    type: z4.literal("tool-approval-request"),
-    approvalId: z4.string(),
-    toolCallId: z4.string(),
-    signature: z4.string().optional(),
-    isAutomatic: z4.boolean().optional(),
-    reason: z4.string().optional()
+  z5.object({
+    type: z5.literal("tool-approval-request"),
+    approvalId: z5.string(),
+    toolCallId: z5.string(),
+    signature: z5.string().optional(),
+    isAutomatic: z5.boolean().optional(),
+    reason: z5.string().optional()
   }).strict(),
-  z4.object({
-    type: z4.literal("tool-approval-response"),
-    approvalId: z4.string(),
-    approved: z4.boolean(),
-    reason: z4.string().optional(),
-    providerExecuted: z4.boolean().optional()
+  z5.object({
+    type: z5.literal("tool-approval-response"),
+    approvalId: z5.string(),
+    approved: z5.boolean(),
+    reason: z5.string().optional(),
+    providerExecuted: z5.boolean().optional()
   }).strict()
 ]);
 
 // src/agent-runtime/provider-journal.ts
-var Hash = z5.string().regex(/^[a-f0-9]{64}$/);
-var Message = z5.object({
+var Hash = z6.string().regex(/^[a-f0-9]{64}$/);
+var Message = z6.object({
   ...ProviderJournalOptions,
-  role: z5.enum(["system", "user", "assistant", "tool"]),
-  content: z5.union([z5.string(), z5.array(ProviderJournalContentSchema)])
+  role: z6.enum(["system", "user", "assistant", "tool"]),
+  content: z6.union([z6.string(), z6.array(ProviderJournalContentSchema)])
 }).strict();
-var ProviderJournalMessageSchema = z5.object({ sha256: Hash, message: Message }).strict();
-var ProviderJournalRequestSchema = z5.object({
-  runId: z5.string(),
-  attempt: z5.int().nonnegative(),
-  stepNumber: z5.int().nonnegative(),
-  modelId: z5.string(),
+var ProviderJournalMessageSchema = z6.object({ sha256: Hash, message: Message }).strict();
+var ProviderJournalRequestSchema = z6.object({
+  runId: z6.string(),
+  attempt: z6.int().nonnegative(),
+  stepNumber: z6.int().nonnegative(),
+  modelId: z6.string(),
   instructionsSha256: Hash,
-  messageShas: z5.array(Hash),
+  messageShas: z6.array(Hash),
   bodySha256: Hash
 }).strict();
-var ProviderJournalResponseSchema = z5.object({
-  runId: z5.string(),
-  attempt: z5.int().nonnegative(),
-  stepNumber: z5.int().nonnegative(),
-  response: z5.object({ id: z5.string(), provider: z5.string().optional() }).strict()
+var ProviderJournalResponseSchema = z6.object({
+  runId: z6.string(),
+  attempt: z6.int().nonnegative(),
+  stepNumber: z6.int().nonnegative(),
+  response: z6.object({ id: z6.string(), provider: z6.string().optional() }).strict()
 }).strict();
 
-export { AgentStoreEventKindSchema2, AgentStoreEventEnvelopeSchema2, AppendAgentStoreEventSchema2, ReadAgentStoreEventsSchema2, AgentStoreEventPageSchema2, AgentStoreConflictSchema2, AgentStoreNotFoundSchema2, AgentStoreAppliedSchema2, AgentStoreDuplicateSchema2, AgentStoreMutationResultSchema2, AgentRunViewSchema2, AcceptInputAndAssignRunSchema2, AcquireAgentRunSchema2, CheckpointRunAssistantSchema2, RecordRunOperationSchema2, CommitRunTerminalSchema2, RequestRunInterruptSchema2, RecoverAgentRunSchema2, ReplaceCompactedRangeSchema2, SeedConversationInputSchema2, AgentRecoverableDescriptorSchema2, AgentRecoverablePageSchema2, AgentStoreTransitionSchema2, AgentStoreCheckpointRecordSchema, AgentStoreTransitionRecordSchema2, decodeAgentStoreEvent2, agentStoreEventDraft, canonicalAgentJson2, AgentConversationArchiveSchema2, encodeAgentConversationArchive2, decodeAgentConversationArchive2, createToolChronology, advanceToolChronology, canProjectToolChronology, isAssistantHistoryEvidence2, isCompleteAgentHistoryTurn, assistantStatus, ProviderJournalMessageSchema, ProviderJournalRequestSchema, ProviderJournalResponseSchema };
+export { AgentStoreEventKindSchema2, AgentStoreEventEnvelopeSchema2, AppendAgentStoreEventSchema2, ReadAgentStoreEventsSchema2, AgentStoreEventPageSchema2, AgentStoreConflictSchema2, AgentStoreNotFoundSchema2, AgentStoreAppliedSchema2, AgentStoreDuplicateSchema2, AgentStoreMutationResultSchema2, AgentRunViewSchema2, AcceptInputAndAssignRunSchema2, AcquireAgentRunSchema2, CheckpointRunAssistantSchema2, RecordRunOperationSchema2, CommitRunTerminalSchema2, RequestRunInterruptSchema2, RecoverAgentRunSchema2, ReplaceCompactedRangeSchema2, SeedConversationInputSchema2, AgentRecoverableDescriptorSchema2, AgentRecoverablePageSchema2, AgentStoreTransitionSchema2, AgentStoreCheckpointRecordSchema, AgentStoreTransitionRecordSchema2, decodeAgentStoreEvent2, agentStoreEventDraft, canonicalAgentJson2, AgentConversationArchiveSchema2, encodeAgentConversationArchive2, decodeAgentConversationArchive2, createToolChronology, advanceToolChronology, canProjectToolChronology, isAssistantHistoryEvidence2, isCompleteAgentHistoryTurn, assistantStatus, ProviderJournalMessageSchema, ProviderJournalRequestSchema, ProviderJournalResponseSchema, AgentRuntimeHeadSchema2, AgentStoredRunSchema2, AgentAdmissionReceiptSchema2, AgentSeedReceiptSchema2, AgentHistoryMutationSchema2, ACTIVE_AGENT_RUN_STATES2, isActiveRunState, emptyHead };

package/dist/internal/exclusive-lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exclusive-lock.d.ts","sourceRoot":"","sources":["../../src/internal/exclusive-lock.ts"],"names":[],"mappings":"AA6BA,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EAGxB,MAAM,wBAAwB,CAAC;AAMhC,iCAAiC;AACjC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;IACnC,kFAAkF;IAClF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,yEAAyE;IACzE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,uFAAuF;IACvF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3C;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GACpC;IACE,kDAAkD;IAClD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,sBAAsB,CAAC;CAC7C,CAAC;AAwSN;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,2BAA2B,EACpC,KAAK,SAAI,GACR,OAAO,CAAC,oBAAoB,CAAC,CAgC/B;AAED,gFAAgF;AAChF,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAEpC"}
+{"version":3,"file":"exclusive-lock.d.ts","sourceRoot":"","sources":["../../src/internal/exclusive-lock.ts"],"names":[],"mappings":"AA6BA,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EAGxB,MAAM,wBAAwB,CAAC;AAMhC,iCAAiC;AACjC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;IACnC,kFAAkF;IAClF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,yEAAyE;IACzE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,uFAAuF;IACvF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3C;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GACpC;IACE,kDAAkD;IAClD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,sBAAsB,CAAC;CAC7C,CAAC;AA4SN;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,2BAA2B,EACpC,KAAK,SAAI,GACR,OAAO,CAAC,oBAAoB,CAAC,CAgC/B;AAED,gFAAgF;AAChF,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAEpC"}