@vib-rato/ai 0.16.0

package/src/providers/dashscope-token-plan-headers.d.ts

@@ -0,0 +1,57 @@
+/**
+ * DashScope Token Plan canonical request headers.
+ *
+ * Reproduces QwenLM/qwen-code's DashScopeOpenAICompatibleProvider.buildHeaders()
+ * defaultHeaders so the built-in `alibaba-token-plan` provider emits the same
+ * client identity / cache / auth-type fingerprint upstream sends. DashScope is
+ * compatibility-sensitive to this fingerprint; a non-identical set can cause
+ * request instability and affect first-event latency (vib-rato #3557).
+ *
+ * Upstream pin (reproduce EXACTLY here):
+ *   Repository:    QwenLM/qwen-code
+ *   Commit:        f4cd6e1d8bbb1c24e7e5d1a40187d8e28aa7c4fb
+ *   Version:       0.21.1
+ *   Source:        packages/core/src/core/openaiContentGenerator/provider/dashscope.ts
+ *   buildHeaders():
+ *     const userAgent = `QwenCode/${version} (${process.platform}; ${process.arch})`;
+ *     const defaultHeaders = {
+ *       'User-Agent': userAgent,
+ *       'X-DashScope-CacheControl': 'enable',
+ *       'X-DashScope-UserAgent': userAgent,
+ *       'X-DashScope-AuthType': authType,
+ *     };
+ *     return customHeaders ? { ...defaultHeaders, ...customHeaders } : defaultHeaders;
+ *
+ * The Token Plan preset authenticates with AuthType.USE_OPENAI ('openai'), so
+ * X-DashScope-AuthType is the constant 'openai'. Pin the version so an upstream
+ * bump is an explicit parity update rather than silent drift.
+ */
+export declare const QWEN_CODE_UPSTREAM_REPO = "QwenLM/qwen-code";
+export declare const QWEN_CODE_UPSTREAM_COMMIT = "f4cd6e1d8bbb1c24e7e5d1a40187d8e28aa7c4fb";
+export declare const QWEN_CODE_UPSTREAM_VERSION = "0.21.1";
+/**
+ * The Qwen Code CLI version string used in identity headers. Pinned to the
+ * upstream version at {@link QWEN_CODE_UPSTREAM_COMMIT}; change both together
+ * as an explicit parity update.
+ */
+export declare function qwenCodeUserAgent(version?: string): string;
+/**
+ * Canonical DashScope Token Plan headers (upstream defaultHeaders, no caller
+ * overrides applied). Exposed for tests/fixtures so the pinned wire set lives
+ * in exactly one place.
+ */
+export declare function dashscopeTokenPlanDefaultHeaders(version?: string): Readonly<Record<string, string>>;
+/**
+ * Merge canonical DashScope Token Plan identity headers onto a caller's header
+ * map, reproducing upstream buildHeaders() precedence EXACTLY:
+ *   `{ ...defaultHeaders, ...customHeaders }` — caller wins per header.
+ *
+ * This mirrors Vibrato's existing kimi-code injection order
+ * (`headers = { ...getKimiCommonHeaders(), ...headers }`): canonical identity as
+ * the base, caller-supplied headers overriding individual keys. A caller that
+ * pins `User-Agent` takes that key; the other canonicals still apply.
+ *
+ * A null/undefined `callerHeaders` returns the canonical set alone (upstream
+ * `customHeaders ? {...} : defaultHeaders` shortcut).
+ */
+export declare function mergeDashScopeTokenPlanHeaders(callerHeaders: Record<string, string> | undefined, version?: string): Record<string, string>;

package/src/providers/dashscope-token-plan-headers.ts

