stitchkit 0.77.0 → 0.79.0

package/dist/index-7gnkny4z.js

@@ -0,0 +1,326 @@
+// src/application/channel.ts
+import { z } from "zod";
+var PositiveSafeIntegerSchema = z.number().int().positive().safe();
+var BoundedChannelPolicySchema = z.enum(["ordered", "latest"]);
+var BoundedChannelStateSchema = z.enum(["open", "draining", "closed", "failed"]);
+var BoundedChannelSnapshotSchema = z.object({
+  state: BoundedChannelStateSchema,
+  policy: BoundedChannelPolicySchema,
+  queuedItems: z.number().int().nonnegative(),
+  queuedBytes: z.number().int().nonnegative(),
+  waitingReader: z.boolean(),
+  offered: z.number().int().nonnegative(),
+  delivered: z.number().int().nonnegative(),
+  queued: z.number().int().nonnegative(),
+  coalesced: z.number().int().nonnegative(),
+  refused: z.number().int().nonnegative(),
+  discarded: z.number().int().nonnegative()
+}).strict().readonly();
+
+class BoundedChannelReaderError extends Error {
+  constructor() {
+    super("A bounded channel permits only one pending next() call");
+    this.name = "BoundedChannelReaderError";
+  }
+}
+function createBoundedChannel(config) {
+  const policy = BoundedChannelPolicySchema.parse(config.policy);
+  const maxItems = PositiveSafeIntegerSchema.parse(config.maxItems);
+  const maxBytes = PositiveSafeIntegerSchema.parse(config.maxBytes);
+  const queue = [];
+  let state = "open";
+  let queuedBytes = 0;
+  let waiting;
+  let failure;
+  let hasFailure = false;
+  let offered = 0;
+  let delivered = 0;
+  let queued = 0;
+  let coalesced = 0;
+  let refused = 0;
+  let discarded = 0;
+  const removeAbortListener = () => {
+    config.signal?.removeEventListener("abort", abortChannel);
+  };
+  const snapshot = () => BoundedChannelSnapshotSchema.parse({
+    state,
+    policy,
+    queuedItems: queue.length,
+    queuedBytes,
+    waitingReader: waiting !== undefined,
+    offered,
+    delivered,
+    queued,
+    coalesced,
+    refused,
+    discarded
+  });
+  const clearQueue = () => {
+    discarded += queue.length;
+    queue.length = 0;
+    queuedBytes = 0;
+  };
+  const settleClosed = () => {
+    if (state !== "draining" || queue.length > 0)
+      return;
+    state = "closed";
+    removeAbortListener();
+    const reader = waiting;
+    waiting = undefined;
+    reader?.resolve({ done: true, value: undefined });
+  };
+  const close = (options = {}) => {
+    if (state === "closed" || state === "failed")
+      return snapshot();
+    const mode = options.mode ?? "drain";
+    if (mode !== "drain" && mode !== "discard") {
+      throw new TypeError("Bounded channel close mode must be drain or discard");
+    }
+    if (mode === "discard") {
+      clearQueue();
+      state = "closed";
+      removeAbortListener();
+      const reader = waiting;
+      waiting = undefined;
+      reader?.resolve({ done: true, value: undefined });
+      return snapshot();
+    }
+    state = "draining";
+    settleClosed();
+    return snapshot();
+  };
+  function abortChannel() {
+    close({ mode: "discard" });
+  }
+  const channel = {
+    [Symbol.asyncIterator]() {
+      return channel;
+    },
+    offer(value) {
+      offered += 1;
+      if (state !== "open") {
+        refused += 1;
+        return { outcome: "refused", reason: "not-open" };
+      }
+      const bytes = config.sizeOf(value);
+      if (!Number.isSafeInteger(bytes) || bytes < 0) {
+        throw new TypeError("Bounded channel sizeOf() must return a non-negative safe integer");
+      }
+      if (bytes > maxBytes) {
+        refused += 1;
+        return { outcome: "refused", reason: "item-too-large" };
+      }
+      const reader = waiting;
+      if (reader) {
+        waiting = undefined;
+        delivered += 1;
+        reader.resolve({ done: false, value });
+        return { outcome: "delivered" };
+      }
+      if (policy === "latest" && queue.length > 0) {
+        const previous = queue[0];
+        if (!previous)
+          throw new Error("Bounded latest channel lost its pending value");
+        queue[0] = { value, bytes };
+        queuedBytes += bytes - previous.bytes;
+        coalesced += 1;
+        return { outcome: "coalesced", replaced: 1 };
+      }
+      if (queue.length >= maxItems) {
+        refused += 1;
+        return { outcome: "refused", reason: "item-capacity" };
+      }
+      if (queuedBytes + bytes > maxBytes) {
+        refused += 1;
+        return { outcome: "refused", reason: "byte-capacity" };
+      }
+      queue.push({ value, bytes });
+      queuedBytes += bytes;
+      queued += 1;
+      return { outcome: "queued" };
+    },
+    next() {
+      if (hasFailure)
+        return Promise.reject(failure);
+      const next = queue.shift();
+      if (next) {
+        queuedBytes -= next.bytes;
+        delivered += 1;
+        settleClosed();
+        return Promise.resolve({ done: false, value: next.value });
+      }
+      if (state === "closed" || state === "draining") {
+        settleClosed();
+        return Promise.resolve({ done: true, value: undefined });
+      }
+      if (waiting)
+        return Promise.reject(new BoundedChannelReaderError);
+      return new Promise((resolve, reject) => {
+        waiting = { resolve, reject };
+      });
+    },
+    return() {
+      close({ mode: "discard" });
+      return Promise.resolve({ done: true, value: undefined });
+    },
+    throw(error) {
+      channel.fail(error);
+      return Promise.reject(error);
+    },
+    close,
+    fail(error) {
+      if (state === "closed" || state === "failed")
+        return snapshot();
+      failure = error;
+      hasFailure = true;
+      state = "failed";
+      clearQueue();
+      removeAbortListener();
+      const reader = waiting;
+      waiting = undefined;
+      reader?.reject(error);
+      return snapshot();
+    },
+    getSnapshot: snapshot
+  };
+  if (config.signal?.aborted)
+    abortChannel();
+  else
+    config.signal?.addEventListener("abort", abortChannel, { once: true });
+  return channel;
+}
+var CreditWindowSnapshotSchema = z.object({
+  state: z.enum(["open", "closed"]),
+  capacityBytes: PositiveSafeIntegerSchema,
+  availableBytes: z.number().int().nonnegative(),
+  leasedBytes: z.number().int().nonnegative(),
+  acquired: z.number().int().nonnegative(),
+  refused: z.number().int().nonnegative(),
+  replenishedBytes: z.number().int().nonnegative(),
+  waiting: z.number().int().nonnegative()
+}).strict().readonly();
+function createCreditWindow(config) {
+  const capacityBytes = PositiveSafeIntegerSchema.parse(config.capacityBytes);
+  let availableBytes = capacityBytes;
+  let state = "open";
+  let acquired = 0;
+  let refused = 0;
+  let replenishedBytes = 0;
+  const waiters = new Set;
+  const snapshot = () => CreditWindowSnapshotSchema.parse({
+    state,
+    capacityBytes,
+    availableBytes,
+    leasedBytes: capacityBytes - availableBytes,
+    acquired,
+    refused,
+    replenishedBytes,
+    waiting: waiters.size
+  });
+  const serveWaiters = () => {
+    for (const waiter of waiters) {
+      if (waiter.bytes > availableBytes)
+        return;
+      waiter.settle({ outcome: "leased", lease: lease(waiter.bytes) });
+    }
+  };
+  const lease = (requested) => {
+    availableBytes -= requested;
+    acquired += 1;
+    let leaseReleased = false;
+    return {
+      bytes: requested,
+      get released() {
+        return leaseReleased;
+      },
+      release() {
+        if (leaseReleased)
+          return;
+        leaseReleased = true;
+        availableBytes += requested;
+        replenishedBytes += requested;
+        if (availableBytes > capacityBytes) {
+          throw new Error("Credit window accounting exceeded its capacity");
+        }
+        serveWaiters();
+      }
+    };
+  };
+  const tryLease = (requested) => {
+    if (state === "closed")
+      return { outcome: "refused", reason: "closed" };
+    if (requested > capacityBytes) {
+      return { outcome: "refused", reason: "larger-than-window" };
+    }
+    if (requested > availableBytes) {
+      return { outcome: "refused", reason: "insufficient-credit" };
+    }
+    return { outcome: "leased", lease: lease(requested) };
+  };
+  const acquireNow = (requested) => {
+    const result = tryLease(requested);
+    if (result.outcome === "refused")
+      refused += 1;
+    return result;
+  };
+  const acquireWaiting = (requested, options) => {
+    const timeoutMs = options.timeoutMs === undefined ? undefined : PositiveSafeIntegerSchema.parse(options.timeoutMs);
+    const immediate = tryLease(requested);
+    if (immediate.outcome === "leased")
+      return Promise.resolve(immediate);
+    if (immediate.reason !== "insufficient-credit") {
+      refused += 1;
+      return Promise.resolve({ outcome: "refused", reason: immediate.reason });
+    }
+    if (options.signal?.aborted) {
+      refused += 1;
+      return Promise.resolve({ outcome: "refused", reason: "aborted" });
+    }
+    return new Promise((resolve) => {
+      let settled = false;
+      let timer;
+      const waiter = {
+        bytes: requested,
+        settle(result) {
+          if (settled)
+            return;
+          settled = true;
+          if (timer !== undefined)
+            clearTimeout(timer);
+          options.signal?.removeEventListener("abort", onAbort);
+          waiters.delete(waiter);
+          if (result.outcome === "refused")
+            refused += 1;
+          resolve(result);
+        }
+      };
+      function onAbort() {
+        waiter.settle({ outcome: "refused", reason: "aborted" });
+      }
+      waiters.add(waiter);
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      if (timeoutMs !== undefined) {
+        timer = setTimeout(() => {
+          waiter.settle({ outcome: "refused", reason: "timed-out" });
+        }, timeoutMs);
+      }
+    });
+  };
+  function acquire(bytes, options) {
+    const requested = PositiveSafeIntegerSchema.parse(bytes);
+    return options === undefined ? acquireNow(requested) : acquireWaiting(requested, options);
+  }
+  return {
+    acquire,
+    close() {
+      state = "closed";
+      for (const waiter of [...waiters]) {
+        waiter.settle({ outcome: "refused", reason: "closed" });
+      }
+      return snapshot();
+    },
+    getSnapshot: snapshot
+  };
+}
+
+export { BoundedChannelPolicySchema, BoundedChannelStateSchema, BoundedChannelSnapshotSchema, BoundedChannelReaderError, createBoundedChannel, CreditWindowSnapshotSchema, createCreditWindow };

