mancode 0.6.4 → 0.6.6

package/dist/chunk-GI24QVXE.js

@@ -0,0 +1,1099 @@
+import {
+  scanSensitiveText
+} from "./chunk-IRZQYMHD.js";
+
+// src/gateway/errors.ts
+var GatewayError = class extends Error {
+  constructor(code, status = 400) {
+    super(code);
+    this.code = code;
+    this.status = status;
+  }
+};
+function gatewayErrorCode(error) {
+  return error instanceof GatewayError ? error.code : "MANCODE_GATEWAY_FAILED";
+}
+
+// src/gateway/json.ts
+import { parseTree } from "jsonc-parser";
+function parseStrictJson(source) {
+  if (Buffer.byteLength(source) > 1024 * 1024)
+    throw new GatewayError("MANCODE_GATEWAY_JSON_LIMIT");
+  let depth = 0;
+  let structures = 0;
+  let inString = false;
+  let escaped = false;
+  for (const character of source) {
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') inString = false;
+    } else if (character === '"') inString = true;
+    else if (character === "{" || character === "[") {
+      if (++depth > 48 || ++structures > 8e3)
+        throw new GatewayError("MANCODE_GATEWAY_JSON_LIMIT");
+    } else if (character === "}" || character === "]") depth--;
+    else if ((character === "," || character === ":") && ++structures > 8e3)
+      throw new GatewayError("MANCODE_GATEWAY_JSON_LIMIT");
+  }
+  const errors = [];
+  const tree = parseTree(source, errors, {
+    allowTrailingComma: false,
+    disallowComments: true,
+    allowEmptyContent: false
+  });
+  if (!tree || errors.length)
+    throw new GatewayError("MANCODE_GATEWAY_INVALID_JSON");
+  let count = 0;
+  const visit = (node, depth2) => {
+    if (depth2 > 48 || ++count > 4e4)
+      throw new GatewayError("MANCODE_GATEWAY_JSON_LIMIT");
+    if (node.type === "object") {
+      const keys = /* @__PURE__ */ new Set();
+      for (const property2 of node.children ?? []) {
+        const key = property2.children?.[0]?.value;
+        if (keys.has(key))
+          throw new GatewayError("MANCODE_GATEWAY_DUPLICATE_KEY");
+        keys.add(key);
+      }
+    }
+    for (const child of node.children ?? []) visit(child, depth2 + 1);
+  };
+  visit(tree, 0);
+  return tree;
+}
+function property(node, name) {
+  return node.type === "object" ? node.children?.find((child) => child.children?.[0]?.value === name)?.children?.[1] : void 0;
+}
+function stringValue(node) {
+  return node?.type === "string" ? node.value : void 0;
+}
+function applyJsonEdits(input, edits) {
+  let source = input;
+  let last = source.length;
+  for (const edit of [...edits].sort((a, b) => b.offset - a.offset)) {
+    if (edit.offset + edit.length > last)
+      throw new GatewayError("MANCODE_GATEWAY_OVERLAPPING_EDIT");
+    source = source.slice(0, edit.offset) + edit.text + source.slice(edit.offset + edit.length);
+    last = edit.offset;
+  }
+  return source;
+}
+function replaceString(edits, node, value) {
+  if (value !== node.value)
+    edits.push({
+      offset: node.offset,
+      length: node.length,
+      text: JSON.stringify(value)
+    });
+}
+
+// src/gateway/mapping.ts
+import { randomBytes } from "crypto";
+var TOKEN_PREFIX = "__MANCODE_";
+var TOKEN_PATTERN = /__MANCODE_[a-f0-9]{32}__/g;
+var DEFAULT_MAPPING_LIMITS = {
+  entries: 4096,
+  bytes: 4 * 1024 * 1024,
+  ttlMs: 15 * 6e4,
+  lineage: 256
+};
+var MappingStore = class {
+  constructor(scope, limits = DEFAULT_MAPPING_LIMITS, now = Date.now) {
+    this.scope = scope;
+    this.limits = limits;
+    this.now = now;
+  }
+  entries = /* @__PURE__ */ new Map();
+  originals = /* @__PURE__ */ new Map();
+  responses = /* @__PURE__ */ new Map();
+  bytes = 0;
+  begin(previousResponseId) {
+    this.prune();
+    const inherited = previousResponseId ? this.responses.get(previousResponseId) : void 0;
+    if (previousResponseId && !inherited)
+      throw new GatewayError("MANCODE_GATEWAY_HISTORY_UNAVAILABLE");
+    const request = new RequestMapping(this);
+    for (const token of inherited?.tokens ?? []) request.authorize(token);
+    return request;
+  }
+  allocate(original) {
+    this.prune();
+    const existing = this.originals.get(original);
+    if (existing) return existing;
+    const bytes = Buffer.byteLength(original);
+    if (this.entries.size >= this.limits.entries || this.bytes + bytes > this.limits.bytes)
+      throw new GatewayError("MANCODE_GATEWAY_MAPPING_CAPACITY", 429);
+    const token = `${TOKEN_PREFIX}${randomBytes(16).toString("hex")}__`;
+    this.entries.set(token, {
+      original,
+      expires: this.now() + this.limits.ttlMs,
+      pins: 0,
+      bytes
+    });
+    this.originals.set(original, token);
+    this.bytes += bytes;
+    return token;
+  }
+  pin(token) {
+    const entry = this.entries.get(token);
+    if (!entry) throw new GatewayError("MANCODE_GATEWAY_UNKNOWN_TOKEN");
+    entry.pins++;
+  }
+  original(token) {
+    const entry = this.entries.get(token);
+    if (!entry) throw new GatewayError("MANCODE_GATEWAY_UNKNOWN_TOKEN");
+    return entry.original;
+  }
+  finish(tokens, responseId) {
+    if (responseId) {
+      if (this.responses.has(responseId))
+        throw new GatewayError("MANCODE_GATEWAY_RESPONSE_REPLAY");
+      if (this.responses.size >= this.limits.lineage)
+        this.responses.delete(this.responses.keys().next().value);
+      this.responses.set(responseId, {
+        tokens: new Set(tokens),
+        expires: this.now() + this.limits.ttlMs
+      });
+    }
+  }
+  release(tokens) {
+    for (const token of tokens) {
+      const entry = this.entries.get(token);
+      if (entry) {
+        entry.pins--;
+        entry.expires = this.now() + this.limits.ttlMs;
+      }
+    }
+  }
+  prune() {
+    for (const [token, entry] of this.entries)
+      if (entry.pins === 0 && entry.expires <= this.now()) {
+        this.entries.delete(token);
+        this.originals.delete(entry.original);
+        this.bytes -= entry.bytes;
+      }
+    for (const [id, lineage] of this.responses)
+      if (lineage.expires <= this.now() || [...lineage.tokens].some((token) => !this.entries.has(token)))
+        this.responses.delete(id);
+  }
+};
+var RequestMapping = class {
+  constructor(store) {
+    this.store = store;
+  }
+  authorized = /* @__PURE__ */ new Set();
+  claudeReadAllowed = false;
+  released = false;
+  authorize(token) {
+    if (this.authorized.has(token)) return;
+    this.store.pin(token);
+    this.authorized.add(token);
+  }
+  mask(input, ruleIds) {
+    let value = input;
+    for (const match of value.matchAll(TOKEN_PATTERN)) this.authorize(match[0]);
+    if (value.replace(TOKEN_PATTERN, "").includes(TOKEN_PREFIX))
+      throw new GatewayError("MANCODE_GATEWAY_MALFORMED_TOKEN");
+    const scan = scanSensitiveText(value, ruleIds);
+    if (scan.status !== "complete")
+      throw new GatewayError("MANCODE_GATEWAY_SCAN_FAILED");
+    const ranges = [];
+    for (const finding of scan.findings) {
+      const last = ranges.at(-1);
+      if (last && finding.start <= last.end)
+        last.end = Math.max(last.end, finding.end);
+      else ranges.push({ start: finding.start, end: finding.end });
+    }
+    for (const range of ranges.reverse()) {
+      const original = value.slice(range.start, range.end);
+      const token = this.store.allocate(original);
+      this.authorize(token);
+      value = value.slice(0, range.start) + token + value.slice(range.end);
+    }
+    return value;
+  }
+  maskLiteral(value) {
+    if (value === "") return value;
+    if (/^__MANCODE_[a-f0-9]{32}__$/.test(value)) {
+      this.authorize(value);
+      return value;
+    }
+    if (value.includes(TOKEN_PREFIX))
+      throw new GatewayError("MANCODE_GATEWAY_MALFORMED_TOKEN");
+    const token = this.store.allocate(value);
+    this.authorize(token);
+    return token;
+  }
+  restore(value) {
+    const stripped = value.replace(TOKEN_PATTERN, "");
+    if (stripped.includes(TOKEN_PREFIX))
+      throw new GatewayError("MANCODE_GATEWAY_MALFORMED_TOKEN");
+    return value.replace(TOKEN_PATTERN, (token) => {
+      if (!this.authorized.has(token))
+        throw new GatewayError("MANCODE_GATEWAY_UNAUTHORIZED_TOKEN");
+      return this.store.original(token);
+    });
+  }
+  finish(responseId) {
+    this.store.finish(this.authorized, responseId);
+  }
+  withoutKnownEchoes(value) {
+    let result = value;
+    const originals = [...this.authorized].map((token) => this.store.original(token)).sort((a, b) => b.length - a.length);
+    for (const original of originals) result = result.split(original).join("");
+    return result;
+  }
+  release() {
+    if (!this.released) {
+      this.released = true;
+      this.store.release(this.authorized);
+    }
+  }
+};
+var IncrementalRestorer = class {
+  constructor(mapping) {
+    this.mapping = mapping;
+  }
+  pending = "";
+  push(input, final = false) {
+    let value = this.pending + input;
+    this.pending = "";
+    if (!final) {
+      const tokenStart = value.lastIndexOf(TOKEN_PREFIX);
+      if (tokenStart >= 0 && value.length - tokenStart < TOKEN_PREFIX.length + 34) {
+        this.pending = value.slice(tokenStart);
+        value = value.slice(0, tokenStart);
+      } else
+        for (let length = TOKEN_PREFIX.length - 1; length > 0; length--) {
+          const lastComplete = [...value.matchAll(TOKEN_PATTERN)].at(-1);
+          const completeEnd = lastComplete ? lastComplete.index + lastComplete[0].length : 0;
+          if (value.length - length >= completeEnd && value.endsWith(TOKEN_PREFIX.slice(0, length))) {
+            this.pending = value.slice(-length);
+            value = value.slice(0, -length);
+            break;
+          }
+        }
+    }
+    return this.mapping.restore(value);
+  }
+};
+
+// src/gateway/protocol.ts
+import { createHash } from "crypto";
+import path from "path";
+var SENSITIVE_NUMBER_KEY = /(?:phone|mobile|telephone|id_?card|card_?number|account_?number|ssn)/i;
+var CREDENTIAL_KEY = /(?:^|[_-])(?:password|passwd|secret|token|api[_-]?key|access[_-]?key|authorization|cookie)$/i;
+function assertNoSensitive(value, rules) {
+  const scan = scanSensitiveText(value, rules);
+  if (scan.status !== "complete")
+    throw new GatewayError("MANCODE_GATEWAY_SCAN_FAILED");
+  if (scan.findings.length || value.includes(TOKEN_PREFIX))
+    throw new GatewayError("MANCODE_GATEWAY_SENSITIVE_STRUCTURE");
+}
+function transformData(source, node, edits, mapping, restore, rules, key = "") {
+  const credential = !restore && CREDENTIAL_KEY.test(key) && (!rules || rules.includes("named-secret"));
+  if (credential && (node.type === "object" || node.type === "array"))
+    throw new GatewayError("MANCODE_GATEWAY_CREDENTIAL_CONTAINER_UNSUPPORTED");
+  if (node.type === "string") {
+    replaceString(
+      edits,
+      node,
+      restore ? mapping.restore(node.value) : credential ? mapping.maskLiteral(node.value) : mapping.mask(node.value, rules)
+    );
+  } else if (node.type === "number" && SENSITIVE_NUMBER_KEY.test(key) || credential && node.type !== "object" && node.type !== "array" && node.type !== "null") {
+    throw new GatewayError("MANCODE_GATEWAY_SENSITIVE_NUMBER");
+  } else if (node.type === "object") {
+    for (const field of node.children ?? []) {
+      const name = field.children?.[0];
+      const value = field.children?.[1];
+      if (!name || !value)
+        throw new GatewayError("MANCODE_GATEWAY_INVALID_JSON");
+      assertNoSensitive(name.value, rules);
+      transformData(source, value, edits, mapping, restore, rules, name.value);
+    }
+  } else
+    for (const value of node.children ?? [])
+      transformData(source, value, edits, mapping, restore, rules, key);
+}
+function scanStructure(source, node, rules) {
+  if (node.type === "string") assertNoSensitive(node.value, rules);
+  else
+    for (const child of node.children ?? [])
+      scanStructure(source, child, rules);
+}
+function transformToolDefinitions(source, node, edits, mapping, rules, fieldName = "") {
+  if (node.type === "string" && (fieldName === "description" || fieldName === "title")) {
+    replaceString(edits, node, mapping.mask(node.value, rules));
+    return;
+  }
+  if (node.type === "object") {
+    for (const field of node.children ?? []) {
+      const key = field.children?.[0];
+      const value = field.children?.[1];
+      if (!key || !value)
+        throw new GatewayError("MANCODE_GATEWAY_INVALID_JSON");
+      assertNoSensitive(key.value, rules);
+      if (key.value === "enum" || key.value === "const" || key.value === "pattern" || key.value === "required")
+        scanStructure(source, value, rules);
+      else
+        transformToolDefinitions(
+          source,
+          value,
+          edits,
+          mapping,
+          rules,
+          key.value
+        );
+    }
+  } else if (node.type === "array")
+    for (const child of node.children ?? [])
+      transformToolDefinitions(source, child, edits, mapping, rules, fieldName);
+  else scanStructure(source, node, rules);
+}
+function transformText(value, mapping, restore, rules) {
+  if (!restore && /^[\s]*[\[{]/.test(value)) {
+    try {
+      const tree = parseStrictJson(value);
+      const edits = [];
+      transformData(value, tree, edits, mapping, false, rules);
+      return applyJsonEdits(value, edits);
+    } catch (error) {
+      if (!(error instanceof GatewayError) || error.code !== "MANCODE_GATEWAY_INVALID_JSON")
+        throw error;
+    }
+  }
+  return restore ? mapping.restore(value) : mapping.mask(value, rules);
+}
+var CLAUDE_READ_SCHEMA_SHA256 = "384be111a755f235f20b1c632d0ed1a665e9f16d191f02108e80232c7fc4b488";
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value && typeof value === "object")
+    return Object.fromEntries(
+      Object.entries(value).sort(([a], [b]) => a.localeCompare(b, "en")).map(([key, child]) => [key, canonical(child)])
+    );
+  return value;
+}
+function restoreToolArguments(source, mapping, name) {
+  const tree = parseStrictJson(source);
+  let needsRestore = false;
+  const inspect = (node) => {
+    if (node.type === "string" && node.value.includes(TOKEN_PREFIX))
+      needsRestore = true;
+    for (const child of node.children ?? []) inspect(child);
+  };
+  inspect(tree);
+  if (!needsRestore) return source;
+  if (!mapping?.claudeReadAllowed || name !== "Read" || tree.type !== "object")
+    throw new GatewayError("MANCODE_GATEWAY_TOOL_SINK_UNSUPPORTED");
+  for (const field of tree.children ?? []) {
+    const key = field.children?.[0]?.value;
+    const value = field.children?.[1];
+    if (key === "file_path") continue;
+    if ((key === "offset" || key === "limit") && value?.type === "number" && Number.isSafeInteger(value.value) && value.value >= (key === "offset" ? 0 : 1))
+      continue;
+    if (key === "pages" && value?.type === "string" && /^\d+(?:-\d+)?$/.test(value.value))
+      continue;
+    throw new GatewayError("MANCODE_GATEWAY_TOOL_SINK_UNSUPPORTED");
+  }
+  const filePath = property(tree, "file_path");
+  if (filePath?.type !== "string" || !/^__MANCODE_[a-f0-9]{32}__$/.test(filePath.value))
+    throw new GatewayError("MANCODE_GATEWAY_TOOL_PATH_COMPOSITION");
+  const restored = mapping.restore(filePath.value);
+  if (!path.isAbsolute(restored) && !path.win32.isAbsolute(restored) || /[\0\r\n]/.test(restored) || restored.startsWith("//") || restored.startsWith("\\\\"))
+    throw new GatewayError("MANCODE_GATEWAY_TOOL_PATH_INVALID");
+  const edits = [];
+  replaceString(edits, filePath, restored);
+  return applyJsonEdits(source, edits);
+}
+function content(source, node, edits, mapping, restore, coverage, rules) {
+  if (node.type === "string") {
+    replaceString(
+      edits,
+      node,
+      transformText(node.value, mapping, restore, rules)
+    );
+    return;
+  }
+  if (node.type === "array") {
+    for (const child of node.children ?? [])
+      content(source, child, edits, mapping, restore, coverage, rules);
+    return;
+  }
+  if (node.type !== "object")
+    throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_CONTENT");
+  const type = stringValue(property(node, "type"));
+  const allowed = {
+    message: ["type", "role", "content", "id", "status", "phase"],
+    input_text: ["type", "text", "cache_control"],
+    output_text: ["type", "text", "annotations", "logprobs"],
+    text: ["type", "text", "cache_control", "citations"],
+    refusal: ["type", "refusal"],
+    function_call: ["type", "id", "call_id", "name", "arguments", "status"],
+    tool_use: ["type", "id", "name", "input", "cache_control"],
+    function_call_output: ["type", "id", "call_id", "output", "status"],
+    tool_result: [
+      "type",
+      "tool_use_id",
+      "content",
+      "is_error",
+      "cache_control"
+    ],
+    thinking: ["type", "thinking", "signature", "cache_control"],
+    redacted_thinking: ["type", "data", "cache_control"],
+    reasoning: ["type", "id", "summary", "encrypted_content", "status"]
+  };
+  const keys = allowed[type ?? (property(node, "role") ? "message" : "")];
+  if (!keys || node.children?.some((field) => !keys.includes(field.children?.[0]?.value)))
+    throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_CONTENT");
+  for (const name of [
+    "id",
+    "call_id",
+    "tool_use_id",
+    "name",
+    "role",
+    "status",
+    "phase",
+    "type"
+  ]) {
+    const value = property(node, name);
+    if (value && (value.type !== "string" || value.value.length > 256))
+      throw new GatewayError("MANCODE_GATEWAY_INVALID_PROTOCOL_ID");
+  }
+  const cacheControl = property(node, "cache_control");
+  if (cacheControl) scanStructure(source, cacheControl, rules);
+  if (type === "thinking" || type === "redacted_thinking" || type === "reasoning") {
+    coverage.opaque++;
+    return;
+  }
+  if (type === "input_text" || type === "output_text" || type === "text" || type === "refusal") {
+    const field = property(node, type === "refusal" ? "refusal" : "text");
+    if (!field || field.type !== "string")
+      throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_CONTENT");
+    replaceString(
+      edits,
+      field,
+      transformText(field.value, mapping, restore, rules)
+    );
+    for (const child of node.children ?? []) {
+      const name = child.children?.[0]?.value;
+      const value = child.children?.[1];
+      if (value && name !== "text" && name !== "refusal" && name !== "type")
+        scanStructure(source, value, rules);
+    }
+    return;
+  }
+  if (type === "function_call" || type === "tool_use") {
+    const args = property(
+      node,
+      type === "function_call" ? "arguments" : "input"
+    );
+    if (!args) throw new GatewayError("MANCODE_GATEWAY_TOOL_ARGUMENTS_MISSING");
+    if (args.type === "string") {
+      const inner = args.value;
+      if (restore)
+        replaceString(
+          edits,
+          args,
+          restoreToolArguments(
+            inner,
+            mapping,
+            stringValue(property(node, "name"))
+          )
+        );
+      else {
+        const innerEdits = [];
+        transformData(
+          inner,
+          parseStrictJson(inner),
+          innerEdits,
+          mapping,
+          false,
+          rules
+        );
+        replaceString(edits, args, applyJsonEdits(inner, innerEdits));
+      }
+    } else if (type === "tool_use" && args.type === "object") {
+      if (restore) {
+        const restored = restoreToolArguments(
+          source.slice(args.offset, args.offset + args.length),
+          mapping,
+          stringValue(property(node, "name"))
+        );
+        edits.push({
+          offset: args.offset,
+          length: args.length,
+          text: restored
+        });
+      } else transformData(source, args, edits, mapping, false, rules);
+    } else throw new GatewayError("MANCODE_GATEWAY_INVALID_TOOL_ARGUMENTS");
+    return;
+  }
+  if (type === "function_call_output" || type === "tool_result") {
+    const field = property(
+      node,
+      type === "function_call_output" ? "output" : "content"
+    );
+    if (!field) throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_CONTENT");
+    content(source, field, edits, mapping, restore, coverage, rules);
+    return;
+  }
+  if (type === "message" || !type && property(node, "role")) {
+    const field = property(node, "content");
+    if (!field) throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_CONTENT");
+    content(source, field, edits, mapping, restore, coverage, rules);
+    return;
+  }
+  throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_CONTENT");
+}
+var REQUEST_FIELDS = {
+  responses: /* @__PURE__ */ new Set([
+    "model",
+    "input",
+    "instructions",
+    "tools",
+    "tool_choice",
+    "parallel_tool_calls",
+    "store",
+    "stream",
+    "temperature",
+    "top_p",
+    "max_output_tokens",
+    "text",
+    "reasoning",
+    "metadata",
+    "previous_response_id",
+    "include",
+    "service_tier",
+    "prompt_cache_key",
+    "prompt_cache_retention",
+    "truncation",
+    "user",
+    "safety_identifier",
+    "client_metadata"
+  ]),
+  messages: /* @__PURE__ */ new Set([
+    "model",
+    "messages",
+    "system",
+    "tools",
+    "tool_choice",
+    "stream",
+    "temperature",
+    "top_p",
+    "top_k",
+    "max_tokens",
+    "stop_sequences",
+    "metadata",
+    "thinking",
+    "service_tier",
+    "context_management",
+    "output_config"
+  ])
+};
+function transformRequest(source, protocol, mapping, rules, verifiedHost) {
+  const tree = parseStrictJson(source);
+  const edits = [];
+  const coverage = { opaque: 0 };
+  if (tree.type !== "object")
+    throw new GatewayError("MANCODE_GATEWAY_INVALID_REQUEST");
+  const bodyField = protocol === "responses" ? "input" : "messages";
+  if (!property(tree, bodyField))
+    throw new GatewayError("MANCODE_GATEWAY_INVALID_REQUEST");
+  for (const child of tree.children ?? []) {
+    const name = child.children?.[0]?.value;
+    const value = child.children?.[1];
+    if (!value || !REQUEST_FIELDS[protocol].has(name))
+      throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_FIELD");
+    if (name === bodyField || name === "system" || name === "instructions")
+      content(source, value, edits, mapping, false, coverage, rules);
+    else if (name === "metadata" || name === "client_metadata")
+      transformData(source, value, edits, mapping, false, rules);
+    else if (name === "context_management") {
+      const control = JSON.parse(
+        source.slice(value.offset, value.offset + value.length)
+      );
+      if (JSON.stringify(canonical(control)) !== JSON.stringify(
+        canonical({
+          edits: [{ type: "clear_thinking_20251015", keep: "all" }]
+        })
+      ))
+        throw new GatewayError("MANCODE_GATEWAY_CONTEXT_CONTROL_UNSUPPORTED");
+    } else if (name === "output_config") {
+      const effort = stringValue(property(value, "effort"));
+      if (value.type !== "object" || value.children?.length !== 1 || !effort || !["low", "medium", "high", "max"].includes(effort))
+        throw new GatewayError("MANCODE_GATEWAY_OUTPUT_CONFIG_UNSUPPORTED");
+    } else if (name === "previous_response_id") {
+      if (value.type !== "string")
+        throw new GatewayError("MANCODE_GATEWAY_INVALID_HISTORY");
+    } else {
+      if (name === "tools" && protocol === "messages" && verifiedHost === "claude-code/2.1.142") {
+        for (const tool of value.children ?? []) {
+          const schema = property(tool, "input_schema");
+          if (stringValue(property(tool, "name")) === "Read" && schema) {
+            const schemaValue = JSON.parse(
+              source.slice(schema.offset, schema.offset + schema.length)
+            );
+            const digest = createHash("sha256").update(JSON.stringify(canonical(schemaValue))).digest("hex");
+            mapping.claudeReadAllowed = digest === CLAUDE_READ_SCHEMA_SHA256;
+          }
+        }
+      }
+      if (name === "tools")
+        transformToolDefinitions(source, value, edits, mapping, rules);
+      else scanStructure(source, value, rules);
+    }
+  }
+  return { body: applyJsonEdits(source, edits), opaqueBlocks: coverage.opaque };
+}
+function transformResponse(source, protocol, mapping) {
+  const tree = parseStrictJson(source);
+  const edits = [];
+  const coverage = { opaque: 0 };
+  const output = property(
+    tree,
+    protocol === "responses" ? "output" : "content"
+  );
+  if (!output) throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_RESPONSE");
+  content(source, output, edits, mapping, true, coverage);
+  return { body: applyJsonEdits(source, edits), opaqueBlocks: coverage.opaque };
+}
+function transformContentItem(source, mapping) {
+  const tree = parseStrictJson(source);
+  const edits = [];
+  const coverage = { opaque: 0 };
+  content(source, tree, edits, mapping, true, coverage);
+  return { body: applyJsonEdits(source, edits), opaqueBlocks: coverage.opaque };
+}
+
+// src/gateway/sse.ts
+var SseDecoder = class {
+  constructor(maxEventBytes = 256 * 1024) {
+    this.maxEventBytes = maxEventBytes;
+  }
+  decoder = new TextDecoder("utf-8", { fatal: true });
+  pending = "";
+  push(chunk, final = false) {
+    try {
+      this.pending += this.decoder.decode(chunk, { stream: !final });
+    } catch {
+      throw new GatewayError("MANCODE_GATEWAY_INVALID_UTF8");
+    }
+    const frames = [];
+    for (; ; ) {
+      const match = /\r?\n\r?\n/.exec(this.pending);
+      if (!match) break;
+      const block = this.pending.slice(0, match.index);
+      this.pending = this.pending.slice(match.index + match[0].length);
+      if (Buffer.byteLength(block) > this.maxEventBytes)
+        throw new GatewayError("MANCODE_GATEWAY_EVENT_LIMIT");
+      let event;
+      const data = [];
+      for (const line of block.split(/\r?\n/)) {
+        if (line.startsWith(":") || line === "") continue;
+        const colon = line.indexOf(":");
+        const name = colon < 0 ? line : line.slice(0, colon);
+        const value = colon < 0 ? "" : line.slice(colon + 1).replace(/^ /, "");
+        if (name === "event") event = value;
+        else if (name === "data") data.push(value);
+        else throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_SSE_FIELD");
+      }
+      if (data.length) frames.push({ event, data: data.join("\n") });
+      if (frames.length > 256)
+        throw new GatewayError("MANCODE_GATEWAY_EVENT_QUEUE_LIMIT");
+    }
+    if (Buffer.byteLength(this.pending) > this.maxEventBytes)
+      throw new GatewayError("MANCODE_GATEWAY_EVENT_LIMIT");
+    if (final && this.pending.trim())
+      throw new GatewayError("MANCODE_GATEWAY_TRUNCATED_SSE");
+    return frames;
+  }
+};
+function encodeSse(frame) {
+  return `${frame.event ? `event: ${frame.event}
+` : ""}${frame.data.split("\n").map((line) => `data: ${line}`).join("\n")}
+
+`;
+}
+var RESPONSE_METADATA = /* @__PURE__ */ new Set(["response.in_progress", "response.queued"]);
+var OPAQUE_EVENTS = /* @__PURE__ */ new Set([
+  "response.reasoning_summary_part.added",
+  "response.reasoning_summary_part.done",
+  "response.reasoning_summary_text.delta",
+  "response.reasoning_summary_text.done",
+  "response.reasoning_text.delta",
+  "response.reasoning_text.done"
+]);
+var ProtocolStream = class {
+  constructor(protocol, mapping, maxChannels = 128, maxToolBytes = 256 * 1024) {
+    this.protocol = protocol;
+    this.mapping = mapping;
+    this.maxChannels = maxChannels;
+    this.maxToolBytes = maxToolBytes;
+  }
+  texts = /* @__PURE__ */ new Map();
+  tools = /* @__PURE__ */ new Map();
+  anthropicTypes = /* @__PURE__ */ new Map();
+  responseId;
+  completed = false;
+  opaqueBlocks = 0;
+  accept(frame) {
+    if (frame.data === "[DONE]") {
+      if (!this.completed)
+        throw new GatewayError("MANCODE_GATEWAY_TRUNCATED_RESPONSE");
+      return [frame];
+    }
+    if (this.completed)
+      throw new GatewayError("MANCODE_GATEWAY_EVENT_AFTER_DONE");
+    const tree = parseStrictJson(frame.data);
+    const type = stringValue(property(tree, "type"));
+    if (!type || frame.event && frame.event !== type)
+      throw new GatewayError("MANCODE_GATEWAY_EVENT_TYPE_MISMATCH");
+    return this.protocol === "responses" ? this.responses(frame, tree, type) : this.messages(frame, tree, type);
+  }
+  finish() {
+    if (!this.completed)
+      throw new GatewayError("MANCODE_GATEWAY_TRUNCATED_RESPONSE");
+    for (const channel of this.texts.values())
+      if (!channel.closed)
+        throw new GatewayError("MANCODE_GATEWAY_UNFINISHED_CHANNEL");
+    for (const channel of this.tools.values())
+      if (!channel.closed)
+        throw new GatewayError("MANCODE_GATEWAY_UNFINISHED_TOOL");
+  }
+  key(tree) {
+    const index = property(tree, "output_index")?.value;
+    const content2 = property(tree, "content_index")?.value ?? 0;
+    const item = stringValue(property(tree, "item_id"));
+    if (!Number.isSafeInteger(index) || index < 0 || !Number.isSafeInteger(content2) || content2 < 0 || !item || item.length > 256)
+      throw new GatewayError("MANCODE_GATEWAY_CHANNEL_ID_INVALID");
+    return `${index}:${content2}:${item}`;
+  }
+  limitChannels() {
+    if (this.texts.size + this.tools.size >= this.maxChannels)
+      throw new GatewayError("MANCODE_GATEWAY_CHANNEL_LIMIT");
+  }
+  textDelta(key, delta, done = false) {
+    let channel = this.texts.get(key);
+    if (!channel) {
+      this.limitChannels();
+      channel = {
+        restorer: new IncrementalRestorer(this.mapping),
+        closed: false
+      };
+      this.texts.set(key, channel);
+    }
+    if (channel.closed)
+      throw new GatewayError("MANCODE_GATEWAY_CHANNEL_ALREADY_DONE");
+    const restored = channel.restorer.push(delta, done);
+    channel.closed = done;
+    return restored;
+  }
+  toolDelta(key, delta) {
+    let channel = this.tools.get(key);
+    if (!channel) {
+      this.limitChannels();
+      channel = { arguments: "", closed: false };
+      this.tools.set(key, channel);
+    }
+    if (channel.closed)
+      throw new GatewayError("MANCODE_GATEWAY_CHANNEL_ALREADY_DONE");
+    if (Buffer.byteLength(channel.arguments) + Buffer.byteLength(delta) > this.maxToolBytes)
+      throw new GatewayError("MANCODE_GATEWAY_TOOL_LIMIT");
+    channel.arguments += delta;
+  }
+  toolDone(key, snapshot) {
+    const channel = this.tools.get(key);
+    if (channel?.closed)
+      throw new GatewayError("MANCODE_GATEWAY_CHANNEL_ALREADY_DONE");
+    if (snapshot !== void 0 && channel?.arguments && snapshot !== channel.arguments)
+      throw new GatewayError("MANCODE_GATEWAY_TOOL_SNAPSHOT_MISMATCH");
+    const argumentsText = snapshot ?? (channel?.arguments || "{}");
+    const restored = restoreToolArguments(
+      argumentsText,
+      this.mapping,
+      channel?.name
+    );
+    if (channel) channel.closed = true;
+    return restored;
+  }
+  responses(frame, tree, type) {
+    if (type === "response.created") {
+      if (this.responseId)
+        throw new GatewayError("MANCODE_GATEWAY_DUPLICATE_RESPONSE");
+      const response = property(tree, "response");
+      this.responseId = response && stringValue(property(response, "id"));
+      if (!this.responseId)
+        throw new GatewayError("MANCODE_GATEWAY_RESPONSE_ID_MISSING");
+      const output = response && property(response, "output");
+      if (output?.children?.length)
+        throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_RESPONSE");
+      return [frame];
+    }
+    if (type === "response.output_text.delta" || type === "response.refusal.delta") {
+      const delta = property(tree, "delta");
+      if (delta?.type !== "string")
+        throw new GatewayError("MANCODE_GATEWAY_INVALID_DELTA");
+      const edits = [];
+      const value = this.textDelta(this.key(tree), delta.value);
+      replaceString(edits, delta, value);
+      return value ? [{ ...frame, data: applyJsonEdits(frame.data, edits) }] : [];
+    }
+    if (type === "response.output_text.done" || type === "response.refusal.done") {
+      const fieldName = type === "response.refusal.done" ? "refusal" : "text";
+      const field = property(tree, fieldName);
+      if (field?.type !== "string")
+        throw new GatewayError("MANCODE_GATEWAY_INVALID_DELTA");
+      const tail = this.textDelta(this.key(tree), "", true);
+      const edits = [];
+      replaceString(edits, field, this.mapping.restore(field.value));
+      const output = [];
+      if (tail) {
+        const delta = {
+          type: type.replace(/\.done$/, ".delta"),
+          item_id: property(tree, "item_id")?.value,
+          output_index: property(tree, "output_index")?.value,
+          content_index: property(tree, "content_index")?.value,
+          delta: tail
+        };
+        output.push({ event: delta.type, data: JSON.stringify(delta) });
+      }
+      output.push({ ...frame, data: applyJsonEdits(frame.data, edits) });
+      return output;
+    }
+    if (type === "response.function_call_arguments.delta") {
+      const delta = stringValue(property(tree, "delta"));
+      if (delta === void 0)
+        throw new GatewayError("MANCODE_GATEWAY_INVALID_DELTA");
+      if (!this.tools.has(this.key(tree)))
+        throw new GatewayError("MANCODE_GATEWAY_UNKNOWN_TOOL_CHANNEL");
+      this.toolDelta(this.key(tree), delta);
+      return [];
+    }
+    if (type === "response.function_call_arguments.done") {
+      const args = stringValue(property(tree, "arguments"));
+      if (args === void 0)
+        throw new GatewayError("MANCODE_GATEWAY_INVALID_TOOL_ARGUMENTS");
+      const value = this.toolDone(this.key(tree), args);
+      const delta = {
+        type: "response.function_call_arguments.delta",
+        item_id: property(tree, "item_id")?.value,
+        output_index: property(tree, "output_index")?.value,
+        delta: value
+      };
+      return [{ event: delta.type, data: JSON.stringify(delta) }, frame];
+    }
+    if (type === "response.output_item.added" || type === "response.output_item.done" || type === "response.content_part.added" || type === "response.content_part.done") {
+      const item = property(
+        tree,
+        type.includes("output_item") ? "item" : "part"
+      );
+      if (!item) throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_EVENT");
+      if (type === "response.output_item.added" && stringValue(property(item, "type")) === "function_call" && stringValue(property(item, "arguments")) !== "")
+        throw new GatewayError("MANCODE_GATEWAY_NONEMPTY_INITIAL_TOOL");
+      if (type === "response.output_item.added" && stringValue(property(item, "type")) === "function_call" && stringValue(property(item, "arguments")) === "") {
+        const itemSource = frame.data.slice(
+          item.offset,
+          item.offset + item.length
+        );
+        const itemTree = parseStrictJson(itemSource);
+        const argumentsNode = property(itemTree, "arguments");
+        if (!argumentsNode)
+          throw new GatewayError("MANCODE_GATEWAY_INVALID_TOOL_ARGUMENTS");
+        transformContentItem(
+          applyJsonEdits(itemSource, [
+            {
+              offset: argumentsNode.offset,
+              length: argumentsNode.length,
+              text: JSON.stringify("{}")
+            }
+          ]),
+          this.mapping
+        );
+        const index = property(tree, "output_index")?.value;
+        const itemId = stringValue(property(item, "id"));
+        if (!Number.isSafeInteger(index) || index < 0 || !itemId)
+          throw new GatewayError("MANCODE_GATEWAY_CHANNEL_ID_INVALID");
+        const key = `${index}:0:${itemId}`;
+        if (this.tools.has(key))
+          throw new GatewayError("MANCODE_GATEWAY_DUPLICATE_TOOL");
+        this.toolDelta(key, "");
+        const channel = this.tools.get(key);
+        channel.name = stringValue(property(item, "name"));
+        return [frame];
+      }
+      const result = transformContentItem(
+        frame.data.slice(item.offset, item.offset + item.length),
+        this.mapping
+      );
+      this.opaqueBlocks += result.opaqueBlocks;
+      return [
+        {
+          ...frame,
+          data: applyJsonEdits(frame.data, [
+            { offset: item.offset, length: item.length, text: result.body }
+          ])
+        }
+      ];
+    }
+    if (type === "response.completed") {
+      const response = property(tree, "response");
+      if (!response || stringValue(property(response, "id")) !== this.responseId)
+        throw new GatewayError("MANCODE_GATEWAY_RESPONSE_SCOPE_MISMATCH");
+      const result = transformResponse(
+        frame.data.slice(response.offset, response.offset + response.length),
+        "responses",
+        this.mapping
+      );
+      this.opaqueBlocks += result.opaqueBlocks;
+      this.completed = true;
+      this.finish();
+      return [
+        {
+          ...frame,
+          data: applyJsonEdits(frame.data, [
+            {
+              offset: response.offset,
+              length: response.length,
+              text: result.body
+            }
+          ])
+        }
+      ];
+    }
+    if (OPAQUE_EVENTS.has(type)) {
+      this.opaqueBlocks++;
+      return [frame];
+    }
+    if (RESPONSE_METADATA.has(type)) return [frame];
+    throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_EVENT");
+  }
+  messages(frame, tree, type) {
+    if (type === "ping") return [frame];
+    if (type === "message_start") {
+      if (this.responseId)
+        throw new GatewayError("MANCODE_GATEWAY_DUPLICATE_RESPONSE");
+      const message = property(tree, "message");
+      this.responseId = message && stringValue(property(message, "id"));
+      if (!this.responseId || property(message, "content")?.children?.length)
+        throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_RESPONSE");
+      return [frame];
+    }
+    if (type === "message_delta") return [frame];
+    if (type === "message_stop") {
+      this.completed = true;
+      this.finish();
+      return [frame];
+    }
+    const index = property(tree, "index")?.value;
+    if (!Number.isSafeInteger(index) || index < 0)
+      throw new GatewayError("MANCODE_GATEWAY_CHANNEL_ID_INVALID");
+    const key = `messages:${index}`;
+    if (type === "content_block_start") {
+      if (this.anthropicTypes.has(index) || this.anthropicTypes.size >= this.maxChannels)
+        throw new GatewayError("MANCODE_GATEWAY_CHANNEL_LIMIT");
+      const block = property(tree, "content_block");
+      const blockType = block && stringValue(property(block, "type"));
+      if (!block || !blockType)
+        throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_EVENT");
+      this.anthropicTypes.set(index, blockType);
+      if (blockType === "tool_use") {
+        const input = property(block, "input");
+        if (input?.type !== "object" || input.children?.length)
+          throw new GatewayError("MANCODE_GATEWAY_NONEMPTY_INITIAL_TOOL");
+        transformContentItem(
+          frame.data.slice(block.offset, block.offset + block.length),
+          this.mapping
+        );
+        this.toolDelta(key, "");
+        const channel = this.tools.get(key);
+        channel.initial = frame;
+        channel.name = stringValue(property(block, "name"));
+        return [];
+      }
+      const result = transformContentItem(
+        frame.data.slice(block.offset, block.offset + block.length),
+        this.mapping
+      );
+      this.opaqueBlocks += result.opaqueBlocks;
+      return [
+        {
+          ...frame,
+          data: applyJsonEdits(frame.data, [
+            { offset: block.offset, length: block.length, text: result.body }
+          ])
+        }
+      ];
+    }
+    if (type === "content_block_delta") {
+      const delta = property(tree, "delta");
+      const deltaType = delta && stringValue(property(delta, "type"));
+      if (!delta) throw new GatewayError("MANCODE_GATEWAY_INVALID_DELTA");
+      if (deltaType === "input_json_delta" && this.anthropicTypes.get(index) === "tool_use") {
+        const value = stringValue(property(delta, "partial_json"));
+        if (value === void 0)
+          throw new GatewayError("MANCODE_GATEWAY_INVALID_DELTA");
+        this.toolDelta(key, value);
+        return [];
+      }
+      if (deltaType === "text_delta" && this.anthropicTypes.get(index) === "text") {
+        const field = property(delta, "text");
+        if (field?.type !== "string")
+          throw new GatewayError("MANCODE_GATEWAY_INVALID_DELTA");
+        const edits = [];
+        const value = this.textDelta(key, field.value);
+        replaceString(edits, field, value);
+        return value ? [{ ...frame, data: applyJsonEdits(frame.data, edits) }] : [];
+      }
+      if ((deltaType === "thinking_delta" || deltaType === "signature_delta") && this.anthropicTypes.get(index) === "thinking") {
+        this.opaqueBlocks++;
+        return [frame];
+      }
+      throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_EVENT");
+    }
+    if (type === "content_block_stop") {
+      if (!this.anthropicTypes.has(index))
+        throw new GatewayError("MANCODE_GATEWAY_CHANNEL_ID_INVALID");
+      const tool = this.tools.get(key);
+      if (tool) {
+        const args = this.toolDone(key);
+        const delta = {
+          type: "content_block_delta",
+          index,
+          delta: { type: "input_json_delta", partial_json: args }
+        };
+        return [
+          tool.initial,
+          { event: delta.type, data: JSON.stringify(delta) },
+          frame
+        ];
+      }
+      const tail = this.texts.has(key) ? this.textDelta(key, "", true) : "";
+      if (tail) {
+        const delta = {
+          type: "content_block_delta",
+          index,
+          delta: { type: "text_delta", text: tail }
+        };
+        return [{ event: delta.type, data: JSON.stringify(delta) }, frame];
+      }
+      return [frame];
+    }
+    throw new GatewayError("MANCODE_GATEWAY_UNSUPPORTED_EVENT");
+  }
+};
+
+export {
+  GatewayError,
+  gatewayErrorCode,
+  parseStrictJson,
+  property,
+  stringValue,
+  MappingStore,
+  transformRequest,
+  transformResponse,
+  SseDecoder,
+  encodeSse,
+  ProtocolStream
+};
+//# sourceMappingURL=chunk-GI24QVXE.js.map