@d-ai/omp 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,38 @@
-# Temporary Holding Version
+# @d-ai/omp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+omp 插件。登录 D.AI 后，`/model` 里使用 `dai/<文本模型>`。只接对话模型，没有生图、视频、音频。
+
+## 安装
+
+```bash
+omp plugin install @d-ai/omp
+```
+
+重启 omp。
+
+从本仓库开发时：
+
+```bash
+pnpm -C sdks/typescript build
+cd sdks/omp && npm install && npm run build
+omp plugin link /绝对路径/sdks/omp
+```
+
+## 发布
+
+改 `package.json` 的 `version`（npm 会拒绝已经发过的版本），在 `sdks/omp` 执行 `npm publish --access public`。
+
+## 登录
+
+```bash
+omp login dai
+```
+
+1. `1`：浏览器授权。生产走 `https://dai.itbug.shop`，`DAI_BASE_URL` 指向 `127.0.0.1` 或 `localhost` 时走本地。
+2. `2`：粘贴 `ddsk_` API key。
+
+模型列表跟这次登录的站点。OAuth 登录后，没再设置 `DAI_BASE_URL` 也会用凭证里的 issuer，而不是改去生产。`/v1/models` 目前只认 `ddsk_`；OAuth 令牌被拒时改用该站点的公开文本目录。
+
+也可以不登录，直接 `export DAI_API_KEY=ddsk_...`。
+
+然后 `/model`，选 `dai/` 开头的模型。Claude 的 `@300k`、`@1m`、`:fast`、`:slow` 与 Pi 插件相同。

package/dist/index.js

