stitchkit 0.78.0 → 0.80.0

package/dist/{index-qyrqwr4c.js → index-77fekveh.js}

@@ -37,5 +37,8 @@ function mapObject(source, mapper) {
   }
   return result;
 }
+function mapObjectTypeBoundary(source, mapper) {
+  return mapObject(source, (key, value) => mapper(key, value));
+}
 
-export { typedEntries, isRecord, callRuntimeHandler, executableAgentRuntimeTools, transportResult, mapObject };
+export { typedEntries, isRecord, callRuntimeHandler, executableAgentRuntimeTools, transportResult, mapObject, mapObjectTypeBoundary };

package/dist/{index-k45qqrdh.js → index-7ag81v2f.js}

@@ -1,64 +1,24 @@
+import {
+  DEFAULT_STREAM_LINE_BYTES,
+  inputIsQuery,
+  parseSSE,
+  readBoundedUtf8Lines
+} from "./index-hb5pf3s4.js";
+import {
+  createTraceContext,
+  formatTraceparent
+} from "./index-fxz0v7vg.js";
 import {
   ContractStreamFrameSchema,
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
   parseTrailingWildcard
-} from "./index-7z69kyrh.js";
+} from "./index-y01f4223.js";
 import {
   isRecord,
   mapObject,
   transportResult,
   typedEntries
-} from "./index-ksp6e2ye.js";
-
-// src/internal/random-hex.ts
-function randomHex(bytes) {
-  const arr = new Uint8Array(bytes);
-  crypto.getRandomValues(arr);
-  let hex = "";
-  for (const byte of arr)
-    hex += byte.toString(16).padStart(2, "0");
-  return hex;
-}
-
-// src/observability/trace.ts
-var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(.*)$/i;
-function createTraceContext() {
-  return { traceId: randomHex(16), spanId: randomHex(8) };
-}
-function parseTraceparent(header) {
-  if (!header)
-    return null;
-  const match = TRACEPARENT_RE.exec(header.trim());
-  if (!match?.[1] || !match[2] || !match[3] || !match[4] || match[5] === undefined)
-    return null;
-  const version = match[1].toLowerCase();
-  if (version === "ff")
-    return null;
-  const suffix = match[5];
-  if (version === "00" ? suffix !== "" : suffix !== "" && !/^(?:-[0-9a-f]{2,})+$/i.test(suffix)) {
-    return null;
-  }
-  const traceId = match[2].toLowerCase();
-  const parentSpanId = match[3].toLowerCase();
-  const traceFlags = match[4].toLowerCase();
-  if (/^0+$/.test(traceId) || /^0+$/.test(parentSpanId))
-    return null;
-  return { traceId, spanId: randomHex(8), parentSpanId, traceFlags };
-}
-function formatTraceparent(ctx) {
-  return `00-${ctx.traceId}-${ctx.spanId}-${ctx.traceFlags ?? "01"}`;
-}
-function childSpan(parent) {
-  return {
-    traceId: parent.traceId,
-    spanId: randomHex(8),
-    parentSpanId: parent.spanId,
-    ...parent.tracestate !== undefined && { tracestate: parent.tracestate },
-    ...parent.baggage !== undefined && { baggage: parent.baggage },
-    ...parent.traceFlags !== undefined && { traceFlags: parent.traceFlags }
-  };
-}
-var encoder = new TextEncoder;
+} from "./index-77fekveh.js";
 
 // src/browser/http.ts
 import ky, {
@@ -373,114 +333,6 @@ function createHttpClient(config) {
     }
   };
 }