@@ -0,0 +1,84 @@
+/**
+ * DashScope Token Plan canonical request headers.
+ *
+ * Reproduces QwenLM/qwen-code's DashScopeOpenAICompatibleProvider.buildHeaders()
+ * defaultHeaders so the built-in `alibaba-token-plan` provider emits the same
+ * client identity / cache / auth-type fingerprint upstream sends. DashScope is
+ * compatibility-sensitive to this fingerprint; a non-identical set can cause
+ * request instability and affect first-event latency (vib-rato #3557).
+ *
+ * Upstream pin (reproduce EXACTLY here):
+ *   Repository:    QwenLM/qwen-code
+ *   Commit:        f4cd6e1d8bbb1c24e7e5d1a40187d8e28aa7c4fb
+ *   Version:       0.21.1
+ *   Source:        packages/core/src/core/openaiContentGenerator/provider/dashscope.ts
+ *   buildHeaders():
+ *     const userAgent = `QwenCode/${version} (${process.platform}; ${process.arch})`;
+ *     const defaultHeaders = {
+ *       'User-Agent': userAgent,
+ *       'X-DashScope-CacheControl': 'enable',
+ *       'X-DashScope-UserAgent': userAgent,
+ *       'X-DashScope-AuthType': authType,
+ *     };
+ *     return customHeaders ? { ...defaultHeaders, ...customHeaders } : defaultHeaders;
+ *
+ * The Token Plan preset authenticates with AuthType.USE_OPENAI ('openai'), so
+ * X-DashScope-AuthType is the constant 'openai'. Pin the version so an upstream
+ * bump is an explicit parity update rather than silent drift.
+ */
+export const QWEN_CODE_UPSTREAM_REPO = "QwenLM/qwen-code";
+export const QWEN_CODE_UPSTREAM_COMMIT = "f4cd6e1d8bbb1c24e7e5d1a40187d8e28aa7c4fb";
+export const QWEN_CODE_UPSTREAM_VERSION = "0.21.1";
+
+// Upstream Token Plan preset uses AuthType.USE_OPENAI = 'openai'.
+const QWEN_CODE_TOKEN_PLAN_AUTH_TYPE = "openai";
+
+/**
+ * The Qwen Code CLI version string used in identity headers. Pinned to the
+ * upstream version at {@link QWEN_CODE_UPSTREAM_COMMIT}; change both together
+ * as an explicit parity update.
+ */
+export function qwenCodeUserAgent(version: string = QWEN_CODE_UPSTREAM_VERSION): string {
+	// process.platform / process.arch are read verbatim, matching upstream
+	// (e.g. "linux", "darwin", "win32"; "x64", "arm64"). No normalization.
+	return `QwenCode/${version} (${process.platform}; ${process.arch})`;
+}
+
+/**
+ * Canonical DashScope Token Plan headers (upstream defaultHeaders, no caller
+ * overrides applied). Exposed for tests/fixtures so the pinned wire set lives
+ * in exactly one place.
+ */
+export function dashscopeTokenPlanDefaultHeaders(
+	version: string = QWEN_CODE_UPSTREAM_VERSION,
+): Readonly<Record<string, string>> {
+	const userAgent = qwenCodeUserAgent(version);
+	return Object.freeze({
+		"User-Agent": userAgent,
+		"X-DashScope-CacheControl": "enable",
+		"X-DashScope-UserAgent": userAgent,
+		"X-DashScope-AuthType": QWEN_CODE_TOKEN_PLAN_AUTH_TYPE,
+	});
+}
+
+/**
+ * Merge canonical DashScope Token Plan identity headers onto a caller's header
+ * map, reproducing upstream buildHeaders() precedence EXACTLY:
+ *   `{ ...defaultHeaders, ...customHeaders }` — caller wins per header.
+ *
+ * This mirrors Vibrato's existing kimi-code injection order
+ * (`headers = { ...getKimiCommonHeaders(), ...headers }`): canonical identity as
+ * the base, caller-supplied headers overriding individual keys. A caller that
+ * pins `User-Agent` takes that key; the other canonicals still apply.
+ *
+ * A null/undefined `callerHeaders` returns the canonical set alone (upstream
+ * `customHeaders ? {...} : defaultHeaders` shortcut).
+ */
+export function mergeDashScopeTokenPlanHeaders(
+	callerHeaders: Record<string, string> | undefined,
+	version: string = QWEN_CODE_UPSTREAM_VERSION,
+): Record<string, string> {
+	const defaults = dashscopeTokenPlanDefaultHeaders(version);
+	if (!callerHeaders) return { ...defaults };
+	return { ...defaults, ...callerHeaders };
+}

package/src/providers/error-message.d.ts

@@ -0,0 +1,27 @@
+import type { Api, Model } from "../types";
+export declare function createProviderErrorMessage(model: Model<Api>, err: unknown): {
+    role: "assistant";
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    api: Api;
+    provider: string;
+    model: string;
+    usage: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        totalTokens: number;
+        cost: {
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+            total: number;
+        };
+    };
+    stopReason: "error";
+    timestamp: number;
+};

package/src/providers/error-message.ts

