deepcodex 0.1.0

package/vendor/codex-router/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 codex-router contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/codex-router/deepseek-responses.js

@@ -0,0 +1,55 @@
+// Vendored from duolahypercho/codex-router at 63ec1f3602c28f2a28ccb7e9edaf7b4f7d191c6c.
+// Source: src/deepseek-responses.js; MIT license in LICENSE.
+import { agentMessagesAsUserMessages } from "./namespace-relay.js";
+
+// The current direct Flash endpoint speaks Responses natively. Keep older
+// aliases and reseller routes on their separately verified wire contracts.
+export function usesDeepSeekResponses(model) {
+  return model?.provider === "deepseek" && model?.upstreamModel === "deepseek-flash";
+}
+
+// Current native endpoint aliases, documented in DeepSeek's thinking guide.
+// In particular xhigh maps to high; it is not the legacy Chat profile's max.
+export function deepSeekResponsesEffort(value) {
+  if (value === "none") return "none";
+  if (["minimal", "low"].includes(value)) return "low";
+  return ["max", "ultra"].includes(value) ? "max" : "high";
+}
+
+function reasoningContent(value) {
+  const texts = typeof value === "string" ? [value]
+    : Array.isArray(value) ? value.map((part) => part?.text) : [];
+  return texts.filter((text) => typeof text === "string" && text)
+    .map((text) => ({ type: "reasoning_text", text }));
+}
+
+// Plaintext reasoning uses an array of reasoning_text parts, not a JSON string.
+// DeepSeek ignores summary/encrypted_content; older Chat-bridged turns can have
+// only a summary. Replay its text once as reasoning, preserving part boundaries.
+export function deepSeekResponsesInput(input) {
+  if (!Array.isArray(input)) return input;
+  // The task text is already recovered; expose Codex handoffs as ordinary
+  // messages because the public endpoint does not understand agent_message.
+  return agentMessagesAsUserMessages(input).flatMap((item) => {
+    if (item?.type !== "reasoning") return [item];
+    let content = reasoningContent(item.content);
+    if (!content.length) content = reasoningContent(item.summary);
+    return content.length ? [{ type: "reasoning", content }] : [];
+  });
+}
+
+// Only apply_patch has a native custom-tool contract at this endpoint. Other
+// Codex freeform tools use the existing reversible function-tool bridge.
+export function deepSeekCustomToolNames(tools, input, choice) {
+  const names = new Set();
+  const add = (type, name) => {
+    if ((type === "custom" || type === "custom_tool_call") &&
+        typeof name === "string" && name && name !== "apply_patch") names.add(name);
+  };
+  for (const tool of Array.isArray(tools) ? tools : []) add(tool?.type, tool?.name);
+  for (const item of Array.isArray(input) ? input : []) add(item?.type, item?.name);
+  add(choice?.type, choice?.name);
+  for (const tool of choice?.type === "allowed_tools" && Array.isArray(choice.tools)
+    ? choice.tools : []) add(tool?.type, tool?.name);
+  return [...names];
+}

package/vendor/codex-router/json-number-rewrite.js

@@ -0,0 +1,58 @@
+// Vendored from duolahypercho/codex-router at 63ec1f3602c28f2a28ccb7e9edaf7b4f7d191c6c.
+// Source: src/json-number-rewrite.js; MIT license in LICENSE.
+const MAX_EXACT_JSON_NUMBER_LENGTH = 4096;
+const JSON_NUMBER_PARTS =
+  /^(-?)(0|[1-9]\d*)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
+
+// Normalize a bounded JSON number as an exact decimal coefficient + power.
+// This compares mathematical decimal values rather than spellings, so 1.0 and
+// 1e3 can survive a rewrite when JSON.stringify emits 1 and 1000 respectively,
+// while underflow and rounded high-precision tokens cannot.
+function canonicalDecimalToken(token) {
+  if (typeof token !== "string" || token.length > MAX_EXACT_JSON_NUMBER_LENGTH) {
+    return undefined;
+  }
+  const match = JSON_NUMBER_PARTS.exec(token);
+  if (!match) return undefined;
+  const [, sign, integer, fraction = "", exponentText = "0"] = match;
+  let digits = integer + fraction;
+  if (/^0+$/u.test(digits)) return sign === "-" ? "-0" : "0";
+
+  const exponentSign = exponentText.startsWith("-") ? -1 : 1;
+  const unsignedExponent = exponentText.replace(/^[+-]/u, "");
+  const significantExponent = unsignedExponent.replace(/^0+/u, "") || "0";
+  // A non-zero finite Number cannot retain an exponent remotely this large;
+  // bounding it also prevents attacker-controlled giant integer arithmetic.
+  if (significantExponent.length > 6) return undefined;
+  let exponent = exponentSign * Number(significantExponent) - fraction.length;
+
+  digits = digits.replace(/^0+/u, "");
+  const trailingZeros = /0+$/u.exec(digits)?.[0].length || 0;
+  if (trailingZeros) {
+    digits = digits.slice(0, -trailingZeros);
+    exponent += trailingZeros;
+  }
+  return `${sign}${digits}e${exponent}`;
+}
+
+// Permission to JSON.parse and later JSON.stringify a numeric token without
+// changing its exact mathematical decimal value. JavaScript's Number parser
+// can otherwise underflow or round a token while still returning a finite
+// value, which would silently mutate unrelated response fields during a
+// compatibility rewrite.
+export function jsonNumberIsStableForRewrite(token) {
+  if (typeof token !== "string" || token.length > MAX_EXACT_JSON_NUMBER_LENGTH) {
+    return false;
+  }
+  const parsed = Number(token);
+  if (
+    !Number.isFinite(parsed) ||
+    Object.is(parsed, -0) ||
+    (Number.isInteger(parsed) && !Number.isSafeInteger(parsed))
+  ) {
+    return false;
+  }
+  const original = canonicalDecimalToken(token);
+  const serialized = canonicalDecimalToken(JSON.stringify(parsed));
+  return original !== undefined && original === serialized;
+}