@nyte-ai/plugin 0.0.0-stage → 0.0.18

package/dist/chunks/billing-ejx2hv52.js

@@ -0,0 +1,323 @@
+import {
+  messageSchema2,
+  matchesRecord2
+} from "./billing-0y7dfkp2.js";
+
+// examples/claude-code/transcript.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import {
+  getDeclaredTools,
+  getInitialSystemMessage,
+  hasToolRedefinitions,
+  renderSystemMessageUpdate
+} from "@nyte-ai/ai";
+var TOOL_PREFIX2 = "mcp__nyte__";
+var NATIVE_REPLAY_DIAGNOSTIC = "claude-code.native-assistant.v1";
+var NATIVE_TOOL_CHANGES_BETA2 = "mid-conversation-tool-changes-2026-07-01";
+var DEFERRED_TOOL_PLACEHOLDER = {
+  name: "__nyte_deferred_placeholder__",
+  description: "Reserved placeholder. Never available. Never call this.",
+  input_schema: { type: "object", properties: {}, required: [] },
+  defer_loading: true
+};
+function sanitizeSurrogates(text) {
+  return text.replace(/[\uD800-\uDFFF]/gu, "�");
+}
+function assistantProjection(message) {
+  const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("").trim();
+  const toolCalls = message.content.filter((block) => block.type === "toolCall").map((block) => ({ id: block.id, name: block.name, input: structuredClone(block.arguments) }));
+  return { text, toolCalls };
+}
+var projectionSchema = Type.Object({
+  text: Type.String(),
+  toolCalls: Type.Array(Type.Object({
+    id: Type.String(),
+    name: Type.String(),
+    input: Type.Record(Type.String(), Type.Unknown())
+  }))
+});
+var replayCarrierSchema = Type.Object({
+  version: Type.Literal(1),
+  message: messageSchema2,
+  projection: projectionSchema,
+  initialUserPrefix: Type.Optional(Type.Array(Type.Unknown())),
+  initialSystemMessages: Type.Optional(Type.Array(Type.Unknown()))
+});
+function replayCarrier(message) {
+  const diagnostic = message.diagnostics?.find((item) => item.type === NATIVE_REPLAY_DIAGNOSTIC);
+  const candidate = diagnostic?.details?.carrier;
+  return Value.Check(replayCarrierSchema, candidate) ? candidate : undefined;
+}
+function replayMetadata(messages, key) {
+  for (let index = messages.length - 1;index >= 0; index--) {
+    const message = messages[index];
+    if (message?.role !== "assistant")
+      continue;
+    const value = replayCarrier(message)?.[key];
+    if (value)
+      return structuredClone(value);
+  }
+  return;
+}
+function getInitialUserPrefix2(messages) {
+  return replayMetadata(messages, "initialUserPrefix");
+}
+function getInitialSystemMessages2(messages) {
+  return replayMetadata(messages, "initialSystemMessages");
+}
+function imageBlock(block) {
+  return {
+    type: "image",
+    source: { type: "base64", media_type: block.mimeType, data: block.data }
+  };
+}
+function userContent(content) {
+  if (typeof content === "string")
+    return content ? [{ type: "text", text: sanitizeSurrogates(content) }] : [];
+  return content.map((block) => block.type === "text" ? { type: "text", text: sanitizeSurrogates(block.text) } : imageBlock(block));
+}
+function toolResultContent(message) {
+  const hasImages = message.content.some((block) => block.type === "image");
+  if (!hasImages) {
+    return sanitizeSurrogates(message.content.filter((block) => block.type === "text").map((block) => block.text).join(`
+`));
+  }
+  return message.content.map((block) => block.type === "text" ? { type: "text", text: sanitizeSurrogates(block.text) } : imageBlock(block));
+}
+function canonicalAssistantContent(message) {
+  const blocks = [];
+  for (const block of message.content) {
+    if (block.type === "text" && block.text.trim()) {
+      blocks.push({ type: "text", text: sanitizeSurrogates(block.text) });
+    } else if (block.type === "thinking" && block.thinking.trim() && block.thinkingSignature) {
+      if (block.redacted) {
+        blocks.push({ type: "redacted_thinking", data: block.thinkingSignature });
+      } else {
+        blocks.push({
+          type: "thinking",
+          thinking: sanitizeSurrogates(block.thinking),
+          signature: block.thinkingSignature
+        });
+      }
+    } else if (block.type === "toolCall") {
+      blocks.push({
+        type: "tool_use",
+        id: block.id,
+        name: `${TOOL_PREFIX2}${block.name}`,
+        input: structuredClone(block.arguments)
+      });
+    }
+  }
+  return blocks;
+}
+function assistantContent(message) {
+  const carrier = replayCarrier(message);
+  if (carrier && JSON.stringify(assistantProjection(message)) === JSON.stringify(carrier.projection)) {
+    return structuredClone(carrier.message.content);
+  }
+  if (carrier) {
+    return canonicalAssistantContent({
+      ...message,
+      content: message.content.filter((block) => block.type !== "thinking")
+    });
+  }
+  return canonicalAssistantContent(message);
+}
+function prepareFrames2(messages) {
+  const frames = [];
+  for (const message of messages) {
+    if (message.role === "system")
+      continue;
+    let role;
+    let blocks;
+    if (message.role === "user") {
+      role = "user";
+      blocks = userContent(message.content);
+    } else if (message.role === "assistant") {
+      role = "assistant";
+      blocks = assistantContent(message);
+    } else {
+      role = "user";
+      blocks = [
+        {
+          type: "tool_result",
+          tool_use_id: message.toolCallId,
+          content: toolResultContent(message),
+          is_error: message.isError
+        }
+      ];
+    }
+    if (blocks.length === 0)
+      continue;
+    const previous = frames.at(-1);
+    if (role === "user" && previous?.type === "user") {
+      previous.message.content.push(...blocks);
+    } else {
+      frames.push({ type: role, message: { role, content: blocks } });
+    }
+  }
+  const final = frames.at(-1);
+  if (!final || final.type !== "user" || final.message.content.length === 0) {
+    throw new Error("Claude Code history must end in a non-empty user or tool-result message");
+  }
+  for (let index = 0;index < frames.length - 1; index++) {
+    const frame = frames[index];
+    if (frame?.type === "user")
+      frame.shouldQuery = false;
+  }
+  return frames;
+}
+function withoutNullVariant(schema) {
+  if (Array.isArray(schema))
+    return schema.map(withoutNullVariant);
+  if (!matchesRecord2(schema))
+    return schema;
+  const output = {};
+  for (const [key, value] of Object.entries(schema))
+    output[key] = withoutNullVariant(value);
+  if (Array.isArray(output.type) && output.type.includes("null")) {
+    const remaining = output.type.filter((value) => value !== "null");
+    output.type = remaining.length === 1 ? remaining[0] : remaining;
+  }
+  if (Array.isArray(output.anyOf)) {
+    const nonNull = output.anyOf.filter((branch) => !(matchesRecord2(branch) && branch.type === "null"));
+    if (nonNull.length === 1 && nonNull.length !== output.anyOf.length) {
+      const replacement = nonNull[0];
+      delete output.anyOf;
+      if (replacement && typeof replacement === "object")
+        Object.assign(output, replacement);
+    }
+  }
+  return output;
+}
+function normalizeInputSchema(schema) {
+  const normalized = withoutNullVariant(schema);
+  if (!matchesRecord2(normalized))
+    throw new Error("Tool input schema must be an object");
+  for (const key of ["oneOf", "allOf", "anyOf"])
+    delete normalized[key];
+  if (!normalized.type)
+    normalized.type = "object";
+  if (normalized.type === "object" && (!normalized.properties || typeof normalized.properties !== "object")) {
+    normalized.properties = {};
+  }
+  return normalized;
+}
+function prepareTools2(tools) {
+  const names = new Set;
+  const manifest = [];
+  const nativeTools = [];
+  for (const tool of tools) {
+    if (!/^[A-Za-z0-9_-]{1,50}$/u.test(tool.name) || names.has(tool.name)) {
+      throw new Error("Claude Code tool names must be unique ASCII identifiers of at most 50 characters");
+    }
+    names.add(tool.name);
+    const schema = normalizeInputSchema(tool.parameters);
+    manifest.push({ name: tool.name, description: tool.description, inputSchema: schema });
+    nativeTools.push({
+      name: `${TOOL_PREFIX2}${tool.name}`,
+      description: tool.description,
+      input_schema: schema
+    });
+  }
+  return { manifest, nativeTools, names };
+}
+function nativeSystemBlocks(message) {
+  const blocks = [];
+  const text = renderSystemMessageUpdate(message);
+  if (text)
+    blocks.push({ type: "text", text: sanitizeSurrogates(text) });
+  for (const tool of message.toolsRemoved ?? []) {
+    blocks.push({
+      type: "tool_removal",
+      tool: { type: "tool_reference", name: `${TOOL_PREFIX2}${tool.name}` }
+    });
+  }
+  for (const tool of message.toolsAdded ?? []) {
+    blocks.push({
+      type: "tool_addition",
+      tool: { type: "tool_reference", name: `${TOOL_PREFIX2}${tool.name}` }
+    });
+  }
+  return blocks;
+}
+function prepareNativeTranscript2(messages, supported) {
+  const initial = getInitialSystemMessage(messages);
+  const initialTools = initial?.toolsAdded ?? [];
+  if (!supported || initialTools.length === 0 || hasToolRedefinitions(messages))
+    return;
+  const declared = getDeclaredTools(messages);
+  const prepared = prepareTools2(declared);
+  const nativeByName = new Map(prepared.nativeTools.map((tool) => [String(tool.name).slice(TOOL_PREFIX2.length), tool]));
+  const initialNames = new Set(initialTools.map((tool) => tool.name));
+  const initialNative = initialTools.map((tool) => {
+    const native = nativeByName.get(tool.name);
+    if (native === undefined)
+      throw new Error(`Missing declared tool ${tool.name}`);
+    return structuredClone(native);
+  });
+  const final = initialNative.at(-1);
+  if (final)
+    final.cache_control = { type: "ephemeral", ttl: "1h" };
+  const laterNative = declared.filter((tool) => !initialNames.has(tool.name)).map((tool) => ({ ...structuredClone(nativeByName.get(tool.name)), defer_loading: true }));
+  const systemInjections = [];
+  let pending = [];
+  let assistantOrdinal = 0;
+  const flush = (beforeAssistant) => {
+    for (const content of pending)
+      systemInjections.push({ beforeAssistant, content });
+    pending = [];
+  };
+  for (let index = 1;index < messages.length; index++) {
+    const message = messages[index];
+    if (message === undefined)
+      continue;
+    if (message.role === "system") {
+      const blocks = nativeSystemBlocks(message);
+      if (blocks.length)
+        pending.push(blocks);
+    } else if (message.role === "assistant" && assistantContent(message).length > 0) {
+      flush(assistantOrdinal);
+      assistantOrdinal += 1;
+    }
+  }
+  flush(null);
+  return {
+    requestTools: [...initialNative, structuredClone(DEFERRED_TOOL_PLACEHOLDER), ...laterNative],
+    systemInjections
+  };
+}
+function buildExtraBody2(nativeTools, options, adaptive) {
+  const body = { tools: nativeTools };
+  if (options?.maxTokens !== undefined)
+    body.max_tokens = options.maxTokens;
+  if (options?.reasoning) {
+    if (adaptive)
+      body.thinking = { type: "adaptive" };
+    body.output_config = {
+      effort: options.reasoning === "minimal" ? "low" : options.reasoning
+    };
+  } else {
+    body.thinking = { type: "disabled" };
+    body.context_management = { edits: [] };
+  }
+  return body;
+}
+function makeReplayDiagnostic2(message, output, initialUserPrefix, initialSystemMessages) {
+  return {
+    type: NATIVE_REPLAY_DIAGNOSTIC,
+    timestamp: Date.now(),
+    details: {
+      carrier: {
+        version: 1,
+        message: structuredClone(message),
+        projection: assistantProjection(output),
+        ...initialUserPrefix ? { initialUserPrefix: structuredClone(initialUserPrefix) } : {},
+        ...initialSystemMessages ? { initialSystemMessages: structuredClone(initialSystemMessages) } : {}
+      }
+    }
+  };
+}
+
+export { TOOL_PREFIX2, NATIVE_TOOL_CHANGES_BETA2, getInitialUserPrefix2, getInitialSystemMessages2, prepareFrames2, prepareTools2, prepareNativeTranscript2, buildExtraBody2, makeReplayDiagnostic2 };