@@ -0,0 +1,21 @@
+import type { Api, Model } from "../types";
+
+export function createProviderErrorMessage(model: Model<Api>, err: unknown) {
+	return {
+		role: "assistant" as const,
+		content: [{ type: "text" as const, text: err instanceof Error ? err.message : String(err) }],
+		api: model.api,
+		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: "error" as const,
+		timestamp: Date.now(),
+	};
+}

package/src/providers/github-copilot-headers.d.ts

@@ -0,0 +1,40 @@
+import type { Message } from "../types";
+/**
+ * Infer whether the current request to Copilot is user-initiated or agent-initiated.
+ * Accepts `unknown[]` because providers may pass pre-converted message shapes.
+ */
+export type CopilotInitiator = "user" | "agent";
+export type CopilotPremiumRequests = number;
+export type CopilotDynamicHeaders = {
+    headers: Record<string, string>;
+    initiator: CopilotInitiator;
+    premiumRequests: CopilotPremiumRequests;
+};
+export declare function resolveGitHubCopilotBaseUrl(baseUrl: string | undefined, apiKey: string | undefined): string | undefined;
+export declare function inferCopilotInitiator(messages: unknown[]): CopilotInitiator;
+/** Check whether any message in the conversation contains image content. */
+export declare function hasCopilotVisionInput(messages: Message[]): boolean;
+/**
+ * Resolve an explicitly configured Copilot initiator header, if present.
+ * Handles case-insensitive X-Initiator keys and returns the last valid value.
+ */
+export declare function getCopilotInitiatorOverride(headers: Record<string, string> | undefined): CopilotInitiator | undefined;
+export type CopilotPlanTier = "free" | "paid";
+export declare function getCopilotPremiumMultiplier(premiumMultiplier: number | undefined, planTier?: string): number;
+export declare function getCopilotPremiumRequests(params: {
+    initiator: CopilotInitiator;
+    premiumMultiplier?: number;
+    planTier?: string;
+}): CopilotPremiumRequests;
+/**
+ * Build dynamic Copilot headers that vary per-request.
+ * Static headers (User-Agent, Editor-Version, etc.) come from model.headers.
+ */
+export declare function buildCopilotDynamicHeaders(params: {
+    messages: unknown[];
+    hasImages: boolean;
+    premiumMultiplier?: number;
+    headers?: Record<string, string>;
+    initiatorOverride?: CopilotInitiator;
+    planTier?: string;
+}): CopilotDynamicHeaders;

package/src/providers/github-copilot-headers.ts