package/dist/index-7zbps32p.js

@@ -0,0 +1,89 @@
+import {
+  safeJsonParse
+} from "./index-kzfs85xp.js";
+import {
+  isRecord
+} from "./index-77fekveh.js";
+
+// src/tools/coerce.ts
+import { z } from "zod";
+function needsJsonCoercion(schema) {
+  if (schema instanceof z.ZodArray || schema instanceof z.ZodObject || schema instanceof z.ZodRecord || schema instanceof z.ZodTuple || schema instanceof z.ZodUnion) {
+    return true;
+  }
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
+    return needsJsonCoercion(schema.unwrap());
+  }
+  return false;
+}
+function acceptsRawString(schema) {
+  const type = schema._zod.def.type;
+  if (type === "string" || type === "template_literal")
+    return true;
+  if (schema instanceof z.ZodLiteral) {
+    return schema.def.values.some((value) => typeof value === "string");
+  }
+  if (schema instanceof z.ZodEnum) {
+    return schema.options.some((value) => typeof value === "string");
+  }
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
+    return acceptsRawString(schema.unwrap());
+  }
+  if (schema instanceof z.ZodUnion) {
+    return schema.def.options.some((option) => acceptsRawString(option));
+  }
+  return false;
+}
+function matchingVariant(union, value) {
+  const disc = union.def.discriminator;
+  const tag = value[disc];
+  for (const option of union.def.options) {
+    if (!(option instanceof z.ZodObject))
+      continue;
+    const field = option.shape[disc];
+    if (field instanceof z.ZodLiteral && field.def.values.some((v) => v === tag))
+      return option;
+    if (field instanceof z.ZodEnum && field.options.some((v) => v === tag))
+      return option;
+  }
+  return;
+}
+function coerceValue(value, schema) {
+  if (!schema)
+    return value;
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
+    return coerceValue(value, schema.unwrap());
+  }
+  let current = value;
+  if (typeof current === "string" && needsJsonCoercion(schema)) {
+    if (acceptsRawString(schema))
+      return current;
+    try {
+      current = safeJsonParse(current);
+    } catch {
+      return value;
+    }
+  }
+  if (schema instanceof z.ZodObject && isRecord(current)) {
+    const shape = schema.shape;
+    const out = {};
+    for (const [key, item] of Object.entries(current)) {
+      out[key] = coerceValue(item, shape[key]);
+    }
+    return out;
+  }
+  if (schema instanceof z.ZodArray && Array.isArray(current)) {
+    return current.map((item) => coerceValue(item, schema.element));
+  }
+  if (schema instanceof z.ZodDiscriminatedUnion && isRecord(current)) {
+    const variant = matchingVariant(schema, current);
+    return variant ? coerceValue(current, variant) : current;
+  }
+  return current;
+}
+function coerceJsonArgs(args, schema) {
+  const coerced = coerceValue(args, schema);
+  return isRecord(coerced) ? coerced : args;
+}
+
+export { coerceJsonArgs };

