stitchkit 0.93.0 → 0.94.1

package/dist/index-e42wzzz5.js

@@ -1,154 +0,0 @@
-import {
-  AgentToolError,
-  resolveToolDurability
-} from "./index-kw9t5ayn.js";
-import {
-  collectToolSurface
-} from "./index-2c2bjw3s.js";
-import {
-  createToolRunner,
-  formatToolError
-} from "./index-mzvgxp0n.js";
-import {
-  isToolExecutionControlError,
-  toolCauseFromResult,
-  toolResultFromError
-} from "./index-yn8remb1.js";
-import {
-  isRecord
-} from "./index-77fekveh.js";
-
-// src/tools/agent.ts
-import { jsonSchema, tool } from "ai";
-function mountAgent(services, config = {}) {
-  const serviceList = Array.isArray(services) ? services : [services];
-  if (config.registry && config.runtimeTools) {
-    throw new Error("mountAgent accepts either runtimeTools or a registry, not both");
-  }
-  const runtimeTools = config.registry ? config.registry.tools : config.runtimeTools;
-  const tools = {};
-  const runTool = createToolRunner({
-    source: "agent",
-    extend: config.extend,
-    context: config.context,
-    hooks: config.hooks,
-    lifecycle: config.lifecycle,
-    errorHint: config.errorHint,
-    coerceJsonArgs: config.coerceJsonArgs,
-    onOutputStrip: config.onOutputStrip
-  });
-  for (const entry of collectToolSurface({
-    surface: { services: serviceList, runtimeTools },
-    transport: "AGENT",
-    extend: config.extend,
-    flattenUnionInput: config.flattenUnionInput
-  })) {
-    const { mountable } = entry;
-    const inputSchema = jsonSchema(mountable.presentationSchema, {
-      validate: async (value) => isRecord(value) ? { success: true, value } : { success: false, error: new Error("Tool arguments must be an object") }
-    });
-    const execute = async (rawArgs, options) => {
-      const args = isRecord(rawArgs) ? rawArgs : {};
-      const durability = resolveToolDurability(options.context, options.toolCallId, options.abortSignal) ?? config.durability?.(options.toolCallId, options.abortSignal);
-      const callContext = { signal: options.abortSignal, toolCallId: options.toolCallId };
-      const executeTool = durability ? createToolRunner({
-        source: "agent",
-        extend: config.extend,
-        context: {
-          ...config.context,
-          step: durability.step.bind(durability),
-          sleep: durability.sleep.bind(durability),
-          waitFor: durability.waitFor.bind(durability)
-        },
-        hooks: config.hooks,
-        lifecycle: config.lifecycle,
-        errorHint: config.errorHint,
-        coerceJsonArgs: config.coerceJsonArgs,
-        onOutputStrip: config.onOutputStrip
-      }) : runTool;
-      const result = await executeTool(mountable, args, callContext).catch((err) => {
-        if (isToolExecutionControlError(err))
-          throw err;
-        throw new AgentToolError(formatToolError(toolResultFromError(err), mountable.name, config.errorHint), err);
-      });
-      if (result.ok)
-        return result.data;
-      throw new AgentToolError(formatToolError(result, mountable.name, config.errorHint), toolCauseFromResult(result));
-    };
-    const presenter = entry.kind === "runtime" ? entry.definition.present?.agent : undefined;
-    if (entry.kind === "runtime" && presenter) {
-      const { definition } = entry;
-      const output = definition.output;
-      if (!output) {
-        throw new Error(`Runtime tool "${definition.name}" presenter requires an output schema`);
-      }
-      tools[definition.name] = tool({
-        description: definition.description,
-        inputSchema,
-        outputSchema: output,
-        execute,
-        toModelOutput: async ({ output: rawOutput }) => {
-          const parsed = output.safeParse(rawOutput);
-          if (!parsed.success) {
-            return { type: "text", value: JSON.stringify(rawOutput) };
-          }
-          return presenter(parsed.data);
-        }
-      });
-    } else {
-      const output = entry.kind === "runtime" ? entry.definition.output : undefined;
-      tools[mountable.name] = tool({
-        description: mountable.method.desc,
-        inputSchema,
-        ...output && { outputSchema: output },
-        execute
-      });
-    }
-  }
-  return tools;
-}
-
-// src/tools/manifest.ts
-function utf8Length(value) {
-  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
-}
-function describeToolCatalog(config) {
-  const deferred = new Set(config.deferredNames ?? []);
-  const entries = collectToolSurface({
-    surface: config,
-    transport: config.transport,
-    extend: config.extend,
-    flattenUnionInput: config.flattenUnionInput
-  }).map(({ kind, service, action, mountable }) => {
-    const schemaBytes = utf8Length(mountable.presentationSchema);
-    return {
-      name: mountable.name,
-      description: mountable.method.desc,
-      inputSchema: mountable.presentationSchema,
-      source: { kind, service, action },
-      schemaBytes,
-      deferred: deferred.has(mountable.name)
-    };
-  });
-  if (config.maxSchemaBytes !== undefined) {
-    const total = entries.reduce((sum, entry) => sum + entry.schemaBytes, 0);
-    if (total > config.maxSchemaBytes) {
-      throw new TypeError(`Tool catalog schemas use ${total} bytes, exceeding maxSchemaBytes ${config.maxSchemaBytes}`);
-    }
-  }
-  return entries;
-}
-function buildToolManifest(config) {
-  return collectToolSurface({
-    surface: config,
-    transport: config.transport,
-    extend: config.extend,
-    flattenUnionInput: config.flattenUnionInput
-  }).map(({ mountable }) => ({
-    name: mountable.name,
-    description: mountable.method.desc,
-    inputSchema: mountable.presentationSchema
-  }));
-}
-
-export { mountAgent, describeToolCatalog, buildToolManifest };