@@ -0,0 +1,1253 @@
+import { createServer } from "node:http";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+//#region ../pi/src/claude-variants.ts
+const CONTEXT_300K = 3e5;
+const CONTEXT_1M = 1e6;
+/** Gateway accepts `speed: fast` only for these upstream ids. */
+const FAST_CLAUDE_MODELS = /* @__PURE__ */ new Set(["claude-opus-4-8", "claude-opus-5"]);
+const CLAUDE_VARIANT_ID = /^(claude-[a-z0-9]+(?:[._-][a-z0-9]+)*)@(300k|1m)(?::(fast|slow))?$/iu;
+function expandClaudeChatModels(models) {
+	const expanded = [];
+	for (const model of models) {
+		expanded.push(model);
+		if (model.api !== "anthropic-messages") continue;
+		const speeds = FAST_CLAUDE_MODELS.has(model.id) ? [
+			void 0,
+			"fast",
+			"slow"
+		] : [void 0];
+		for (const context of contextChoices(model.contextWindow)) for (const speed of speeds) expanded.push(variantModel(model, context, speed));
+	}
+	return expanded;
+}
+/**
+* Pi sends `model.id` as the Anthropic `model` field. Variant rows keep a
+* suffixed id so compaction uses 300k or 1m, and this rewrite restores the
+* upstream id plus `speed` before the gateway sees the body.
+* Return `undefined` to leave the payload unchanged.
+*/
+function rewriteClaudeProviderPayload(payload) {
+	if (!isRecord(payload) || typeof payload.model !== "string") return;
+	const parsed = parseClaudeVariantId(payload.model);
+	if (!parsed) return;
+	const next = {
+		...payload,
+		model: parsed.upstreamId
+	};
+	if (parsed.speed === "fast" && FAST_CLAUDE_MODELS.has(parsed.upstreamId)) next.speed = "fast";
+	else if (parsed.speed === "slow") next.speed = "standard";
+	else delete next.speed;
+	return next;
+}
+function contextChoices(contextWindow) {
+	const choices = [];
+	if (contextWindow > CONTEXT_300K) choices.push({
+		label: "300k",
+		tokens: CONTEXT_300K
+	});
+	if (contextWindow >= CONTEXT_1M) choices.push({
+		label: "1m",
+		tokens: CONTEXT_1M
+	});
+	return choices;
+}
+function variantModel(model, context, speed) {
+	const suffix = speed === void 0 ? "" : `:${speed}`;
+	return {
+		...model,
+		id: `${model.id}@${context.label}${suffix}`,
+		name: `${model.name} @${context.label}${suffix}`,
+		contextWindow: context.tokens,
+		maxTokens: Math.min(model.maxTokens, context.tokens),
+		...speed === "fast" ? { cost: doubleCost(model.cost) } : {}
+	};
+}
+function doubleCost(cost) {
+	return {
+		input: cost.input * 2,
+		output: cost.output * 2,
+		cacheRead: cost.cacheRead * 2,
+		cacheWrite: cost.cacheWrite * 2
+	};
+}
+function parseClaudeVariantId(id) {
+	const match = CLAUDE_VARIANT_ID.exec(id);
+	if (!match?.[1] || !match[2]) return;
+	const speed = match[3]?.toLowerCase();
+	return {
+		upstreamId: match[1].toLowerCase(),
+		...speed === "fast" || speed === "slow" ? { speed } : {}
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region ../pi/src/thinking.ts
+/** GPT-5.6: off→none, no minimal, xhigh+max. */
+const GPT_5_6 = {
+	off: "none",
+	minimal: null,
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh",
+	max: "max"
+};
+/** GPT-6: thinking cannot be disabled; low through max. */
+const GPT_6 = {
+	off: null,
+	minimal: null,
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh",
+	max: "max"
+};
+/** GPT-5.2–5.5: off→none, no minimal, xhigh, no max. */
+const GPT_5_4 = {
+	off: "none",
+	minimal: null,
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh",
+	max: null
+};
+const GPT_5_1 = {
+	off: "none",
+	minimal: null,
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: null,
+	max: null
+};
+/** Original GPT-5: thinking cannot be off; minimal through high. */
+const GPT_5 = {
+	off: null,
+	minimal: "minimal",
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: null,
+	max: null
+};
+const O_SERIES = {
+	off: null,
+	minimal: null,
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: null,
+	max: null
+};
+const KNOWN = {
+	"gpt-6-astra": GPT_6,
+	"gpt-5.6-luna": GPT_5_6,
+	"gpt-5.6-sol": GPT_5_6,
+	"gpt-5.6-terra": GPT_5_6,
+	"gpt-5.5": GPT_5_4,
+	"gpt-5.5-pro": {
+		...GPT_5_4,
+		off: null,
+		low: null
+	},
+	"gpt-5.4": GPT_5_4,
+	"gpt-5.4-mini": GPT_5_4,
+	"gpt-5.4-nano": GPT_5_4,
+	"gpt-5.4-pro": {
+		...GPT_5_4,
+		off: null,
+		low: null
+	},
+	"gpt-5.2": GPT_5_4,
+	"gpt-5.1": GPT_5_1,
+	"gpt-5": GPT_5,
+	"gpt-5-mini": GPT_5,
+	"gpt-5-nano": GPT_5,
+	"gpt-5-pro": {
+		off: null,
+		minimal: null,
+		low: null,
+		medium: null,
+		high: "high",
+		xhigh: null,
+		max: null
+	}
+};
+const NO_REASONING = /* @__PURE__ */ new Set(["gpt-5-chat-latest", "gpt-5.3-chat-latest"]);
+/** Opus 4.7+ / Fable: adaptive effort. off and minimal are unsupported. */
+const CLAUDE_XHIGHER = {
+	xhigh: "xhigh",
+	max: "max"
+};
+const CLAUDE_OFF = {
+	off: null,
+	xhigh: "xhigh",
+	max: "max"
+};
+/** Opus 5.5 accepts the full effort range. */
+const CLAUDE_FULL = {
+	off: null,
+	minimal: null,
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh",
+	max: "max"
+};
+const CLAUDE_ADAPTIVE = {
+	forceAdaptiveThinking: true,
+	supportsStrictTools: true
+};
+const CLAUDE_NO_TEMPERATURE = {
+	...CLAUDE_ADAPTIVE,
+	supportsTemperature: false
+};
+const CLAUDE_PROFILES = {
+	"claude-fable-5": {
+		reasoning: true,
+		thinkingLevelMap: CLAUDE_OFF,
+		input: ["text", "image"],
+		compat: CLAUDE_ADAPTIVE
+	},
+	"claude-opus-4-7": {
+		reasoning: true,
+		thinkingLevelMap: CLAUDE_XHIGHER,
+		input: ["text", "image"],
+		compat: CLAUDE_NO_TEMPERATURE
+	},
+	"claude-opus-4-8": {
+		reasoning: true,
+		thinkingLevelMap: CLAUDE_XHIGHER,
+		input: ["text", "image"],
+		compat: CLAUDE_NO_TEMPERATURE
+	},
+	"claude-opus-5": {
+		reasoning: true,
+		thinkingLevelMap: CLAUDE_OFF,
+		input: ["text", "image"],
+		compat: CLAUDE_NO_TEMPERATURE
+	},
+	"claude-opus-5-5": {
+		reasoning: true,
+		thinkingLevelMap: CLAUDE_FULL,
+		input: ["text", "image"],
+		compat: CLAUDE_NO_TEMPERATURE
+	}
+};
+function chatModelThinking(id) {
+	const claude = claudeThinking(id);
+	if (claude) return claude;
+	if (NO_REASONING.has(id)) return {
+		reasoning: false,
+		input: ["text", "image"]
+	};
+	const known = KNOWN[id];
+	if (known) return {
+		reasoning: true,
+		thinkingLevelMap: known,
+		input: visionInput(id)
+	};
+	if (/^gpt-6(?:[-.]|$)/iu.test(id)) return {
+		reasoning: true,
+		thinkingLevelMap: GPT_6,
+		input: ["text", "image"]
+	};
+	if (/^gpt-5\.6/iu.test(id)) return {
+		reasoning: true,
+		thinkingLevelMap: GPT_5_6,
+		input: ["text", "image"]
+	};
+	if (/^gpt-5\.(?:2|3|4|5)/iu.test(id)) return {
+		reasoning: true,
+		thinkingLevelMap: GPT_5_4,
+		input: ["text", "image"]
+	};
+	if (/^gpt-5\.1/iu.test(id)) return {
+		reasoning: true,
+		thinkingLevelMap: GPT_5_1,
+		input: ["text", "image"]
+	};
+	if (/^gpt-5(?:[-.]|$)/iu.test(id)) return {
+		reasoning: true,
+		thinkingLevelMap: GPT_5,
+		input: ["text", "image"]
+	};
+	if (/^(?:o1|o3|o4)(?:[-.]|$)/iu.test(id)) return {
+		reasoning: true,
+		thinkingLevelMap: O_SERIES,
+		input: ["text"]
+	};
+	if (/reason/iu.test(id)) return {
+		reasoning: true,
+		input: ["text"]
+	};
+	return {
+		reasoning: false,
+		input: ["text"]
+	};
+}
+function visionInput(id) {
+	return /^(?:gpt-5|gpt-6)/iu.test(id) ? ["text", "image"] : ["text"];
+}
+function claudeThinking(id) {
+	const known = CLAUDE_PROFILES[id];
+	if (known) return known;
+	if (!/^claude-/iu.test(id)) return;
+	if (/^claude-opus-5-5(?:[-.]|$)/iu.test(id)) return CLAUDE_PROFILES["claude-opus-5-5"];
+	if (/^claude-opus-5(?:[-.]|$)/iu.test(id)) return CLAUDE_PROFILES["claude-opus-5"];
+	if (/^claude-opus-4-8(?:[-.]|$)/iu.test(id)) return CLAUDE_PROFILES["claude-opus-4-8"];
+	if (/^claude-opus-4-7(?:[-.]|$)/iu.test(id)) return CLAUDE_PROFILES["claude-opus-4-7"];
+	if (/^claude-fable-/iu.test(id)) return CLAUDE_PROFILES["claude-fable-5"];
+	return {
+		reasoning: true,
+		thinkingLevelMap: CLAUDE_XHIGHER,
+		input: ["text", "image"],
+		compat: CLAUDE_NO_TEMPERATURE
+	};
+}
+//#endregion
+//#region src/discover.ts
+async function discoverChatModels(options) {
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	let models = parseChatModels(await fetchJson(fetchImpl, `${options.origin}/api/system/public/capability-docs`, options.signal));
+	if (options.apiKey) models = await filterByAccountModels(models, options, fetchImpl);
+	return models;
+}
+async function filterByAccountModels(models, options, fetchImpl) {
+	const apiKey = options.apiKey;
+	if (!apiKey) return models;
+	try {
+		const listed = await fetchJson(fetchImpl, `${options.origin}/v1/models`, options.signal, apiKey);
+		const allowed = new Set((listed.data ?? []).map((model) => model.id?.trim()).filter((id) => Boolean(id)));
+		if (allowed.size > 0) return models.filter((model) => allowed.has(model.id));
+		return models;
+	} catch (error) {
+		if (apiKey.startsWith("ddoa_") && error instanceof CatalogRequestError && error.status === 401) return models;
+		throw error;
+	}
+}
+function parseChatModels(docs) {
+	const models = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const capability of docs.data ?? []) {
+		const code = capability.capability_code?.trim() ?? "";
+		if (code !== "openai_chat_completions" && code !== "claude_messages") continue;
+		for (const model of capability.models ?? []) {
+			const id = model.model_code?.trim();
+			if (!id || !model.token_rate || seen.has(id)) continue;
+			seen.add(id);
+			models.push(toChatModel(id, model, code));
+		}
+	}
+	return models;
+}
+function toChatModel(id, model, capability) {
+	const rate = model.token_rate;
+	const thinking = chatModelThinking(id);
+	const api = chatApi(model, capability);
+	return {
+		id,
+		name: model.display_name?.trim() || id,
+		api,
+		reasoning: thinking.reasoning,
+		...thinking.thinkingLevelMap === void 0 ? {} : { thinkingLevelMap: thinking.thinkingLevelMap },
+		...thinking.compat === void 0 ? {} : { compat: thinking.compat },
+		input: thinking.input,
+		cost: chatCost(api, rate),
+		contextWindow: Math.max(1, rate?.context_window_tokens ?? 128e3),
+		maxTokens: Math.max(1, rate?.prepay_completion_token_limit ?? 16384)
+	};
+}
+function chatCost(api, rate) {
+	const input = rate?.input_usd_per_1m_tokens ?? 0;
+	const output = rate?.output_usd_per_1m_tokens ?? 0;
+	if (api === "anthropic-messages") return {
+		input,
+		output,
+		cacheRead: input * 2 / 20,
+		cacheWrite: input * 25 / 20
+	};
+	return {
+		input,
+		output,
+		cacheRead: rate?.billing_rules?.cache_read_usd_per_1m_tokens ?? input,
+		cacheWrite: rate?.billing_rules?.cache_write_usd_per_1m_tokens ?? input
+	};
+}
+var CatalogRequestError = class extends Error {
+	status;
+	constructor(status) {
+		super(status === 401 ? "D.AI 登录已失效。重新执行 omp login dai" : `D.AI 模型目录请求失败（${status}）`);
+		this.name = "CatalogRequestError";
+		this.status = status;
+	}
+};
+function chatApi(model, capability) {
+	const path = model.integration_docs?.path ?? "";
+	if (capability === "claude_messages" || path.includes("/v1/messages")) return "anthropic-messages";
+	if (path.includes("/responses")) return "openai-responses";
+	return "openai-completions";
+}
+async function fetchJson(fetchImpl, url, signal, apiKey) {
+	const headers = new Headers({ accept: "application/json" });
+	if (apiKey) headers.set("authorization", `Bearer ${apiKey}`);
+	const response = await fetchImpl(url, {
+		headers,
+		...signal ? { signal } : {}
+	});
+	if (!response.ok) throw new CatalogRequestError(response.status);
+	return await response.json();
+}
+//#endregion
+//#region ../typescript/dist/index.js
+var SdkError = class extends Error {
+	name = "SdkError";
+};
+var RequestAbortedError = class extends SdkError {
+	name = "RequestAbortedError";
+	constructor() {
+		super("D.AI media request was aborted");
+	}
+};
+var RequestTimeoutError = class extends SdkError {
+	timeoutMs;
+	name = "RequestTimeoutError";
+	constructor(timeoutMs) {
+		super(`D.AI media request timed out after ${timeoutMs}ms`);
+		this.timeoutMs = timeoutMs;
+	}
+};
+var ApiError = class extends SdkError {
+	status;
+	errorType;
+	code;
+	requestId;
+	bodyPreview;
+	raw;
+	name = "ApiError";
+	constructor(status, message, errorType, code, requestId, bodyPreview = "", raw) {
+		super(`${message} (HTTP ${status})`);
+		this.status = status;
+		this.errorType = errorType;
+		this.code = code;
+		this.requestId = requestId;
+		this.bodyPreview = bodyPreview;
+		this.raw = raw;
+	}
+};
+/** What the consent screen requests by default. */
+const DEFAULT_OAUTH_SCOPES = [
+	"openid",
+	"profile",
+	"email",
+	"offline_access"
+];
+/**
+* OAuth 2.1 + OIDC client for D.AI as the identity provider.
+*
+* Covers the protocol half of the authorization code flow: discovery, PKCE
+* authorization URLs, code exchange, refresh, revocation and userinfo. The
+* browser redirect, the loopback callback server and token storage belong to
+* the host application; `examples/oauth-demo` in the D.AI repository is a
+* complete Bun reference implementation.
+*
+* Public clients (the default) are PKCE-only. Create the client with a
+* `clientSecret` for confidential clients; token and revocation requests then
+* use HTTP Basic.
+*/
+var OAuthClient = class {
+	issuer;
+	clientId;
+	timeoutMs;
+	#clientSecret;
+	#redirectUri;
+	#scopes;
+	#headers;
+	#fetch;
+	#discovery;
+	#jwks;
+	constructor(configuration) {
+		const clientId = configuration.clientId?.trim() ?? "";
+		if (!clientId) throw new SdkError("clientId is required");
+		this.issuer = normalizeIssuer(configuration.issuer ?? "https://dai.itbug.shop");
+		this.clientId = clientId;
+		this.#clientSecret = configuration.clientSecret?.trim() ?? "";
+		this.#redirectUri = configuration.redirectUri;
+		this.#scopes = normalizeScope(configuration.scopes ?? DEFAULT_OAUTH_SCOPES);
+		this.timeoutMs = configuration.timeoutMs ?? 6e4;
+		if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) throw new SdkError("timeoutMs must be greater than zero");
+		this.#headers = new Headers(configuration.headers);
+		const fetchImplementation = configuration.fetch ?? globalThis.fetch;
+		if (typeof fetchImplementation !== "function") throw new SdkError("A Fetch API implementation is required");
+		this.#fetch = fetchImplementation.bind(globalThis);
+	}
+	/** Discovery document, fetched once and cached for the client's lifetime. */
+	async discover(options = {}) {
+		if (this.#discovery) return this.#discovery;
+		const { body } = await this.#request("GET", `${this.issuer}/.well-known/openid-configuration`, options);
+		this.#discovery = discoveryFromBody(body);
+		return this.#discovery;
+	}
+	/**
+	* Builds the browser authorization URL and the PKCE material for one login
+	* attempt. Send the user to `url`, keep `state` and `codeVerifier` in the
+	* host application, then pass them to {@link exchangeCode}.
+	*/
+	async authorizationUrl(options = {}) {
+		const discovery = await this.discover(options);
+		const redirectUri = options.redirectUri ?? this.#redirectUri;
+		if (!redirectUri) throw new SdkError("redirectUri is required; pass it here or set it in the configuration");
+		const scope = normalizeScope(options.scope ?? this.#scopes);
+		if (scope.length === 0) throw new SdkError("At least one scope is required");
+		const state = options.state ?? randomToken();
+		const nonce = options.nonce ?? randomToken();
+		const { codeVerifier, codeChallenge } = await createPkcePair();
+		const url = new URL(discovery.authorizationEndpoint);
+		url.searchParams.set("client_id", this.clientId);
+		url.searchParams.set("redirect_uri", redirectUri);
+		url.searchParams.set("response_type", "code");
+		url.searchParams.set("scope", scope.join(" "));
+		url.searchParams.set("state", state);
+		url.searchParams.set("nonce", nonce);
+		url.searchParams.set("code_challenge", codeChallenge);
+		url.searchParams.set("code_challenge_method", "S256");
+		if (options.prompt !== void 0) url.searchParams.set("prompt", options.prompt);
+		const scopeValue = scope.join(" ");
+		return {
+			url: url.toString(),
+			state,
+			nonce,
+			codeVerifier,
+			codeChallenge,
+			scope: scopeValue
+		};
+	}
+	/** Exchanges the callback `code` for tokens. Codes are single-use. */
+	async exchangeCode(request, options = {}) {
+		const discovery = await this.discover(options);
+		const form = new URLSearchParams({
+			grant_type: "authorization_code",
+			code: request.code,
+			client_id: this.clientId,
+			code_verifier: request.codeVerifier
+		});
+		const redirectUri = request.redirectUri ?? this.#redirectUri;
+		if (redirectUri) form.set("redirect_uri", redirectUri);
+		const { body } = await this.#request("POST", discovery.tokenEndpoint, {
+			...options,
+			form,
+			basic: this.#clientSecret.length > 0
+		});
+		return tokensFromBody(body);
+	}
+	/**
+	* Rotates the refresh token. D.AI invalidates the old one immediately;
+	* replaying a rotated token revokes the whole token family server-side.
+	*/
+	async refresh(refreshToken, options = {}) {
+		const discovery = await this.discover(options);
+		const form = new URLSearchParams({
+			grant_type: "refresh_token",
+			refresh_token: refreshToken,
+			client_id: this.clientId
+		});
+		if (options.scope !== void 0) {
+			const scope = normalizeScope(options.scope);
+			if (scope.length === 0) throw new SdkError("scope cannot be empty when narrowing a refresh");
+			form.set("scope", scope.join(" "));
+		}
+		const { body } = await this.#request("POST", discovery.tokenEndpoint, {
+			...options,
+			form,
+			basic: this.#clientSecret.length > 0
+		});
+		return tokensFromBody(body);
+	}
+	/** RFC 7009 revocation. Unknown or foreign tokens are accepted silently. */
+	async revoke(token, options = {}) {
+		const discovery = await this.discover(options);
+		if (!discovery.revocationEndpoint) throw new SdkError("The issuer does not advertise a revocation endpoint");
+		await this.#request("POST", discovery.revocationEndpoint, {
+			...options,
+			form: new URLSearchParams({
+				token,
+				client_id: this.clientId
+			}),
+			basic: this.#clientSecret.length > 0
+		});
+	}
+	/** OIDC userinfo; fields are trimmed by the granted scope. */
+	async userinfo(accessToken, options = {}) {
+		const discovery = await this.discover(options);
+		const { body } = await this.#request("GET", discovery.userinfoEndpoint, {
+			...options,
+			bearer: accessToken
+		});
+		return userInfoFromBody(body);
+	}
+	/**
+	* Verifies an id_token against the issuer's JWKS with WebCrypto (RS256).
+	* No JWT dependency is needed. `nonce` is checked only when supplied.
+	*/
+	async verifyIdToken(idToken, options = {}) {
+		const [headerPart, payloadPart, signaturePart] = idToken.split(".");
+		if (!headerPart || !payloadPart || !signaturePart) throw new SdkError("id_token is not a valid JWT");
+		const header = decodeJsonPart(headerPart);
+		const claims = decodeJsonPart(payloadPart);
+		const algorithm = header.alg === "RS256";
+		const jwks = options.jwks ?? await this.#loadJwks(options);
+		const key = jwks.keys.find((candidate) => candidate.kid === header.kid) ?? jwks.keys[0];
+		if (!key) throw new SdkError("JWKS contains no usable key");
+		const subtle = requireWebCrypto().subtle;
+		const cryptoKey = await subtle.importKey("jwk", key, {
+			name: "RSASSA-PKCS1-v1_5",
+			hash: "SHA-256"
+		}, false, ["verify"]);
+		const signature = await subtle.verify({ name: "RSASSA-PKCS1-v1_5" }, cryptoKey, decodeBase64UrlBytes(signaturePart), new TextEncoder().encode(`${headerPart}.${payloadPart}`));
+		const audience = Array.isArray(claims.aud) ? claims.aud : claims.aud ? [claims.aud] : [];
+		const expectedIssuer = options.issuer ?? (await this.discover(options)).issuer;
+		const checks = {
+			algorithm,
+			signature,
+			issuer: claims.iss === expectedIssuer,
+			audience: audience.includes(options.clientId ?? this.clientId),
+			expiry: typeof claims.exp === "number" && claims.exp > Date.now() / 1e3,
+			nonce: options.nonce === void 0 || claims.nonce === options.nonce
+		};
+		return {
+			valid: Object.values(checks).every(Boolean),
+			header,
+			claims,
+			checks
+		};
+	}
+	async #loadJwks(options) {
+		if (this.#jwks) return this.#jwks;
+		const discovery = await this.discover(options);
+		const { body } = await this.#request("GET", discovery.jwksUri, options);
+		const keys = body.keys;
+		if (!Array.isArray(keys)) throw new SdkError("The JWKS document has no keys");
+		this.#jwks = { keys };
+		return this.#jwks;
+	}
+	async #request(method, url, options) {
+		const controller = new AbortController();
+		const forwardAbort = () => controller.abort(options.signal?.reason);
+		if (options.signal) {
+			if (options.signal.aborted) forwardAbort();
+			else options.signal.addEventListener("abort", forwardAbort, { once: true });
+		}
+		const timeout = setTimeout(() => controller.abort(new RequestTimeoutError(this.timeoutMs)), this.timeoutMs);
+		try {
+			const headers = new Headers(this.#headers);
+			mergeHeaders(headers, options.headers);
+			let body;
+			if (options.form) {
+				body = options.form;
+				headers.set("content-type", "application/x-www-form-urlencoded");
+			}
+			if (options.bearer !== void 0) headers.set("authorization", `Bearer ${options.bearer}`);
+			if (options.basic) {
+				if (this.#clientSecret.length === 0) throw new SdkError("A client secret is required for confidential client auth");
+				headers.set("authorization", `Basic ${base64Encode(new TextEncoder().encode(`${this.clientId}:${this.#clientSecret}`))}`);
+			}
+			const response = await this.#fetch(url, {
+				method,
+				headers,
+				...body === void 0 ? {} : { body },
+				signal: controller.signal,
+				redirect: "manual"
+			});
+			const text = await response.text();
+			let body_ = {};
+			if (text.length > 0) try {
+				const parsed = JSON.parse(text);
+				if (isJsonObject(parsed)) body_ = parsed;
+			} catch {}
+			if (!response.ok) throw apiErrorFrom(response, body_, text);
+			return {
+				status: response.status,
+				body: body_
+			};
+		} catch (error) {
+			if (controller.signal.aborted) {
+				const reason = controller.signal.reason;
+				if (reason instanceof RequestTimeoutError) throw reason;
+				throw new RequestAbortedError();
+			}
+			throw error;
+		} finally {
+			clearTimeout(timeout);
+			options.signal?.removeEventListener("abort", forwardAbort);
+		}
+	}
+};
+function normalizeIssuer(value) {
+	const issuer = value.trim().replace(/\/+$/, "");
+	if (!issuer) throw new SdkError("issuer is required");
+	try {
+		new URL(issuer);
+	} catch {
+		throw new SdkError(`issuer is not a valid URL: ${issuer}`);
+	}
+	return issuer;
+}
+function normalizeScope(value) {
+	return (typeof value === "string" ? value.split(/\s+/) : [...value]).map((item) => item.trim()).filter((item) => item.length > 0);
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function stringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string");
+}
+function discoveryFromBody(body) {
+	const issuer = stringValue(body.issuer);
+	const authorizationEndpoint = stringValue(body.authorization_endpoint);
+	const tokenEndpoint = stringValue(body.token_endpoint);
+	const userinfoEndpoint = stringValue(body.userinfo_endpoint);
+	const jwksUri = stringValue(body.jwks_uri);
+	const revocationEndpoint = stringValue(body.revocation_endpoint);
+	if (!issuer || !authorizationEndpoint || !tokenEndpoint || !userinfoEndpoint || !jwksUri) throw new SdkError("The discovery document is missing required endpoints");
+	return {
+		issuer,
+		authorizationEndpoint,
+		tokenEndpoint,
+		userinfoEndpoint,
+		jwksUri,
+		...revocationEndpoint === void 0 ? {} : { revocationEndpoint },
+		scopesSupported: stringArray(body.scopes_supported),
+		responseTypesSupported: stringArray(body.response_types_supported),
+		grantTypesSupported: stringArray(body.grant_types_supported),
+		codeChallengeMethodsSupported: stringArray(body.code_challenge_methods_supported),
+		tokenEndpointAuthMethodsSupported: stringArray(body.token_endpoint_auth_methods_supported),
+		idTokenSigningAlgValuesSupported: stringArray(body.id_token_signing_alg_values_supported),
+		claimsSupported: stringArray(body.claims_supported)
+	};
+}
+function tokensFromBody(body) {
+	const accessToken = stringValue(body.access_token);
+	if (!accessToken) throw new SdkError("The token response is missing access_token");
+	const expiresIn = typeof body.expires_in === "number" ? body.expires_in : NaN;
+	if (!Number.isFinite(expiresIn)) throw new SdkError("The token response is missing expires_in");
+	const refreshToken = stringValue(body.refresh_token);
+	const idToken = stringValue(body.id_token);
+	return {
+		accessToken,
+		tokenType: stringValue(body.token_type) ?? "Bearer",
+		expiresIn,
+		scope: stringValue(body.scope) ?? "",
+		...refreshToken === void 0 ? {} : { refreshToken },
+		...idToken === void 0 ? {} : { idToken }
+	};
+}
+function userInfoFromBody(body) {
+	const sub = stringValue(body.sub);
+	if (!sub) throw new SdkError("The userinfo response is missing sub");
+	const optional = {};
+	for (const [field, key] of [
+		["preferred_username", "preferredUsername"],
+		["name", "name"],
+		["picture", "picture"],
+		["email", "email"],
+		["role", "role"],
+		["user_tier", "userTier"]
+	]) {
+		const value = stringValue(body[field]);
+		if (value !== void 0) optional[key] = value;
+	}
+	if (typeof body.email_verified === "boolean") optional.emailVerified = body.email_verified;
+	return {
+		sub,
+		...optional
+	};
+}
+function apiErrorFrom(response, body, text) {
+	const errorType = stringValue(body.error);
+	const message = stringValue(body.error_description) ?? errorType ?? response.statusText ?? `HTTP ${response.status}`;
+	return new ApiError(response.status, message, errorType, void 0, response.headers.get("x-request-id") ?? void 0, text.slice(0, 2e3), body);
+}
+function mergeHeaders(target, source) {
+	if (source === void 0) return;
+	for (const [name, value] of new Headers(source)) target.set(name, value);
+}
+function requireWebCrypto() {
+	const crypto = globalThis.crypto;
+	if (!crypto?.subtle) throw new SdkError("WebCrypto is required for PKCE and id_token verification");
+	return crypto;
+}
+function randomToken(bytes = 32) {
+	const buffer = new Uint8Array(bytes);
+	requireWebCrypto().getRandomValues(buffer);
+	return base64UrlEncode(buffer);
+}
+async function createPkcePair() {
+	const codeVerifier = randomToken(32);
+	const digest = await requireWebCrypto().subtle.digest("SHA-256", new TextEncoder().encode(codeVerifier));
+	return {
+		codeVerifier,
+		codeChallenge: base64UrlEncode(new Uint8Array(digest))
+	};
+}
+function base64Encode(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+function base64UrlEncode(bytes) {
+	return base64Encode(bytes).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function decodeBase64UrlBytes(value) {
+	const normalized = value.replaceAll("-", "+").replaceAll("_", "/");
+	const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+	const binary = atob(padded);
+	const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+	for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+	return bytes;
+}
+function decodeJsonPart(part) {
+	try {
+		const parsed = JSON.parse(new TextDecoder().decode(decodeBase64UrlBytes(part)));
+		if (!isJsonObject(parsed)) throw new Error("not an object");
+		return parsed;
+	} catch {
+		throw new SdkError("id_token contains an invalid JWT segment");
+	}
+}
+//#endregion
+//#region src/target.ts
+const PROD_ORIGIN = "https://dai.itbug.shop";
+const PROD_CLIENT_ID = "ddc_Go98eEOhzDjmvw5k09CM";
+const DEV_CLIENT_ID = "ddc_SgjSciyD25ZhE6zJ7ZVU";
+const CALLBACK_HOST = "127.0.0.1";
+const CALLBACK_PORT = 53682;
+const CALLBACK_URL = `http://${CALLBACK_HOST}:${CALLBACK_PORT}/callback`;
+const OAUTH_SCOPES = [
+	"openid",
+	"profile",
+	"email",
+	"offline_access",
+	"media"
+];
+function explicitDaiOrigin(env = process.env) {
+	const value = firstNonEmpty(env.DAI_ISSUER, env.DAI_BASE_URL);
+	return value === void 0 ? void 0 : normalizeOrigin(value);
+}
+function resolveDaiTarget(env = process.env) {
+	const origin = explicitDaiOrigin(env) ?? "https://dai.itbug.shop";
+	const override = env.DAI_OMP_CLIENT_ID?.trim();
+	if (override) return {
+		origin,
+		clientId: override
+	};
+	if (isLoopbackOrigin(origin)) return {
+		origin,
+		clientId: DEV_CLIENT_ID
+	};
+	if (origin === "https://dai.itbug.shop") return {
+		origin,
+		clientId: PROD_CLIENT_ID
+	};
+	throw new Error(`没有 ${origin} 对应的 OAuth client。设置 DAI_OMP_CLIENT_ID，或使用 ${PROD_ORIGIN}`);
+}
+function normalizeOrigin(value) {
+	const trimmed = value.trim();
+	if (!trimmed) throw new Error("DAI_BASE_URL 不能为空");
+	let url;
+	try {
+		url = new URL(trimmed);
+	} catch {
+		throw new Error(`DAI_BASE_URL 不是合法地址：${trimmed}`);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("DAI_BASE_URL 必须是 http 或 https");
+	const path = url.pathname.replace(/\/+$/u, "").replace(/\/v1$/u, "");
+	if (path && path !== "/") throw new Error("DAI_BASE_URL 只能是站点根地址，不要带路径");
+	return url.origin;
+}
+function isLoopbackOrigin(origin) {
+	const hostname = new URL(origin).hostname;
+	return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "[::1]" || hostname === "::1";
+}
+function firstNonEmpty(...values) {
+	for (const value of values) {
+		const trimmed = value?.trim();
+		if (trimmed) return trimmed;
+	}
+}
+//#endregion
+//#region src/callback.ts
+const CALLBACK_TIMEOUT_MS = 18e4;
+function waitForOAuthCallback(options) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const server = createServer((request, response) => {
+			handleCallback(request, response, options.expectedState, finish);
+		});
+		const timer = setTimeout(() => {
+			finish(/* @__PURE__ */ new Error("浏览器授权超时（3 分钟）。重新执行 omp login dai"));
+		}, CALLBACK_TIMEOUT_MS);
+		const onAbort = () => {
+			finish(/* @__PURE__ */ new Error("登录已取消"));
+		};
+		function finish(error, code) {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			options.signal?.removeEventListener("abort", onAbort);
+			server.close();
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve(code ?? "");
+		}
+		if (options.signal?.aborted) {
+			finish(/* @__PURE__ */ new Error("登录已取消"));
+			return;
+		}
+		options.signal?.addEventListener("abort", onAbort, { once: true });
+		server.on("error", (error) => {
+			if (error.code === "EADDRINUSE") {
+				finish(/* @__PURE__ */ new Error("回调端口 53682 已被占用。关掉占用它的程序后重试"));
+				return;
+			}
+			finish(error);
+		});
+		server.listen(CALLBACK_PORT, CALLBACK_HOST, () => {
+			try {
+				options.onListening?.();
+			} catch (error) {
+				finish(error instanceof Error ? error : new Error(String(error)));
+			}
+		});
+	});
+}
+function handleCallback(request, response, expectedState, finish) {
+	const url = new URL(request.url ?? "/", CALLBACK_URL);
+	if (request.method !== "GET" || url.pathname !== "/callback") {
+		sendHtml(response, 404, "找不到页面");
+		return;
+	}
+	const oauthError = url.searchParams.get("error");
+	if (oauthError) {
+		const description = url.searchParams.get("error_description") ?? oauthError;
+		sendHtml(response, 400, "授权没有完成，回到终端查看原因。", () => {
+			finish(/* @__PURE__ */ new Error(`D.AI 授权失败：${description}`));
+		});
+		return;
+	}
+	const state = url.searchParams.get("state");
+	const code = url.searchParams.get("code")?.trim();
+	if (state !== expectedState || !code) {
+		sendHtml(response, 400, "授权回调无效。回到终端重新登录。", () => {
+			finish(/* @__PURE__ */ new Error("授权回调的 state 或 code 无效"));
+		});
+		return;
+	}
+	sendHtml(response, 200, "D.AI 授权完成。可以关闭这个页面，回到 omp。", () => {
+		finish(void 0, code);
+	});
+}
+function sendHtml(response, status, message, onDone) {
+	const body = `<!doctype html><meta charset="utf-8"><title>D.AI</title><p>${escapeHtml(message)}</p>`;
+	if (onDone) response.on("finish", onDone);
+	response.writeHead(status, {
+		"content-type": "text/html; charset=utf-8",
+		"cache-control": "no-store"
+	});
+	response.end(body);
+}
+function escapeHtml(value) {
+	return value.replace(/[&<>"]/gu, (char) => {
+		switch (char) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			default: return "&quot;";
+		}
+	});
+}
+//#endregion
+//#region src/login.ts
+async function loginDai(callbacks, env = process.env) {
+	const choice = (await callbacks.onPrompt({
+		message: "D.AI 登录方式：1 浏览器授权，2 粘贴 API key",
+		placeholder: "1"
+	})).trim().toLowerCase();
+	if (choice === "2" || choice === "key" || choice === "apikey") return promptApiKey(callbacks);
+	if (choice === "1" || choice === "oauth") return browserLogin(callbacks, resolveDaiTarget(env));
+	throw new Error("请输入 1（浏览器授权）或 2（粘贴 API key）");
+}
+async function refreshDaiToken(credentials, env = process.env, signal) {
+	if (credentials.access.startsWith("ddsk_")) return credentials;
+	const target = targetFromCredentials(credentials, env);
+	const client = oauthClient(target);
+	const request = signal ? { signal } : {};
+	const tokens = await client.refresh(credentials.refresh, request);
+	if (!tokens.refreshToken) throw new Error("刷新结果没有 refresh token。重新执行 omp login dai");
+	return {
+		access: tokens.accessToken,
+		refresh: tokens.refreshToken,
+		expires: Date.now() + tokens.expiresIn * 1e3,
+		apiEndpoint: target.origin,
+		projectId: target.clientId,
+		...credentials.accountId === void 0 ? {} : { accountId: credentials.accountId },
+		...credentials.email === void 0 ? {} : { email: credentials.email }
+	};
+}
+function daiApiKey(credentials) {
+	return credentials.access;
+}
+async function promptApiKey(callbacks) {
+	const key = (await callbacks.onPrompt({
+		message: "D.AI API key（ddsk_...）",
+		secret: true
+	})).trim();
+	if (!key.startsWith("ddsk_")) throw new Error("API key 必须以 ddsk_ 开头");
+	return key;
+}
+async function browserLogin(callbacks, target) {
+	const client = oauthClient(target);
+	const request = callbacks.signal ? { signal: callbacks.signal } : {};
+	let pending;
+	try {
+		pending = await client.authorizationUrl(request);
+	} catch (error) {
+		throw new Error(loginError(error));
+	}
+	callbacks.onProgress?.(`打开浏览器登录 ${target.origin}`);
+	const code = await waitForOAuthCallback({
+		expectedState: pending.state,
+		...callbacks.signal ? { signal: callbacks.signal } : {},
+		onListening() {
+			callbacks.onAuth({
+				url: pending.url,
+				instructions: "在浏览器登录 D.AI 并同意授权。完成后回到终端。"
+			});
+		}
+	});
+	let tokens;
+	try {
+		tokens = await client.exchangeCode({
+			code,
+			codeVerifier: pending.codeVerifier,
+			redirectUri: CALLBACK_URL
+		}, request);
+	} catch (error) {
+		throw new Error(loginError(error));
+	}
+	if (!tokens.refreshToken) throw new Error("授权结果没有 refresh token。确认客户端允许 offline_access");
+	const identity = await readIdentity(client, tokens.accessToken, callbacks.signal);
+	return {
+		access: tokens.accessToken,
+		refresh: tokens.refreshToken,
+		expires: Date.now() + tokens.expiresIn * 1e3,
+		apiEndpoint: target.origin,
+		projectId: target.clientId,
+		...identity.accountId === void 0 ? {} : { accountId: identity.accountId },
+		...identity.email === void 0 ? {} : { email: identity.email }
+	};
+}
+function oauthClient(target) {
+	return new OAuthClient({
+		issuer: target.origin,
+		clientId: target.clientId,
+		redirectUri: CALLBACK_URL,
+		scopes: OAUTH_SCOPES
+	});
+}
+function targetFromCredentials(credentials, env) {
+	if (credentials.apiEndpoint && credentials.projectId) return {
+		origin: credentials.apiEndpoint,
+		clientId: credentials.projectId
+	};
+	return resolveDaiTarget({
+		...env,
+		...credentials.apiEndpoint === void 0 ? {} : { DAI_ISSUER: credentials.apiEndpoint }
+	});
+}
+async function readIdentity(client, accessToken, signal) {
+	try {
+		const info = await client.userinfo(accessToken, signal ? { signal } : {});
+		return {
+			accountId: info.sub,
+			...info.email ? { email: info.email } : {}
+		};
+	} catch {
+		return {};
+	}
+}
+function loginError(error) {
+	if (error instanceof SdkError) return `D.AI 登录失败：${error.message}`;
+	if (error instanceof Error) return error.message;
+	return "D.AI 登录失败";
+}
+//#endregion
+//#region src/models.ts
+const EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+function toOmpChatModels(models, origin) {
+	return expandClaudeChatModels(models).map((model) => toOmpChatModel(model, origin));
+}
+function chatModelBaseUrl(origin, api) {
+	return api === "anthropic-messages" ? origin : `${origin}/v1`;
+}
+function toOmpChatModel(model, origin) {
+	const thinking = ompThinking(model);
+	return {
+		id: model.id,
+		name: model.name,
+		api: model.api,
+		baseUrl: chatModelBaseUrl(origin, model.api),
+		reasoning: model.reasoning,
+		input: model.input,
+		cost: model.cost,
+		contextWindow: model.contextWindow,
+		maxTokens: model.maxTokens,
+		supportsTools: true,
+		...thinking
+	};
+}
+function ompThinking(model) {
+	const map = model.thinkingLevelMap;
+	if (!model.reasoning || map === void 0) return {};
+	const efforts = EFFORTS.filter((level) => typeof map[level] === "string");
+	const effortMap = {};
+	for (const level of efforts) {
+		const wire = map[level];
+		if (typeof wire === "string" && wire !== level) effortMap[level] = wire;
+	}
+	const mapped = Object.keys(effortMap).length > 0;
+	return {
+		thinking: {
+			efforts,
+			requiresEffort: map.off === null || map.off === void 0,
+			...mapped ? { effortMap } : {}
+		},
+		...model.api === "anthropic-messages" ? {} : { compat: {
+			supportsReasoningEffort: true,
+			...mapped ? { reasoningEffortMap: effortMap } : {}
+		} }
+	};
+}
+//#endregion
+//#region src/stored-origin.ts
+async function resolveDiscoveryOrigin(apiKey, env = process.env) {
+	const explicit = explicitDaiOrigin(env);
+	if (explicit !== void 0) return explicit;
+	if (apiKey?.startsWith("ddoa_")) {
+		const stored = await readStoredOauthOrigin(env);
+		if (stored !== void 0) return stored;
+	}
+	return PROD_ORIGIN;
+}
+async function readStoredOauthOrigin(env) {
+	const dbPath = agentDbPath(env);
+	if (!existsSync(dbPath)) return;
+	let db;
+	try {
+		db = await openReadonly(dbPath);
+		if (db === void 0) return;
+		const row = db.get("SELECT data FROM auth_credentials WHERE provider = ? AND credential_type = ? ORDER BY updated_at DESC LIMIT 1", "dai", "oauth");
+		if (row === void 0) return;
+		const parsed = JSON.parse(row.data);
+		return typeof parsed.apiEndpoint === "string" ? normalizeOrigin(parsed.apiEndpoint) : void 0;
+	} catch {
+		return;
+	} finally {
+		db?.close();
+	}
+}
+function agentDbPath(env) {
+	const override = env.PI_CODING_AGENT_DIR?.trim();
+	if (override) return join(override, "agent.db");
+	const configRoot = env.PI_CONFIG_DIR?.trim() || join(homedir(), ".omp");
+	const profile = env.OMP_PROFILE?.trim() || env.PI_PROFILE?.trim();
+	const agentDir = profile ? join(configRoot, "profiles", profile, "agent") : join(configRoot, "agent");
+	return join(agentDir, "agent.db");
+}
+async function openReadonly(dbPath) {
+	const bunDb = await openBun(dbPath);
+	if (bunDb !== void 0) return bunDb;
+	return openNode(dbPath);
+}
+async function openBun(dbPath) {
+	try {
+		const db = new (await (import("bun:sqlite"))).Database(dbPath, { readonly: true });
+		return wrap(db.query.bind(db), () => db.close());
+	} catch {
+		return;
+	}
+}
+async function openNode(dbPath) {
+	try {
+		const db = new (await (import("node:sqlite"))).DatabaseSync(dbPath, { readOnly: true });
+		return wrap((sql) => db.prepare(sql), () => db.close());
+	} catch {
+		return;
+	}
+}
+function wrap(prepare, close) {
+	return {
+		get(sql, ...params) {
+			const row = prepare(sql).get(...params);
+			if (row === null || row === void 0 || typeof row !== "object" || !("data" in row)) return;
+			const data = row.data;
+			return typeof data === "string" ? { data } : void 0;
+		},
+		close
+	};
+}
+//#endregion
+//#region src/provider.ts
+function registerDaiProvider(pi) {
+	pi.on("before_provider_request", (event) => rewriteClaudeProviderPayload(event.payload));
+	pi.registerProvider("dai", {
+		name: "D.AI",
+		baseUrl: "https://dai.itbug.shop/v1",
+		api: "openai-completions",
+		apiKey: "DAI_API_KEY",
+		authHeader: true,
+		models: [],
+		async fetchDynamicModels(apiKey) {
+			const key = typeof apiKey === "string" ? apiKey.trim() : "";
+			const origin = await resolveDiscoveryOrigin(key || void 0);
+			return toOmpChatModels(await discoverChatModels({
+				origin,
+				...key ? { apiKey: key } : {}
+			}), origin);
+		},
+		oauth: {
+			name: "D.AI",
+			login(callbacks) {
+				return loginDai(callbacks);
+			},
+			refreshToken(credentials, signal) {
+				return refreshDaiToken(credentials, process.env, signal);
+			},
+			getApiKey: daiApiKey
+		}
+	});
+}
+//#endregion
+//#region src/index.ts
+function daiOmp(pi) {
+	registerDaiProvider(pi);
+}
+//#endregion
+export { daiOmp as default };

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "@d-ai/omp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "omp plugin: log in to D.AI and use its text models",
+  "license": "MIT",
+  "type": "module",
+  "keywords": ["omp-plugin", "pi-package"],
+  "homepage": "https://dai.itbug.shop",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mdddj/dd_server_rust_private.git",
+    "directory": "sdks/omp"
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "check": "npm run typecheck && npm run build",
+    "prepublishOnly": "npm run check"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@d-ai/media-sdk": "file:../typescript",
+    "@types/node": "^26.6.3",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2"
+  },
+  "omp": {
+    "extensions": ["./dist/index.js"]
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}