package/dist/index-85vfqd7m.js

@@ -0,0 +1,135 @@
+import {
+  AgentAssistantPlaceholderSchema,
+  AgentMessageSchema,
+  AgentProviderEnvelopeSchema,
+  AgentRecordIdSchema,
+  AgentRecordVersionSchema,
+  AgentRunMetricsSchema,
+  AgentRunSchema,
+  AgentRunStateSchema,
+  AgentTerminalReasonSchema,
+  AgentTimestampSchema
+} from "./index-x1th9s8c.js";
+
+// src/agent-runtime/event-schema.ts
+import { z } from "zod";
+var AgentAdmissionEventSchema = z.object({
+  type: z.literal("admission"),
+  eventId: AgentRecordIdSchema,
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  input: AgentMessageSchema,
+  run: AgentRunSchema,
+  assistant: z.union([AgentAssistantPlaceholderSchema, AgentMessageSchema]),
+  emittedAt: AgentTimestampSchema
+});
+var EventIdentitySchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  emittedAt: AgentTimestampSchema
+});
+var AgentTransientDeltaEventSchema = EventIdentitySchema.extend({
+  type: z.literal("assistant-delta"),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  textDelta: z.string()
+});
+var AgentTransientReasoningIdentitySchema = EventIdentitySchema.extend({
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  provider: AgentProviderEnvelopeSchema.optional()
+});
+var AgentReasoningStartEventSchema = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-start")
+});
+var AgentReasoningDeltaEventSchema = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-delta"),
+  textDelta: z.string()
+});
+var AgentReasoningEndEventSchema = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-end")
+});
+var AgentCheckpointEventSchema = EventIdentitySchema.extend({
+  type: z.literal("assistant-checkpoint"),
+  eventId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  message: AgentMessageSchema,
+  metrics: AgentRunMetricsSchema.optional()
+});
+var AgentRunStateEventSchema = EventIdentitySchema.extend({
+  type: z.literal("run-state"),
+  eventId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  state: AgentRunStateSchema
+});
+var AgentToolStatusEventSchema = EventIdentitySchema.extend({
+  type: z.literal("tool-status"),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  callId: AgentRecordIdSchema,
+  toolName: z.string().min(1),
+  status: z.enum(["started", "completed", "failed", "interrupted"]),
+  input: z.json().optional(),
+  output: z.json().optional()
+});
+var AgentTerminalEventSchema = EventIdentitySchema.extend({
+  type: z.literal("terminal"),
+  eventId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  reason: AgentTerminalReasonSchema,
+  policyName: z.string().min(1).optional(),
+  message: AgentMessageSchema,
+  metrics: AgentRunMetricsSchema.optional()
+});
+var AgentRuntimeEventSchema = z.discriminatedUnion("type", [
+  AgentAdmissionEventSchema,
+  AgentTransientDeltaEventSchema,
+  AgentReasoningStartEventSchema,
+  AgentReasoningDeltaEventSchema,
+  AgentReasoningEndEventSchema,
+  AgentCheckpointEventSchema,
+  AgentRunStateEventSchema,
+  AgentToolStatusEventSchema,
+  AgentTerminalEventSchema
+]);
+var AgentRuntimeEventCursorSchema = z.object({
+  snapshotVersion: AgentRecordVersionSchema.optional(),
+  durableEventIds: z.array(AgentRecordIdSchema).optional(),
+  runtimeEpoch: z.string().min(1).optional(),
+  sequence: z.int().nonnegative().optional()
+});
+function isDurableEvent(event) {
+  return event.type === "admission" || event.type === "assistant-checkpoint" || event.type === "run-state" || event.type === "terminal";
+}
+function advanceAgentRuntimeEventCursor(rawCursor, event) {
+  const cursor = AgentRuntimeEventCursorSchema.parse(rawCursor);
+  if (isDurableEvent(event)) {
+    const previous = cursor.snapshotVersion;
+    const durableEventIds = previous === event.snapshotVersion ? cursor.durableEventIds ?? [] : [];
+    if (previous !== undefined && event.snapshotVersion < previous || durableEventIds.includes(event.eventId)) {
+      return { status: "duplicate", cursor };
+    }
+    return {
+      status: "accepted",
+      cursor: {
+        ...cursor,
+        snapshotVersion: event.snapshotVersion,
+        durableEventIds: [...durableEventIds, event.eventId]
+      }
+    };
+  }
+  const previousSequence = cursor.runtimeEpoch === event.runtimeEpoch ? cursor.sequence : undefined;
+  if (previousSequence !== undefined && event.sequence <= previousSequence) {
+    return { status: "duplicate", cursor };
+  }
+  return {
+    status: previousSequence !== undefined && event.sequence > previousSequence + 1 ? "gap" : "accepted",
+    cursor: { ...cursor, runtimeEpoch: event.runtimeEpoch, sequence: event.sequence }
+  };
+}
+function agentDurableEventId(type, runId, snapshotVersion) {
+  return `${runId}:${type}:${snapshotVersion}`;
+}
+
+export { AgentAdmissionEventSchema, AgentTransientDeltaEventSchema, AgentReasoningStartEventSchema, AgentReasoningDeltaEventSchema, AgentReasoningEndEventSchema, AgentCheckpointEventSchema, AgentRunStateEventSchema, AgentToolStatusEventSchema, AgentTerminalEventSchema, AgentRuntimeEventSchema, AgentRuntimeEventCursorSchema, advanceAgentRuntimeEventCursor, agentDurableEventId };