package/dist/chunks/billing-h13r0byk.js

@@ -0,0 +1,80 @@
+// src/approvals/schema.ts
+import { standard, ToolClassType } from "@nyte-ai/schema";
+import { Type } from "typebox";
+var policy = standard(Type.Union([Type.Literal("ask"), Type.Literal("auto-edit"), Type.Literal("full")]));
+var PERMISSIONS2 = "permissions";
+var approvalPolicy2 = policy;
+var APPROVAL_POLICIES2 = [
+  { value: "ask", label: "Ask first", description: "Asks before every command and file change" },
+  {
+    value: "auto-edit",
+    label: "Auto-edit",
+    description: "Edits workspace files, asks before commands and anything outside"
+  },
+  { value: "full", label: "Full access", description: "Runs every tool without asking" }
+];
+var reasonType = Type.Union([
+  Type.Literal("shell"),
+  Type.Literal("edit"),
+  Type.Literal("outside"),
+  Type.Literal("tool")
+]);
+var decision = Type.Union([
+  Type.Literal("once"),
+  Type.Literal("session"),
+  Type.Literal("deny"),
+  Type.Null()
+]);
+var state = standard(Type.Object({ tool: Type.String(), class: ToolClassType, reason: reasonType, decision }));
+var empty = standard(Type.Object({}));
+var actions = { once: { input: empty }, session: { input: empty }, deny: { input: empty } };
+var APPROVAL_ACTIONS2 = [
+  { action: "once", label: "Allow once" },
+  { action: "session", label: "Allow for this session" },
+  { action: "deny", label: "Deny" }
+];
+function approvalPrompt2(current) {
+  const subject = current.class;
+  switch (subject.kind) {
+    case "shell":
+      return { title: "Run this command?", detail: subject.command };
+    case "edit":
+      return {
+        title: current.reason === "outside" ? "Edit outside the workspace?" : "Edit this file?",
+        detail: subject.path
+      };
+    case "read":
+    case "list":
+      return { title: `Use ${current.tool}?`, detail: subject.path };
+    case "delegate":
+      return { title: `Use ${current.tool}?`, detail: subject.title ?? "" };
+    case "custom":
+      return { title: `Use ${current.tool}?`, detail: subject.label };
+    default: {
+      const exhaustive = subject;
+      return exhaustive;
+    }
+  }
+}
+var approval2 = {
+  kind: "ask/approval",
+  state,
+  actions,
+  fallback: (current, { id }) => {
+    const prompt = approvalPrompt2(current);
+    return `${prompt.title} ${prompt.detail} (${id})${current.decision === null ? "" : ` Answered: ${current.decision}`}`;
+  }
+};
+function openApprovals2(view) {
+  return (view?.parts ?? []).flatMap((part) => {
+    if (part.partKind !== approval2.kind || part.status.kind !== "live")
+      return [];
+    const checked = approval2.state["~standard"].validate(part.state);
+    if (checked instanceof Promise || checked.issues !== undefined || checked.value.decision !== null)
+      return [];
+    const { tool, reason } = checked.value;
+    return [{ part: part.id, tool, class: checked.value.class, reason }];
+  });
+}
+
+export { PERMISSIONS2, approvalPolicy2, APPROVAL_POLICIES2, APPROVAL_ACTIONS2, approvalPrompt2, approval2, openApprovals2 };

