mixdog 1.3.4 → 1.4.0

package/src/runtime/agent/orchestrator/providers/devin-wire-session.mjs

@@ -0,0 +1,190 @@
+// Devin request identity and the session-token -> user JWT exchange.
+import { isIP } from 'node:net';
+import { DEVIN_ENUMS } from './devin-wire-protobuf.mjs';
+import { DevinWireError, devinUnary } from './devin-wire-transport.mjs';
+
+export const DEVIN_DEFAULT_BASE_URL = 'https://server.codeium.com';
+export const DEVIN_GET_USER_JWT_PATH = '/exa.auth_pb.AuthService/GetUserJwt';
+// Unary; metadata is `devinRequestMetadata({ apiKey })` with the apiKey the
+// JWT exchange accepted and no userJwt. See AssignModelRequest.
+export const DEVIN_ASSIGN_MODEL_PATH = '/exa.api_server_pb.ApiServerService/AssignModel';
+export const DEVIN_SESSION_TOKEN_PREFIX = 'devin-session-token$';
+
+const DEVIN_OS = { darwin: 'darwin', win32: 'windows' }[process.platform] ?? 'linux';
+
+// Released CLI identity used for auth and chat. The backend gates the CLI
+// model surface and router assignment on this tuple.
+const CLI_IDENTITY = Object.freeze({
+  ideName: 'devin-cli',
+  ideType: 'chisel',
+  ideVersion: '3000.11.3',
+  extensionName: 'chisel',
+  extensionVersion: '3000.11.3',
+});
+
+// Dev-channel identity that unlocks the full native model config set.
+const DISCOVERY_IDENTITY = Object.freeze({
+  ideName: 'chisel',
+  ideVersion: '0.0.0-dev',
+  extensionName: 'chisel',
+  extensionVersion: '0.0.0-dev',
+});
+
+// Editor identity under which legacy Windsurf Enterprise seats expose their
+// full roster (with the raw, unprefixed key); sent without `os`.
+const LEGACY_IDENTITY = Object.freeze({
+  ideName: 'windsurf',
+  ideVersion: '3.2.23',
+  extensionName: 'windsurf',
+  extensionVersion: '1.48.2',
+});
+
+// Display slots the native client advertises for discovery; UNSPECIFIED (0)
+// is implicit. Asking for the internal slots returns the full catalog, which
+// is then filtered client-side.
+const { DisplayOption } = DEVIN_ENUMS;
+export const DEVIN_SUPPORTED_MODEL_DISPLAYS = Object.freeze([
+  DisplayOption.MODEL_ROUTER,
+  DisplayOption.QUICK_REVIEW,
+  DisplayOption.INTERNAL_DEFAULT,
+  DisplayOption.UNCLASSIFIED,
+  DisplayOption.NORMAL,
+]);
+
+// The session token as the wire carries it: the scheme prefix is required.
+export function normalizeDevinSessionToken(token) {
+  const value = String(token || '');
+  if (!value) return '';
+  return value.startsWith(DEVIN_SESSION_TOKEN_PREFIX) ? value : `${DEVIN_SESSION_TOKEN_PREFIX}${value}`;
+}
+
+// `Metadata` for every Devin call. `apiKey` is sent exactly as given (use
+// normalizeDevinSessionToken for session tokens). client: 'cli' (auth, chat),
+// 'discovery' (GetCliModelConfigs) or 'legacy' (legacy discovery fallback).
+export function devinRequestMetadata({ apiKey = '', userJwt = '', client = 'cli' } = {}) {
+  if (client === 'discovery') {
+    return {
+      apiKey,
+      ...DISCOVERY_IDENTITY,
+      locale: 'en',
+      os: DEVIN_OS,
+      supportedModelDisplays: [...DEVIN_SUPPORTED_MODEL_DISPLAYS],
+    };
+  }
+  if (client === 'legacy') return { apiKey, ...LEGACY_IDENTITY, locale: 'en' };
+  return { apiKey, userJwt, ...CLI_IDENTITY, locale: 'en', os: DEVIN_OS };
+}
+
+function isPrivateIPv4(address) {
+  const [a, b] = address.split('.').map(Number);
+  return (
+    a === 0 ||
+    a === 10 ||
+    a === 127 ||
+    (a === 100 && b >= 64 && b <= 127) ||
+    (a === 169 && b === 254) ||
+    (a === 172 && b >= 16 && b <= 31) ||
+    (a === 192 && b === 168) ||
+    (a === 198 && (b === 18 || b === 19)) ||
+    a >= 224
+  );
+}
+
+function isPrivateIPv6(address) {
+  const value = address.toLowerCase();
+  if (value === '::' || value === '::1') return true;
+  const mapped = value.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  if (mapped) return isPrivateIPv4(mapped[1]);
+  // WHATWG URL serializes mapped IPv4 as hex groups (::ffff:7f00:1).
+  const mappedHex = value.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+  if (mappedHex) {
+    const high = parseInt(mappedHex[1], 16);
+    const low = parseInt(mappedHex[2], 16);
+    return isPrivateIPv4(`${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`);
+  }
+  return /^f[cd]/.test(value) || /^fe[89ab]/.test(value) || /^ff/.test(value);
+}
+
+function rejectApiHost(reason) {
+  return new DevinWireError(`Devin returned an unsafe API host: ${reason}`, {
+    code: 'protocol',
+    retryable: false,
+  });
+}
+
+// Validates a server-supplied API host before any credential is sent to it.
+// Only public https origins (optionally with a path) are accepted; returns
+// the normalized base URL without a trailing slash.
+export function validateDevinApiHost(value) {
+  let url;
+  try {
+    url = new URL(String(value || '').trim());
+  } catch {
+    throw rejectApiHost('not a URL');
+  }
+  if (url.protocol !== 'https:') throw rejectApiHost('https is required');
+  if (url.username || url.password) throw rejectApiHost('embedded credentials');
+  if (url.search || url.hash) throw rejectApiHost('query or fragment');
+  const hostname = url.hostname
+    .replace(/^\[|\]$/g, '')
+    .replace(/\.$/, '')
+    .toLowerCase();
+  if (!hostname) throw rejectApiHost('missing host');
+  const family = isIP(hostname);
+  if (family === 4 && isPrivateIPv4(hostname)) throw rejectApiHost('private address');
+  if (family === 6 && isPrivateIPv6(hostname)) throw rejectApiHost('private address');
+  if (!family) {
+    if (!hostname.includes('.')) throw rejectApiHost('single-label host');
+    if (/(?:^|\.)(?:localhost|local|internal|localdomain|home\.arpa)$/.test(hostname)) {
+      throw rejectApiHost('local host name');
+    }
+  }
+  return `${url.origin}${url.pathname.replace(/\/+$/, '')}`;
+}
+
+async function requestUserJwt({ apiKey, baseUrl, fetchFn, signal }) {
+  return devinUnary({
+    baseUrl,
+    path: DEVIN_GET_USER_JWT_PATH,
+    requestType: 'GetUserJwtRequest',
+    responseType: 'GetUserJwtResponse',
+    message: { metadata: devinRequestMetadata({ apiKey }) },
+    fetchFn,
+    signal,
+  });
+}
+
+// Exchanges a Devin session token for the user JWT chat calls carry.
+// Returns { jwt, apiKey, apiHost? }: `apiKey` is the wire key that was
+// accepted (the prefixed session token, or the raw token for legacy keys),
+// to be reused in `Metadata.apiKey`; `apiHost` is the validated per-account
+// API server when the server names one.
+export async function exchangeDevinUserJwt({
+  sessionToken,
+  fetchFn = fetch,
+  signal,
+  baseUrl = DEVIN_DEFAULT_BASE_URL,
+}) {
+  const raw = String(sessionToken || '');
+  if (!raw) {
+    throw new DevinWireError('Devin session token is missing', { code: 'unauthenticated', status: 401 });
+  }
+  let apiKey = normalizeDevinSessionToken(raw);
+  let response;
+  try {
+    response = await requestUserJwt({ apiKey, baseUrl, fetchFn, signal });
+  } catch (error) {
+    // Raw API keys are rejected (HTTP 401) with the session prefix; retry them as-is.
+    if (!(error instanceof DevinWireError) || error.status !== 401 || raw === apiKey) throw error;
+    apiKey = raw;
+    response = await requestUserJwt({ apiKey, baseUrl, fetchFn, signal });
+  }
+  const jwt = String(response.userJwt || '');
+  if (!jwt) throw new DevinWireError('Devin GetUserJwt returned no user JWT', { code: 'protocol' });
+  const customHost = String(response.customApiServerUrl || '').trim();
+  return {
+    jwt,
+    apiKey,
+    ...(customHost ? { apiHost: validateDevinApiHost(customHost) } : {}),
+  };
+}

