@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/devin-DXOeNyU7.mjs

@@ -0,0 +1,542 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { C as error, S as debug, T as warn, _ as parseStreamingJsonThrottled, g as parseStreamingJson } from "./src-DTid0g4K.mjs";
+import { l as finalize, o as DevinApiError, r as ValidationError, s as ProviderResponseError, w as create, x as attach, y as Flag } from "./error-B3bevhrs.mjs";
+import { a as normalizeSystemPrompts, g as isDemotedThinking, k as toolWireSchema, m as transformMessages } from "./utils-2Wq2eATG.mjs";
+import { t as calculateCost } from "./models-CfT4coYT.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-BDPi64mK.mjs";
+import { E as create$1, c as messageDesc, i as fromBinary, r as fileDesc, t as toBinary } from "./to-binary-B1BEBIPC.mjs";
+import { a as ChatMessagePromptSchema, c as PromptCacheOptionsSchema, d as ImageDataSchema, f as MetadataSchema, l as ChatToolCallSchema, m as file_buf_validate_validate, n as GetChatMessageResponseSchema, o as ChatToolChoiceSchema, p as file_exa_codeium_common_pb_codeium_common, s as ChatToolDefinitionSchema, t as GetChatMessageRequestSchema, u as CompletionConfigurationSchema } from "./api_server_pb-CDZgLMta.mjs";
+import { t as deterministicUuid } from "./deterministic-id-D-yIV_eI.mjs";
+import { gunzipSync, gzipSync } from "node:zlib";
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@17.3.5/node_modules/@oh-my-pi/pi-catalog/src/discovery/devin-gen/exa/auth_pb/auth_pb.ts
+/**
+* Describes the file exa/auth_pb/auth.proto.
+*/
+const file_exa_auth_pb_auth = /*@__PURE__*/ fileDesc("ChZleGEvYXV0aF9wYi9hdXRoLnByb3RvEgtleGEuYXV0aF9wYiJGChFHZXRVc2VySnd0UmVxdWVzdBIxCghtZXRhZGF0YRgBIAEoCzIfLmV4YS5jb2RlaXVtX2NvbW1vbl9wYi5NZXRhZGF0YSJFChJHZXRVc2VySnd0UmVzcG9uc2USEAoIdXNlcl9qd3QYASABKAkSHQoVY3VzdG9tX2FwaV9zZXJ2ZXJfdXJsGAIgASgJMlwKC0F1dGhTZXJ2aWNlEk0KCkdldFVzZXJKd3QSHi5leGEuYXV0aF9wYi5HZXRVc2VySnd0UmVxdWVzdBofLmV4YS5hdXRoX3BiLkdldFVzZXJKd3RSZXNwb25zZWIGcHJvdG8z", [file_buf_validate_validate, file_exa_codeium_common_pb_codeium_common]);
+/**
+* Describes the message exa.auth_pb.GetUserJwtRequest.
+* Use `create(GetUserJwtRequestSchema)` to create a new message.
+*/
+const GetUserJwtRequestSchema = /*@__PURE__*/ messageDesc(file_exa_auth_pb_auth, 0);
+/**
+* Describes the message exa.auth_pb.GetUserJwtResponse.
+* Use `create(GetUserJwtResponseSchema)` to create a new message.
+*/
+const GetUserJwtResponseSchema = /*@__PURE__*/ messageDesc(file_exa_auth_pb_auth, 1);
+const CHAT_MESSAGE_PATH = "/exa.api_server_pb.ApiServerService/GetChatMessage";
+const DEVIN_IDE_VERSION = "3.2.23";
+const DEVIN_EXTENSION_VERSION = "1.48.2";
+const DEVIN_SESSION_TOKEN_PREFIX = "devin-session-token$";
+const DEVIN_AUTH_PATH = "/exa.auth_pb.AuthService/GetUserJwt";
+const DEVIN_DEFAULT_STOP_PATTERNS = [
+	"<|user|>",
+	"<|bot|>",
+	"<|context_request|>",
+	"<|endoftext|>",
+	"<|end_of_turn|>"
+];
+/** Connect streaming framing: flag byte bit 0x01 = gzip payload, 0x02 = end-of-stream JSON trailers. */
+const CONNECT_COMPRESSED_FLAG = 1;
+const CONNECT_END_STREAM_FLAG = 2;
+/**
+* Hard upper bound on a single Connect frame payload. The 4-byte length prefix
+* is otherwise attacker-controlled (up to `2**32 - 1`), so a malicious or buggy
+* peer could force {@link streamDevin}'s reader to buffer gigabytes via
+* `Buffer.concat` before the idle-timeout wrapper aborts. Well above any
+* legitimate Cascade response but tight enough that a corrupt length prefix
+* fails fast instead of consuming memory.
+*/
+const MAX_CONNECT_FRAME_PAYLOAD = 16777216;
+/**
+* Recovery heuristic for opaque Devin `invalid_argument` trailers. This is not
+* asserted to be the backend's hard limit: small requests can hit the same
+* intermittent error, while compactable message history this large is likely
+* to benefit from the existing context-overflow maintenance path.
+*/
+const LARGE_HISTORY_RECOVERY_BYTES = 524288;
+const streamDevin = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const startTime = performance.now();
+		let firstTokenTime;
+		const output = {
+			role: "assistant",
+			content: [],
+			api: "devin-agent",
+			provider: model.provider,
+			model: model.id,
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			},
+			stopReason: "stop",
+			timestamp: Date.now()
+		};
+		let currentTextBlock = null;
+		let currentThinkingBlock = null;
+		const toolBlocks = /* @__PURE__ */ new Map();
+		const toolPartialJson = /* @__PURE__ */ new Map();
+		const toolLastParseLen = /* @__PURE__ */ new Map();
+		let activeToolCallId;
+		let latestStopReason = 0;
+		const markFirstToken = () => {
+			if (firstTokenTime === void 0) firstTokenTime = performance.now();
+		};
+		const endTextBlock = () => {
+			const block = currentTextBlock;
+			if (!block) return;
+			currentTextBlock = null;
+			stream.push({
+				type: "text_end",
+				contentIndex: output.content.indexOf(block),
+				content: block.text,
+				partial: output
+			});
+		};
+		const endThinkingBlock = () => {
+			const block = currentThinkingBlock;
+			if (!block) return;
+			currentThinkingBlock = null;
+			stream.push({
+				type: "thinking_end",
+				contentIndex: output.content.indexOf(block),
+				content: block.thinking,
+				partial: output
+			});
+		};
+		try {
+			const fetchImpl = options?.fetch ?? fetch;
+			const baseUrl = (model.baseUrl || "https://server.codeium.com").replace(/\/+$/, "");
+			const apiKey = normalizeDevinSessionToken(options?.apiKey);
+			const auth = await fetchDevinAuthMetadata(apiKey, baseUrl, fetchImpl, options?.signal);
+			const chatBaseUrl = auth.baseUrl ?? baseUrl;
+			const request = buildDevinChatRequest(model, context, options, apiKey, auth.userJwt);
+			const reqBytes = toBinary(GetChatMessageRequestSchema, request);
+			const gz = gzipSync(reqBytes);
+			debug("devin: sending chat request", {
+				model: model.id,
+				tools: context.tools?.length ?? 0,
+				requestBytes: reqBytes.byteLength,
+				compressedBytes: gz.byteLength
+			});
+			const frame = Buffer.alloc(5 + gz.length);
+			frame[0] = CONNECT_COMPRESSED_FLAG;
+			frame.writeUInt32BE(gz.length, 1);
+			frame.set(gz, 5);
+			const response = await fetchImpl(chatBaseUrl + CHAT_MESSAGE_PATH, {
+				method: "POST",
+				headers: {
+					"content-type": "application/connect+proto",
+					"connect-protocol-version": "1",
+					"connect-content-encoding": "gzip",
+					"accept-encoding": "identity",
+					"user-agent": "connect-go/1.18.1 (go1.26.3)",
+					"connect-accept-encoding": "gzip",
+					...options?.headers ?? {}
+				},
+				body: frame,
+				signal: options?.signal
+			});
+			if (!response.ok) {
+				const text = await response.text();
+				throw new DevinApiError(`Devin API error ${response.status} ${response.statusText}: ${text}`, response.status);
+			}
+			if (!response.body) throw new ProviderResponseError("Devin API error: response body is empty", {
+				provider: model.provider,
+				kind: "empty-body"
+			});
+			const body = response.body;
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			const reader = body.getReader();
+			let pending = Buffer.alloc(0);
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (value && value.length > 0) pending = pending.length === 0 ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.concat([pending, value]);
+				while (pending.length >= 5) {
+					const flag = pending[0];
+					const len = pending.readUInt32BE(1);
+					if (len > MAX_CONNECT_FRAME_PAYLOAD) throw new ProviderResponseError(`Devin Connect frame length ${len} exceeds ${MAX_CONNECT_FRAME_PAYLOAD}-byte cap`, {
+						provider: model.provider,
+						kind: "envelope"
+					});
+					if (pending.length < 5 + len) break;
+					const payload = pending.subarray(5, 5 + len);
+					pending = pending.subarray(5 + len);
+					if (flag & CONNECT_END_STREAM_FLAG) {
+						const trailerError = readConnectTrailerError((flag & CONNECT_COMPRESSED_FLAG ? gunzipSync(payload) : payload).toString("utf8").trim());
+						if (trailerError) {
+							const error = new ValidationError(trailerError.formatted);
+							if (firstTokenTime === void 0 && trailerError.code.toLowerCase() === "invalid_argument" && /\binternal error\b/i.test(trailerError.message)) {
+								let activeTailCount = 0;
+								const lastRole = context.messages.at(-1)?.role;
+								if (lastRole === "user" || lastRole === "developer") {
+									activeTailCount = 1;
+									if (lastRole === "developer") for (let i = context.messages.length - 2; i >= 0; i--) {
+										const role = context.messages[i].role;
+										if (role !== "user" && role !== "developer") break;
+										activeTailCount++;
+									}
+								}
+								const shrinkablePrompts = activeTailCount > 0 ? request.chatMessagePrompts.slice(0, -activeTailCount) : request.chatMessagePrompts;
+								const historyBytes = toBinary(GetChatMessageRequestSchema, create$1(GetChatMessageRequestSchema, { chatMessagePrompts: shrinkablePrompts })).byteLength;
+								if (historyBytes >= LARGE_HISTORY_RECOVERY_BYTES) {
+									attach(error, create(Flag.ContextOverflow));
+									warn("devin: treating large-history invalid_argument as context overflow", {
+										model: model.id,
+										historyBytes,
+										requestBytes: reqBytes.byteLength,
+										compressedBytes: gz.byteLength
+									});
+								}
+							}
+							throw error;
+						}
+						continue;
+					}
+					const raw = flag & CONNECT_COMPRESSED_FLAG ? gunzipSync(payload) : payload;
+					const msg = fromBinary(GetChatMessageResponseSchema, raw);
+					if (msg.messageId && !output.responseId) output.responseId = msg.messageId;
+					if (msg.deltaThinking) {
+						markFirstToken();
+						const block = currentThinkingBlock ?? {
+							type: "thinking",
+							thinking: ""
+						};
+						if (currentThinkingBlock !== block) {
+							output.content.push(block);
+							currentThinkingBlock = block;
+							stream.push({
+								type: "thinking_start",
+								contentIndex: output.content.length - 1,
+								partial: output
+							});
+						}
+						block.thinking += msg.deltaThinking;
+						if (msg.deltaSignature) block.thinkingSignature = msg.deltaSignature;
+						stream.push({
+							type: "thinking_delta",
+							contentIndex: output.content.indexOf(block),
+							delta: msg.deltaThinking,
+							partial: output
+						});
+					}
+					if (msg.deltaText) {
+						markFirstToken();
+						endThinkingBlock();
+						const block = currentTextBlock ?? {
+							type: "text",
+							text: ""
+						};
+						if (currentTextBlock !== block) {
+							output.content.push(block);
+							currentTextBlock = block;
+							stream.push({
+								type: "text_start",
+								contentIndex: output.content.length - 1,
+								partial: output
+							});
+						}
+						block.text += msg.deltaText;
+						stream.push({
+							type: "text_delta",
+							contentIndex: output.content.indexOf(block),
+							delta: msg.deltaText,
+							partial: output
+						});
+					}
+					if (msg.deltaToolCalls.length > 0) {
+						markFirstToken();
+						endTextBlock();
+						endThinkingBlock();
+						for (const tc of msg.deltaToolCalls) {
+							const toolCallId = tc.id || activeToolCallId;
+							if (!toolCallId) continue;
+							let block = toolBlocks.get(toolCallId);
+							if (!block) {
+								block = {
+									type: "toolCall",
+									id: toolCallId,
+									name: tc.name,
+									arguments: {}
+								};
+								output.content.push(block);
+								toolBlocks.set(toolCallId, block);
+								toolPartialJson.set(toolCallId, "");
+								stream.push({
+									type: "toolcall_start",
+									contentIndex: output.content.length - 1,
+									partial: output
+								});
+							}
+							if (tc.name) block.name = tc.name;
+							activeToolCallId = toolCallId;
+							if (!tc.argumentsJson) continue;
+							const previousJson = toolPartialJson.get(toolCallId) ?? "";
+							const accumulated = tc.argumentsJson.startsWith(previousJson) ? tc.argumentsJson : previousJson + tc.argumentsJson;
+							const delta = accumulated.slice(previousJson.length);
+							toolPartialJson.set(toolCallId, accumulated);
+							const throttled = parseStreamingJsonThrottled(accumulated, toolLastParseLen.get(toolCallId) ?? 0);
+							if (throttled) {
+								block.arguments = throttled.value;
+								toolLastParseLen.set(toolCallId, throttled.parsedLen);
+							}
+							stream.push({
+								type: "toolcall_delta",
+								contentIndex: output.content.indexOf(block),
+								delta,
+								partial: output
+							});
+						}
+					}
+					if (msg.stopReason !== 0) latestStopReason = msg.stopReason;
+					if (msg.usage) {
+						output.usage.input = Number(msg.usage.inputTokens);
+						output.usage.output = Number(msg.usage.outputTokens);
+						output.usage.cacheRead = Number(msg.usage.cacheReadTokens);
+						output.usage.cacheWrite = Number(msg.usage.cacheWriteTokens);
+						output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+					}
+				}
+				if (done) break;
+			}
+			endTextBlock();
+			endThinkingBlock();
+			for (const [id, block] of toolBlocks) {
+				block.arguments = parseStreamingJson(toolPartialJson.get(id));
+				stream.push({
+					type: "toolcall_end",
+					contentIndex: output.content.indexOf(block),
+					toolCall: block,
+					partial: output
+				});
+			}
+			const doneReason = toolBlocks.size > 0 ? "toolUse" : latestStopReason === 3 ? "length" : "stop";
+			output.stopReason = doneReason;
+			calculateCost(model, output.usage);
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "done",
+				reason: doneReason,
+				message: output
+			});
+			stream.end();
+		} catch (error$1) {
+			error("devin: stream failed", { error: String(error$1) });
+			const result = await finalize(error$1, {
+				api: model.api,
+				signal: options?.signal
+			});
+			output.stopReason = result.stopReason;
+			output.errorStatus = result.status;
+			output.errorId = result.id;
+			output.errorMessage = result.message;
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "error",
+				reason: result.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+function normalizeDevinSessionToken(apiKey) {
+	if (!apiKey) return "";
+	return apiKey.startsWith(DEVIN_SESSION_TOKEN_PREFIX) ? apiKey : `${DEVIN_SESSION_TOKEN_PREFIX}${apiKey}`;
+}
+async function fetchDevinAuthMetadata(apiKey, baseUrl, fetchImpl, signal) {
+	const request = create$1(GetUserJwtRequestSchema, { metadata: create$1(MetadataSchema, {
+		apiKey,
+		ideName: "windsurf",
+		ideVersion: DEVIN_IDE_VERSION,
+		extensionName: "windsurf",
+		extensionVersion: DEVIN_EXTENSION_VERSION,
+		locale: "en"
+	}) });
+	const response = await fetchImpl(`${baseUrl}${DEVIN_AUTH_PATH}`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/proto",
+			"connect-protocol-version": "1",
+			accept: "*/*"
+		},
+		body: toBinary(GetUserJwtRequestSchema, request),
+		signal
+	});
+	const payload = new Uint8Array(await response.arrayBuffer());
+	if (!response.ok) throw new DevinApiError(`Devin auth error ${response.status} ${response.statusText}: ${new TextDecoder().decode(payload)}`, response.status);
+	const decoded = decodeDevinUserJwtResponse(payload);
+	if (!decoded.userJwt) throw new ProviderResponseError("Devin auth error: GetUserJwt returned an empty user JWT", {
+		provider: "devin",
+		kind: "runtime"
+	});
+	const customBaseUrl = decoded.customApiServerUrl.trim();
+	return {
+		userJwt: decoded.userJwt,
+		...customBaseUrl ? { baseUrl: customBaseUrl.replace(/\/+$/, "") } : void 0
+	};
+}
+function decodeDevinUserJwtResponse(payload) {
+	try {
+		return fromBinary(GetUserJwtResponseSchema, payload);
+	} catch {
+		return fromBinary(GetUserJwtResponseSchema, gunzipSync(payload));
+	}
+}
+/**
+* Build a {@link GetChatMessageRequest} for one Cascade turn. Auth rides inside
+* `Metadata.apiKey`; the system prompt is the flattened `prompt` string and the
+* conversation history maps to `chatMessagePrompts`.
+*/
+function buildDevinChatRequest(model, context, options, apiKey, userJwt) {
+	const cascadeId = options?.conversationId ?? options?.sessionId ?? crypto.randomUUID();
+	const stopPatterns = options?.stopSequences && options.stopSequences.length > 0 ? [...DEVIN_DEFAULT_STOP_PATTERNS, ...options.stopSequences] : DEVIN_DEFAULT_STOP_PATTERNS;
+	const messages = transformMessages(context.messages, model);
+	return create$1(GetChatMessageRequestSchema, {
+		metadata: create$1(MetadataSchema, {
+			apiKey,
+			userJwt,
+			ideName: "windsurf",
+			ideVersion: DEVIN_IDE_VERSION,
+			extensionName: "windsurf",
+			extensionVersion: DEVIN_EXTENSION_VERSION,
+			locale: "en"
+		}),
+		prompt: normalizeSystemPrompts(context.systemPrompt).join("\n\n"),
+		chatMessagePrompts: buildChatMessagePrompts(messages, cascadeId, model),
+		chatModelUid: options?.chatModelUid ?? model.requestModelId ?? model.id,
+		requestType: 5,
+		plannerMode: 1,
+		toolChoice: create$1(ChatToolChoiceSchema, { choice: {
+			case: "optionName",
+			value: "auto"
+		} }),
+		systemPromptCacheOptions: create$1(PromptCacheOptionsSchema, { type: 1 }),
+		disableParallelToolCalls: true,
+		cascadeId,
+		executionId: crypto.randomUUID(),
+		configuration: create$1(CompletionConfigurationSchema, {
+			numCompletions: 1n,
+			maxTokens: BigInt(options?.maxTokens ?? model.maxTokens ?? 64e3),
+			maxNewlines: 200n,
+			temperature: options?.temperature ?? .4,
+			firstTemperature: options?.temperature ?? .4,
+			topK: 50n,
+			topP: options?.topP ?? 1,
+			stopPatterns,
+			fimEotProbThreshold: 1
+		}),
+		tools: (context.tools ?? []).map((tool) => create$1(ChatToolDefinitionSchema, {
+			name: tool.name,
+			description: tool.description,
+			jsonSchemaString: JSON.stringify(toolWireSchema(tool)),
+			strict: tool.strict ?? false
+		}))
+	});
+}
+/** Map omp `Message` history onto Cascade `ChatMessagePrompt`s (USER / SYSTEM / TOOL channels). */
+function buildChatMessagePrompts(messages, cascadeId, model) {
+	const prompts = [];
+	for (const [index, msg] of messages.entries()) if (msg.role === "user" || msg.role === "developer") {
+		let promptText = "";
+		const images = [];
+		if (typeof msg.content === "string") promptText = msg.content;
+		else for (const part of msg.content) if (part.type === "text") promptText += part.text;
+		else if (part.type === "image") images.push(create$1(ImageDataSchema, {
+			base64Data: part.data,
+			mimeType: part.mimeType
+		}));
+		prompts.push(create$1(ChatMessagePromptSchema, {
+			messageId: deterministicUuid(`${cascadeId}\0${index}\0${msg.role}`),
+			source: 1,
+			prompt: promptText,
+			images
+		}));
+	} else if (msg.role === "assistant") {
+		const isNativeDevinMessage = msg.api === model.api && msg.provider === model.provider && msg.model === model.id;
+		let promptText = "";
+		let thinkingText = "";
+		let signature = "";
+		const toolCalls = [];
+		for (const part of msg.content) if (part.type === "text") promptText += `${part.text}${isDemotedThinking(part) ? "\n" : ""}`;
+		else if (part.type === "thinking") {
+			thinkingText += part.thinking;
+			if (isNativeDevinMessage && !signature && part.thinkingSignature) signature = part.thinkingSignature;
+		} else if (part.type === "toolCall") toolCalls.push(create$1(ChatToolCallSchema, {
+			id: part.id,
+			name: part.name,
+			argumentsJson: JSON.stringify(part.arguments)
+		}));
+		if (!promptText && !thinkingText && !signature && toolCalls.length === 0) continue;
+		prompts.push(create$1(ChatMessagePromptSchema, {
+			messageId: isNativeDevinMessage && msg.responseId ? msg.responseId : `bot-${deterministicUuid(`${cascadeId}\0${index}\0assistant`)}`,
+			source: 2,
+			prompt: promptText,
+			thinking: thinkingText,
+			signature,
+			signatureType: "",
+			toolCalls
+		}));
+	} else {
+		let resultText = "";
+		const images = [];
+		for (const part of msg.content) if (part.type === "text") resultText += part.text;
+		else if (part.type === "image") images.push(create$1(ImageDataSchema, {
+			base64Data: part.data,
+			mimeType: part.mimeType
+		}));
+		prompts.push(create$1(ChatMessagePromptSchema, {
+			messageId: deterministicUuid(`${cascadeId}\0${index}\0tool\0${msg.toolCallId}`),
+			source: 4,
+			toolCallId: msg.toolCallId,
+			toolResultIsError: msg.isError,
+			prompt: resultText,
+			images
+		}));
+	}
+	return prompts;
+}
+/**
+* Parse a Connect end-of-stream JSON trailer and return its structured error
+* when it carries `{ error: { code, message } }`, else `null`. The trailer is
+* untrusted server output, so the shape is checked with guards rather than asserted.
+*/
+function readConnectTrailerError(text) {
+	if (text.length === 0) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return null;
+	}
+	if (!parsed || typeof parsed !== "object" || !("error" in parsed)) return null;
+	const err = parsed.error;
+	if (!err || typeof err !== "object") return null;
+	const code = "code" in err && typeof err.code === "string" ? err.code : "";
+	const message = "message" in err && typeof err.message === "string" ? err.message : "";
+	if (!code && !message) return null;
+	return {
+		code,
+		message,
+		formatted: `Devin stream error${code ? ` ${code}` : ""}: ${message}`
+	};
+}
+//#endregion
+export { streamDevin };

