@xiaozhiclaw/provider-core-server 0.1.0 → 0.1.2

package/dist/credential-resolver.d.ts

@@ -1,5 +1,5 @@
 import type { ProviderRegistry } from "@xiaozhiclaw/provider-core";
-import type { ProviderCoreRequest } from "./request-normalizer.js";
+import type { ProviderCoreMediaRequest, ProviderCoreRequest } from "./request-normalizer.js";
 export interface ResolvedCredential {
     apiKey: string;
     baseUrl?: string;
@@ -11,7 +11,7 @@ export interface ResolvedCredential {
     egressEndpoint?: string;
 }
 export interface CredentialResolveContext {
-    request: ProviderCoreRequest;
+    request: ProviderCoreRequest | ProviderCoreMediaRequest;
     registry: Pick<ProviderRegistry, "resolveApiKey">;
 }
 export interface CredentialReport {

package/dist/credential-resolver.js

@@ -1,6 +1,8 @@
 export class EnvCredentialResolver {
     async resolve(context) {
         const apiKey = context.registry.resolveApiKey(context.request.provider);
+        if (!apiKey && isNoAuthProvider(context))
+            return { apiKey: "", source: "env" };
         if (!apiKey)
             throw new Error(`Missing API key for provider: ${context.request.provider}`);
         return { apiKey, source: "env" };
@@ -23,6 +25,8 @@ export class ExternalKeyPoolResolver {
         this.fallback = config.fallback ?? new EnvCredentialResolver();
     }
     async resolve(context) {
+        if (isNoAuthProvider(context))
+            return this.fallback.resolve(context);
         if (!this.baseUrl)
             return this.fallback.resolve(context);
         const controller = new AbortController();
@@ -103,6 +107,10 @@ export class ExternalKeyPoolResolver {
         });
     }
 }
+function isNoAuthProvider(context) {
+    const registry = context.registry;
+    return registry.getProvider?.(context.request.provider)?.authType === "none";
+}
 function normalizeEgressMode(value) {
     return value === "regional_proxy" ? "regional_proxy" : "direct";
 }

package/dist/request-normalizer.d.ts

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

package/dist/request-normalizer.js

@@ -14,3 +14,20 @@ export function normalizeProviderCoreRequest(body) {
         throw new Error("messages must be an array.");
     return candidate;
 }
+export function normalizeProviderCoreMediaRequest(body) {
+    if (!body || typeof body !== "object") {
+        throw new Error("Request body must be an object.");
+    }
+    const candidate = body;
+    if (!candidate.provider)
+        throw new Error("provider is required.");
+    if (!candidate.model)
+        throw new Error("model is required.");
+    if (!candidate.mediaType)
+        throw new Error("mediaType is required.");
+    return {
+        ...candidate,
+        protocol: "media",
+        prompt: candidate.prompt ?? candidate.text ?? "",
+    };
+}

package/dist/routes.d.ts

@@ -1,12 +1,23 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { type ModelInfo, type ProviderDef, type ProviderEvent } from "@xiaozhiclaw/provider-core";
+import { type MediaResult, type ModelInfo, type ProviderDef, type ProviderEvent } from "@xiaozhiclaw/provider-core";
 import type { ProviderCoreServerConfig } from "./config.js";
-import { type ProviderCoreRequest } from "./request-normalizer.js";
+import { type ProviderCoreMediaRequest, 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>;
+    generateMedia(request: ProviderCoreMediaRequest, signal?: AbortSignal): Promise<MediaResult>;
+    getMediaTaskStatus?(provider: string, taskId: string, signal?: AbortSignal): Promise<{
+        status: string;
+        task: Record<string, unknown>;
+    }>;
+    listMediaTasks?(provider: string, options?: {
+        after?: string;
+        limit?: number;
+        status?: string;
+    }, signal?: AbortSignal): Promise<Record<string, unknown>>;
+    deleteMediaTask?(provider: string, taskId: string, signal?: AbortSignal): Promise<void>;
 }
 export interface ProviderCoreCatalogModel extends ModelInfo {
     provider: string;
@@ -19,6 +30,7 @@ export declare class FixtureProviderCoreRuntime implements ProviderCoreRuntime {
     listModels(): ProviderCoreCatalogModel[];
     invoke(request: ProviderCoreRequest): Promise<ProviderEvent[]>;
     stream(request: ProviderCoreRequest): AsyncIterable<ProviderEvent>;
+    generateMedia(request: ProviderCoreMediaRequest): Promise<MediaResult>;
 }
 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

@@ -2,7 +2,7 @@ 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 { normalizeProviderCoreMediaRequest, normalizeProviderCoreRequest } from "./request-normalizer.js";
 import { startSse, writeProviderEvent } from "./sse.js";
 export class FixtureProviderCoreRuntime {
     listProviders() {
@@ -24,6 +24,16 @@ export class FixtureProviderCoreRuntime {
         yield { type: "usage.delta", usage: { promptTokens: request.messages.length, completionTokens: 4 } };
         yield { type: "response.completed", usage: { promptTokens: request.messages.length, completionTokens: 4 }, finishReason: "stop" };
     }
+    async generateMedia(request) {
+        return {
+            mediaUrls: [`https://provider-core.fixture/media/${request.model}`],
+            model: request.model,
+            size: request.size,
+            billingUnit: request.mediaType === "embedding" ? "per_token" : "per_call",
+            billingQuantity: request.mediaType === "embedding" ? 1 : (request.n ?? 1),
+            metadata: request.mediaType === "embedding" ? { embeddings: [[0.1, 0.2, 0.3]], dimensions: 3 } : undefined,
+        };
+    }
 }
 export async function routeProviderCoreRequest(req, res, config, runtime) {
     const context = createRequestContext(req);
@@ -68,6 +78,51 @@ export async function routeProviderCoreRequest(req, res, config, runtime) {
         logRequestComplete(req, context, 200);
         return;
     }
+    if (url.pathname === "/v1/media/generate" && req.method === "POST") {
+        const request = normalizeProviderCoreMediaRequest(await readJson(req));
+        sendJson(res, 200, { result: await runtime.generateMedia(request) });
+        logRequestComplete(req, context, 200);
+        return;
+    }
+    if (url.pathname === "/v1/media/tasks" && req.method === "GET") {
+        const provider = url.searchParams.get("provider") ?? "";
+        if (!provider || !runtime.listMediaTasks) {
+            sendJson(res, 400, { error: { message: "provider is required or task listing is unsupported" } });
+            logRequestComplete(req, context, 400);
+            return;
+        }
+        sendJson(res, 200, await runtime.listMediaTasks(provider, {
+            after: url.searchParams.get("after") ?? undefined,
+            limit: Number(url.searchParams.get("limit") ?? "") || undefined,
+            status: url.searchParams.get("status") ?? undefined,
+        }));
+        logRequestComplete(req, context, 200);
+        return;
+    }
+    const taskMatch = url.pathname.match(/^\/v1\/media\/tasks\/([^/]+)$/);
+    if (taskMatch && req.method === "GET") {
+        const provider = url.searchParams.get("provider") ?? "";
+        if (!provider || !runtime.getMediaTaskStatus) {
+            sendJson(res, 400, { error: { message: "provider is required or task status is unsupported" } });
+            logRequestComplete(req, context, 400);
+            return;
+        }
+        sendJson(res, 200, await runtime.getMediaTaskStatus(provider, decodeURIComponent(taskMatch[1])));
+        logRequestComplete(req, context, 200);
+        return;
+    }
+    if (taskMatch && req.method === "DELETE") {
+        const provider = url.searchParams.get("provider") ?? "";
+        if (!provider || !runtime.deleteMediaTask) {
+            sendJson(res, 400, { error: { message: "provider is required or task deletion is unsupported" } });
+            logRequestComplete(req, context, 400);
+            return;
+        }
+        await runtime.deleteMediaTask(provider, decodeURIComponent(taskMatch[1]));
+        sendJson(res, 200, { ok: true });
+        logRequestComplete(req, context, 200);
+        return;
+    }
     sendJson(res, 404, { error: { message: "Not found" } });
     logRequestComplete(req, context, 404);
 }

package/dist/runtime.d.ts

@@ -1,7 +1,7 @@
-import { type ProviderDef, type ProviderEvent } from "@xiaozhiclaw/provider-core";
+import { type MediaResult, 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 { ProviderCoreMediaRequest, ProviderCoreRequest } from "./request-normalizer.js";
 import { type ProviderCoreCatalogModel, type ProviderCoreRuntime } from "./routes.js";
 export declare class RealProviderCoreRuntime implements ProviderCoreRuntime {
     private registry;
@@ -11,5 +11,18 @@ export declare class RealProviderCoreRuntime implements ProviderCoreRuntime {
     listModels(): Promise<ProviderCoreCatalogModel[]>;
     invoke(request: ProviderCoreRequest, signal?: AbortSignal): Promise<ProviderEvent[]>;
     stream(request: ProviderCoreRequest, signal?: AbortSignal): AsyncIterable<ProviderEvent>;
+    generateMedia(request: ProviderCoreMediaRequest, signal?: AbortSignal): Promise<MediaResult>;
+    getMediaTaskStatus(provider: string, taskId: string, signal?: AbortSignal): Promise<{
+        status: string;
+        task: Record<string, unknown>;
+    }>;
+    listMediaTasks(provider: string, options?: {
+        after?: string;
+        limit?: number;
+        status?: string;
+    }, signal?: AbortSignal): Promise<Record<string, unknown>>;
+    deleteMediaTask(provider: string, taskId: string, signal?: AbortSignal): Promise<void>;
     private reportCredential;
+    private resolveProviderCredential;
+    private mediaTransportForProvider;
 }

package/dist/runtime.js

@@ -1,4 +1,4 @@
-import { createLLMClient, ProviderRegistry, } from "@xiaozhiclaw/provider-core";
+import { createLLMClient, isAsyncMediaTransport, MediaClient, ProviderRegistry, } from "@xiaozhiclaw/provider-core";
 import { EnvCredentialResolver, ExternalKeyPoolResolver } from "./credential-resolver.js";
 import { flattenProviderModels } from "./routes.js";
 export class RealProviderCoreRuntime {
@@ -94,6 +94,62 @@ export class RealProviderCoreRuntime {
             throw error;
         }
     }
+    async generateMedia(request, signal) {
+        const providerDef = this.registry.getProvider(request.provider);
+        if (!providerDef)
+            throw new Error(`Unknown provider: ${request.provider}`);
+        const started = Date.now();
+        let credential;
+        try {
+            credential = await this.credentialResolver.resolve({ request, registry: this.registry });
+            if (credential.baseUrl)
+                this.registry.applyOverride(request.provider, { baseUrl: credential.baseUrl });
+            const mediaClient = new MediaClient({ registry: this.registry });
+            const transport = mediaClient.getTransport(request.provider);
+            if (!transport)
+                throw new Error(`Provider does not support media generation: ${request.provider}`);
+            const result = await transport.generate(request, credential.apiKey, signal);
+            await this.reportCredential(credential, {
+                success: true,
+                latencyMs: Date.now() - started,
+                promptTokens: result.billingUnit === "per_token" ? Number(result.billingQuantity ?? 0) : undefined,
+            });
+            return result;
+        }
+        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,
+                });
+            }
+            throw error;
+        }
+    }
+    async getMediaTaskStatus(provider, taskId, signal) {
+        const credential = await this.resolveProviderCredential(provider, taskId);
+        const transport = this.mediaTransportForProvider(provider, credential.baseUrl);
+        if (!isAsyncMediaTransport(transport) || !transport.getTaskStatus)
+            throw new Error(`Provider does not support media task status: ${provider}`);
+        return transport.getTaskStatus(taskId, credential.apiKey, signal);
+    }
+    async listMediaTasks(provider, options, signal) {
+        const credential = await this.resolveProviderCredential(provider, "media-tasks");
+        const transport = this.mediaTransportForProvider(provider, credential.baseUrl);
+        if (!isAsyncMediaTransport(transport))
+            throw new Error(`Provider does not support media task listing: ${provider}`);
+        return transport.listVideoTasks(credential.apiKey, options, signal);
+    }
+    async deleteMediaTask(provider, taskId, signal) {
+        const credential = await this.resolveProviderCredential(provider, taskId);
+        const transport = this.mediaTransportForProvider(provider, credential.baseUrl);
+        if (!isAsyncMediaTransport(transport))
+            throw new Error(`Provider does not support media task deletion: ${provider}`);
+        await transport.deleteVideoTask(taskId, credential.apiKey, signal);
+    }
     async reportCredential(credential, report) {
         try {
             await this.credentialResolver.report?.(credential, report);
@@ -102,6 +158,26 @@ export class RealProviderCoreRuntime {
             // Credential reporting must never mask a successful model response.
         }
     }
+    async resolveProviderCredential(provider, model) {
+        return this.credentialResolver.resolve({
+            request: {
+                protocol: "media",
+                provider,
+                model,
+                mediaType: "video",
+                prompt: "",
+            },
+            registry: this.registry,
+        });
+    }
+    mediaTransportForProvider(provider, baseUrl) {
+        if (baseUrl)
+            this.registry.applyOverride(provider, { baseUrl });
+        const transport = new MediaClient({ registry: this.registry }).getTransport(provider);
+        if (!transport)
+            throw new Error(`Provider does not support media generation: ${provider}`);
+        return transport;
+    }
 }
 function createCredentialResolver(config) {
     if (!config || config.credentialResolver === "env")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaozhiclaw/provider-core-server",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Internal HTTP/SSE server for QLogic Provider Core",
   "type": "module",
   "main": "./dist/server.js",
@@ -15,7 +15,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@xiaozhiclaw/provider-core": "^0.1.0"
+    "@xiaozhiclaw/provider-core": "^0.1.2"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",