package/dist/index-f477k430.js

@@ -1,324 +0,0 @@
-import {
-  RealtimeRequestInvalidAcknowledgementError,
-  RealtimeRequestRejectedError
-} from "./index-2qzskm8h.js";
-import {
-  zodIssues
-} from "./index-e0znv5gn.js";
-import {
-  AppError
-} from "./index-2vtcmrj9.js";
-
-// src/realtime/rejected-frame.ts
-var REALTIME_REJECTION_KEY = "@stitchkit/realtime-rejected";
-var MAX_REJECTION_ISSUES = 20;
-function realtimeRejectionEnvelope(report) {
-  return { [REALTIME_REJECTION_KEY]: report };
-}
-function asRealtimeRejection(value) {
-  if (typeof value !== "object" || value === null)
-    return null;
-  const report = Reflect.get(value, REALTIME_REJECTION_KEY);
-  if (typeof report !== "object" || report === null)
-    return null;
-  const event = Reflect.get(report, "event");
-  const reason = Reflect.get(report, "reason");
-  const message = Reflect.get(report, "message");
-  if (typeof event !== "string" || typeof reason !== "string" || typeof message !== "string") {
-    return null;
-  }
-  if (reason.length === 0)
-    return null;
-  const issues = parseIssues(Reflect.get(report, "issues"));
-  return { event, reason, message, ...issues !== undefined && { issues } };
-}
-function parseIssues(value) {
-  if (!Array.isArray(value))
-    return;
-  const issues = [];
-  for (const entry of value.slice(0, MAX_REJECTION_ISSUES)) {
-    if (typeof entry !== "object" || entry === null)
-      continue;
-    const path = Reflect.get(entry, "path");
-    const code = Reflect.get(entry, "code");
-    const message = Reflect.get(entry, "message");
-    if (typeof path === "string" && typeof code === "string" && typeof message === "string") {
-      const branch = Reflect.get(entry, "branch");
-      issues.push({
-        path,
-        code,
-        message,
-        ...typeof branch === "number" && Number.isInteger(branch) && branch > 0 && { branch }
-      });
-    }
-  }
-  return issues.length > 0 ? issues : undefined;
-}
-
-// src/internal/optional-peer.ts
-function isModuleNotFound(error) {
-  if (typeof error !== "object" || error === null)
-    return false;
-  const code = "code" in error ? error.code : undefined;
-  const message = "message" in error && typeof error.message === "string" ? error.message : "";
-  return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || message.includes("Cannot find module") || message.includes("Cannot find package");
-}
-
-// src/realtime/rejection.ts
-import { z } from "zod";
-function realtimeContractViolation(options) {
-  const issues = options.cause instanceof z.ZodError ? zodIssues(options.cause) : undefined;
-  const reason = options.reason.replaceAll("-", " ");
-  const error = new AppError("REALTIME_CONTRACT_VIOLATION", `Realtime event "${options.event}" (${options.direction}, ${options.phase}): ${reason}`, 500, {
-    event: options.event,
-    direction: options.direction,
-    phase: options.phase,
-    reason: options.reason,
-    fault: options.fault,
-    ...issues !== undefined && { issues }
-  });
-  if (options.cause !== undefined)
-    error.cause = options.cause;
-  return { ...options, error };
-}
-
-// src/realtime/socket.ts
-function method(target, name) {
-  const value = Reflect.get(target, name);
-  if (typeof value !== "function") {
-    throw new Error(`Realtime target does not implement ${name}()`);
-  }
-  return (...args) => Reflect.apply(value, target, args);
-}
-function splitWireArguments(definition, args) {
-  const trailing = args.at(-1);
-  const replyTo = typeof trailing === "function" ? (...callbackArgs) => Reflect.apply(trailing, undefined, callbackArgs) : undefined;
-  if (!definition.ack || !replyTo)
-    return { values: args, ...replyTo && { replyTo } };
-  return { values: args.slice(0, -1), acknowledgement: replyTo, replyTo };
-}
-function eventDefinition(registry, event, direction) {
-  const definition = registry[event];
-  if (!definition) {
-    throw realtimeContractViolation({
-      event,
-      direction,
-      phase: "arguments",
-      reason: "unknown-event",
-      fault: "local"
-    }).error;
-  }
-  return definition;
-}
-function reportRejected(rejected, hook, logger) {
-  if (!hook) {
-    if (logger) {
-      logger.warn(rejected.error.message, rejected.error.details);
-      return;
-    }
-    console.warn(`[stitchkit] rejected realtime ${rejected.direction} event "${rejected.event}" (${rejected.phase})`, rejected.error);
-    return;
-  }
-  Promise.resolve(hook(rejected)).catch((error) => {
-    console.error("[stitchkit] realtime rejection hook failed", error);
-  });
-}
-function answerWithRejection(acknowledgement, report, logger) {
-  if (!acknowledgement)
-    return;
-  try {
-    acknowledgement(realtimeRejectionEnvelope(report));
-  } catch (error) {
-    const message = "[stitchkit] could not answer a rejected realtime frame";
-    if (logger)
-      logger.warn(message, { error });
-    else
-      console.warn(message, error);
-  }
-}
-function parseRealtimeRequestArguments(registry, event, direction, args) {
-  const definition = eventDefinition(registry, event, direction);
-  const parsed = definition.args.safeParse(args);
-  if (!parsed.success) {
-    throw realtimeContractViolation({
-      event,
-      direction,
-      phase: "arguments",
-      reason: "invalid-arguments",
-      fault: "local",
-      cause: parsed.error
-    }).error;
-  }
-  if (!definition.ack) {
-    throw realtimeContractViolation({
-      event,
-      direction,
-      phase: "acknowledgement",
-      reason: "missing-acknowledgement",
-      fault: "local"
-    }).error;
-  }
-  return parsed.data;
-}
-function parseRealtimeRequestAcknowledgement(schema, event, direction, value, hook, logger) {
-  const refusal = asRealtimeRejection(value);
-  if (refusal) {
-    reportRejected(realtimeContractViolation({
-      event,
-      direction,
-      phase: "arguments",
-      reason: "rejected-by-peer",
-      fault: "local"
-    }), hook, logger);
-    throw new RealtimeRequestRejectedError(event, refusal.reason, refusal.message, refusal.issues);
-  }
-  const parsed = schema.safeParse(value);
-  if (parsed.success)
-    return parsed.data;
-  const rejected = realtimeContractViolation({
-    event,
-    direction,
-    phase: "acknowledgement",
-    reason: "invalid-acknowledgement-value",
-    fault: "peer",
-    cause: parsed.error
-  });
-  reportRejected(rejected, hook, logger);
-  throw new RealtimeRequestInvalidAcknowledgementError(event, rejected.error);
-}
-function createValidatedRealtimeSocket({
-  target,
-  inbound,
-  outbound,
-  inboundDirection,
-  outboundDirection,
-  onRejected,
-  logger,
-  subscribe
-}) {
-  const emitTarget = method(target, "emit");
-  return {
-    on: (event, handler) => {
-      const definition = eventDefinition(inbound, event, inboundDirection);
-      const wrapped = (...wireArgs) => {
-        const { values, acknowledgement, replyTo } = splitWireArguments(definition, wireArgs);
-        const parsed = definition.args.safeParse(values);
-        if (!parsed.success) {
-          const rejected = realtimeContractViolation({
-            event,
-            direction: inboundDirection,
-            phase: "arguments",
-            reason: "invalid-arguments",
-            fault: "peer",
-            cause: parsed.error
-          });
-          reportRejected(rejected, onRejected, logger);
-          answerWithRejection(replyTo, {
-            event,
-            reason: "invalid-arguments",
-            message: rejected.error.message,
-            issues: zodIssues(parsed.error).slice(0, MAX_REJECTION_ISSUES)
-          }, logger);
-          return;
-        }
-        if (definition.ack && !acknowledgement) {
-          reportRejected(realtimeContractViolation({
-            event,
-            direction: inboundDirection,
-            phase: "acknowledgement",
-            reason: "missing-acknowledgement",
-            fault: "peer"
-          }), onRejected, logger);
-          return;
-        }
-        const applicationArgs = [...parsed.data];
-        if (definition.ack) {
-          applicationArgs.push((value) => {
-            const ack = definition.ack?.safeParse(value);
-            if (!ack?.success) {
-              if (ack) {
-                reportRejected(realtimeContractViolation({
-                  event,
-                  direction: outboundDirection,
-                  phase: "acknowledgement",
-                  reason: "invalid-acknowledgement-value",
-                  fault: "local",
-                  cause: ack.error
-                }), onRejected, logger);
-              }
-              return;
-            }
-            acknowledgement?.(ack.data);
-          });
-        }
-        Reflect.apply(handler, undefined, applicationArgs);
-      };
-      if (subscribe)
-        return subscribe(event, wrapped);
-      const onTarget = method(target, "on");
-      const offTarget = method(target, "off");
-      onTarget(event, wrapped);
-      return () => {
-        offTarget(event, wrapped);
-      };
-    },
-    emit: (event, ...args) => {
-      const definition = eventDefinition(outbound, event, outboundDirection);
-      const { values, acknowledgement } = splitWireArguments(definition, args);
-      const parsed = definition.args.safeParse(values);
-      if (!parsed.success) {
-        throw realtimeContractViolation({
-          event,
-          direction: outboundDirection,
-          phase: "arguments",
-          reason: "invalid-arguments",
-          fault: "local",
-          cause: parsed.error
-        }).error;
-      }
-      if (definition.ack && !acknowledgement) {
-        throw realtimeContractViolation({
-          event,
-          direction: outboundDirection,
-          phase: "acknowledgement",
-          reason: "missing-acknowledgement",
-          fault: "local"
-        }).error;
-      }
-      const wireArgs = [...parsed.data];
-      if (definition.ack && acknowledgement) {
-        wireArgs.push((value) => {
-          const refusal = asRealtimeRejection(value);
-          if (refusal) {
-            reportRejected(realtimeContractViolation({
-              event,
-              direction: outboundDirection,
-              phase: "arguments",
-              reason: "rejected-by-peer",
-              fault: "local"
-            }), onRejected, logger);
-            return;
-          }
-          const ack = definition.ack?.safeParse(value);
-          if (!ack?.success) {
-            if (ack) {
-              reportRejected(realtimeContractViolation({
-                event,
-                direction: inboundDirection,
-                phase: "acknowledgement",
-                reason: "invalid-acknowledgement-value",
-                fault: "peer",
-                cause: ack.error
-              }), onRejected, logger);
-            }
-            return;
-          }
-          acknowledgement(ack.data);
-        });
-      }
-      return emitTarget(event, ...wireArgs) !== false;
-    }
-  };
-}
-
-export { isModuleNotFound, REALTIME_REJECTION_KEY, asRealtimeRejection, parseRealtimeRequestArguments, parseRealtimeRequestAcknowledgement, createValidatedRealtimeSocket };