@@ -0,0 +1,140 @@
+import type { Message } from "../types";
+import { getGitHubCopilotBaseUrl, parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
+/**
+ * Infer whether the current request to Copilot is user-initiated or agent-initiated.
+ * Accepts `unknown[]` because providers may pass pre-converted message shapes.
+ */
+export type CopilotInitiator = "user" | "agent";
+export type CopilotPremiumRequests = number;
+export type CopilotDynamicHeaders = {
+	headers: Record<string, string>;
+	initiator: CopilotInitiator;
+	premiumRequests: CopilotPremiumRequests;
+};
+export function resolveGitHubCopilotBaseUrl(
+	baseUrl: string | undefined,
+	apiKey: string | undefined,
+): string | undefined {
+	if (!apiKey) return baseUrl;
+	const { enterpriseUrl } = parseGitHubCopilotApiKey(apiKey);
+	if (!enterpriseUrl) return baseUrl;
+	if (baseUrl && !baseUrl.includes("githubcopilot.com")) return baseUrl;
+	return getGitHubCopilotBaseUrl(enterpriseUrl);
+}
+export function inferCopilotInitiator(messages: unknown[]): CopilotInitiator {
+	if (messages.length === 0) return "user";
+
+	const last = messages[messages.length - 1] as Record<string, unknown>;
+	const attribution = last.attribution;
+	if (typeof attribution === "string") {
+		const normalizedAttribution = attribution.trim().toLowerCase();
+		if (normalizedAttribution === "user" || normalizedAttribution === "agent") {
+			return normalizedAttribution;
+		}
+	}
+
+	const role = last.role as string | undefined;
+	if (!role) return "user";
+
+	if (role !== "user") return "agent";
+
+	// Check if last content block is a tool_result (Anthropic-converted shape)
+	const content = last.content;
+	if (Array.isArray(content) && content.length > 0) {
+		const lastBlock = content[content.length - 1] as Record<string, unknown>;
+		if (lastBlock.type === "tool_result") {
+			return "agent";
+		}
+	}
+
+	return "user";
+}
+
+/** Check whether any message in the conversation contains image content. */
+export function hasCopilotVisionInput(messages: Message[]): boolean {
+	return messages.some(msg => {
+		if (msg.role === "user" && Array.isArray(msg.content)) {
+			return msg.content.some(c => c.type === "image");
+		}
+		if (msg.role === "toolResult" && Array.isArray(msg.content)) {
+			return msg.content.some(c => c.type === "image");
+		}
+		return false;
+	});
+}
+
+/**
+ * Resolve an explicitly configured Copilot initiator header, if present.
+ * Handles case-insensitive X-Initiator keys and returns the last valid value.
+ */
+export function getCopilotInitiatorOverride(headers: Record<string, string> | undefined): CopilotInitiator | undefined {
+	if (!headers) return undefined;
+
+	let override: CopilotInitiator | undefined;
+	for (const [key, value] of Object.entries(headers)) {
+		if (key.toLowerCase() !== "x-initiator") continue;
+		const normalized = value.trim().toLowerCase();
+		if (normalized === "user" || normalized === "agent") {
+			override = normalized;
+		}
+	}
+
+	return override;
+}
+
+export type CopilotPlanTier = "free" | "paid";
+
+function normalizeCopilotPlanTier(planTier: string | undefined): CopilotPlanTier {
+	if (planTier === "paid") return "paid";
+	return "free";
+}
+export function getCopilotPremiumMultiplier(premiumMultiplier: number | undefined, planTier?: string): number {
+	const normalizedMultiplier = premiumMultiplier ?? 1;
+	if (normalizeCopilotPlanTier(planTier) === "free" && normalizedMultiplier === 0) {
+		return 1;
+	}
+	return normalizedMultiplier;
+}
+
+export function getCopilotPremiumRequests(params: {
+	initiator: CopilotInitiator;
+	premiumMultiplier?: number;
+	planTier?: string;
+}): CopilotPremiumRequests {
+	if (params.initiator === "agent") return 0;
+	return getCopilotPremiumMultiplier(params.premiumMultiplier, params.planTier);
+}
+
+/**
+ * Build dynamic Copilot headers that vary per-request.
+ * Static headers (User-Agent, Editor-Version, etc.) come from model.headers.
+ */
+export function buildCopilotDynamicHeaders(params: {
+	messages: unknown[];
+	hasImages: boolean;
+	premiumMultiplier?: number;
+	headers?: Record<string, string>;
+	initiatorOverride?: CopilotInitiator;
+	planTier?: string;
+}): CopilotDynamicHeaders {
+	const initiator =
+		params.initiatorOverride ?? getCopilotInitiatorOverride(params.headers) ?? inferCopilotInitiator(params.messages);
+	const headers: Record<string, string> = {
+		"X-Initiator": initiator,
+		"Openai-Intent": "conversation-edits",
+	};
+
+	if (params.hasImages) {
+		headers["Copilot-Vision-Request"] = "true";
+	}
+
+	return {
+		headers,
+		initiator,
+		premiumRequests: getCopilotPremiumRequests({
+			initiator,
+			premiumMultiplier: params.premiumMultiplier,
+			planTier: params.planTier,
+		}),
+	};
+}

package/src/providers/gitlab-duo.d.ts

@@ -0,0 +1,27 @@
+import type { Api, Context, Model, SimpleStreamOptions } from "../types";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+type GitLabProvider = "anthropic" | "openai";
+type GitLabOpenAIApiType = "chat" | "responses";
+export type GitLabModelMapping = {
+    provider: GitLabProvider;
+    model: string;
+    openaiApiType?: GitLabOpenAIApiType;
+    name: string;
+    reasoning: boolean;
+    input: ("text" | "image")[];
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+    contextWindow: number;
+    maxTokens: number;
+};
+export declare const MODEL_MAPPINGS: Record<string, GitLabModelMapping>;
+export declare function getModelMapping(modelId: string): GitLabModelMapping | undefined;
+export declare function getGitLabDuoModels(): Model<Api>[];
+export declare function clearGitLabDuoDirectAccessCache(): void;
+export declare function isGitLabDuoModel(model: Model<Api>): boolean;
+export declare function streamGitLabDuo(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
+export {};