package/dist/chunks/billing-j643d12p.js

@@ -0,0 +1,197 @@
+import {
+  matchesRecord2,
+  parseRequest2,
+  parseRequestMessages2
+} from "./billing-0y7dfkp2.js";
+
+// examples/claude-code/replay.ts
+function withoutCacheControl(value) {
+  if (Array.isArray(value))
+    return value.map(withoutCacheControl);
+  if (!matchesRecord2(value))
+    return value;
+  const output = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (key !== "cache_control")
+      output[key] = withoutCacheControl(child);
+  }
+  return output;
+}
+function requestMessages(body) {
+  if (!body)
+    return;
+  try {
+    return parseRequest2(body).messages;
+  } catch {
+    return;
+  }
+}
+function deriveInitialUserPrefix2(body, canonicalContent) {
+  if (canonicalContent.length === 0)
+    return;
+  const actual = requestMessages(body)?.[0];
+  if (actual?.role !== "user" || !Array.isArray(actual.content) || actual.content.length < canonicalContent.length) {
+    return;
+  }
+  const suffix = actual.content.slice(-canonicalContent.length).map(withoutCacheControl);
+  if (JSON.stringify(suffix) !== JSON.stringify(canonicalContent.map(withoutCacheControl)))
+    return;
+  return structuredClone(actual.content.slice(0, -canonicalContent.length));
+}
+function deriveInitialSystemMessages2(body) {
+  const messages = requestMessages(body);
+  if (messages?.[0]?.role !== "user")
+    return;
+  let end = 1;
+  while (messages[end]?.role === "system")
+    end += 1;
+  const systems = messages.slice(1, end);
+  let trailingStart = messages.length;
+  while (trailingStart > end && messages[trailingStart - 1]?.role === "system")
+    trailingStart -= 1;
+  if (trailingStart < messages.length)
+    systems.push(...messages.slice(trailingStart));
+  return systems.length ? structuredClone(systems) : undefined;
+}
+function contentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((block) => matchesRecord2(block) && typeof block.text === "string" ? block.text : "").join("");
+}
+function setCacheBreakpoint(message) {
+  if (typeof message.content === "string") {
+    message.content = [
+      { type: "text", text: message.content, cache_control: { type: "ephemeral", ttl: "1h" } }
+    ];
+    return;
+  }
+  if (!Array.isArray(message.content) || message.content.length === 0)
+    return;
+  const last = message.content.at(-1);
+  if (!matchesRecord2(last))
+    return;
+  last.cache_control = { type: "ephemeral", ttl: "1h" };
+}
+function setReplayCacheBreakpoints(messages) {
+  const userIndexes = messages.map((message, index) => message.role === "user" ? index : -1).filter((index) => index >= 0);
+  if (userIndexes.length >= 3) {
+    for (const message of messages) {
+      if (message.role === "system")
+        message.content = withoutCacheControl(message.content);
+    }
+    const previousIndex = userIndexes.at(-2);
+    const previous = previousIndex === undefined ? undefined : messages[previousIndex];
+    if (previous)
+      setCacheBreakpoint(previous);
+  }
+  const final = messages.at(-1);
+  if (final)
+    setCacheBreakpoint(final);
+}
+function removeRepeatedUserReminders(messages, prefix) {
+  const reminder = contentText(prefix).trimEnd();
+  if (!reminder || !prefix)
+    return;
+  const normalizedPrefix = JSON.stringify(prefix.map(withoutCacheControl));
+  for (let index = 1;index < messages.length; index++) {
+    const message = messages[index];
+    if (message?.role !== "user" || !Array.isArray(message.content))
+      continue;
+    const leading = message.content.slice(0, prefix.length).map(withoutCacheControl);
+    if (JSON.stringify(leading) === normalizedPrefix)
+      message.content.splice(0, prefix.length);
+    const toolResult = message.content.findLast((block) => matchesRecord2(block) && block.type === "tool_result");
+    if (!matchesRecord2(toolResult))
+      continue;
+    const suffix = `
+${reminder}`;
+    if (typeof toolResult.content === "string" && toolResult.content.endsWith(suffix)) {
+      toolResult.content = toolResult.content.slice(0, -suffix.length);
+    } else if (Array.isArray(toolResult.content)) {
+      const final = toolResult.content.at(-1);
+      if (matchesRecord2(final) && final.type === "text" && typeof final.text === "string") {
+        if (final.text === reminder)
+          toolResult.content.pop();
+        else if (final.text.endsWith(suffix))
+          final.text = final.text.slice(0, -suffix.length);
+      }
+    }
+  }
+}
+function injectNativeSystemMessages(messages, injections) {
+  const byAssistant = new Map;
+  const trailing = [];
+  for (const injection of injections) {
+    const message = { role: "system", content: structuredClone(injection.content) };
+    if (injection.beforeAssistant === null)
+      trailing.push(message);
+    else {
+      const pending = byAssistant.get(injection.beforeAssistant) ?? [];
+      pending.push(message);
+      byAssistant.set(injection.beforeAssistant, pending);
+    }
+  }
+  const output = [];
+  let assistantOrdinal = 0;
+  for (const message of messages) {
+    if (message.role === "assistant") {
+      output.push(...byAssistant.get(assistantOrdinal) ?? []);
+      byAssistant.delete(assistantOrdinal);
+      assistantOrdinal += 1;
+    }
+    output.push(message);
+  }
+  if (byAssistant.size > 0)
+    throw new Error("Claude Code request lost an assistant boundary needed by system history");
+  output.push(...trailing);
+  return output;
+}
+function normalizeLeadingSystemCache(system) {
+  if (!Array.isArray(system))
+    return;
+  for (const block of system) {
+    if (matchesRecord2(block))
+      delete block.cache_control;
+  }
+  const last = system.at(-1);
+  if (matchesRecord2(last)) {
+    last.cache_control = { type: "ephemeral", ttl: "1h" };
+  }
+}
+function rewriteInitialRequest2(body, prefix, canonicalContent, initialSystemMessages, nativeSystemInjections) {
+  const payload = parseRequest2(body);
+  let messages = payload.messages;
+  const first = messages?.[0];
+  if (first?.role !== "user" || !Array.isArray(first.content)) {
+    throw new Error("Claude Code request is missing its initial user message");
+  }
+  if (prefix)
+    first.content = [...structuredClone(prefix), ...structuredClone(canonicalContent)];
+  if (initialSystemMessages?.length && messages) {
+    let systemEnd = 1;
+    while (messages[systemEnd]?.role === "system")
+      systemEnd += 1;
+    messages.splice(1, systemEnd - 1, ...parseRequestMessages2(structuredClone(initialSystemMessages)));
+    const initialText = initialSystemMessages.map((message) => matchesRecord2(message) ? contentText(message.content) : "").join(`
+`);
+    while (messages.at(-1)?.role === "system") {
+      const trailingText = contentText(messages.at(-1)?.content);
+      if (!trailingText || !initialText.includes(trailingText))
+        break;
+      messages.pop();
+    }
+    removeRepeatedUserReminders(messages, prefix);
+  }
+  if (nativeSystemInjections) {
+    messages = injectNativeSystemMessages(messages, nativeSystemInjections);
+    payload.messages = messages;
+    normalizeLeadingSystemCache(payload.system);
+  }
+  if (initialSystemMessages?.length || nativeSystemInjections)
+    setReplayCacheBreakpoints(messages);
+  return Buffer.from(JSON.stringify(payload));
+}
+
+export { deriveInitialUserPrefix2, deriveInitialSystemMessages2, rewriteInitialRequest2 };