@xiaozhiclaw/provider-core-server 0.1.0

package/dist/auth.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingMessage } from "node:http";
+export declare function isAuthorized(req: IncomingMessage, serviceToken?: string): boolean;

package/dist/auth.js

@@ -0,0 +1,9 @@
+export function isAuthorized(req, serviceToken) {
+    if (!serviceToken)
+        return true;
+    const authHeader = req.headers.authorization;
+    if (authHeader === `Bearer ${serviceToken}`)
+        return true;
+    const headerToken = req.headers["x-provider-core-token"];
+    return headerToken === serviceToken;
+}

package/dist/cluster.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveProviderCoreWorkerCount(env?: NodeJS.ProcessEnv, cpuCount?: number): number;
+export declare function startProviderCoreCluster(): void;

package/dist/cluster.js

@@ -0,0 +1,44 @@
+import cluster from "node:cluster";
+import os from "node:os";
+import { loadConfig } from "./config.js";
+import { createProviderCoreServer } from "./server.js";
+export function resolveProviderCoreWorkerCount(env = process.env, cpuCount = os.availableParallelism()) {
+    const requested = Number.parseInt(env.PROVIDER_CORE_WORKERS ?? "", 10);
+    const defaultWorkers = Math.min(2, Math.max(1, cpuCount));
+    const workers = Number.isFinite(requested) && requested > 0 ? requested : defaultWorkers;
+    return Math.max(1, Math.min(workers, Math.max(1, cpuCount)));
+}
+export function startProviderCoreCluster() {
+    if (!cluster.isPrimary) {
+        const config = loadConfig();
+        const server = createProviderCoreServer(config);
+        server.listen(config.port, config.host, () => {
+            console.log(`Provider Core worker ${process.pid} listening on http://${config.host}:${config.port}`);
+        });
+        return;
+    }
+    const workerCount = resolveProviderCoreWorkerCount();
+    console.log(`Provider Core cluster primary ${process.pid} starting ${workerCount} workers`);
+    let shuttingDown = false;
+    for (let i = 0; i < workerCount; i += 1) {
+        cluster.fork();
+    }
+    cluster.on("exit", (worker, code, signal) => {
+        if (shuttingDown)
+            return;
+        console.error(`Provider Core worker ${worker.process.pid ?? "unknown"} exited (${code ?? signal}); restarting`);
+        cluster.fork();
+    });
+    const shutdown = () => {
+        shuttingDown = true;
+        for (const worker of Object.values(cluster.workers ?? {})) {
+            worker?.disconnect();
+        }
+        setTimeout(() => process.exit(0), 20_000).unref();
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    startProviderCoreCluster();
+}

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+export interface ProviderCoreServerConfig {
+    host: string;
+    port: number;
+    serviceToken?: string;
+    version: string;
+    runtime: "fixture" | "real";
+    credentialResolver: "env" | "external" | "external_optional";
+    keyPoolUrl?: string;
+    keyPoolToken?: string;
+    keyPoolTimeoutMs: number;
+}
+export declare function loadConfig(env?: NodeJS.ProcessEnv): ProviderCoreServerConfig;

package/dist/config.js

@@ -0,0 +1,17 @@
+export function loadConfig(env = process.env) {
+    return {
+        host: env.PROVIDER_CORE_HOST ?? "127.0.0.1",
+        port: Number(env.PROVIDER_CORE_PORT ?? "8787"),
+        serviceToken: env.PROVIDER_CORE_TOKEN,
+        version: env.PROVIDER_CORE_VERSION ?? "0.1.0",
+        runtime: env.PROVIDER_CORE_RUNTIME === "real" ? "real" : "fixture",
+        credentialResolver: env.PROVIDER_CORE_CREDENTIAL_RESOLVER === "external"
+            ? "external"
+            : env.PROVIDER_CORE_CREDENTIAL_RESOLVER === "external_optional"
+                ? "external_optional"
+                : "env",
+        keyPoolUrl: env.PROVIDER_CORE_KEY_POOL_URL,
+        keyPoolToken: env.PROVIDER_CORE_KEY_POOL_TOKEN,
+        keyPoolTimeoutMs: Number(env.PROVIDER_CORE_KEY_POOL_TIMEOUT_MS ?? "3000"),
+    };
+}

package/dist/credential-resolver.d.ts

@@ -0,0 +1,49 @@
+import type { ProviderRegistry } from "@xiaozhiclaw/provider-core";
+import type { ProviderCoreRequest } from "./request-normalizer.js";
+export interface ResolvedCredential {
+    apiKey: string;
+    baseUrl?: string;
+    source: "env" | "key-pool";
+    leaseId?: string;
+    credentialId?: string;
+    egressMode?: "direct" | "regional_proxy";
+    egressRegion?: string;
+    egressEndpoint?: string;
+}
+export interface CredentialResolveContext {
+    request: ProviderCoreRequest;
+    registry: Pick<ProviderRegistry, "resolveApiKey">;
+}
+export interface CredentialReport {
+    success: boolean;
+    statusCode?: number;
+    errorType?: string;
+    errorMessage?: string;
+    latencyMs?: number;
+    promptTokens?: number;
+    completionTokens?: number;
+}
+export interface CredentialResolver {
+    resolve(context: CredentialResolveContext): Promise<ResolvedCredential>;
+    report?(credential: ResolvedCredential, report: CredentialReport): Promise<void>;
+}
+export declare class EnvCredentialResolver implements CredentialResolver {
+    resolve(context: CredentialResolveContext): Promise<ResolvedCredential>;
+}
+export interface ExternalKeyPoolResolverConfig {
+    url?: string;
+    token?: string;
+    mode: "external" | "external_optional";
+    timeoutMs?: number;
+    fallback?: CredentialResolver;
+}
+export declare class ExternalKeyPoolResolver implements CredentialResolver {
+    private readonly baseUrl;
+    private readonly token?;
+    private readonly mode;
+    private readonly timeoutMs;
+    private readonly fallback;
+    constructor(config: ExternalKeyPoolResolverConfig);
+    resolve(context: CredentialResolveContext): Promise<ResolvedCredential>;
+    report(credential: ResolvedCredential, report: CredentialReport): Promise<void>;
+}

package/dist/credential-resolver.js

@@ -0,0 +1,116 @@
+export class EnvCredentialResolver {
+    async resolve(context) {
+        const apiKey = context.registry.resolveApiKey(context.request.provider);
+        if (!apiKey)
+            throw new Error(`Missing API key for provider: ${context.request.provider}`);
+        return { apiKey, source: "env" };
+    }
+}
+export class ExternalKeyPoolResolver {
+    baseUrl;
+    token;
+    mode;
+    timeoutMs;
+    fallback;
+    constructor(config) {
+        if (!config.url && config.mode === "external") {
+            throw new Error("PROVIDER_CORE_KEY_POOL_URL is required when credential resolver is external");
+        }
+        this.baseUrl = (config.url ?? "").replace(/\/$/, "");
+        this.token = config.token;
+        this.mode = config.mode;
+        this.timeoutMs = config.timeoutMs ?? 3000;
+        this.fallback = config.fallback ?? new EnvCredentialResolver();
+    }
+    async resolve(context) {
+        if (!this.baseUrl)
+            return this.fallback.resolve(context);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const metadata = context.request.metadata;
+            const response = await fetch(`${this.baseUrl}/lease`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    ...(this.token ? { authorization: `Bearer ${this.token}` } : {}),
+                },
+                body: JSON.stringify({
+                    provider: context.request.provider,
+                    public_model: context.request.metadata?.publicModel ?? context.request.model,
+                    native_model: context.request.model,
+                    request_id: context.request.metadata?.requestId ?? `provider_core_${Date.now().toString(36)}`,
+                    protocol: context.request.protocol,
+                    user_id: metadata?.userId,
+                    session_id: metadata?.sessionId ?? metadata?.workspaceId,
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok)
+                throw new Error(`Key Pool lease failed: ${response.status}`);
+            const body = await response.json();
+            const data = body.data ?? {};
+            const apiKey = String(data.api_key ?? data.apiKey ?? "");
+            if (!apiKey)
+                throw new Error("Key Pool lease response missing api_key");
+            const egressMode = normalizeEgressMode(data.egress_mode ?? data.egressMode);
+            const egressEndpoint = typeof data.egress_endpoint === "string" ? data.egress_endpoint
+                : typeof data.egressEndpoint === "string" ? data.egressEndpoint
+                    : undefined;
+            return {
+                apiKey,
+                baseUrl: resolveBaseUrlForEgress({
+                    apiBase: typeof data.api_base === "string" ? data.api_base : typeof data.apiBase === "string" ? data.apiBase : undefined,
+                    egressMode,
+                    egressEndpoint,
+                }),
+                source: "key-pool",
+                leaseId: String(data.lease_id ?? data.leaseId ?? ""),
+                credentialId: String(data.credential_id ?? data.credentialId ?? ""),
+                egressMode,
+                egressRegion: String(data.egress_region ?? data.egressRegion ?? "local"),
+                egressEndpoint,
+            };
+        }
+        catch (error) {
+            if (this.mode === "external_optional") {
+                return this.fallback.resolve(context);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async report(credential, report) {
+        if (!credential.leaseId || !this.baseUrl)
+            return;
+        await fetch(`${this.baseUrl}/leases/${encodeURIComponent(credential.leaseId)}/report`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                ...(this.token ? { authorization: `Bearer ${this.token}` } : {}),
+            },
+            body: JSON.stringify({
+                success: report.success,
+                status_code: report.statusCode,
+                error_type: report.errorType,
+                error_message: report.errorMessage,
+                latency_ms: report.latencyMs,
+                prompt_tokens: report.promptTokens ?? 0,
+                completion_tokens: report.completionTokens ?? 0,
+            }),
+        });
+    }
+}
+function normalizeEgressMode(value) {
+    return value === "regional_proxy" ? "regional_proxy" : "direct";
+}
+function resolveBaseUrlForEgress({ apiBase, egressMode, egressEndpoint, }) {
+    if (egressMode === "direct")
+        return apiBase;
+    if (!egressEndpoint) {
+        throw new Error("Key Pool lease selected regional_proxy egress without egress_endpoint");
+    }
+    return egressEndpoint;
+}

package/dist/health.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderCoreServerConfig } from "./config.js";
+export declare function healthPayload(config: ProviderCoreServerConfig): Record<string, unknown>;

package/dist/health.js

@@ -0,0 +1,8 @@
+export function healthPayload(config) {
+    return {
+        status: "ok",
+        service: "provider-core-server",
+        version: config.version,
+        time: new Date().toISOString(),
+    };
+}

package/dist/logging.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export interface RequestContext {
+    requestId: string;
+    startMs: number;
+}
+export declare function createRequestContext(req: IncomingMessage): RequestContext;
+export declare function attachRequestId(res: ServerResponse, context: RequestContext): void;
+export declare function logRequest(req: IncomingMessage, context: RequestContext, message: string, extra?: Record<string, unknown>): void;
+export declare function logRequestComplete(req: IncomingMessage, context: RequestContext, statusCode: number): void;

package/dist/logging.js

@@ -0,0 +1,28 @@
+import { randomUUID } from "node:crypto";
+export function createRequestContext(req) {
+    const headerRequestId = req.headers["x-request-id"];
+    return {
+        requestId: typeof headerRequestId === "string" && headerRequestId ? headerRequestId : randomUUID(),
+        startMs: Date.now(),
+    };
+}
+export function attachRequestId(res, context) {
+    res.setHeader("x-request-id", context.requestId);
+}
+export function logRequest(req, context, message, extra) {
+    console.log(JSON.stringify({
+        level: "info",
+        service: "provider-core-server",
+        requestId: context.requestId,
+        method: req.method,
+        url: req.url,
+        message,
+        ...extra,
+    }));
+}
+export function logRequestComplete(req, context, statusCode) {
+    logRequest(req, context, "request.complete", {
+        statusCode,
+        elapsedMs: Date.now() - context.startMs,
+    });
+}

package/dist/request-normalizer.d.ts

@@ -0,0 +1,16 @@
+import type { LLMRequest } from "@xiaozhiclaw/provider-core";
+export type PublicProtocol = "openai-chat" | "openai-responses" | "anthropic-messages";
+export interface ProviderCoreRequest extends LLMRequest {
+    protocol: PublicProtocol;
+    provider: string;
+    metadata?: {
+        userId?: string;
+        workspaceId?: string;
+        sessionId?: string;
+        requestId?: string;
+        publicModel?: string;
+        source?: "qlogicagent" | "llmrouter";
+    };
+    providerOptions?: Record<string, unknown>;
+}
+export declare function normalizeProviderCoreRequest(body: unknown): ProviderCoreRequest;

package/dist/request-normalizer.js

@@ -0,0 +1,16 @@
+export function normalizeProviderCoreRequest(body) {
+    if (!body || typeof body !== "object") {
+        throw new Error("Request body must be an object.");
+    }
+    const candidate = body;
+    if (!candidate.protocol || !["openai-chat", "openai-responses", "anthropic-messages"].includes(candidate.protocol)) {
+        throw new Error("protocol must be openai-chat, openai-responses, or anthropic-messages.");
+    }
+    if (!candidate.provider)
+        throw new Error("provider is required.");
+    if (!candidate.model)
+        throw new Error("model is required.");
+    if (!Array.isArray(candidate.messages))
+        throw new Error("messages must be an array.");
+    return candidate;
+}

package/dist/routes.d.ts

@@ -0,0 +1,24 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type ModelInfo, type ProviderDef, type ProviderEvent } from "@xiaozhiclaw/provider-core";
+import type { ProviderCoreServerConfig } from "./config.js";
+import { type ProviderCoreRequest } from "./request-normalizer.js";
+export interface ProviderCoreRuntime {
+    listProviders(): ProviderDef[];
+    listModels(): Promise<ProviderCoreCatalogModel[]> | ProviderCoreCatalogModel[];
+    invoke(request: ProviderCoreRequest, signal?: AbortSignal): Promise<ProviderEvent[]>;
+    stream(request: ProviderCoreRequest, signal?: AbortSignal): AsyncIterable<ProviderEvent>;
+}
+export interface ProviderCoreCatalogModel extends ModelInfo {
+    provider: string;
+    providerName: string;
+    transport: ProviderDef["transport"];
+    nativeModelId: string;
+}
+export declare class FixtureProviderCoreRuntime implements ProviderCoreRuntime {
+    listProviders(): ProviderDef[];
+    listModels(): ProviderCoreCatalogModel[];
+    invoke(request: ProviderCoreRequest): Promise<ProviderEvent[]>;
+    stream(request: ProviderCoreRequest): AsyncIterable<ProviderEvent>;
+}
+export declare function routeProviderCoreRequest(req: IncomingMessage, res: ServerResponse, config: ProviderCoreServerConfig, runtime: ProviderCoreRuntime): Promise<void>;
+export declare function flattenProviderModels(providers: ProviderDef[]): ProviderCoreCatalogModel[];

