stitchkit 0.68.11 → 0.70.0

package/dist/{index-8vpzxg55.js → index-10gbbbaa.js}

@@ -1,16 +1,18 @@
 import {
   AgentAdmissionReceiptSchema,
+  AgentConversationMessagePageSchema,
+  AgentConversationPageSchema,
   AgentHistoryMutationSchema,
   AgentRecoverableDescriptorSchema,
   AgentRecoverablePageSchema,
   AgentRuntimeHeadSchema,
   AgentStoredRunSchema,
   createAgentRuntimeStore
-} from "./index-hqza5nde.js";
+} from "./index-hsabxjz0.js";
 import {
   AgentMessageSchema,
   AgentRunSchema
-} from "./index-ysphyxax.js";
+} from "./index-x1th9s8c.js";
 
 // src/agent-runtime/sqlite.ts
 import { z } from "zod";
@@ -35,6 +37,15 @@ var RecoverableRowSchema = z.object({
 });
 var MetaRowSchema = z.object({ value: z.string() });
 var TableRowSchema = z.object({ name: z.string() });
+var ConversationHeadRowSchema = z.object({
+  conversation_id: z.string(),
+  version: z.number().int().nonnegative()
+});
+var CountRowSchema = z.object({ count: z.number().int().nonnegative() });
+var MessagePageRowSchema = z.object({
+  position: z.number().int().nonnegative(),
+  payload: z.string()
+});
 var SCHEMA_VERSION = 1;
 var TABLES = [
   "stitchkit_agent_runtime_heads",
@@ -70,6 +81,22 @@ function recoveryCursor(conversationId, runId) {
 function parseRecoveryCursor(cursor) {
   return z.tuple([z.string().min(1), z.string().min(1)]).parse(parseJson(cursor));
 }
+function conversationCursor(conversationId) {
+  return encodeJson([conversationId]);
+}
+function parseConversationCursor(cursor) {
+  return z.tuple([z.string().min(1)]).parse(parseJson(cursor))[0];
+}
+function messageCursor(position) {
+  return encodeJson([position]);
+}
+function parseMessageCursor(cursor) {
+  return z.tuple([z.int().nonnegative()]).parse(parseJson(cursor))[0];
+}
+function messagePreview(message) {
+  const text = message.parts.find((part) => part.type === "text");
+  return text?.type === "text" ? text.text.slice(0, 160) : message.role;
+}
 function initializeAgentRuntimeSqlite(database) {
   const existing = database.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE 'stitchkit_agent_runtime_%' ORDER BY name`).all().map((row) => TableRowSchema.parse(row).name);
   const hasMeta = existing.includes("stitchkit_agent_runtime_meta");
@@ -389,6 +416,80 @@ function createSqliteAgentRuntimeStore(config) {
   };
   return {
     store: createAgentRuntimeStore(driver),
+    conversations: {
+      list: (input) => serial(async () => {
+        if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 1000) {
+          throw new TypeError("Conversation page limit must be between 1 and 1000");
+        }
+        const cursor = input.cursor ? parseConversationCursor(input.cursor) : undefined;
+        const search = input.search?.trim();
+        const clauses = [
+          ...cursor ? ["conversation_id > ?"] : [],
+          ...search ? ["instr(conversation_id, ?) > 0"] : []
+        ];
+        const parameters = [
+          ...cursor ? [cursor] : [],
+          ...search ? [search] : [],
+          input.limit + 1
+        ];
+        const rows = database.prepare(`
+              SELECT conversation_id, version FROM stitchkit_agent_runtime_heads
+              ${clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : ""}
+              ORDER BY conversation_id ASC LIMIT ?
+            `).all(...parameters).map((row) => ConversationHeadRowSchema.parse(row));
+        const hasMore = rows.length > input.limit;
+        const pageRows = rows.slice(0, input.limit);
+        const items = pageRows.map((row) => {
+          const latestRaw = database.prepare(`
+                SELECT position, payload FROM stitchkit_agent_runtime_messages
+                WHERE conversation_id = ? AND active = 1
+                ORDER BY position DESC LIMIT 1
+              `).get(row.conversation_id);
+          if (missing(latestRaw)) {
+            throw new Error("Agent conversation head has no active history");
+          }
+          const latest = AgentMessageSchema.parse(parseJson(MessagePageRowSchema.parse(latestRaw).payload));
+          const active = CountRowSchema.parse(database.prepare(`
+                  SELECT count(*) AS count FROM stitchkit_agent_runtime_runs
+                  WHERE conversation_id = ?
+                    AND state IN ('queued', 'running', 'interrupt_requested')
+                `).get(row.conversation_id));
+          return {
+            conversationId: row.conversation_id,
+            version: row.version,
+            updatedAt: latest.updatedAt,
+            preview: messagePreview(latest),
+            activeRuns: active.count
+          };
+        });
+        const last = pageRows.at(-1);
+        return AgentConversationPageSchema.parse({
+          items,
+          ...hasMore && last ? { nextCursor: conversationCursor(last.conversation_id) } : {}
+        });
+      }),
+      messages: (input) => serial(async () => {
+        if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 1000) {
+          throw new TypeError("Conversation message page limit must be between 1 and 1000");
+        }
+        const cursor = input.cursor ? parseMessageCursor(input.cursor) : undefined;
+        const before = input.direction === "before";
+        const rows = database.prepare(`
+              SELECT position, payload FROM stitchkit_agent_runtime_messages
+              WHERE conversation_id = ? AND active = 1
+              ${cursor === undefined ? "" : before ? "AND position < ?" : "AND position > ?"}
+              ORDER BY position ${before ? "DESC" : "ASC"} LIMIT ?
+            `).all(input.conversationId, ...cursor === undefined ? [] : [cursor], input.limit + 1).map((row) => MessagePageRowSchema.parse(row));
+        const hasMore = rows.length > input.limit;
+        const pageRows = rows.slice(0, input.limit);
+        const ordered = before ? [...pageRows].reverse() : pageRows;
+        const boundary = pageRows.at(-1);
+        return AgentConversationMessagePageSchema.parse({
+          items: ordered.map((row) => AgentMessageSchema.parse(parseJson(row.payload))),
+          ...hasMore && boundary ? { nextCursor: messageCursor(boundary.position) } : {}
+        });
+      })
+    },
     async close() {
       if (closed)
         return;

package/dist/{index-hcx9yypn.js → index-38hs3a58.js}

@@ -7,7 +7,7 @@ import {
   defaultSignalSource,
   guardSignalCallback,
   reportSignalError
-} from "./index-hxh98zbm.js";
+} from "./index-vbf2p6me.js";
 import {
   extractIp,
   getClientInfo,
@@ -18,31 +18,33 @@ import {
   runWithRequestContext,
   setRequestEndpoint,
   setRequestError
-} from "./index-f24xg2cw.js";
+} from "./index-ktsps64f.js";
 import {
   ShutdownOptionsSchema
 } from "./index-dk6e56g0.js";
 import {
-  DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
   errorCode,
-  isUnsafeKey,
-  joinRoutePath,
   normalizeError,
-  parseTrailingWildcard,
   recordedErrorMessage,
   resolveTraceContext,
-  safeJsonParse,
   validateDeclaredOutput,
   zodIssues
-} from "./index-pgsyp3xh.js";
+} from "./index-bd17ytae.js";
 import {
-  isRecord,
-  transportResult
-} from "./index-qyrqwr4c.js";
+  DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
+  isUnsafeKey,
+  joinRoutePath,
+  parseTrailingWildcard,
+  safeJsonParse
+} from "./index-vj3vvpaa.js";
 import {
   AppError,
   badRequest
 } from "./index-0w9abg87.js";
+import {
+  isRecord,
+  transportResult
+} from "./index-qyrqwr4c.js";
 
 // src/server/multipart.ts
 var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;

package/dist/index-3xnq72rz.js

@@ -0,0 +1,21 @@
+// src/tools/agent-tool-error.ts
+var AGENT_TOOL_ERROR_BRAND = Symbol.for("stitchkit.AgentToolError");
+
+class AgentToolError extends Error {
+  output;
+  constructor(output, cause) {
+    let message = "Tool execution failed";
+    try {
+      message = JSON.stringify(output);
+    } catch {}
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = "AgentToolError";
+    this.output = output;
+    Object.defineProperty(this, AGENT_TOOL_ERROR_BRAND, { value: true });
+  }
+}
+function isAgentToolError(value) {
+  return typeof value === "object" && value !== null && AGENT_TOOL_ERROR_BRAND in value;
+}
+
+export { AgentToolError, isAgentToolError };

package/dist/index-7rey2b8s.js

@@ -0,0 +1,73 @@
+import {
+  executeToolMethod
+} from "./index-qzbg46b6.js";
+import {
+  assertToolExtensionCompatible,
+  mergeSchemas,
+  projectToolSurface,
+  rebuildObject
+} from "./index-22by16v6.js";
+
+// src/tools/mount.ts
+import { z } from "zod";
+function applyExtend(base, extra) {
+  if (base instanceof z.ZodObject) {
+    assertToolExtensionCompatible(base, extra);
+    return rebuildObject(base, { ...extra, ...base.shape });
+  }
+  return z.intersection(z.object(extra), base);
+}
+function contractToolMountable(projected, extend) {
+  const method = projected.source;
+  const baseArgumentSchema = mergeSchemas(method.paramsSchema, method.inputSchema);
+  const argumentSchema = projected.shouldExtend && extend ? applyExtend(baseArgumentSchema, extend.schema) : baseArgumentSchema;
+  return {
+    method,
+    name: projected.name,
+    argumentSchema,
+    presentationSchema: projected.presentationSchema,
+    shouldExtend: projected.shouldExtend
+  };
+}
+function collectTools(service, transport, config = {}) {
+  const { extend, flattenUnionInput = false, assertNames = true } = config;
+  const tools = [];
+  for (const projected of projectToolSurface({ services: [service] }, transport === "HTTP" ? "AGENT" : transport, {
+    extend,
+    flattenUnionInput,
+    assertNames,
+    assertUniqueNames: false
+  })) {
+    if (projected.kind !== "contract")
+      continue;
+    tools.push(contractToolMountable(projected, extend));
+  }
+  return tools;
+}
+function createToolRunner(config) {
+  const extension = config.extend ? {
+    schema: z.object(config.extend.schema),
+    resolve: config.extend.resolve
+  } : undefined;
+  return async function runOneToolCall(tool, rawArgs, context) {
+    return executeToolMethod(tool.method, tool.name, rawArgs, { ...config.context, ...context, source: config.source }, config.hooks, config.lifecycle, config.coerceJsonArgs ?? true, config.onOutputStrip ? (paths) => config.onOutputStrip?.(tool.name, paths) : undefined, tool.shouldExtend ? extension : undefined);
+  };
+}
+function formatToolError(result, toolName, errorHint) {
+  const err = { error: result.code };
+  if (result.details)
+    err.details = result.details;
+  const hints = [];
+  if (result.hint)
+    hints.push(result.hint);
+  if (errorHint && toolName) {
+    const global = errorHint(toolName, result.code);
+    if (global)
+      hints.push(global);
+  }
+  if (hints.length > 0)
+    err._hint = hints.join(" ");
+  return err;
+}
+
+export { contractToolMountable, collectTools, createToolRunner, formatToolError };

package/dist/{index-22tjt2rk.js → index-aczggrty.js}

@@ -1,6 +1,6 @@
 import {
   isUnsafeKey
-} from "./index-pgsyp3xh.js";
+} from "./index-vj3vvpaa.js";
 import {
   isRecord
 } from "./index-qyrqwr4c.js";

package/dist/index-bd17ytae.js

@@ -0,0 +1,192 @@
+import {
+  AppError
+} from "./index-0w9abg87.js";
+import {
+  isRecord
+} from "./index-qyrqwr4c.js";
+
+// 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
+  }));
+}
+var MAX_DETAIL_ISSUES = 20;
+function errorCode(err) {
+  if (AppError.is(err))
+    return err.code;
+  if (err instanceof z.ZodError)
+    return "VALIDATION_ERROR";
+  return;
+}
+function recordedErrorMessage(code, envelopeMessage, thrown) {
+  if ((code === "INTERNAL_SERVER_ERROR" || code === "REALTIME_CONTRACT_VIOLATION") && thrown !== undefined) {
+    if (thrown instanceof Error)
+      return thrown.message;
+    if (typeof thrown === "string")
+      return thrown;
+  }
+  return envelopeMessage;
+}
+function normalizeError(err) {
+  if (AppError.is(err)) {
+    if (err.code === "REALTIME_CONTRACT_VIOLATION") {
+      return new AppError("REALTIME_CONTRACT_VIOLATION", "Realtime contract violation", 500);
+    }
+    return err;
+  }
+  if (err instanceof z.ZodError) {
+    return new AppError("VALIDATION_ERROR", formatZodError(err), 400, {
+      issues: zodIssues(err).slice(0, MAX_DETAIL_ISSUES)
+    });
+  }
+  console.error("[stitchkit] unhandled error:", err);
+  return new AppError("INTERNAL_SERVER_ERROR", "Internal server error", 500);
+}
+function strippedPaths(before, after, prefix) {
+  if (Array.isArray(before)) {
+    if (!Array.isArray(after))
+      return [];
+    return before.flatMap((item, i) => strippedPaths(item, after[i], `${prefix}[${i}]`));
+  }
+  if (!isRecord(before) || !isRecord(after))
+    return [];
+  const paths = [];
+  for (const [key, value] of Object.entries(before)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (!(key in after)) {
+      paths.push(path);
+      continue;
+    }
+    paths.push(...strippedPaths(value, after[key], path));
+  }
+  return paths;
+}
+function validateHandlerOutput(schema, data, onStripped) {
+  const parsed = schema.safeParse(data);
+  if (parsed.success) {
+    if (onStripped) {
+      const paths = strippedPaths(data, parsed.data, "");
+      if (paths.length > 0)
+        onStripped(paths);
+    }
+    return { ok: true, data: parsed.data };
+  }
+  return {
+    ok: false,
+    message: `Handler output does not match the contract: ${formatZodError(parsed.error)}`
+  };
+}
+function validateDeclaredOutput(schema, data, onStripped) {
+  if (!schema) {
+    if (data === undefined || data === null)
+      return { ok: true, data };
+    return {
+      ok: false,
+      message: "Handler returned data but the contract declares no output"
+    };
+  }
+  if (data === undefined) {
+    return {
+      ok: false,
+      message: "Handler returned undefined but the contract declares an output"
+    };
+  }
+  return validateHandlerOutput(schema, data, onStripped);
+}
+
+// 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 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;
+}
+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 resolveTraceContext(req) {
+  return parseTraceparent(req.headers.get("traceparent")) ?? createTraceContext();
+}
+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;
+function boundedPropagationValue(value, maxBytes, maxMembers) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  if (!trimmed || encoder.encode(trimmed).byteLength > maxBytes)
+    return;
+  for (const character of trimmed) {
+    const code = character.charCodeAt(0);
+    if (code <= 31 || code === 127)
+      return;
+  }
+  const members = trimmed.split(",");
+  if (members.length > maxMembers || members.some((member) => !member.trim())) {
+    return;
+  }
+  return trimmed;
+}
+function resolvePropagationContext(metadata, fallback) {
+  const traceparent = metadata?.traceparent;
+  const parsed = typeof traceparent === "string" ? parseTraceparent(traceparent) : null;
+  const trace = traceparent === undefined ? fallback ?? createTraceContext() : parsed ?? createTraceContext();
+  const tracestate = parsed ? boundedPropagationValue(metadata?.tracestate, 512, 32) : undefined;
+  const baggage = boundedPropagationValue(metadata?.baggage, 8192, 180);
+  return {
+    ...trace,
+    ...tracestate !== undefined && { tracestate },
+    ...baggage !== undefined && { baggage }
+  };
+}
+
+export { formatZodError, zodIssues, errorCode, recordedErrorMessage, normalizeError, validateDeclaredOutput, createTraceContext, parseTraceparent, formatTraceparent, resolveTraceContext, childSpan, resolvePropagationContext };

package/dist/{index-xyvxez9r.js → index-da1aqnhb.js}

@@ -2,20 +2,20 @@ import {
   contextContributionDelta,
   mergeContextContribution,
   prepareContextContribution
-} from "./index-hxh98zbm.js";
+} from "./index-vbf2p6me.js";
 import {
   base64UrlToBytes,
   bytesToBase64Url,
   isUnsafeKey,
   safeJsonParse
-} from "./index-pgsyp3xh.js";
-import {
-  isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-vj3vvpaa.js";
 import {
   forbidden,
   unauthorized
 } from "./index-0w9abg87.js";
+import {
+  isRecord
+} from "./index-qyrqwr4c.js";
 
 // src/server/middleware/cookies.ts
 function parseCookies(header) {

package/dist/index-es0h4w26.js

@@ -0,0 +1,63 @@
+// src/agent-runtime/terminal-status.ts
+function isSpeakableAssistantStatus(status) {
+  return status === "completed" || status === "interrupted" || status === "committed";
+}
+function isAssistantHistoryEvidence(status, policy) {
+  return isSpeakableAssistantStatus(status) || status === "failed" && policy?.failedAssistant === "assistant-marked";
+}
+function isCompleteAgentHistoryTurn(messages, policy) {
+  if (messages[0]?.role !== "user")
+    return false;
+  const calls = new Set;
+  const completed = new Set;
+  const approvals = new Map;
+  let assistantCount = 0;
+  for (const message of messages) {
+    if (message.role === "assistant") {
+      if (!isAssistantHistoryEvidence(message.status, policy))
+        return false;
+      assistantCount += 1;
+    }
+    for (const part of message.parts) {
+      if (part.type === "tool-call") {
+        if (calls.has(part.callId))
+          return false;
+        calls.add(part.callId);
+      } else if (part.type === "tool-approval-request") {
+        if (!calls.has(part.callId) || completed.has(part.callId) || approvals.has(part.approvalId))
+          return false;
+        if ([...approvals.values()].some((approval) => approval.callId === part.callId))
+          return false;
+        approvals.set(part.approvalId, { callId: part.callId, answered: false });
+      } else if (part.type === "tool-approval-response") {
+        const approval = approvals.get(part.approvalId);
+        if (!approval || approval.answered)
+          return false;
+        approval.answered = true;
+      } else if (part.type === "tool-result") {
+        if (!calls.has(part.callId) || completed.has(part.callId))
+          return false;
+        const approval = [...approvals.values()].find((entry) => entry.callId === part.callId);
+        if (approval && !approval.answered)
+          return false;
+        completed.add(part.callId);
+      }
+    }
+  }
+  return assistantCount > 0 && calls.size === completed.size && [...approvals.values()].every((approval) => approval.answered);
+}
+function assistantStatus(reason) {
+  if (reason === "success" || reason === "policy_stop" || reason === "provider_stop") {
+    return "completed";
+  }
+  if (reason === "superseded")
+    return "superseded";
+  if (reason === "absorbed")
+    return "superseded";
+  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
+    return "interrupted";
+  }
+  return "failed";
+}
+
+export { isAssistantHistoryEvidence, isCompleteAgentHistoryTurn, assistantStatus };