devin-oauth-opencode 0.2.0

package/dist/model-discovery.js

@@ -0,0 +1,340 @@
+import crypto from "node:crypto";
+import { estimateDevinModelCost, getFallbackDevinModels } from "./models";
+// Required picker models. They must remain visible even if live discovery
+// omits them or returns a partial list.
+const REQUIRED_MODEL_IDS = ["glm-5-2", "swe-1.6-fast", "swe-1.6", "swe-1.5-fast", "adaptive"];
+function mergeRequiredDevinModels(discovered) {
+    const byId = new Map();
+    const fallbackById = new Map(getFallbackDevinModels().map((model) => [model.id, model]));
+    for (const model of discovered) {
+        const cost = model.cost ?? estimateDevinModelCost(model.id);
+        byId.set(model.id, { ...model, cost });
+    }
+    for (const requiredId of REQUIRED_MODEL_IDS) {
+        if (byId.has(requiredId))
+            continue;
+        const fallback = fallbackById.get(requiredId);
+        if (fallback) {
+            byId.set(requiredId, {
+                ...fallback,
+                cost: fallback.cost ?? estimateDevinModelCost(fallback.id),
+            });
+        }
+    }
+    return [...byId.values()];
+}
+export function getRequiredDevinModelIds() {
+    return REQUIRED_MODEL_IDS;
+}
+const CODEIUM_API_ORIGIN = "https://server.codeium.com";
+const GET_CLI_MODEL_CONFIGS_PATH = "/exa.api_server_pb.ApiServerService/GetCliModelConfigs";
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+const DEFAULT_MAX_TOKENS = 64_000;
+const MODEL_CACHE_TTL_MS = 10 * 60_000;
+const DEFAULT_DISCOVERY_TIMEOUT_MS = 2_000;
+function encodeVarint(value) {
+    const bytes = [];
+    let current = BigInt(value);
+    while (current > 127n) {
+        bytes.push(Number(current & 0x7fn) | 0x80);
+        current >>= 7n;
+    }
+    bytes.push(Number(current));
+    return bytes;
+}
+function encodeString(fieldNum, value) {
+    const bytes = Buffer.from(value, "utf8");
+    return Buffer.from([
+        ...encodeVarint((fieldNum << 3) | 2),
+        ...encodeVarint(bytes.length),
+        ...bytes,
+    ]);
+}
+function connectEnvelope(payload) {
+    const frame = Buffer.alloc(5);
+    frame[0] = 0;
+    frame.writeUInt32BE(payload.length, 1);
+    return Buffer.concat([frame, payload]);
+}
+function encodeBytes(fieldNum, value) {
+    return Buffer.from([
+        ...encodeVarint((fieldNum << 3) | 2),
+        ...encodeVarint(value.length),
+        ...value,
+    ]);
+}
+function buildGetCliModelConfigsRequest(apiKey, version) {
+    // Captured Devin CLI traffic sends a field-1 metadata message over application/proto.
+    return encodeBytes(1, Buffer.concat([
+        encodeString(1, "chisel"),
+        encodeString(2, version),
+        encodeString(3, apiKey),
+        encodeString(4, "en"),
+        encodeString(5, process.platform === "darwin" ? "mac" : process.platform),
+        encodeString(7, version),
+        encodeString(12, "chisel"),
+        encodeBytes(30, Buffer.from([3, 4, 6])),
+        encodeString(31, crypto.randomBytes(366).toString("hex")),
+    ]));
+}
+function readVarint(buffer, offset) {
+    let value = 0n;
+    let shift = 0n;
+    let next = offset;
+    while (next < buffer.length) {
+        const byte = buffer[next];
+        value |= BigInt(byte & 0x7f) << shift;
+        next++;
+        if (byte < 0x80)
+            return { value, next };
+        shift += 7n;
+    }
+    return null;
+}
+function parseFields(buffer) {
+    const fields = [];
+    let offset = 0;
+    while (offset < buffer.length) {
+        const key = readVarint(buffer, offset);
+        if (!key)
+            break;
+        offset = key.next;
+        const fieldNum = Number(key.value >> 3n);
+        const wireType = Number(key.value & 7n);
+        if (wireType === 0) {
+            const value = readVarint(buffer, offset);
+            if (!value)
+                break;
+            fields.push({ fieldNum, wireType, value: value.value });
+            offset = value.next;
+        }
+        else if (wireType === 1) {
+            const end = offset + 8;
+            if (end > buffer.length)
+                break;
+            fields.push({ fieldNum, wireType, value: buffer.subarray(offset, end) });
+            offset = end;
+        }
+        else if (wireType === 2) {
+            const length = readVarint(buffer, offset);
+            if (!length)
+                break;
+            offset = length.next;
+            const end = offset + Number(length.value);
+            if (end > buffer.length)
+                break;
+            fields.push({ fieldNum, wireType, value: buffer.subarray(offset, end) });
+            offset = end;
+        }
+        else if (wireType === 5) {
+            const end = offset + 4;
+            if (end > buffer.length)
+                break;
+            fields.push({ fieldNum, wireType, value: buffer.subarray(offset, end) });
+            offset = end;
+        }
+        else {
+            break;
+        }
+    }
+    return fields;
+}
+function parseConnectEnvelopes(buffer) {
+    const envelopes = [];
+    let offset = 0;
+    while (offset + 5 <= buffer.length) {
+        const flags = buffer[offset];
+        const length = buffer.readUInt32BE(offset + 1);
+        offset += 5;
+        const end = offset + length;
+        if (end > buffer.length)
+            break;
+        envelopes.push({ flags, body: buffer.subarray(offset, end) });
+        offset = end;
+    }
+    return envelopes;
+}
+function readFloat32(value) {
+    if (value.length < 4)
+        return undefined;
+    return Number(value.readFloatLE(0).toPrecision(6));
+}
+function normalizeModelId(value) {
+    const normalized = value
+        .trim()
+        .replace(/^MODEL_/i, "")
+        .replace(/_/g, "-")
+        .replace(/SWE-(\d+)-(\d+)/i, "swe-$1.$2")
+        .toLowerCase();
+    if (normalized === "swe-1.5")
+        return "swe-1.5-fast";
+    if (normalized === "swe-1.5-slow")
+        return "swe-1.5";
+    return normalized;
+}
+function firstString(fields, fieldNum) {
+    const value = fields.find((field) => field.fieldNum === fieldNum && Buffer.isBuffer(field.value))?.value;
+    return Buffer.isBuffer(value) ? value.toString("utf8").trim() : undefined;
+}
+function parseCostEntry(buffer) {
+    const fields = parseFields(buffer);
+    const label = firstString(fields, 1);
+    const rawValue = fields.find((field) => field.fieldNum === 4 && Buffer.isBuffer(field.value))?.value;
+    const value = Buffer.isBuffer(rawValue) ? readFloat32(rawValue) : undefined;
+    if (!label || value === undefined)
+        return null;
+    return { label, value };
+}
+function parseModelConfig(buffer) {
+    const fields = parseFields(buffer);
+    const name = firstString(fields, 1);
+    const uid = firstString(fields, 22) ?? firstString(fields, 18) ?? firstString(fields, 2);
+    if (!name || !uid)
+        return null;
+    const costEntries = new Map();
+    for (const field of fields) {
+        if (![16, 32].includes(field.fieldNum) || !Buffer.isBuffer(field.value))
+            continue;
+        const entry = parseCostEntry(field.value);
+        if (entry)
+            costEntries.set(entry.label.toLowerCase(), entry.value);
+    }
+    const input = costEntries.get("input");
+    const cachedInput = costEntries.get("cached input");
+    const output = costEntries.get("output");
+    const cost = input !== undefined || cachedInput !== undefined || output !== undefined
+        ? {
+            input: input ?? 0,
+            output: output ?? 0,
+            cache: { read: cachedInput ?? 0, write: 0 },
+        }
+        : undefined;
+    return {
+        id: normalizeModelId(uid),
+        modelUid: uid,
+        name,
+        cost,
+    };
+}
+function parseModelConfigs(buffer) {
+    const configs = [];
+    const envelopes = parseConnectEnvelopes(buffer);
+    const bodies = envelopes.length > 0
+        ? envelopes.filter((envelope) => envelope.flags !== 2).map((envelope) => envelope.body)
+        : [buffer];
+    for (const body of bodies) {
+        for (const field of parseFields(body)) {
+            if (field.fieldNum !== 1 || !Buffer.isBuffer(field.value))
+                continue;
+            const config = parseModelConfig(field.value);
+            if (config)
+                configs.push(config);
+        }
+    }
+    return configs;
+}
+function toDevinModel(config) {
+    return {
+        id: config.id,
+        name: config.name,
+        enumValue: 0,
+        modelUid: config.modelUid,
+        reasoning: true,
+        contextWindow: DEFAULT_CONTEXT_WINDOW,
+        maxTokens: DEFAULT_MAX_TOKENS,
+        cost: config.cost,
+    };
+}
+async function callGetCliModelConfigs(apiKey, version, timeoutMs = DEFAULT_DISCOVERY_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+        response = await fetch(`${CODEIUM_API_ORIGIN}${GET_CLI_MODEL_CONFIGS_PATH}`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/proto",
+                "connect-protocol-version": "1",
+                authorization: `Basic ${apiKey}-${apiKey}`,
+            },
+            body: new Uint8Array(buildGetCliModelConfigsRequest(apiKey, version)),
+            signal: controller.signal,
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    if (!response.ok) {
+        throw new Error(`Model config request failed with ${response.status}`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+}
+let cachedModelKey = "";
+let cachedModels = null;
+let cachedModelTime = 0;
+let inFlightModelKey = "";
+let inFlightModels = null;
+function discoveryCacheKey(apiKey, version) {
+    return `${crypto.createHash("sha256").update(apiKey).digest("hex").slice(0, 16)}:${version}`;
+}
+function isCacheFresh(cacheKey, now = Date.now()) {
+    return Boolean(cachedModels && cachedModelKey === cacheKey && now - cachedModelTime < MODEL_CACHE_TTL_MS);
+}
+export function getCachedDevinModels(apiKey, version = "3000.1.23") {
+    if (!apiKey || apiKey === "devin-local") {
+        return mergeRequiredDevinModels(getFallbackDevinModels());
+    }
+    const cacheKey = discoveryCacheKey(apiKey, version);
+    if (cachedModels && cachedModelKey === cacheKey)
+        return cachedModels;
+    return mergeRequiredDevinModels(getFallbackDevinModels());
+}
+export async function getDiscoveredDevinModels(apiKey, version = "3000.1.23", options = {}) {
+    if (!apiKey || apiKey === "devin-local") {
+        return mergeRequiredDevinModels(getFallbackDevinModels());
+    }
+    const cacheKey = discoveryCacheKey(apiKey, version);
+    if (isCacheFresh(cacheKey))
+        return cachedModels;
+    if (inFlightModels && inFlightModelKey === cacheKey)
+        return inFlightModels;
+    inFlightModelKey = cacheKey;
+    inFlightModels = (async () => {
+        try {
+            const response = await callGetCliModelConfigs(apiKey, version, options.timeoutMs);
+            const discovered = parseModelConfigs(response).map(toDevinModel);
+            const base = discovered.length > 0 ? discovered : getFallbackDevinModels();
+            cachedModels = mergeRequiredDevinModels(base);
+            cachedModelKey = cacheKey;
+            cachedModelTime = Date.now();
+        }
+        catch {
+            if (!(options.allowStale ?? true) || cachedModelKey !== cacheKey || !cachedModels) {
+                cachedModels = mergeRequiredDevinModels(getFallbackDevinModels());
+                cachedModelKey = cacheKey;
+                cachedModelTime = Date.now();
+            }
+        }
+        finally {
+            inFlightModelKey = "";
+            inFlightModels = null;
+        }
+        return cachedModels;
+    })();
+    return inFlightModels;
+}
+export function clearDiscoveredModelCache() {
+    cachedModelKey = "";
+    cachedModels = null;
+    cachedModelTime = 0;
+    inFlightModelKey = "";
+    inFlightModels = null;
+}
+export const __test = {
+    clearDiscoveredModelCache,
+    connectEnvelope,
+    encodeString,
+    parseConnectEnvelopes,
+    parseFields,
+    parseModelConfigs,
+};

package/dist/models.d.ts

@@ -0,0 +1,27 @@
+export declare const DEVIN_PROVIDER_ID = "devin";
+export declare const DEVIN_PROVIDER_NPM = "@ai-sdk/openai-compatible";
+export interface DevinModel {
+    id: string;
+    name: string;
+    enumValue: number;
+    modelUid: string;
+    reasoning: boolean;
+    contextWindow: number;
+    maxTokens: number;
+    cost?: ModelCost;
+}
+export interface ModelCost {
+    input: number;
+    output: number;
+    cache: {
+        read: number;
+        write: number;
+    };
+}
+export declare function estimateDevinModelCost(modelId: string): ModelCost;
+export declare function getDefaultModel(): DevinModel;
+export declare function getFallbackDevinModels(): DevinModel[];
+export declare function setDevinModels(models: readonly DevinModel[]): void;
+export declare function getDevinModels(): DevinModel[];
+export declare function resolveDevinModel(modelId?: string): DevinModel;
+export declare function buildDevinProviderModels(port: number, models?: readonly DevinModel[]): Record<string, any>;

package/dist/models.js

@@ -0,0 +1,150 @@
+export const DEVIN_PROVIDER_ID = "devin";
+export const DEVIN_PROVIDER_NPM = "@ai-sdk/openai-compatible";
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+const DEFAULT_MAX_TOKENS = 64_000;
+const FALLBACK_MODELS = [
+    {
+        id: "swe-1.6-fast",
+        name: "SWE 1.6 Fast",
+        enumValue: 421,
+        modelUid: "swe-1-6-fast",
+        reasoning: true,
+        contextWindow: DEFAULT_CONTEXT_WINDOW,
+        maxTokens: DEFAULT_MAX_TOKENS,
+    },
+    {
+        id: "glm-5-2",
+        name: "GLM-5.2 High",
+        enumValue: 0,
+        modelUid: "glm-5-2",
+        reasoning: true,
+        contextWindow: DEFAULT_CONTEXT_WINDOW,
+        maxTokens: DEFAULT_MAX_TOKENS,
+    },
+    {
+        id: "swe-1.6",
+        name: "SWE 1.6",
+        enumValue: 420,
+        modelUid: "swe-1-6",
+        reasoning: true,
+        contextWindow: DEFAULT_CONTEXT_WINDOW,
+        maxTokens: DEFAULT_MAX_TOKENS,
+    },
+    {
+        id: "swe-1.5-fast",
+        name: "SWE 1.5 Fast",
+        enumValue: 359,
+        modelUid: "swe-1-5",
+        reasoning: true,
+        contextWindow: DEFAULT_CONTEXT_WINDOW,
+        maxTokens: DEFAULT_MAX_TOKENS,
+    },
+    {
+        id: "adaptive",
+        name: "Adaptive",
+        enumValue: 0,
+        modelUid: "adaptive",
+        reasoning: true,
+        contextWindow: DEFAULT_CONTEXT_WINDOW,
+        maxTokens: DEFAULT_MAX_TOKENS,
+    },
+];
+const ALIASES = {
+    "glm-5.2": "glm-5-2",
+    "glm-5-2-high": "glm-5-2",
+    "swe-1-6-fast": "swe-1.6-fast",
+    "swe-1.6:fast": "swe-1.6-fast",
+    "swe-1-6": "swe-1.6",
+    "swe-1-5-fast": "swe-1.5-fast",
+    "swe-1.5:fast": "swe-1.5-fast",
+    "MODEL_SWE_1_6_FAST": "swe-1.6-fast",
+    "MODEL_SWE_1_6": "swe-1.6",
+    "MODEL_SWE_1_5": "swe-1.5-fast",
+    MODEL_ADAPTIVE: "adaptive",
+};
+const MODEL_BY_ID = new Map(FALLBACK_MODELS.map((model) => [model.id, model]));
+// $/M token rates from Devin model docs/API. Dynamic discovery overrides these when available.
+const MODEL_COST_TABLE = {
+    "glm-5-2": { input: 0.3, output: 1.5, cache: { read: 0.03, write: 0 } },
+    "swe-1.6-fast": { input: 0.3, output: 1.5, cache: { read: 0.03, write: 0 } },
+    "swe-1.6": { input: 0.3, output: 1.5, cache: { read: 0.03, write: 0 } },
+    "swe-1.5-fast": { input: 0.3, output: 1.5, cache: { read: 0.03, write: 0 } },
+    "adaptive": { input: 0.3, output: 1.5, cache: { read: 0.03, write: 0 } },
+};
+const DEFAULT_COST = { input: 0, output: 0, cache: { read: 0, write: 0 } };
+let activeModels = [...FALLBACK_MODELS];
+function canonicalModelId(modelId) {
+    const normalized = modelId.trim().replace(/^devin\//i, "").replace(/_/g, "-").toLowerCase();
+    return ALIASES[modelId.trim()] ?? ALIASES[normalized] ?? normalized;
+}
+export function estimateDevinModelCost(modelId) {
+    return MODEL_COST_TABLE[canonicalModelId(modelId)] ?? DEFAULT_COST;
+}
+export function getDefaultModel() {
+    return FALLBACK_MODELS[0];
+}
+export function getFallbackDevinModels() {
+    return [...FALLBACK_MODELS];
+}
+export function setDevinModels(models) {
+    activeModels = models.length > 0 ? [...models] : [...FALLBACK_MODELS];
+}
+export function getDevinModels() {
+    return [...activeModels];
+}
+export function resolveDevinModel(modelId) {
+    if (!modelId)
+        return getDefaultModel();
+    const resolvedId = canonicalModelId(modelId);
+    return activeModels.find((model) => model.id === resolvedId || model.modelUid === resolvedId)
+        ?? MODEL_BY_ID.get(resolvedId)
+        ?? getDefaultModel();
+}
+export function buildDevinProviderModels(port, models = activeModels) {
+    setDevinModels(models);
+    return Object.fromEntries(models.map((model) => [
+        model.id,
+        {
+            id: model.id,
+            providerID: DEVIN_PROVIDER_ID,
+            api: {
+                id: model.id,
+                url: `http://localhost:${port}/v1`,
+                npm: DEVIN_PROVIDER_NPM,
+            },
+            name: model.name,
+            capabilities: {
+                temperature: true,
+                reasoning: model.reasoning,
+                attachment: false,
+                toolcall: true,
+                input: {
+                    text: true,
+                    audio: false,
+                    image: false,
+                    video: false,
+                    pdf: false,
+                },
+                output: {
+                    text: true,
+                    audio: false,
+                    image: false,
+                    video: false,
+                    pdf: false,
+                },
+                interleaved: false,
+            },
+            cost: model.cost ?? estimateDevinModelCost(model.id),
+            limit: {
+                context: model.contextWindow,
+                input: model.contextWindow,
+                output: model.maxTokens,
+            },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "",
+            variants: {},
+        },
+    ]));
+}

package/dist/proxy.d.ts

@@ -0,0 +1,10 @@
+import { buildDevinProviderModels } from "./models";
+import { type ChatCompletionRequest } from "./devin";
+export declare const DEVIN_PROXY_DEFAULT_PORT = 65534;
+type ChatTransport = (request: ChatCompletionRequest) => AsyncIterable<string> | Promise<AsyncIterable<string> | string> | string;
+export declare function setChatTransportForTests(transport?: ChatTransport): void;
+export declare function getProxyPort(): number | undefined;
+export declare function stopProxy(): void;
+export declare function startProxy(forceLocal?: boolean): Promise<number>;
+export declare function proxyBaseURL(port?: number): string;
+export { buildDevinProviderModels };