threadwire 0.1.8 → 0.1.9

package/src/isolated-state.js

@@ -12,10 +12,12 @@ const OWNER = "threadwire-isolated-runtime"
  * Authenticated registry of both public session aliases and private volume
  * ownership. Lineage ownership deliberately outlives an expired alias until
  * Docker confirms that the volume was deleted.
- * @param {{file: string, key: string, namespace: string, now?: () => number, random?: (size: number) => Buffer}} options
+ * @param {{file: string, key: string, namespace: string, provider?: "codex" | "kimi", now?: () => number, random?: (size: number) => Buffer}} options
  */
 export async function openStateRegistry(options) {
-  if (!/^\/.+/u.test(options.file) || options.key.length < 32 || !/^[A-Za-z0-9_.-]{1,64}$/u.test(options.namespace)) {
+  const provider = options.provider ?? "codex"
+  if (!/^\/.+/u.test(options.file) || options.key.length < 32 || !/^[A-Za-z0-9_.-]{1,64}$/u.test(options.namespace)
+    || (provider !== "codex" && provider !== "kimi")) {
     throw new Error("Invalid isolated state configuration")
   }
   const now = options.now ?? Date.now
@@ -31,28 +33,35 @@ export async function openStateRegistry(options) {
   try {
     const document = JSON.parse(await readFile(options.file, "utf8"))
     const payload = JSON.stringify(document.payload)
-    if (![1, 2, 3].includes(document.version) || typeof document.mac !== "string" || !equalMac(document.mac, mac(options.key, payload))) throw new Error()
+    if (![1, 2, 3, 4].includes(document.version) || typeof document.mac !== "string" || !equalMac(document.mac, mac(options.key, payload))) throw new Error()
+    if (document.version < 4 && provider !== "codex") throw new Error()
     if (!Array.isArray(document.payload?.sessions)) throw new Error()
-    for (const entry of document.payload.sessions) {
-      if (!validSession(entry)) throw new Error()
+    for (const rawEntry of document.payload.sessions) {
+      if (!validSession(rawEntry, document.version === 4)) throw new Error()
+      const entry = document.version === 4 ? rawEntry : {...rawEntry, provider: "codex"}
+      if (entry.provider !== provider) throw new Error()
       sessions.set(entry.sessionId, without(entry, "sessionId"))
       lineages.set(entry.lineage, lineageFromSession(options.namespace, entry))
     }
     if (document.version === 2) {
       if (!Array.isArray(document.payload.lineages)) throw new Error()
       for (const entry of document.payload.lineages) {
-        if (!validLineage(entry, options.namespace)) throw new Error()
-        lineages.set(entry.lineage, entry)
+        if (!validLineage(entry, options.namespace, false)) throw new Error()
+        lineages.set(entry.lineage, {...entry, provider: "codex"})
       }
     }
-    if (document.version === 3) {
+    if (document.version === 3 || document.version === 4) {
       if (!Array.isArray(document.payload.lineages) || !Array.isArray(document.payload.runs)) throw new Error()
-      for (const entry of document.payload.lineages) {
-        if (!validLineage(entry, options.namespace)) throw new Error()
+      for (const rawEntry of document.payload.lineages) {
+        if (!validLineage(rawEntry, options.namespace, document.version === 4)) throw new Error()
+        const entry = document.version === 4 ? rawEntry : {...rawEntry, provider: "codex"}
+        if (entry.provider !== provider) throw new Error()
         lineages.set(entry.lineage, entry)
       }
-      for (const entry of document.payload.runs) {
-        canonicalRunIdentity(entry)
+      for (const rawEntry of document.payload.runs) {
+        canonicalRunIdentity(rawEntry)
+        const entry = document.version === 4 ? rawEntry : {...rawEntry, provider: "codex", sealVersion: 3}
+        if (entry.provider !== provider) throw new Error()
         runs.set(entry.run, entry)
       }
     }
@@ -69,7 +78,7 @@ export async function openStateRegistry(options) {
       runs: [...runState.values()]
     }
     const serializedPayload = JSON.stringify(payload)
-    const document = JSON.stringify({version: 3, payload, mac: mac(options.key, serializedPayload)})
+    const document = JSON.stringify({version: 4, payload, mac: mac(options.key, serializedPayload)})
     const temporary = join(dirname(options.file), `.sessions-${random(12).toString("hex")}.tmp`)
     let handle
     try {
@@ -104,17 +113,33 @@ export async function openStateRegistry(options) {
     return result
   }
   const allocationRecord = (allocation) => ({
+    provider: allocation.provider,
     task: allocation.task,
     lineage: allocation.lineage,
     volume: allocation.volume,
     labels: allocation.labels
   })
+  const ownsRunSeal = (identity, seal, legacyLabels = false) => {
+    const persisted = runs.get(identity.run)
+    if (!persisted || typeof seal !== "string") return false
+    try {
+      if (canonicalRunIdentity(persisted) !== canonicalRunIdentity(identity)) return false
+      const legacySeal = persisted.sealVersion === 3
+      if (legacyLabels !== legacySeal) return false
+      const canonical = legacySeal ? legacyCanonicalRunIdentity(persisted) : canonicalRunIdentity(persisted)
+      return equalMac(seal, mac(options.key, canonical))
+    } catch {
+      return false
+    }
+  }
 
   return {
     namespace: options.namespace,
+    provider,
     allocate(task) {
       const lineage = random(24).toString("hex")
       return {
+        provider,
         task,
         lineage,
         volume: `threadwire-state-${options.namespace}-${lineage}`,
@@ -122,22 +147,29 @@ export async function openStateRegistry(options) {
       }
     },
     sealRun(identity) {
+      if (identity.sealVersion !== undefined) throw new Error("Invalid isolated run identity")
       return mac(options.key, canonicalRunIdentity(identity))
     },
-    ownsRun(identity, seal) {
+    ownsRunSeal(identity, seal, legacyLabels = false) {
+      return ownsRunSeal(identity, seal, legacyLabels)
+    },
+    ownsRun(identity, seal, legacyLabels = false) {
       const lineage = lineages.get(identity.lineage)
-      if (!lineage || lineage.volume !== identity.volume || lineage.labels["org.threadwire.task"] !== identity.task) return false
-      return typeof seal === "string" && equalMac(seal, mac(options.key, canonicalRunIdentity(identity)))
+      if (!lineage || lineage.provider !== (identity.provider ?? "codex")
+        || lineage.volume !== identity.volume || lineage.labels["org.threadwire.task"] !== identity.task) return false
+      return ownsRunSeal(identity, seal, legacyLabels)
     },
     async trackRun(identity, signal) {
       await transact(async () => {
         throwIfAborted(signal)
-        canonicalRunIdentity(identity)
-        if (!lineages.has(identity.lineage)) throw new Error("Codex run lineage is unavailable")
-        const existing = runs.get(identity.run)
-        if (existing && canonicalRunIdentity(existing) !== canonicalRunIdentity(identity)) throw new Error("Codex run ownership collision")
+        const normalized = {...identity, provider: identity.provider ?? provider}
+        if (normalized.sealVersion !== undefined) throw new Error("Invalid isolated run identity")
+        canonicalRunIdentity(normalized)
+        if (normalized.provider !== provider || !lineages.has(normalized.lineage)) throw new Error(`${provider === "kimi" ? "Kimi" : "Codex"} run lineage is unavailable`)
+        const existing = runs.get(normalized.run)
+        if (existing && canonicalRunIdentity(existing) !== canonicalRunIdentity(normalized)) throw new Error(`${provider === "kimi" ? "Kimi" : "Codex"} run ownership collision`)
         const nextRuns = new Map(runs)
-        nextRuns.set(identity.run, identity)
+        nextRuns.set(normalized.run, existing ?? normalized)
         await persist(sessions, lineages, nextRuns, signal)
         replace(runs, nextRuns)
         throwIfAborted(signal)
@@ -157,19 +189,20 @@ export async function openStateRegistry(options) {
     runRecords() {
       return [...runs.values()].map((entry) => ({...entry}))
     },
-    lookup(sessionId) {
+    lookup(sessionId, expectedProvider = provider) {
       const entry = sessions.get(sessionId)
-      if (!entry || entry.expiresAt <= now()) return undefined
+      if (!entry || entry.provider !== expectedProvider || entry.expiresAt <= now()) return undefined
       return {...entry, labels: stateLabels(options.namespace, entry.task, entry.lineage)}
     },
     async track(allocation, signal) {
       await transact(async () => {
         throwIfAborted(signal)
-        const existing = lineages.get(allocation.lineage)
-        const candidate = allocationRecord(allocation)
+        const normalized = providerAllocation(allocation, provider)
+        const existing = lineages.get(normalized.lineage)
+        const candidate = allocationRecord(normalized)
         if (existing && JSON.stringify(existing) !== JSON.stringify(candidate)) throw new Error("Codex lineage ownership collision")
         const nextLineages = new Map(lineages)
-        nextLineages.set(allocation.lineage, candidate)
+        nextLineages.set(normalized.lineage, candidate)
         await persist(sessions, nextLineages, runs, signal)
         replace(lineages, nextLineages)
         throwIfAborted(signal)
@@ -178,21 +211,23 @@ export async function openStateRegistry(options) {
     async register(sessionIds, allocation, ttlMs, signal) {
       await transact(async () => {
         throwIfAborted(signal)
-        const candidate = allocationRecord(allocation)
-        const owned = lineages.get(allocation.lineage)
+        const normalized = providerAllocation(allocation, provider)
+        const candidate = allocationRecord(normalized)
+        const owned = lineages.get(normalized.lineage)
         if (owned && JSON.stringify(owned) !== JSON.stringify(candidate)) throw new Error("Codex lineage ownership collision")
         const nextSessions = new Map(sessions)
         const nextLineages = new Map(lineages)
         for (const sessionId of sessionIds) {
           const existing = nextSessions.get(sessionId)
-          if (existing && (existing.task !== allocation.task || existing.lineage !== allocation.lineage || existing.volume !== allocation.volume)) {
+          if (existing && (existing.provider !== normalized.provider || existing.task !== normalized.task || existing.lineage !== normalized.lineage || existing.volume !== normalized.volume)) {
             throw new Error("Codex session lineage collision")
           }
           nextSessions.set(sessionId, {
-            task: allocation.task, lineage: allocation.lineage, volume: allocation.volume, expiresAt: now() + ttlMs
+            provider: normalized.provider, task: normalized.task, lineage: normalized.lineage,
+            volume: normalized.volume, expiresAt: now() + ttlMs
           })
         }
-        nextLineages.set(allocation.lineage, candidate)
+        nextLineages.set(normalized.lineage, candidate)
         await persist(nextSessions, nextLineages, runs, signal)
         replace(sessions, nextSessions)
         replace(lineages, nextLineages)
@@ -215,7 +250,7 @@ export async function openStateRegistry(options) {
         const nextLineages = new Map(lineages)
         for (const [sessionId, entry] of nextSessions) if (entry.expiresAt <= now()) nextSessions.delete(sessionId)
         for (const volume of Array.isArray(listed?.Volumes) ? listed.Volumes : []) {
-          const orphan = ownedVolumeRecord(volume, options.namespace)
+          const orphan = ownedVolumeRecord(volume, options.namespace, provider)
           if (orphan && !nextLineages.has(orphan.lineage)) nextLineages.set(orphan.lineage, orphan)
         }
         // Persist removals and adopted cleanup evidence before touching Docker.
@@ -282,7 +317,7 @@ export function validateStateVolume(volume, name, labels) {
   for (const [key, value] of Object.entries(labels)) if (actual[key] !== value) throw new Error("Isolated state volume collision")
 }
 
-function ownedVolumeRecord(volume, namespace) {
+function ownedVolumeRecord(volume, namespace, provider) {
   if (!record(volume) || !record(volume.Labels)) return undefined
   const labels = volume.Labels
   const lineage = labels["org.threadwire.lineage"]
@@ -293,25 +328,33 @@ function ownedVolumeRecord(volume, namespace) {
     || !/^[0-9a-f]{64}$/u.test(labels["org.threadwire.task"])
     || !/^[0-9a-f]{48}$/u.test(lineage)
     || name !== `threadwire-state-${namespace}-${lineage}`) return undefined
-  return {task: "", lineage, volume: name, labels}
+  return {provider, task: "", lineage, volume: name, labels}
+}
+
+function providerAllocation(allocation, expectedProvider) {
+  const actualProvider = allocation.provider ?? "codex"
+  if (actualProvider !== expectedProvider) throw new Error("Isolated state provider mismatch")
+  return {...allocation, provider: actualProvider}
 }
 
 function lineageFromSession(namespace, entry) {
   return {
-    task: entry.task, lineage: entry.lineage, volume: entry.volume,
+    provider: entry.provider, task: entry.task, lineage: entry.lineage, volume: entry.volume,
     labels: stateLabels(namespace, entry.task, entry.lineage)
   }
 }
 
-function validSession(value) {
-  return record(value) && typeof value.sessionId === "string" && typeof value.task === "string"
+function validSession(value, requireProvider = true) {
+  return record(value) && (!requireProvider || value.provider === "codex" || value.provider === "kimi")
+    && typeof value.sessionId === "string" && typeof value.task === "string"
     && /^[0-9a-f]{48}$/u.test(value.lineage)
     && /^threadwire-state-[A-Za-z0-9_.-]+-[0-9a-f]{48}$/u.test(value.volume)
     && Number.isSafeInteger(value.expiresAt)
 }
 
-function validLineage(value, namespace) {
-  return record(value) && typeof value.task === "string" && /^[0-9a-f]{48}$/u.test(value.lineage)
+function validLineage(value, namespace, requireProvider = true) {
+  return record(value) && (!requireProvider || value.provider === "codex" || value.provider === "kimi")
+    && typeof value.task === "string" && /^[0-9a-f]{48}$/u.test(value.lineage)
     && value.volume === `threadwire-state-${namespace}-${value.lineage}` && record(value.labels)
     && Object.keys(value.labels).length === 4
     && value.labels["org.threadwire.owner"] === OWNER
@@ -366,14 +409,15 @@ async function removeAuthenticatedTemps(directory, key, namespace) {
 }
 
 function authenticatedDocument(document, key, namespace) {
-  if (!record(document) || ![1, 2, 3].includes(document.version) || typeof document.mac !== "string"
+  if (!record(document) || ![1, 2, 3, 4].includes(document.version) || typeof document.mac !== "string"
     || !record(document.payload) || !Array.isArray(document.payload.sessions)) return false
   const payload = JSON.stringify(document.payload)
   if (!equalMac(document.mac, mac(key, payload))) return false
-  if (!document.payload.sessions.every(validSession)) return false
+  const current = document.version === 4
+  if (!document.payload.sessions.every((entry) => validSession(entry, current))) return false
   if (document.version === 1) return true
   if (!Array.isArray(document.payload.lineages)
-    || !document.payload.lineages.every((entry) => validLineage(entry, namespace))) return false
+    || !document.payload.lineages.every((entry) => validLineage(entry, namespace, current))) return false
   return document.version === 2 || (Array.isArray(document.payload.runs)
     && document.payload.runs.every((entry) => {
       try { canonicalRunIdentity(entry); return true } catch { return false }
@@ -381,12 +425,29 @@ function authenticatedDocument(document, key, namespace) {
 }
 
 function canonicalRunIdentity(identity) {
+  const keys = [
+    "provider", "namespace", "run", "lineage", "task", "volume", "network", "container",
+    "image", "worktreeType", "worktreeSource", "worktreeSubpath"
+  ]
+  if (!record(identity)) throw new Error("Invalid isolated run identity")
+  const normalized = {...identity, provider: identity.provider ?? "codex"}
+  const legacySeal = normalized.sealVersion === 3 && normalized.provider === "codex"
+  const expectedKeys = legacySeal ? [...keys, "sealVersion"] : keys
+  if (Object.keys(normalized).length !== expectedKeys.length
+    || expectedKeys.some((key) => !Object.prototype.hasOwnProperty.call(normalized, key))
+    || (normalized.provider !== "codex" && normalized.provider !== "kimi")
+    || keys.some((key) => typeof normalized[key] !== "string")) throw new Error("Invalid isolated run identity")
+  return JSON.stringify(Object.fromEntries(keys.map((key) => [key, normalized[key]])))
+}
+
+function legacyCanonicalRunIdentity(identity) {
   const keys = [
     "namespace", "run", "lineage", "task", "volume", "network", "container",
     "image", "worktreeType", "worktreeSource", "worktreeSubpath"
   ]
-  if (!record(identity) || Object.keys(identity).length !== keys.length
-    || keys.some((key) => typeof identity[key] !== "string")) throw new Error("Invalid isolated run identity")
+  if (!record(identity) || identity.provider !== "codex" || identity.sealVersion !== 3
+    || Object.keys(identity).length !== keys.length + 2
+    || keys.some((key) => typeof identity[key] !== "string")) throw new Error("Invalid legacy Codex run identity")
   return JSON.stringify(Object.fromEntries(keys.map((key) => [key, identity[key]])))
 }
 

package/src/isolated-worker.js

@@ -7,6 +7,7 @@ const SAFE_VALUE = /^[^\0\r\n]+$/u
 
 /**
  * @typedef {{
+ *   provider?: "codex" | "kimi",
  *   image: string,
  *   worktree: string,
  *   networkName: string,
@@ -17,6 +18,7 @@ const SAFE_VALUE = /^[^\0\r\n]+$/u
  *   worktreeVolume?: {name: string, subpath: string}
  *   workingDirectory: string,
  *   providerArguments: string[],
+ *   model?: string,
  *   stateVolume: string,
  *   worktreeInode: string,
  *   cwdInode: string
@@ -30,6 +32,8 @@ const SAFE_VALUE = /^[^\0\r\n]+$/u
 
 /** @param {WorkerSpecOptions} options */
 export function buildWorkerContainerSpec(options) {
+  const provider = options.provider ?? "codex"
+  if (provider !== "codex" && provider !== "kimi") throw new Error("Worker provider is invalid")
   if (!DIGEST_IMAGE.test(options.image)) throw new Error("Worker image must use an immutable digest")
   if (!isAbsolute(options.worktree) || normalize(options.worktree) !== options.worktree || options.worktree === "/") {
     throw new Error("Worker worktree must be a normalized non-root absolute path")
@@ -39,19 +43,33 @@ export function buildWorkerContainerSpec(options) {
   }
   if (options.resumeSession !== undefined && !SAFE_VALUE.test(options.resumeSession)) throw new Error("Worker resume session is invalid")
   if (!isAbsolute(options.workingDirectory) || !withinWorktree(options.workingDirectory)) throw new Error("Worker cwd is invalid")
-  const environment = [
+  if (provider === "kimi" && (typeof options.model !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/u.test(options.model))) {
+    throw new Error("Worker Kimi model is invalid")
+  }
+  const commonEnvironment = [
     "HOME=/home/worker",
-    "CODEX_HOME=/home/worker/.codex",
     "TMPDIR=/tmp",
-    `OPENAI_BASE_URL=${options.brokerUrl ?? "http://model-broker:8789/v1"}`,
-    `OPENAI_API_KEY=${options.brokerToken}`,
-    `CODEX_API_KEY=${options.brokerToken}`,
     `THREADWIRE_PROMPT=${options.prompt}`,
-    `THREADWIRE_CODEX_ARGUMENTS=${JSON.stringify(options.providerArguments)}`,
     `THREADWIRE_WORKTREE_INODE=${options.worktreeInode}`,
     `THREADWIRE_CWD_INODE=${options.cwdInode}`,
     ...(options.resumeSession === undefined ? [] : [`THREADWIRE_RESUME_SESSION=${options.resumeSession}`])
   ]
+  const environment = provider === "kimi"
+    ? [
+      ...commonEnvironment,
+      "KIMI_CODE_HOME=/home/worker/.kimi-code",
+      `THREADWIRE_KIMI_MODEL=${options.model}`,
+      `THREADWIRE_KIMI_BROKER_URL=${options.brokerUrl}`,
+      `THREADWIRE_KIMI_BROKER_TOKEN=${options.brokerToken}`
+    ]
+    : [
+      ...commonEnvironment,
+      "CODEX_HOME=/home/worker/.codex",
+      `OPENAI_BASE_URL=${options.brokerUrl ?? "http://model-broker:8789/v1"}`,
+      `OPENAI_API_KEY=${options.brokerToken}`,
+      `CODEX_API_KEY=${options.brokerToken}`,
+      `THREADWIRE_CODEX_ARGUMENTS=${JSON.stringify(options.providerArguments)}`
+    ]
   const worktreeMount = options.worktreeVolume === undefined
     ? {
       Type: "bind",
@@ -73,6 +91,7 @@ export function buildWorkerContainerSpec(options) {
       "org.threadwire.owner": "isolated-runtime",
       ...(options.lineage === undefined ? {} : {
         "org.threadwire.namespace": options.namespace,
+        "org.threadwire.provider": provider,
         "org.threadwire.run": options.runId,
         "org.threadwire.lineage": options.lineage,
         "org.threadwire.task": options.taskHash,
@@ -81,7 +100,9 @@ export function buildWorkerContainerSpec(options) {
         "org.threadwire.run-seal": options.runSeal
       })
     },
-    Entrypoint: ["/usr/local/libexec/threadwire/worker-entrypoint"],
+    Entrypoint: provider === "kimi"
+      ? ["node", "/opt/threadwire/docker/kimi-worker-entrypoint.mjs"]
+      : ["/usr/local/libexec/threadwire/worker-entrypoint"],
     Env: environment,
     WorkingDir: options.workingDirectory,
     User: "10002:10002",

package/src/kimi-model-broker-policy.js

@@ -0,0 +1,209 @@
+// @ts-check
+
+import {randomBytes} from "node:crypto"
+
+const TOKEN_PATTERN = /^[A-Za-z0-9_-]{32,128}$/u
+const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/u
+const MODEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/u
+const ALIAS_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u
+const TASK_PATTERN = /^[0-9a-f]{64}$/u
+const SESSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,511}$/u
+
+/** @typedef {{provider: "kimi", runId: string, networkId: string, taskId: string, sessionId: string, modelAlias: string, model: string, expiresAt: number, active: boolean}} KimiGrant */
+/** @typedef {{alias: string, model: string, protocol: "kimi"}} ApprovedKimiModel */
+const ALLOWED_HEADERS = new Set([
+  "authorization", "content-length", "content-type", "accept", "accept-encoding",
+  "accept-language", "sec-fetch-mode", "user-agent",
+  "x-stainless-arch", "x-stainless-lang", "x-stainless-os",
+  "x-stainless-package-version", "x-stainless-runtime", "x-stainless-runtime-version",
+  "x-stainless-retry-count", "x-stainless-timeout", "x-stainless-async"
+])
+const BODY_KEYS = new Set([
+  "model", "messages", "stream", "stream_options", "tools", "thinking",
+  "max_completion_tokens", "temperature", "top_p", "n", "presence_penalty",
+  "frequency_penalty", "stop", "prompt_cache_key", "response_format"
+])
+const NUMERIC_KEYS = new Set([
+  "max_completion_tokens", "temperature", "top_p", "n", "presence_penalty", "frequency_penalty"
+])
+
+export const KIMI_CHAT_COMPLETIONS_PATH = "/coding/v1/chat/completions"
+
+/** @param {{now?: () => number, random?: (bytes: number) => Buffer}} [options] */
+export function createKimiGrantStore(options = {}) {
+  const now = options.now ?? Date.now
+  const random = options.random ?? randomBytes
+  /** @type {Map<string, KimiGrant>} */
+  const grants = new Map()
+  return {
+    /** @param {{provider: "kimi", runId: string, networkId: string, taskId: string, sessionId: string, modelAlias: string, model: string, ttlMs: number}} grant */
+    issue(grant) {
+      if (grant.provider !== "kimi" || !ID_PATTERN.test(grant.runId) || !ID_PATTERN.test(grant.networkId)
+        || !TASK_PATTERN.test(grant.taskId) || !SESSION_PATTERN.test(grant.sessionId)
+        || !ALIAS_PATTERN.test(grant.modelAlias) || !MODEL_PATTERN.test(grant.model)
+        || !Number.isSafeInteger(grant.ttlMs) || grant.ttlMs < 1 || grant.ttlMs > 3_600_000) {
+        throw new Error("Invalid Kimi broker grant")
+      }
+      const token = random(32).toString("base64url")
+      if (!TOKEN_PATTERN.test(token) || grants.has(token)) throw new Error("Invalid Kimi broker grant")
+      grants.set(token, {...grant, expiresAt: now() + grant.ttlMs, active: false})
+      return token
+    },
+    /** @param {string} token */
+    activate(token) {
+      const grant = currentGrant(grants, token, now)
+      if (grant.active) throw new Error("Kimi broker grant already active")
+      grant.active = true
+      return {...grant}
+    },
+    /** @param {string} token @param {{provider: string, runId: string, networkId: string, taskId: string, sessionId: string, modelAlias: string}} context */
+    authorize(token, context) {
+      const grant = currentGrant(grants, token, now)
+      if (grant.provider !== context.provider || grant.runId !== context.runId
+        || grant.networkId !== context.networkId || grant.taskId !== context.taskId
+        || grant.sessionId !== context.sessionId || grant.modelAlias !== context.modelAlias) {
+        throw new Error("Kimi broker grant lineage denied")
+      }
+      if (!grant.active) throw new Error("Kimi broker grant pending")
+      return {...grant}
+    },
+    /** @param {string} token */
+    revoke(token) { grants.delete(token) },
+    clear() { grants.clear() }
+  }
+}
+
+/**
+ * @param {Map<string, KimiGrant>} grants
+ * @param {string} token
+ * @param {() => number} now
+ */
+function currentGrant(grants, token, now) {
+  const grant = grants.get(token)
+  if (!grant) throw new Error("Kimi broker grant unknown token")
+  if (grant.expiresAt < now()) {
+    grants.delete(token)
+    throw new Error("Kimi broker grant expired")
+  }
+  return grant
+}
+
+/** @param {{method?: string, path?: string, headers?: Record<string, string | string[] | undefined>}} request */
+export function validateKimiBrokerRequest(request) {
+  if (request.method !== "POST" || request.path !== "/v1/chat/completions") {
+    throw new Error("Kimi broker request denied")
+  }
+  for (const header of Object.keys(request.headers ?? {})) {
+    if (!ALLOWED_HEADERS.has(header.toLowerCase())) throw new Error(`Kimi broker request denied header: ${header.toLowerCase()}`)
+  }
+  return {method: "POST", path: "/v1/chat/completions", upstreamPath: KIMI_CHAT_COMPLETIONS_PATH}
+}
+
+/** @param {Buffer} body @param {string} allowedModel */
+export function validateKimiChatBody(body, allowedModel) {
+  const text = body.toString("utf8")
+  if (topLevelKeyCount(text, "model") !== 1) throw denied()
+  let value
+  try { value = JSON.parse(text) } catch { throw denied() }
+  if (!record(value) || Object.keys(value).some((key) => !BODY_KEYS.has(key))) throw denied()
+  if (value.model !== allowedModel || !Array.isArray(value.messages) || value.stream !== true) throw denied()
+  if (value.messages.length === 0 || value.messages.length > 4096 || !value.messages.every(validMessage)) throw denied()
+  if (value.tools !== undefined && (!Array.isArray(value.tools) || value.tools.length > 512 || !value.tools.every(record))) throw denied()
+  if (value.stream_options !== undefined && (!record(value.stream_options)
+    || !exactKeys(value.stream_options, ["include_usage"]) || value.stream_options.include_usage !== true)) throw denied()
+  if (value.thinking !== undefined && !validThinking(value.thinking)) throw denied()
+  if (value.response_format !== undefined && !record(value.response_format)) throw denied()
+  if (value.prompt_cache_key !== undefined && (typeof value.prompt_cache_key !== "string" || value.prompt_cache_key.length > 512)) throw denied()
+  if (value.stop !== undefined && !validStop(value.stop)) throw denied()
+  for (const key of NUMERIC_KEYS) {
+    const item = value[key]
+    if (item !== undefined && (typeof item !== "number" || !Number.isFinite(item))) throw denied()
+  }
+  if (value.max_completion_tokens !== undefined && (typeof value.max_completion_tokens !== "number"
+    || !Number.isSafeInteger(value.max_completion_tokens)
+    || value.max_completion_tokens < 1 || value.max_completion_tokens > 1_000_000)) throw denied()
+  if (value.n !== undefined && value.n !== 1) throw denied()
+  return value
+}
+
+/** @param {unknown} value */
+function validMessage(value) {
+  if (!record(value) || typeof value.role !== "string" || !["system", "user", "assistant", "tool"].includes(value.role)) return false
+  const allowed = new Set(["role", "content", "tool_calls", "tool_call_id", "name", "reasoning_content", "reasoning_details", "reasoning", "tools"])
+  return Object.keys(value).every((key) => allowed.has(key))
+}
+
+/** @param {unknown} value */
+function validThinking(value) {
+  if (!record(value) || Object.keys(value).some((key) => !["type", "effort", "keep"].includes(key))) return false
+  if (value.type !== undefined && value.type !== "enabled" && value.type !== "disabled") return false
+  if (value.effort !== undefined && (typeof value.effort !== "string" || !/^[A-Za-z0-9_-]{1,32}$/u.test(value.effort))) return false
+  return value.keep === undefined || value.keep === "all"
+}
+
+/** @param {unknown} value */
+function validStop(value) {
+  return typeof value === "string" ? value.length <= 512
+    : Array.isArray(value) && value.length <= 16 && value.every((item) => typeof item === "string" && item.length <= 512)
+}
+
+/** @param {string | undefined} authorization */
+export function kimiBearerToken(authorization) {
+  const match = /^Bearer ([A-Za-z0-9_-]{32,128})$/u.exec(authorization ?? "")
+  if (!match || !TOKEN_PATTERN.test(match[1] ?? "")) throw new Error("Kimi broker grant format denied")
+  return /** @type {string} */ (match[1])
+}
+
+/** @param {string | undefined} value */
+export function parseApprovedKimiModels(value) {
+  let parsed
+  try { parsed = JSON.parse(value ?? "") } catch { throw new Error("THREADWIRE_ALLOWED_KIMI_MODELS must contain allowed Kimi models") }
+  if (!record(parsed) || Object.keys(parsed).length < 1 || Object.keys(parsed).length > 32) {
+    throw new Error("THREADWIRE_ALLOWED_KIMI_MODELS must contain allowed Kimi models")
+  }
+  /** @type {Map<string, ApprovedKimiModel>} */
+  const models = new Map()
+  for (const [alias, item] of Object.entries(parsed)) {
+    if (!ALIAS_PATTERN.test(alias) || !record(item) || !exactKeys(item, ["model", "protocol"])
+      || typeof item.model !== "string" || !MODEL_PATTERN.test(item.model) || item.protocol !== "kimi") {
+      throw new Error("THREADWIRE_ALLOWED_KIMI_MODELS must contain allowed Kimi models")
+    }
+    models.set(alias, {alias, model: item.model, protocol: "kimi"})
+  }
+  return models
+}
+
+/** @returns {Error} */
+function denied() { return new Error("Kimi broker request denied") }
+/** @param {unknown} value @returns {value is Record<string, unknown>} */
+function record(value) { return typeof value === "object" && value !== null && !Array.isArray(value) }
+/** @param {Record<string, unknown>} value @param {readonly string[]} keys */
+function exactKeys(value, keys) {
+  const actual = Object.keys(value).sort()
+  return actual.length === keys.length && actual.every((key, index) => key === [...keys].sort()[index])
+}
+
+/** @param {string} text @param {string} wanted @returns {number} */
+function topLevelKeyCount(text, wanted) {
+  let depth = 0
+  let count = 0
+  let index = 0
+  while (index < text.length) {
+    if (text[index] === "\"") {
+      let string = ""
+      index++
+      while (index < text.length && text[index] !== "\"") {
+        if (text[index] === "\\") { index += 2; continue }
+        string += text[index++]
+      }
+      if (depth === 1) {
+        let next = index + 1
+        while (/\s/u.test(text[next] ?? "")) next++
+        if (text[next] === ":" && string === wanted) count++
+      }
+    } else if (text[index] === "{") depth++
+    else if (text[index] === "}") depth--
+    index++
+  }
+  return count
+}