Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
feat(auto): add auto prefix parser
oyi779ddcd8bda81c
diff --git a/open-sse/services/autoCombo/autoPrefix.ts b/open-sse/services/autoCombo/autoPrefix.tsnew file mode 100644index 0000000000..9501f9ed19--- /dev/null+++ b/open-sse/services/autoCombo/autoPrefix.ts@@ -0,0 +1,50 @@+export type AutoVariant = "coding" | "fast" | "cheap" | "offline" | "smart" | "lkgp";++export interface AutoPrefixParseResult {+ valid: boolean;+ variant?: AutoVariant;+ error?: string;+}++const VALID_VARIANTS: AutoVariant[] = ["coding", "fast", "cheap", "offline", "smart", "lkgp"];++/**+ * Parses a model name to determine if it's an auto-prefixed model and extracts the variant.+ *+ * Examples:+ * - "auto" -> { valid: true, variant: undefined } (default)+ * - "auto/coding" -> { valid: true, variant: "coding" }+ * - "auto/lkgp" -> { valid: true, variant: "lkgp" }+ * - "auto/" -> { valid: true, variant: undefined } (default)+ * - "autocoding" -> { valid: false, error: "Invalid auto prefix format" }+ * - "otherModel" -> { valid: false, error: "Not an auto-prefixed model" }+ */+export function parseAutoPrefix(model: string): AutoPrefixParseResult {+ if (!model.startsWith("auto")) {+ return { valid: false, error: "Not an auto-prefixed model" };+ }++ const parts = model.split("/");++ if (parts.length === 1) {+ if (parts[0] === "auto") {+ return { valid: true, variant: undefined }; // Default auto+ } else {+ return { valid: false, error: "Invalid auto prefix format" };+ }+ }++ if (parts.length === 2) {+ if (parts[0] !== "auto") {+ return { valid: false, error: "Invalid auto prefix format" };+ }+ const variant = parts[1] as AutoVariant;+ if (variant === "" || VALID_VARIANTS.includes(variant)) {+ return { valid: true, variant: variant === "" ? undefined : variant };+ } else {+ return { valid: false, error: `Invalid auto variant: ${variant}` };+ }+ }++ return { valid: false, error: "Invalid auto prefix format" };+}diff --git a/tests/unit/autoPrefix.test.ts b/tests/unit/autoPrefix.test.tsnew file mode 100644index 0000000000..cb0588dc61--- /dev/null+++ b/tests/unit/autoPrefix.test.ts@@ -0,0 +1,89 @@+import { parseAutoPrefix } from "../../open-sse/services/autoCombo/autoPrefix.ts";+import assert from "node:assert/strict";+import { describe, it } from "node:test";++describe("parseAutoPrefix", () => {+ it('should return valid for "auto" with no variant', () => {+ const result = parseAutoPrefix("auto");+ assert.strictEqual(result.valid, true);+ assert.strictEqual(result.variant, undefined);+ });++ it('should return valid for "auto/" with no variant', () => {+ const result = parseAutoPrefix("auto/");+ assert.strictEqual(result.valid, true);+ assert.strictEqual(result.variant, undefined);+ });++ it('should return valid for "auto/coding" with coding variant', () => {+ const result = parseAutoPrefix("auto/coding");+ assert.strictEqual(result.valid, true);+ assert.strictEqual(result.variant, "coding");+ });++ it('should return valid for "auto/fast" with fast variant', () => {+ const result = parseAutoPrefix("auto/fast");+ assert.strictEqual(result.valid, true);+ assert.strictEqual(result.variant, "fast");+ });++ it('should return valid for "auto/cheap" with cheap variant', () => {+ const result = parseAutoPrefix("auto/cheap");+ assert.strictEqual(result.valid, true);+ assert.strictEqual(result.variant, "cheap");+ });++ it('should return valid for "auto/offline" with offline variant', () => {+ const result = parseAutoPrefix("auto/offline");+ assert.strictEqual(result.valid, true);+ assert.strictEqual(result.variant, "offline");+ });++ it('should return valid for "auto/smart" with smart variant', () => {+ const result = parseAutoPrefix("auto/smart");+ assert.strictEqual(result.valid, true);+ assert.strictEqual(result.variant, "smart");+ });++ it('should return valid for "auto/lkgp" with lkgp variant', () => {+ const result = parseAutoPrefix("auto/lkgp");+ assert.strictEqual(result.valid, true);+ assert.strictEqual(result.variant, "lkgp");+ });++ it('should return invalid for "autocoding" (invalid format)', () => {+ const result = parseAutoPrefix("autocoding");+ assert.strictEqual(result.valid, false);+ assert.match(result.error || "", /Invalid auto prefix format/);+ });++ it('should return invalid for "auto/unknown" (invalid variant)', () => {+ const result = parseAutoPrefix("auto/unknown");+ assert.strictEqual(result.valid, false);+ assert.match(result.error || "", /Invalid auto variant: unknown/);+ });++ it("should return invalid for a non-auto prefixed model", () => {+ const result = parseAutoPrefix("otherModel");+ assert.strictEqual(result.valid, false);+ assert.match(result.error || "", /Not an auto-prefixed model/);+ });++ it("should return invalid for empty string", () => {+ const result = parseAutoPrefix("");+ assert.strictEqual(result.valid, false);+ assert.match(result.error || "", /Not an auto-prefixed model/);+ });++ it("should return invalid for null/undefined input (handled by TS but for robustness)", () => {+ // @ts-ignore testing invalid input that TS normally prevents+ const result = parseAutoPrefix(null);+ assert.strictEqual(result.valid, false);+ assert.match(result.error || "", /Not an auto-prefixed model/);++ // @ts-ignore+ const result2 = parseAutoPrefix(undefined);+ assert.strictEqual(result2.valid, false);+ assert.match(result2.error || "", /Not an auto-prefixed model/);+ });+});