package/lib/devin-Q1yem3lp.mjs

@@ -0,0 +1,114 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { n as discoveryFetch } from "./utils-DzXZDfYc.mjs";
+import { E as create, i as fromBinary, t as toBinary } from "./to-binary-B1BEBIPC.mjs";
+import { f as MetadataSchema, i as GetCliModelConfigsResponseSchema, r as GetCliModelConfigsRequestSchema } from "./api_server_pb-CDZgLMta.mjs";
+import { gunzipSync } from "node:zlib";
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@17.3.5/node_modules/@oh-my-pi/pi-catalog/src/discovery/devin.ts
+const DEVIN_DEFAULT_BASE_URL = "https://server.codeium.com";
+const DEVIN_GET_CLI_MODEL_CONFIGS_PATH = "/exa.api_server_pb.ApiServerService/GetCliModelConfigs";
+const DEVIN_IDE_VERSION = "3.2.23";
+const DEVIN_EXTENSION_VERSION = "1.48.2";
+const DEVIN_SESSION_TOKEN_PREFIX = "devin-session-token$";
+const DEFAULT_CONTEXT_WINDOW = 2e5;
+const DEFAULT_MAX_TOKENS = 64e3;
+/** Best-effort match for labels whose wording implies a thinking / reasoning-effort variant. */
+const REASONING_LABEL_PATTERN = /think|thinking|minimal|high|medium|low|xhigh|max|reasoning/i;
+const NO_REASONING_LABEL_PATTERN = /\bno thinking\b/i;
+function supportsDevinThinking(config) {
+	if (NO_REASONING_LABEL_PATTERN.test(config.label)) return false;
+	return config.modelInfo?.modelFeatures?.supportsThinking === true || REASONING_LABEL_PATTERN.test(config.label);
+}
+/**
+* Fetches Devin models through the `GetCliModelConfigs` unary Connect RPC and
+* normalizes them into canonical model entries.
+*
+* Returns `null` on request/decode failures.
+* Returns `[]` only when the endpoint responds successfully with no usable models.
+*/
+async function fetchDevinModels(options) {
+	const timeoutMs = options.timeoutMs ?? 5e3;
+	const requestUrl = `${(options.baseUrl ?? DEVIN_DEFAULT_BASE_URL).replace(/\/+$/, "")}${DEVIN_GET_CLI_MODEL_CONFIGS_PATH}`;
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	const signal = options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+	try {
+		const request = create(GetCliModelConfigsRequestSchema, { metadata: create(MetadataSchema, {
+			apiKey: normalizeDevinSessionToken(options.apiKey),
+			ideName: "windsurf",
+			ideVersion: DEVIN_IDE_VERSION,
+			extensionName: "windsurf",
+			extensionVersion: DEVIN_EXTENSION_VERSION
+		}) });
+		const body = toBinary(GetCliModelConfigsRequestSchema, request);
+		const response = await discoveryFetch(options.fetch)(requestUrl, {
+			method: "POST",
+			headers: {
+				"content-type": "application/proto",
+				"connect-protocol-version": "1",
+				accept: "*/*"
+			},
+			body,
+			signal
+		});
+		if (!response.ok) return null;
+		const decoded = decodeCliModelConfigsResponse(new Uint8Array(await response.arrayBuffer()));
+		if (!decoded) return null;
+		return normalizeDevinModels(decoded.clientModelConfigs, options.baseUrl);
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function normalizeDevinSessionToken(apiKey) {
+	if (!apiKey) return "";
+	return apiKey.startsWith(DEVIN_SESSION_TOKEN_PREFIX) ? apiKey : `${DEVIN_SESSION_TOKEN_PREFIX}${apiKey}`;
+}
+/**
+* Decodes a raw (unframed) `GetCliModelConfigsResponse`. Bun's `fetch` usually
+* auto-decompresses gzip, so the direct decode is attempted first; a
+* `gunzipSync` fallback covers runtimes that hand back the still-compressed body.
+*/
+function decodeCliModelConfigsResponse(payload) {
+	try {
+		return fromBinary(GetCliModelConfigsResponseSchema, payload);
+	} catch {
+		try {
+			return fromBinary(GetCliModelConfigsResponseSchema, gunzipSync(payload));
+		} catch {
+			return null;
+		}
+	}
+}
+function normalizeDevinModels(configs, baseUrlOverride) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const config of configs) {
+		if (config.disabled) continue;
+		const id = config.modelUid.trim();
+		if (!id) continue;
+		const input = config.supportsImages ? ["text", "image"] : ["text"];
+		const contextWindow = config.maxTokens > 0 ? config.maxTokens : DEFAULT_CONTEXT_WINDOW;
+		byId.set(id, {
+			id,
+			name: config.label.trim() || id,
+			api: "devin-agent",
+			provider: "devin",
+			baseUrl: baseUrlOverride ?? DEVIN_DEFAULT_BASE_URL,
+			reasoning: supportsDevinThinking(config),
+			input,
+			supportsTools: true,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0
+			},
+			contextWindow,
+			maxTokens: Math.min(config.maxTokens > 0 ? config.maxTokens : DEFAULT_MAX_TOKENS, DEFAULT_MAX_TOKENS)
+		});
+	}
+	return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+//#endregion
+export { fetchDevinModels };