package/src/runtime/agent/orchestrator/providers/devin-wire-tool-args.mjs

@@ -0,0 +1,351 @@
+// Final parse of a Devin tool call's streamed arguments.
+//
+// Empty or whitespace-only arguments are `{}` (zero-argument tools may omit
+// them). Valid JSON parses as is; otherwise a tolerant grammar repairs the
+// common model malformations:
+//   - single-quoted strings and unquoted object keys;
+//   - stray / doubled / trailing commas, `//` and block comments;
+//   - Python `True` / `False` / `None`, relaxed numbers (`+1`, `.5`, `0x1f`);
+//   - invalid `\x` escapes kept literally;
+//   - an apostrophe inside a single-quoted string (`'it's'`) stays content;
+//   - an unquoted string value (`{"paths": src/*}`) up to `,` `}` `]` or newline.
+// Truncated input, trailing garbage, non-finite numbers and barewords that
+// could swallow a sibling field still fail: the call then carries Mixdog's
+// invalid-arguments marker and never runs with half-formed arguments.
+import { makeInvalidToolArgsMarker } from './lib/openai-tool-args.mjs';
+
+const QUOTE = 0x22;
+const SQUOTE = 0x27;
+const BACKSLASH = 0x5c;
+const SLASH = 0x2f;
+const COLON = 0x3a;
+const COMMA = 0x2c;
+const LBRACE = 0x7b;
+const RBRACE = 0x7d;
+const LBRACKET = 0x5b;
+const RBRACKET = 0x5d;
+
+const KEYWORDS = Object.freeze([
+  ['true', true],
+  ['false', false],
+  ['null', null],
+  ['True', true],
+  ['False', false],
+  ['None', null],
+]);
+// Atoms never recovered as strings: a tool must not run with a non-finite or
+// undefined value posing as text.
+const NON_RECOVERABLE_BAREWORDS = new Set(['NaN', 'Infinity', '-Infinity', '+Infinity', 'undefined']);
+const SIMPLE_ESCAPES = Object.freeze({
+  [QUOTE]: '"',
+  [SQUOTE]: "'",
+  [BACKSLASH]: '\\',
+  [SLASH]: '/',
+  98: '\b',
+  102: '\f',
+  110: '\n',
+  114: '\r',
+  116: '\t',
+});
+
+const isWhitespace = (cp) => cp === 0x20 || cp === 0x09 || cp === 0x0a || cp === 0x0d;
+const isHexDigit = (cp) => (cp >= 0x30 && cp <= 0x39) || ((cp | 0x20) >= 0x61 && (cp | 0x20) <= 0x66);
+const isIdentChar = (cp) =>
+  (cp >= 0x30 && cp <= 0x39) || ((cp | 0x20) >= 0x61 && (cp | 0x20) <= 0x7a) || cp === 0x5f || cp === 0x24;
+const isNumberStart = (cp) => cp === 0x2d || cp === 0x2b || cp === 0x2e || (cp >= 0x30 && cp <= 0x39);
+const isNumberChar = (cp) =>
+  (cp >= 0x30 && cp <= 0x39) ||
+  cp === 0x2d ||
+  cp === 0x2b ||
+  cp === 0x2e ||
+  ((cp | 0x20) >= 0x61 && (cp | 0x20) <= 0x66) ||
+  (cp | 0x20) === 0x78;
+
+// The first index at or after `i` past whitespace and comments.
+function skipInsignificant(s, i) {
+  const n = s.length;
+  for (;;) {
+    while (i < n && isWhitespace(s.charCodeAt(i))) i += 1;
+    if (i + 1 < n && s.charCodeAt(i) === SLASH) {
+      const next = s.charCodeAt(i + 1);
+      if (next === SLASH) {
+        i += 2;
+        while (i < n && s.charCodeAt(i) !== 0x0a) i += 1;
+        continue;
+      }
+      if (next === 0x2a) {
+        i += 2;
+        while (i + 1 < n && !(s.charCodeAt(i) === 0x2a && s.charCodeAt(i + 1) === SLASH)) i += 1;
+        i = Math.min(i + 2, n);
+        continue;
+      }
+    }
+    return i;
+  }
+}
+
+function hex4(s, pos) {
+  if (pos + 4 > s.length) return -1;
+  for (let k = pos; k < pos + 4; k += 1) if (!isHexDigit(s.charCodeAt(k))) return -1;
+  return Number.parseInt(s.slice(pos, pos + 4), 16);
+}
+
+function setOwn(target, key, value) {
+  Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+}
+
+class TolerantJsonParser {
+  constructor(src) {
+    this.src = src;
+    this.pos = 0;
+  }
+
+  peek() {
+    return this.src.charCodeAt(this.pos);
+  }
+
+  get atEnd() {
+    return this.pos >= this.src.length;
+  }
+
+  ws() {
+    this.pos = skipInsignificant(this.src, this.pos);
+  }
+
+  fail(message) {
+    throw new SyntaxError(message);
+  }
+
+  parse() {
+    this.ws();
+    if (this.atEnd) this.fail('Unexpected end of JSON input');
+    const value = this.value(false);
+    this.ws();
+    if (!this.atEnd) this.fail(`Unexpected trailing characters at position ${this.pos}`);
+    return value;
+  }
+
+  value(allowBareword) {
+    const c = this.peek();
+    if (c === LBRACE) return this.object();
+    if (c === LBRACKET) return this.array();
+    if (c === QUOTE || c === SQUOTE) return this.string(c);
+    if (isNumberStart(c)) return this.number();
+    const keyword = this.keyword();
+    if (keyword !== undefined) return keyword;
+    if (allowBareword) return this.bareword();
+    return this.fail(`Unexpected token at position ${this.pos}`);
+  }
+
+  object() {
+    this.pos += 1;
+    const out = {};
+    for (;;) {
+      this.ws();
+      if (this.atEnd) this.fail('Unterminated object');
+      const c = this.peek();
+      if (c === RBRACE) {
+        this.pos += 1;
+        return out;
+      }
+      if (c === COMMA) {
+        this.pos += 1;
+        continue;
+      }
+      const key = this.key();
+      this.ws();
+      if (this.peek() !== COLON) this.fail("Expected ':' in object");
+      this.pos += 1;
+      this.ws();
+      if (this.atEnd) this.fail("Expected value after ':'");
+      setOwn(out, key, this.value(true));
+      this.ws();
+      const d = this.peek();
+      if (d === COMMA) {
+        this.pos += 1;
+        continue;
+      }
+      if (d === RBRACE) {
+        this.pos += 1;
+        return out;
+      }
+      this.fail("Expected ',' or '}' in object");
+    }
+  }
+
+  array() {
+    this.pos += 1;
+    const out = [];
+    for (;;) {
+      this.ws();
+      if (this.atEnd) this.fail('Unterminated array');
+      const c = this.peek();
+      if (c === RBRACKET) {
+        this.pos += 1;
+        return out;
+      }
+      if (c === COMMA) {
+        this.pos += 1;
+        continue;
+      }
+      out.push(this.value(true));
+      this.ws();
+      const d = this.peek();
+      if (d === COMMA) {
+        this.pos += 1;
+        continue;
+      }
+      if (d === RBRACKET) {
+        this.pos += 1;
+        return out;
+      }
+      this.fail("Expected ',' or ']' in array");
+    }
+  }
+
+  key() {
+    const c = this.peek();
+    if (c === QUOTE || c === SQUOTE) return this.string(c);
+    const s = this.src;
+    const start = this.pos;
+    while (this.pos < s.length) {
+      const cc = s.charCodeAt(this.pos);
+      if (cc === COLON || cc === COMMA || cc === RBRACE || isWhitespace(cc)) break;
+      this.pos += 1;
+    }
+    if (this.pos === start) this.fail('Expected object key');
+    return s.slice(start, this.pos);
+  }
+
+  // A single quote closes only before a value terminator (or the end), so an
+  // apostrophe stays content; a double quote always closes.
+  closesSingleQuote(from) {
+    const k = skipInsignificant(this.src, from);
+    if (k >= this.src.length) return true;
+    const c = this.src.charCodeAt(k);
+    return c === COMMA || c === RBRACE || c === RBRACKET || c === COLON;
+  }
+
+  string(quote) {
+    const s = this.src;
+    const n = s.length;
+    let i = this.pos + 1;
+    let out = '';
+    let runStart = i;
+    while (i < n) {
+      const cc = s.charCodeAt(i);
+      if (cc === quote) {
+        if (quote === QUOTE || this.closesSingleQuote(i + 1)) {
+          out += s.slice(runStart, i);
+          this.pos = i + 1;
+          return out;
+        }
+        i += 1;
+        continue;
+      }
+      if (cc !== BACKSLASH) {
+        i += 1;
+        continue;
+      }
+      out += s.slice(runStart, i);
+      i += 1;
+      if (i >= n) break;
+      const esc = s.charCodeAt(i);
+      if (SIMPLE_ESCAPES[esc] !== undefined) {
+        out += SIMPLE_ESCAPES[esc];
+      } else if (esc === 0x75) {
+        const unit = hex4(s, i + 1);
+        if (unit >= 0) {
+          out += String.fromCharCode(unit);
+          i += 4;
+        } else {
+          out += '\\u';
+        }
+      } else {
+        out += `\\${s[i]}`;
+      }
+      i += 1;
+      runStart = i;
+    }
+    return this.fail('Unterminated string');
+  }
+
+  number() {
+    const s = this.src;
+    const start = this.pos;
+    while (this.pos < s.length && isNumberChar(s.charCodeAt(this.pos))) this.pos += 1;
+    const token = s.slice(start, this.pos);
+    const value = Number(token);
+    if (!Number.isFinite(value)) this.fail(`Invalid number: ${token}`);
+    return value;
+  }
+
+  keyword() {
+    for (const [word, value] of KEYWORDS) {
+      if (this.src.startsWith(word, this.pos) && !isIdentChar(this.src.charCodeAt(this.pos + word.length))) {
+        this.pos += word.length;
+        return value;
+      }
+    }
+    return undefined;
+  }
+
+  // An unquoted value up to `,` `}` `]` or a newline, trailing space trimmed.
+  // It fails at the end of input and on `"`, `{`, `[` or a key-like `:`
+  // (a missed comma must not swallow the next field); `:/` and `:\` stay
+  // literal so URLs and Windows paths recover.
+  bareword() {
+    const s = this.src;
+    const start = this.pos;
+    let i = start;
+    while (i < s.length) {
+      const cc = s.charCodeAt(i);
+      if (cc === COMMA || cc === RBRACE || cc === RBRACKET || cc === 0x0a || cc === 0x0d) break;
+      const next = s.charCodeAt(i + 1);
+      if (cc === QUOTE || cc === LBRACE || cc === LBRACKET || (cc === COLON && next !== SLASH && next !== BACKSLASH)) {
+        return this.fail(`Unexpected token at position ${start}`);
+      }
+      i += 1;
+    }
+    if (i >= s.length) return this.fail(`Unexpected token at position ${start}`);
+    let end = i;
+    while (end > start && isWhitespace(s.charCodeAt(end - 1))) end -= 1;
+    const word = s.slice(start, end);
+    if (NON_RECOVERABLE_BAREWORDS.has(word)) return this.fail(`Unexpected token at position ${start}`);
+    this.pos = i;
+    return word;
+  }
+}
+
+/** A JSON value with the common model malformations repaired; throws when unrepairable. */
+export function parseDevinJsonWithRepair(json) {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return new TolerantJsonParser(json).parse();
+  }
+}
+
+/** Final tool-call arguments: `{}` when empty, else repaired JSON, else the invalid-arguments marker. */
+export function parseDevinToolArguments(raw) {
+  const text = typeof raw === 'string' ? raw : String(raw ?? '');
+  if (!text.trim()) return {};
+  try {
+    return parseDevinJsonWithRepair(text);
+  } catch (error) {
+    return makeInvalidToolArgsMarker(text, error instanceof Error ? error.message : String(error));
+  }
+}
+
+/** parseToolCalls for the compat stream consumer, with Devin's final argument parse. */
+export function parseDevinToolCalls(choice) {
+  const calls = choice?.message?.tool_calls;
+  if (!calls?.length) return undefined;
+  return calls
+    .filter((call) => call.type === 'function')
+    .map((call) => ({
+      id: call.id,
+      name: call.function.name,
+      arguments: parseDevinToolArguments(call.function.arguments),
+    }));
+}