package/dist/routes.js

@@ -0,0 +1,106 @@
+import { BUILTIN_PROVIDERS } from "@xiaozhiclaw/provider-core";
+import { isAuthorized } from "./auth.js";
+import { healthPayload } from "./health.js";
+import { attachRequestId, createRequestContext, logRequest, logRequestComplete } from "./logging.js";
+import { normalizeProviderCoreRequest } from "./request-normalizer.js";
+import { startSse, writeProviderEvent } from "./sse.js";
+export class FixtureProviderCoreRuntime {
+    listProviders() {
+        return BUILTIN_PROVIDERS;
+    }
+    listModels() {
+        return flattenProviderModels(BUILTIN_PROVIDERS);
+    }
+    async invoke(request) {
+        const events = [];
+        for await (const event of this.stream(request)) {
+            events.push(event);
+        }
+        return events;
+    }
+    async *stream(request) {
+        yield { type: "response.created", id: `resp_${Date.now()}`, model: request.model, provider: request.provider };
+        yield { type: "content.delta", index: 0, text: "Provider Core fixture response" };
+        yield { type: "usage.delta", usage: { promptTokens: request.messages.length, completionTokens: 4 } };
+        yield { type: "response.completed", usage: { promptTokens: request.messages.length, completionTokens: 4 }, finishReason: "stop" };
+    }
+}
+export async function routeProviderCoreRequest(req, res, config, runtime) {
+    const context = createRequestContext(req);
+    attachRequestId(res, context);
+    logRequest(req, context, "request.start");
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    if (url.pathname === "/health" && req.method === "GET") {
+        sendJson(res, 200, healthPayload(config));
+        logRequestComplete(req, context, 200);
+        return;
+    }
+    if (!isAuthorized(req, config.serviceToken)) {
+        sendJson(res, 401, { error: { message: "Unauthorized" } });
+        logRequestComplete(req, context, 401);
+        return;
+    }
+    if (url.pathname === "/v1/providers" && req.method === "GET") {
+        sendJson(res, 200, { providers: runtime.listProviders() });
+        logRequestComplete(req, context, 200);
+        return;
+    }
+    if (url.pathname === "/v1/models" && req.method === "GET") {
+        sendJson(res, 200, { models: await runtime.listModels() });
+        logRequestComplete(req, context, 200);
+        return;
+    }
+    if (url.pathname === "/v1/invoke" && req.method === "POST") {
+        const request = normalizeProviderCoreRequest(await readJson(req));
+        sendJson(res, 200, { events: await runtime.invoke(request) });
+        logRequestComplete(req, context, 200);
+        return;
+    }
+    if (url.pathname === "/v1/stream" && req.method === "POST") {
+        const controller = new AbortController();
+        req.on("close", () => controller.abort());
+        const request = normalizeProviderCoreRequest(await readJson(req));
+        startSse(res);
+        for await (const event of runtime.stream(request, controller.signal)) {
+            writeProviderEvent(res, event);
+        }
+        res.end();
+        logRequestComplete(req, context, 200);
+        return;
+    }
+    sendJson(res, 404, { error: { message: "Not found" } });
+    logRequestComplete(req, context, 404);
+}
+async function readJson(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length === 0)
+        return {};
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function sendJson(res, status, body) {
+    res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(body));
+}
+export function flattenProviderModels(providers) {
+    const models = [];
+    const seen = new Set();
+    for (const provider of providers) {
+        for (const model of provider.models ?? []) {
+            const preferredPublicId = model.aliases?.[0] ?? model.id;
+            const publicId = seen.has(preferredPublicId) ? `${provider.id}/${preferredPublicId}` : preferredPublicId;
+            seen.add(publicId);
+            models.push({
+                ...model,
+                id: publicId,
+                provider: provider.id,
+                providerName: provider.name,
+                transport: provider.transport,
+                nativeModelId: model.id,
+            });
+        }
+    }
+    return models;
+}

