stitchkit 0.0.1 → 0.1.0

package/dist/tools.js

@@ -0,0 +1,654 @@
+import {
+  createClient
+} from "./index-5sxnvwb1.js";
+import {
+  formatZodError,
+  normalizeError
+} from "./index-gfzn1n4n.js";
+import"./index-7wfkbvss.js";
+import {
+  isRecord
+} from "./index-809wc1tt.js";
+
+// src/tools/agent.ts
+import { tool, zodSchema } from "ai";
+
+// src/tools/mount.ts
+import { z as z2 } from "zod";
+
+// src/tools/execute.ts
+async function executeToolMethod(method, toolName, rawArgs, context, hooks) {
+  const startedAt = Date.now();
+  const finish = async (result) => {
+    await hooks?.afterToolCall?.(toolName, rawArgs, result, Date.now() - startedAt, context);
+    return result;
+  };
+  if (hooks?.beforeToolCall) {
+    await hooks.beforeToolCall(toolName, rawArgs, context);
+  }
+  let params;
+  if (method.paramsSchema) {
+    const result = method.paramsSchema.safeParse(rawArgs);
+    if (!result.success) {
+      return finish({
+        ok: false,
+        code: "VALIDATION_ERROR",
+        details: { message: `Invalid params: ${formatZodError(result.error)}` }
+      });
+    }
+    params = result.data;
+  }
+  let input;
+  if (method.inputSchema) {
+    const result = method.inputSchema.safeParse(rawArgs);
+    if (!result.success) {
+      return finish({
+        ok: false,
+        code: "VALIDATION_ERROR",
+        details: { message: `Invalid input: ${formatZodError(result.error)}` }
+      });
+    }
+    input = result.data;
+  }
+  try {
+    const ctx = { params, input, ...context };
+    const data = await method.handler(ctx);
+    const output = data === undefined || data === null ? { status: "ok" } : data;
+    return finish({ ok: true, data: output });
+  } catch (err) {
+    const appErr = normalizeError(err);
+    return finish({
+      ok: false,
+      code: appErr.code,
+      details: appErr.details ?? { message: appErr.message },
+      ...appErr.hint && { hint: appErr.hint }
+    });
+  }
+}
+
+// src/tools/names.ts
+var SINGULAR_EXCEPTIONS = new Set([
+  "analytics",
+  "status",
+  "stats",
+  "settings",
+  "media",
+  "progress",
+  "news"
+]);
+function singularize(name) {
+  if (SINGULAR_EXCEPTIONS.has(name))
+    return name;
+  if (name.endsWith("ies"))
+    return `${name.slice(0, -3)}y`;
+  if (name.endsWith("s") && !name.endsWith("ss"))
+    return name.slice(0, -1);
+  return name;
+}
+function toToolName(serviceName, methodName) {
+  const normalized = serviceName.replace(/-/g, "_");
+  const singular = singularize(normalized);
+  if (methodName === "list")
+    return `list_${normalized}`;
+  if (methodName === "get")
+    return `get_${singular}`;
+  if (methodName === "create")
+    return `create_${singular}`;
+  if (methodName === "update")
+    return `update_${singular}`;
+  if (methodName === "delete")
+    return `delete_${singular}`;
+  const snake = methodName.replace(/([A-Z])/g, "_$1").toLowerCase();
+  return `${snake}_${singular}`.replace(/^_/, "");
+}
+
+// src/tools/schema.ts
+import { z } from "zod";
+function needsJsonCoercion(field) {
+  if (field instanceof z.ZodArray || field instanceof z.ZodObject)
+    return true;
+  if (field instanceof z.ZodOptional || field instanceof z.ZodNullable || field instanceof z.ZodDefault) {
+    return needsJsonCoercion(field.unwrap());
+  }
+  return false;
+}
+var jsonCoerce = (val) => {
+  if (typeof val === "string") {
+    try {
+      return JSON.parse(val);
+    } catch {
+      return val;
+    }
+  }
+  return val;
+};
+function withJsonCoercion(schema) {
+  const shape = schema.shape;
+  const coerced = {};
+  for (const [key, field] of Object.entries(shape)) {
+    if (!needsJsonCoercion(field)) {
+      coerced[key] = field;
+      continue;
+    }
+    let inner = field;
+    const wrappers = [];
+    while (inner instanceof z.ZodOptional || inner instanceof z.ZodNullable) {
+      if (inner instanceof z.ZodOptional) {
+        wrappers.push("optional");
+        inner = inner.unwrap();
+      } else {
+        wrappers.push("nullable");
+        inner = inner.unwrap();
+      }
+    }
+    let result = z.preprocess(jsonCoerce, inner);
+    for (const wrapper of wrappers.reverse()) {
+      result = wrapper === "optional" ? z.optional(result) : z.nullable(result);
+    }
+    coerced[key] = result;
+  }
+  return z.object(coerced);
+}
+function flattenDiscriminatedUnion(union) {
+  const discriminator = union.def.discriminator;
+  const literalValues = [];
+  const fieldToVariants = new Map;
+  const fieldSchemas = {};
+  for (const opt of union.def.options) {
+    if (!(opt instanceof z.ZodObject)) {
+      throw new Error(`flattenDiscriminatedUnion: option for discriminator '${discriminator}' is not a ZodObject`);
+    }
+    const discField = opt.shape[discriminator];
+    if (!(discField instanceof z.ZodLiteral)) {
+      throw new Error(`flattenDiscriminatedUnion: discriminator field '${discriminator}' must be z.literal()`);
+    }
+    const [literalValue] = discField.def.values;
+    if (typeof literalValue !== "string") {
+      throw new Error(`flattenDiscriminatedUnion: discriminator literal must be a string (got ${typeof literalValue})`);
+    }
+    literalValues.push(literalValue);
+    for (const [key, field] of Object.entries(opt.shape)) {
+      if (key === discriminator)
+        continue;
+      const variants = fieldToVariants.get(key) ?? [];
+      variants.push(literalValue);
+      fieldToVariants.set(key, variants);
+      if (!(key in fieldSchemas)) {
+        fieldSchemas[key] = field instanceof z.ZodOptional ? field : z.optional(field);
+      }
+    }
+  }
+  const [firstLiteral, ...restLiterals] = literalValues;
+  if (!firstLiteral) {
+    throw new Error("flattenDiscriminatedUnion: union has no options");
+  }
+  const shape = {
+    [discriminator]: z.enum([firstLiteral, ...restLiterals])
+  };
+  for (const [key, field] of Object.entries(fieldSchemas)) {
+    const variants = fieldToVariants.get(key) ?? [];
+    const hint = `Required if ${discriminator} = ${variants.join(" | ")}`;
+    shape[key] = field instanceof z.ZodType ? field.describe(hint) : field;
+  }
+  return z.object(shape);
+}
+function mergeSchemas(paramsSchema, inputSchema) {
+  const paramsShape = paramsSchema instanceof z.ZodObject ? paramsSchema.shape : {};
+  const inputShape = inputSchema instanceof z.ZodObject ? inputSchema.shape : inputSchema instanceof z.ZodDiscriminatedUnion ? flattenDiscriminatedUnion(inputSchema).shape : {};
+  const paramsKeys = Object.keys(paramsShape);
+  const inputKeys = new Set(Object.keys(inputShape));
+  const conflicts = paramsKeys.filter((k) => inputKeys.has(k));
+  if (conflicts.length > 0) {
+    throw new Error(`Schema merge conflict: ${conflicts.join(", ")} appear in both params and input`);
+  }
+  const merged = { ...paramsShape, ...inputShape };
+  if (Object.keys(merged).length === 0)
+    return z.object({});
+  return withJsonCoercion(z.object(merged));
+}
+
+// src/tools/mount.ts
+function collectTools(service, transport, extend) {
+  const tools = [];
+  for (const [methodName, method] of Object.entries(service.methods)) {
+    if (method.expose && !method.expose.includes(transport))
+      continue;
+    if (method.multipart)
+      continue;
+    const name = method.toolName ?? toToolName(service.name, methodName);
+    const baseSchema = mergeSchemas(method.paramsSchema, method.inputSchema);
+    const shouldExtend = !!extend && (!extend.filter || extend.filter(service, method));
+    const schema = shouldExtend ? z2.object({ ...extend?.schema, ...baseSchema.shape }) : baseSchema;
+    tools.push({ method, name, schema, shouldExtend });
+  }
+  return tools;
+}
+function createToolRunner(config) {
+  const extendKeys = config.extend ? new Set(Object.keys(config.extend.schema)) : null;
+  return async (tool, rawArgs) => {
+    let extraContext = {};
+    if (tool.shouldExtend && config.extend) {
+      extraContext = await config.extend.resolve(rawArgs);
+    }
+    const cleanArgs = extendKeys ? Object.fromEntries(Object.entries(rawArgs).filter(([key]) => !extendKeys.has(key))) : rawArgs;
+    return executeToolMethod(tool.method, tool.name, cleanArgs, { source: config.source, ...config.context, ...extraContext }, config.hooks);
+  };
+}
+function formatToolError(result) {
+  const err = { error: result.code };
+  if (result.details)
+    err.details = result.details;
+  if (result.hint)
+    err._hint = result.hint;
+  return err;
+}
+
+// src/tools/agent.ts
+function formatAgentResult(result) {
+  return result.ok ? result.data : formatToolError(result);
+}
+function mountAgent(service, config = {}) {
+  const tools = {};
+  const runTool = createToolRunner({
+    source: "agent",
+    extend: config.extend,
+    context: config.context,
+    hooks: config.hooks
+  });
+  for (const mountable of collectTools(service, "AGENT", config.extend)) {
+    tools[mountable.name] = tool({
+      description: mountable.method.desc,
+      inputSchema: zodSchema(mountable.schema),
+      execute: async (rawArgs) => {
+        try {
+          const result = await runTool(mountable, rawArgs);
+          return formatAgentResult(result);
+        } catch (err) {
+          const appErr = normalizeError(err);
+          return { error: appErr.code, details: appErr.details };
+        }
+      }
+    });
+  }
+  return tools;
+}
+// src/tools/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z3 } from "zod";
+function textBlock(text) {
+  return [{ type: "text", text }];
+}
+function formatMcpResult(result, hasOutputSchema) {
+  if (result.ok) {
+    const content = textBlock(JSON.stringify(result.data, null, 2));
+    if (hasOutputSchema && isRecord(result.data)) {
+      return { content, structuredContent: result.data };
+    }
+    return { content };
+  }
+  return {
+    content: textBlock(JSON.stringify(formatToolError(result), null, 2)),
+    isError: true
+  };
+}
+function mountMcp(mcpServer, services, config = {}) {
+  const serviceList = Array.isArray(services) ? services : [services];
+  const runTool = createToolRunner({
+    source: "mcp",
+    extend: config.extend,
+    context: config.context,
+    hooks: config.hooks
+  });
+  for (const service of serviceList) {
+    for (const mountable of collectTools(service, "MCP", config.extend)) {
+      try {
+        z3.toJSONSchema(mountable.schema);
+      } catch (err) {
+        console.error(`[stitchkit] SKIPPING MCP tool "${mountable.name}" — schema not JSON Schema-compatible: ${err instanceof Error ? err.message : err}`);
+        continue;
+      }
+      let outputSchema;
+      if (mountable.method.outputSchema instanceof z3.ZodObject) {
+        try {
+          z3.toJSONSchema(mountable.method.outputSchema);
+          outputSchema = mountable.method.outputSchema;
+        } catch {
+          outputSchema = undefined;
+        }
+      }
+      const toolConfig = { description: mountable.method.desc, inputSchema: mountable.schema.shape };
+      if (outputSchema)
+        toolConfig.outputSchema = outputSchema.shape;
+      mcpServer.registerTool(mountable.name, toolConfig, async (rawArgs) => {
+        try {
+          const result = await runTool(mountable, rawArgs);
+          return formatMcpResult(result, outputSchema !== undefined);
+        } catch (err) {
+          const appErr = normalizeError(err);
+          return formatMcpResult({ ok: false, code: appErr.code, details: appErr.details }, false);
+        }
+      });
+    }
+  }
+}
+function buildMcpServer(config, auth) {
+  const server = new McpServer(config.serverInfo, config.instructions ? { instructions: config.instructions } : undefined);
+  const services = typeof config.services === "function" ? config.services(auth) : config.services;
+  const context = config.context?.(auth);
+  mountMcp(server, services, { context, hooks: config.hooks });
+  config.nativeTools?.(server);
+  return server;
+}
+// src/tools/mcp-handler.ts
+import { randomUUID } from "node:crypto";
+import {
+  WebStandardStreamableHTTPServerTransport
+} from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+var EVENT_TTL_MS = 10 * 60 * 1000;
+var SESSION_TTL_MS = 30 * 60 * 1000;
+
+class InMemoryEventStore {
+  events = new Map;
+  counter = 0;
+  async storeEvent(streamId, message) {
+    const eventId = String(++this.counter);
+    this.events.set(eventId, { streamId, message, timestamp: Date.now() });
+    return eventId;
+  }
+  async getStreamIdForEventId(eventId) {
+    return this.events.get(eventId)?.streamId;
+  }
+  async replayEventsAfter(lastEventId, { send }) {
+    const anchor = this.events.get(lastEventId);
+    if (!anchor)
+      return "";
+    const lastIdNum = Number(lastEventId);
+    for (const [eventId, event] of this.events) {
+      if (event.streamId === anchor.streamId && Number(eventId) > lastIdNum) {
+        await send(eventId, event.message);
+      }
+    }
+    return anchor.streamId;
+  }
+  cleanup() {
+    const cutoff = Date.now() - EVENT_TTL_MS;
+    for (const [eventId, event] of this.events) {
+      if (event.timestamp < cutoff)
+        this.events.delete(eventId);
+    }
+  }
+}
+function jsonRpcError(code, message, status) {
+  return Response.json({ jsonrpc: "2.0", error: { code, message }, id: null }, { status });
+}
+function createMcpHandler(config) {
+  const eventStore = new InMemoryEventStore;
+  const sessions = new Map;
+  setInterval(() => {
+    eventStore.cleanup();
+    const cutoff = Date.now() - SESSION_TTL_MS;
+    for (const [id, session] of sessions) {
+      if (session.lastSeen < cutoff) {
+        sessions.delete(id);
+        session.transport.close().catch(() => {
+          return;
+        });
+      }
+    }
+  }, EVENT_TTL_MS).unref();
+  return async (req) => {
+    const auth = await config.auth(req);
+    if (!auth) {
+      return jsonRpcError(-32001, "Authorization required", 401);
+    }
+    const sessionId = req.headers.get("mcp-session-id");
+    if (sessionId) {
+      const existing = sessions.get(sessionId);
+      if (!existing) {
+        return jsonRpcError(-32001, "Session not found", 404);
+      }
+      existing.lastSeen = Date.now();
+      if (req.method === "GET") {
+        existing.transport.closeStandaloneSSEStream();
+      }
+      return existing.transport.handleRequest(req);
+    }
+    const newSessionId = randomUUID();
+    const transport = new WebStandardStreamableHTTPServerTransport({
+      sessionIdGenerator: () => newSessionId,
+      eventStore
+    });
+    const server = buildMcpServer(config, auth);
+    sessions.set(newSessionId, { transport, server, lastSeen: Date.now() });
+    transport.onclose = () => {
+      sessions.delete(newSessionId);
+    };
+    await server.connect(transport);
+    return transport.handleRequest(req);
+  };
+}
+// src/tools/mcp-stdio.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function createStdioMcpServer(config) {
+  const auth = await config.auth;
+  const server = buildMcpServer(config, auth);
+  await server.connect(new StdioServerTransport);
+  return server;
+}
+// src/tools/remote.ts
+function toArgs(ctx) {
+  const { params, input } = ctx;
+  return {
+    ...isRecord(params) ? params : {},
+    ...isRecord(input) ? input : {}
+  };
+}
+function implementRemote(contract, http, options) {
+  const client = createClient(contract, http);
+  const groupScope = contract.meta.scope ?? "public";
+  const methods = {};
+  for (const [key, endpoint] of Object.entries(contract.endpoints)) {
+    methods[key] = {
+      method: endpoint.method,
+      path: endpoint.path,
+      desc: endpoint.desc,
+      toolName: "toolName" in endpoint ? endpoint.toolName : undefined,
+      expose: endpoint.expose,
+      scope: endpoint.scope ?? groupScope,
+      paramsSchema: endpoint.params,
+      inputSchema: endpoint.input,
+      outputSchema: endpoint.output,
+      multipart: endpoint.multipart,
+      handler: async (ctx) => {
+        const call = client[key];
+        if (!call) {
+          throw new Error(`implementRemote: endpoint "${key}" is not exposed over HTTP`);
+        }
+        const args = toArgs(ctx);
+        return call(options?.transformArgs ? await options.transformArgs(key, args) : args);
+      }
+    };
+  }
+  return {
+    name: contract.meta.prefix,
+    prefix: contract.meta.prefix,
+    scope: groupScope,
+    methods
+  };
+}
+// src/tools/view-file.ts
+import { lookup } from "node:dns/promises";
+import { readFile, stat } from "node:fs/promises";
+import { isIP } from "node:net";
+import { extname, resolve, sep } from "node:path";
+import { z as z4 } from "zod";
+var MAX_INLINE_BYTES = 20 * 1024 * 1024;
+var EXT_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".m4a": "audio/mp4",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime"
+};
+function isPrivateIp(ip) {
+  const family = isIP(ip);
+  if (family === 4) {
+    const [a, b] = ip.split(".").map(Number);
+    if (a === undefined || b === undefined)
+      return true;
+    return a === 0 || a === 10 || a === 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127;
+  }
+  if (family === 6) {
+    const lower = ip.toLowerCase();
+    if (lower === "::1" || lower === "::")
+      return true;
+    if (lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb") || lower.startsWith("fc") || lower.startsWith("fd")) {
+      return true;
+    }
+    const mapped = lower.match(/::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+    return mapped?.[1] ? isPrivateIp(mapped[1]) : false;
+  }
+  return false;
+}
+async function assertPublicUrl(url) {
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  if (isIP(host)) {
+    if (isPrivateIp(host))
+      throw new Error("refusing to fetch a private address");
+    return;
+  }
+  if (host === "localhost" || host.endsWith(".local") || host.endsWith(".internal")) {
+    throw new Error("refusing to fetch an internal host");
+  }
+  const records = await lookup(host, { all: true });
+  for (const record of records) {
+    if (isPrivateIp(record.address)) {
+      throw new Error("refusing to fetch a host that resolves to a private address");
+    }
+  }
+}
+async function readCapped(res, max) {
+  const reader = res.body?.getReader();
+  if (!reader)
+    return Buffer.alloc(0);
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      total += value.length;
+      if (total > max) {
+        await reader.cancel();
+        return null;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks);
+}
+async function fetchSource(pathOrUrl, options) {
+  const extMime = EXT_MIME[extname(pathOrUrl).toLowerCase()];
+  if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+    const url = new URL(pathOrUrl);
+    if (!options.allowPrivateHosts)
+      await assertPublicUrl(url);
+    const res = await fetch(url);
+    if (!res.ok)
+      throw new Error(`HTTP ${res.status}`);
+    const headerMime = (res.headers.get("content-type") ?? "").split(";")[0]?.trim() ?? "";
+    const mimeType2 = headerMime || extMime || "application/octet-stream";
+    const declared = Number(res.headers.get("content-length") ?? 0);
+    if (declared > MAX_INLINE_BYTES) {
+      await res.body?.cancel();
+      return { tooLarge: true, mimeType: mimeType2 };
+    }
+    const buffer = await readCapped(res, MAX_INLINE_BYTES);
+    return buffer ? { buffer, mimeType: mimeType2 } : { tooLarge: true, mimeType: mimeType2 };
+  }
+  if (!options.baseDir) {
+    throw new Error("local file paths are disabled — set baseDir to allow them");
+  }
+  const root = resolve(options.baseDir);
+  const target = resolve(root, pathOrUrl);
+  if (target !== root && !target.startsWith(root + sep)) {
+    throw new Error("path escapes the allowed directory");
+  }
+  const info = await stat(target).catch(() => null);
+  if (!info?.isFile())
+    throw new Error("file not found");
+  const mimeType = extMime ?? "application/octet-stream";
+  if (info.size > MAX_INLINE_BYTES)
+    return { tooLarge: true, mimeType };
+  return { buffer: await readFile(target), mimeType };
+}
+async function resolveMedia(pathOrUrl, options = {}) {
+  const extMime = EXT_MIME[extname(pathOrUrl).toLowerCase()];
+  if (extMime?.startsWith("video/")) {
+    return [{ type: "text", text: `[video] ${extMime} — ${pathOrUrl}` }];
+  }
+  const result = await fetchSource(pathOrUrl, options);
+  if ("tooLarge" in result) {
+    return [{ type: "text", text: `[${result.mimeType}] too large to inline — ${pathOrUrl}` }];
+  }
+  const { buffer, mimeType } = result;
+  const sizeKb = (buffer.length / 1024).toFixed(0);
+  if (mimeType.startsWith("video/")) {
+    return [{ type: "text", text: `[video] ${mimeType}, ${sizeKb}KB — ${pathOrUrl}` }];
+  }
+  if (mimeType.startsWith("image/")) {
+    return [
+      { type: "image", data: buffer.toString("base64"), mimeType },
+      { type: "text", text: `[image] ${mimeType}, ${sizeKb}KB` }
+    ];
+  }
+  if (mimeType.startsWith("audio/")) {
+    return [
+      { type: "audio", data: buffer.toString("base64"), mimeType },
+      { type: "text", text: `[audio] ${mimeType}, ${sizeKb}KB` }
+    ];
+  }
+  return [{ type: "text", text: `[${mimeType}] ${sizeKb}KB — ${pathOrUrl}` }];
+}
+function mountViewFile(server, options = {}) {
+  server.registerTool("view_file", {
+    description: "View media (image, audio, video) by URL or local path — returns it as content you can SEE / HEAR. Pass several paths to view multiple files at once. Use it on a generation `output` url to inspect the result.",
+    inputSchema: {
+      paths: z4.union([z4.string(), z4.array(z4.string())]).describe("Media URL(s) or file path(s) to view")
+    }
+  }, async (args) => {
+    const list = Array.isArray(args.paths) ? args.paths : [args.paths];
+    const content = [];
+    for (const pathOrUrl of list) {
+      try {
+        content.push(...await resolveMedia(pathOrUrl, options));
+      } catch (err) {
+        content.push({
+          type: "text",
+          text: `[${pathOrUrl}] Error: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    }
+    return { content };
+  });
+}
+export {
+  resolveMedia,
+  mountViewFile,
+  mountMcp,
+  mountAgent,
+  implementRemote,
+  createStdioMcpServer,
+  createMcpHandler,
+  buildMcpServer
+};