-
-// src/internal/errors.ts
-import { z } from "zod";
-function issuePath(path) {
-  return path.length > 0 ? path.map(String).join(".") : "(root)";
-}
-function formatZodError(error) {
-  const issues = error.issues.slice(0, 5);
-  const lines = issues.map((issue) => `${issuePath(issue.path)}: ${issue.message}`);
-  const suffix = error.issues.length > 5 ? `
-...and ${error.issues.length - 5} more issues` : "";
-  return lines.join(`
-`) + suffix;
-}
-function zodIssues(error) {
-  return error.issues.map((issue) => ({
-    path: issuePath(issue.path),
-    code: issue.code,
-    message: issue.message
-  }));
-}
-
-// src/internal/bounded-lines.ts
-var DEFAULT_STREAM_LINE_BYTES = 1024 * 1024;
-function lineLimit(value) {
-  const resolved = value ?? DEFAULT_STREAM_LINE_BYTES;
-  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
-    throw new TypeError("maxLineBytes must be a positive safe integer");
-  }
-  return resolved;
-}
-function joinBytes(left, right) {
-  if (left.byteLength === 0)
-    return right.slice();
-  const result = new Uint8Array(left.byteLength + right.byteLength);
-  result.set(left);
-  result.set(right, left.byteLength);
-  return result;
-}
-async function* readBoundedUtf8Lines(response, maxLineBytes, requireFinalNewline = false) {
-  const reader = response.body?.getReader();
-  if (!reader)
-    return;
-  const limit = lineLimit(maxLineBytes);
-  const decoder = new TextDecoder("utf-8", { fatal: true });
-  let pending = new Uint8Array;
-  try {
-    for (;; ) {
-      const chunk = await reader.read();
-      if (chunk.done)
-        break;
-      let start = 0;
-      for (let index = 0;index < chunk.value.byteLength; index += 1) {
-        if (chunk.value[index] !== 10)
-          continue;
-        const lineBytes = joinBytes(pending, chunk.value.slice(start, index));
-        if (lineBytes.byteLength > limit) {
-          throw new RangeError(`Stream line exceeds the ${limit} byte limit`);
-        }
-        yield decoder.decode(lineBytes);
-        pending = new Uint8Array;
-        start = index + 1;
-      }
-      pending = joinBytes(pending, chunk.value.slice(start));
-      if (pending.byteLength > limit) {
-        throw new RangeError(`Stream line exceeds the ${limit} byte limit`);
-      }
-    }
-    if (pending.byteLength > 0) {
-      if (requireFinalNewline) {
-        throw new SyntaxError("Stream ended with an unterminated final line");
-      }
-      yield decoder.decode(pending);
-    }
-  } finally {
-    await reader.cancel().catch(() => {
-      return;
-    });
-    reader.releaseLock();
-  }
-}
-
-// src/server/stream.ts
-async function* parseSSE(response, options) {
-  try {
-    for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES)) {
-      const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-      if (!line.startsWith("data:"))
-        continue;
-      const data = line.slice(5).replace(/^ /, "");
-      if (data === "[DONE]")
-        return;
-      try {
-        yield JSON.parse(data);
-      } catch (error) {
-        const failure = error instanceof Error ? error : new Error(String(error));
-        if (!options?.onParseError)
-          throw failure;
-        options.onParseError(data, failure);
-      }
-    }
-  } catch (error) {
-    const failure = error instanceof Error ? error : new Error(String(error));
-    if (!options?.onParseError)
-      throw failure;
-    options.onParseError("", failure);
-  }
-}
 // src/browser/stream.ts
 function parseFailure(raw, error, onParseError) {
   const failure = error instanceof Error ? error : new Error(String(error));
@@ -555,11 +407,6 @@ function buildMultipartForm(descriptor, values) {
   return formData;
 }
 
-// src/internal/http-input.ts
-function inputIsQuery(method) {
-  return method === "GET" || method === "DELETE";
-}
-
 // src/browser/client-url.ts
 function isParamArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string" || typeof item === "number");
@@ -1108,4 +955,4 @@ function createScopedUrlBuilders(contracts, source, scopeConfigs) {
   return buildScopedRegistry(contracts, scopeConfigs, "URL builder", (contract, config) => createUrlBuilder(contract, source, config));
 }
 
-export { randomHex, createTraceContext, parseTraceparent, formatTraceparent, childSpan, ApiError, createHttpClient, formatZodError, zodIssues, parseSSE, parseNDJSON, contractEndpointMatchers, createClient, createClients, createScopedClients, createUrlBuilder, createUrlBuilders, createScopedUrlBuilders };
+export { ApiError, createHttpClient, parseNDJSON, contractEndpointMatchers, createClient, createClients, createScopedClients, createUrlBuilder, createUrlBuilders, createScopedUrlBuilders };

package/dist/{index-n1g2xm6a.js → index-7gnkny4z.js}

@@ -199,5 +199,128 @@ var CreditWindowSnapshotSchema = z.object({
   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 { createBoundedChannel };
+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 };