package/dist/runtime.d.ts

@@ -0,0 +1,15 @@
+import { type ProviderDef, type ProviderEvent } from "@xiaozhiclaw/provider-core";
+import type { ProviderCoreServerConfig } from "./config.js";
+import { type CredentialResolver } from "./credential-resolver.js";
+import type { ProviderCoreRequest } from "./request-normalizer.js";
+import { type ProviderCoreCatalogModel, type ProviderCoreRuntime } from "./routes.js";
+export declare class RealProviderCoreRuntime implements ProviderCoreRuntime {
+    private registry;
+    private credentialResolver;
+    constructor(config?: ProviderCoreServerConfig, credentialResolver?: CredentialResolver);
+    listProviders(): ProviderDef[];
+    listModels(): Promise<ProviderCoreCatalogModel[]>;
+    invoke(request: ProviderCoreRequest, signal?: AbortSignal): Promise<ProviderEvent[]>;
+    stream(request: ProviderCoreRequest, signal?: AbortSignal): AsyncIterable<ProviderEvent>;
+    private reportCredential;
+}

package/dist/runtime.js

@@ -0,0 +1,172 @@
+import { createLLMClient, ProviderRegistry, } from "@xiaozhiclaw/provider-core";
+import { EnvCredentialResolver, ExternalKeyPoolResolver } from "./credential-resolver.js";
+import { flattenProviderModels } from "./routes.js";
+export class RealProviderCoreRuntime {
+    registry = new ProviderRegistry();
+    credentialResolver;
+    constructor(config, credentialResolver) {
+        this.credentialResolver = credentialResolver ?? createCredentialResolver(config);
+    }
+    listProviders() {
+        return this.registry.listProviders();
+    }
+    async listModels() {
+        return flattenProviderModels(this.registry.listProviders().map((provider) => ({
+            ...provider,
+            models: this.registry.listModels(provider.id),
+        })));
+    }
+    async invoke(request, signal) {
+        const events = [];
+        for await (const event of this.stream(request, signal)) {
+            events.push(event);
+        }
+        return events;
+    }
+    async *stream(request, signal) {
+        const providerDef = this.registry.getProvider(request.provider);
+        if (!providerDef)
+            throw new Error(`Unknown provider: ${request.provider}`);
+        const started = Date.now();
+        let credential;
+        let success = true;
+        let lastUsage;
+        try {
+            credential = await this.credentialResolver.resolve({ request, registry: this.registry });
+            const client = createLLMClient({
+                provider: request.provider,
+                model: request.model,
+                apiKey: credential.apiKey,
+                baseUrl: credential.baseUrl,
+            }, this.registry);
+            const responseId = `resp_${Date.now().toString(36)}`;
+            yield {
+                type: "response.created",
+                id: responseId,
+                model: request.model,
+                provider: request.provider,
+                credentialId: credential.credentialId,
+                credentialSource: credential.source,
+                credentialEgressMode: credential.egressMode,
+                credentialEgressRegion: credential.egressRegion,
+            };
+            for await (const chunk of client.transport.stream(toLLMRequest(request), credential.apiKey, signal)) {
+                const event = chunkToProviderEvent(chunk, lastUsage);
+                if (!event)
+                    continue;
+                if (chunk.type === "usage") {
+                    lastUsage = {
+                        promptTokens: chunk.promptTokens,
+                        completionTokens: chunk.completionTokens,
+                        reasoningTokens: chunk.reasoningTokens,
+                        cacheReadTokens: chunk.cacheReadTokens,
+                        cacheCreationTokens: chunk.cacheCreationTokens,
+                    };
+                }
+                if (event.type === "error")
+                    success = false;
+                if (event.type === "response.completed" && lastUsage && !event.usage) {
+                    yield { ...event, usage: lastUsage };
+                }
+                else {
+                    yield event;
+                }
+            }
+            await this.reportCredential(credential, {
+                success,
+                latencyMs: Date.now() - started,
+                promptTokens: lastUsage?.promptTokens,
+                completionTokens: lastUsage?.completionTokens,
+            });
+        }
+        catch (error) {
+            if (credential) {
+                await this.reportCredential(credential, {
+                    success: false,
+                    statusCode: statusCodeFromError(error),
+                    errorType: error instanceof Error ? error.name : "provider_error",
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                    latencyMs: Date.now() - started,
+                    promptTokens: lastUsage?.promptTokens,
+                    completionTokens: lastUsage?.completionTokens,
+                });
+            }
+            throw error;
+        }
+    }
+    async reportCredential(credential, report) {
+        try {
+            await this.credentialResolver.report?.(credential, report);
+        }
+        catch {
+            // Credential reporting must never mask a successful model response.
+        }
+    }
+}
+function createCredentialResolver(config) {
+    if (!config || config.credentialResolver === "env")
+        return new EnvCredentialResolver();
+    return new ExternalKeyPoolResolver({
+        url: config.keyPoolUrl,
+        token: config.keyPoolToken,
+        mode: config.credentialResolver,
+        timeoutMs: config.keyPoolTimeoutMs,
+    });
+}
+function statusCodeFromError(error) {
+    if (typeof error === "object" && error !== null) {
+        const candidate = error;
+        if (typeof candidate.status === "number")
+            return candidate.status;
+        if (typeof candidate.statusCode === "number")
+            return candidate.statusCode;
+    }
+    return undefined;
+}
+function toLLMRequest(request) {
+    const providerOptions = request.providerOptions ?? {};
+    return {
+        ...request,
+        ...providerOptions,
+        model: request.model,
+        messages: request.messages,
+        tools: request.tools,
+    };
+}
+function chunkToProviderEvent(chunk, lastUsage) {
+    switch (chunk.type) {
+        case "delta":
+            return { type: "content.delta", index: 0, text: chunk.text };
+        case "tool_call_delta":
+            return {
+                type: "tool.call.delta",
+                id: chunk.id ?? `tool_${chunk.index}`,
+                name: chunk.name,
+                argumentsDelta: chunk.arguments,
+            };
+        case "reasoning_delta":
+            return { type: "reasoning.delta", text: chunk.text };
+        case "usage":
+            return {
+                type: "usage.delta",
+                usage: {
+                    promptTokens: chunk.promptTokens,
+                    completionTokens: chunk.completionTokens,
+                    reasoningTokens: chunk.reasoningTokens,
+                    cacheReadTokens: chunk.cacheReadTokens,
+                    cacheCreationTokens: chunk.cacheCreationTokens,
+                },
+            };
+        case "annotations":
+            return { type: "annotation", annotation: { annotations: chunk.annotations } };
+        case "builtin_tool_status":
+            return { type: "annotation", annotation: { toolType: chunk.toolType, event: chunk.event, data: chunk.data } };
+        case "error":
+            return { type: "error", error: { message: chunk.message } };
+        case "done":
+            return { type: "response.completed", usage: lastUsage, finishReason: chunk.finishReason };
+        case "response_id":
+        case "reasoning_block_complete":
+            return undefined;
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+import { type Server } from "node:http";
+import { type ProviderCoreServerConfig } from "./config.js";
+import { type ProviderCoreRuntime } from "./routes.js";
+export declare function createProviderCoreServer(config?: ProviderCoreServerConfig, runtime?: ProviderCoreRuntime): Server;

package/dist/server.js

@@ -0,0 +1,19 @@
+import { createServer } from "node:http";
+import { loadConfig } from "./config.js";
+import { FixtureProviderCoreRuntime, routeProviderCoreRequest } from "./routes.js";
+import { RealProviderCoreRuntime } from "./runtime.js";
+export function createProviderCoreServer(config = loadConfig(), runtime = config.runtime === "real" ? new RealProviderCoreRuntime(config) : new FixtureProviderCoreRuntime()) {
+    return createServer((req, res) => {
+        routeProviderCoreRequest(req, res, config, runtime).catch((error) => {
+            res.writeHead(500, { "content-type": "application/json; charset=utf-8" });
+            res.end(JSON.stringify({ error: { message: error instanceof Error ? error.message : String(error) } }));
+        });
+    });
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const config = loadConfig();
+    const server = createProviderCoreServer(config);
+    server.listen(config.port, config.host, () => {
+        console.log(`Provider Core Server listening on http://${config.host}:${config.port}`);
+    });
+}

package/dist/sse.d.ts

@@ -0,0 +1,4 @@
+import type { ServerResponse } from "node:http";
+import type { ProviderEvent } from "@xiaozhiclaw/provider-core";
+export declare function startSse(res: ServerResponse): void;
+export declare function writeProviderEvent(res: ServerResponse, event: ProviderEvent): void;

package/dist/sse.js

@@ -0,0 +1,12 @@
+export function startSse(res) {
+    res.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive",
+        "x-accel-buffering": "no",
+    });
+}
+export function writeProviderEvent(res, event) {
+    res.write(`event: ${event.type}\n`);
+    res.write(`data: ${JSON.stringify(event)}\n\n`);
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@xiaozhiclaw/provider-core-server",
+  "version": "0.1.0",
+  "description": "Internal HTTP/SSE server for QLogic Provider Core",
+  "type": "module",
+  "main": "./dist/server.js",
+  "types": "./dist/server.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "@xiaozhiclaw/provider-core": "^0.1.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  }
+}