package/dist/index-f9mb610r.js

@@ -1,177 +0,0 @@
-import {
-  isUnsafeKey
-} from "./index-kzfs85xp.js";
-import {
-  isRecord
-} from "./index-77fekveh.js";
-
-// src/server/request.ts
-function generateTraceId() {
-  return `${Date.now().toString(36)}-${crypto.randomUUID().slice(0, 8)}`;
-}
-function resolveTraceId(req) {
-  const header = req.headers.get("x-request-id") ?? req.headers.get("x-trace-id");
-  const trimmed = header?.trim();
-  if (trimmed && trimmed.length <= 128 && /^[\w.-]+$/.test(trimmed)) {
-    return trimmed;
-  }
-  return generateTraceId();
-}
-function resolveSocketIp(req, server) {
-  if (typeof server === "object" && server !== null && "requestIP" in server && typeof server.requestIP === "function") {
-    const addr = server.requestIP(req);
-    if (isRecord(addr) && typeof addr.address === "string" && addr.address) {
-      return addr.address;
-    }
-  }
-  if ("ip" in req && typeof req.ip === "string" && req.ip)
-    return req.ip;
-  return;
-}
-function extractIp(req, options = {}) {
-  if (options.trustProxy) {
-    const forwarded = req.headers.get("x-forwarded-for");
-    if (forwarded)
-      return (forwarded.split(",")[0] ?? "").trim().replace(/^::ffff:/, "");
-    const realIp = req.headers.get("x-real-ip");
-    if (realIp)
-      return realIp.trim().replace(/^::ffff:/, "");
-  }
-  return (options.socketIp ?? "").replace(/^::ffff:/, "");
-}
-function getClientInfo(req, options = {}) {
-  return {
-    ipAddress: extractIp(req, options) || undefined,
-    userAgent: req.headers.get("user-agent") ?? undefined
-  };
-}
-function parseQueryParams(url) {
-  const query = {};
-  for (const key of new Set(url.searchParams.keys())) {
-    if (isUnsafeKey(key))
-      continue;
-    const values = url.searchParams.getAll(key);
-    const [first] = values;
-    query[key] = values.length === 1 && first !== undefined ? first : values;
-  }
-  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;
-}
-
-export { generateTraceId, resolveTraceId, resolveSocketIp, extractIp, getClientInfo, parseQueryParams, isPublicIp };