kimi-proxy 0.0.3 → 0.1.1

package/README.md

@@ -74,6 +74,10 @@ What clients receive:
 
 Enable with `ensure_tool_call: true` in model config. The proxy detects missing tool calls and re-prompts the model with a reminder.
 
+When enabled, the proxy also injects a termination tool named `done` and a system instruction telling the model to call it when finished (optionally with `{"final_answer":"..."}`), then strips that termination tool call from the final response.
+
+Control the maximum number of re-prompt attempts with `ENSURE_TOOL_CALL_MAX_ATTEMPTS` (default: `3`, max: `5`).
+
 **Example enforcement flow:**
 
 ```
@@ -116,18 +120,20 @@ Distribute traffic across providers using round-robin, weighted random, random,
 
 - **Extensible architecture** for adding new models and providers
 - **Provider support**: OpenAI-compatible APIs, OpenRouter, Vertex AI
+- **Hybrid logging pipeline**: SQLite metadata with filesystem blobs, LiveStore-backed dashboard with virtualized/lazy blob loading
 
-## Quick Start
+## Quick Start (Bun)
 
 ```bash
-pnpm install
+bun install
 cp .env.example .env
 cp model-config.example.yaml model-config.yaml
 # Edit .env and model-config.yaml with your provider keys and models
-pnpm run dev
+bun run dev            # backend
+bun --cwd frontend dev # dashboard (Vite)
 ```
 
-The API runs on `http://127.0.0.1:8000` and serves the dashboard at `/`.
+The API runs on `http://127.0.0.1:8000` and serves the dashboard (built assets) at `/`. The dev dashboard uses `VITE_API_URL` to point at the backend (defaults to same origin).
 
 ## Configuration
 
@@ -136,8 +142,10 @@ The API runs on `http://127.0.0.1:8000` and serves the dashboard at `/`.
 Set environment variables in `.env`:
 
 - **Generic OpenAI**: `OPENAI_BASE_URL`, `OPENAI_API_KEY`
+- **Anthropic**: `ANTHROPIC_API_KEY`, optional `ANTHROPIC_BASE_URL`
 - **OpenRouter**: `OPENROUTER_API_KEY`, `OPENROUTER_PROVIDERS` (optional), `OPENROUTER_ORDER` (optional)
 - **Vertex AI**: `VERTEX_PROJECT_ID`, `VERTEX_LOCATION`, `GOOGLE_APPLICATION_CREDENTIALS`
+  - `GOOGLE_APPLICATION_CREDENTIALS` can be a path to the JSON key file or the JSON payload itself. Use `VERTEX_CHAT_ENDPOINT` to point at a private MaaS endpoint if needed.
 
 ### Models
 
@@ -159,14 +167,15 @@ models:
 
 ## Dashboard
 
-The web dashboard shows request/response logs and metrics. Access it at the root path when running the proxy.
+The web dashboard shows request/response logs and metrics. Access it at the root path when running the proxy. LiveStore metadata sync pulls from `/api/livestore/pull` in batches (size controlled by `LIVESTORE_BATCH`) and lazily fetches blobs on expansion. Build the dashboard with `bun run build:all` to serve static assets from the backend.
 
 ## Development
 
 ```bash
-pnpm run dev      # Run with hot reload
-pnpm run test     # Run unit tests
-pnpm run build    # TypeScript build
+bun run dev         # Run backend with hot reload
+bun --cwd frontend dev  # Run dashboard
+bun test            # Run tests
+bun run build:all   # Build server + dashboard
 ```
 
 ## Docker

package/dist/config.d.ts

@@ -1,6 +1,6 @@
-import { OpenAIConfig } from "./core/providers/openaiProvider.js";
-import { OpenRouterConfig } from "./core/providers/openRouterProvider.js";
-import { VertexConfig } from "./core/providers/vertexProvider.js";
+import { OpenAIConfig } from "./core/providers/openai.js";
+import { OpenRouterConfig } from "./core/providers/openrouter.js";
+import { VertexConfig } from "./core/providers/vertex.js";
 import { LoadBalancingStrategy, ModelDefinition } from "./core/modelRegistry.js";
 export interface AppConfig {
     server: {
@@ -9,13 +9,21 @@ export interface AppConfig {
     };
     logging: {
         dbPath: string;
+        blobRoot: string;
     };
     streaming: {
         delay: number;
         chunkSize: number;
     };
+    livestore: {
+        batchSize: number;
+    };
     providers: {
         openai?: OpenAIConfig;
+        anthropic?: {
+            apiKey: string;
+            baseUrl?: string;
+        };
         openrouter?: OpenRouterConfig;
         vertex?: VertexConfig;
     };

package/dist/core/clientAdapters.d.ts

@@ -0,0 +1,18 @@
+import { ClientFormat, type JsonValue } from "./types.js";
+import { ClientAdapter, Request, Response } from "./types.js";
+import { type ClientRequest } from "./schemas.js";
+export declare class OpenAIChatClientAdapter implements ClientAdapter {
+    clientFormat: ClientFormat;
+    toUlx(body: ClientRequest, headers: Record<string, string>): Request;
+    fromUlx(ulxResponse: Response, _ulxRequest: Request): JsonValue;
+}
+export declare class AnthropicMessagesClientAdapter implements ClientAdapter {
+    clientFormat: ClientFormat;
+    toUlx(body: ClientRequest, headers: Record<string, string>): Request;
+    fromUlx(ulxResponse: Response): JsonValue;
+}
+export declare class OpenAIResponsesClientAdapter implements ClientAdapter {
+    clientFormat: ClientFormat;
+    toUlx(body: ClientRequest, headers: Record<string, string>): Request;
+    fromUlx(ulxResponse: Response, ulxRequest: Request): JsonValue;
+}

package/dist/core/ensureToolCall.d.ts

@@ -1,4 +1,4 @@
-import { JsonObject, JsonValue } from "./types.js";
+import type { JsonObject, JsonValue, Message, Tool } from "./types.js";
 export declare const ENSURE_TOOL_CALL_STATE_KEY = "__ensureToolCall";
 export declare const DEFAULT_TERMINATION_TOOL_NAME = "done";
 export interface EnsureToolCallState extends JsonObject {
@@ -16,9 +16,9 @@ export declare function getEnsureToolCallState(state: Record<string, JsonValue>)
 export declare function buildBaseInstruction(toolName: string): string;
 export declare function buildReminderInstruction(toolName: string): string;
 export declare function buildFinalAnswerRequirementInstruction(toolName: string): string;
-export declare function createTerminationToolDefinition(name: string): JsonObject;
+export declare function createTerminationToolDefinition(name: string): Tool;
 /**
  * Get messages from the last user message to the end of the array.
  * Returns empty array if no user message is found.
  */
-export declare function getMessagesSinceLastUser(messages: JsonValue[]): JsonValue[];
+export declare function getMessagesSinceLastUser(messages: Message[] | undefined): Message[];

package/dist/core/json.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject } from "./types.js";
+export declare function safeJsonString(value: unknown): string;
+export declare function safeJsonParseObject(value: string | undefined): JsonObject;

package/dist/core/pipeline.d.ts

@@ -1,17 +1,32 @@
-import { PipelineResult, ProxyRequest, RequestTransform, ResponseTransform, JsonObject } from "./types.js";
-import { ConverterRegistry } from "./converters/types.js";
-import { LLMProvider } from "./providers/types.js";
-interface PipelineDeps {
-    converterRegistry: ConverterRegistry;
-    requestTransforms: RequestTransform[];
-    responseTransforms: ResponseTransform[];
+import { type ClientRequest } from "./schemas.js";
+import type { JsonObject } from "./types.js";
+import { ClientAdapter, PipelineResult as PipelineResult, ProviderAdapter, Transform as Transform, Operation as Operation } from "./types.js";
+export declare class ClientRegistry {
+    private adapters;
+    register(adapter: ClientAdapter): void;
+    resolve(clientFormat: string): ClientAdapter;
 }
-export declare class LLMProxyPipeline {
-    private readonly deps;
-    constructor(deps: PipelineDeps);
-    execute(provider: LLMProvider, request: ProxyRequest, providerConfig?: JsonObject): Promise<PipelineResult>;
-    private applyRequestTransforms;
-    private applyResponseTransforms;
-    private transformsByStage;
+export declare class ProviderRegistry {
+    private adapters;
+    register(adapter: ProviderAdapter): void;
+    resolve(key: string): ProviderAdapter;
+}
+export interface PipelineOptions {
+    clientFormat: string;
+    providerKey: string;
+    providerConfig?: JsonObject;
+    requestBody: ClientRequest;
+    requestHeaders: Record<string, string>;
+    operation: Operation;
+    requestId?: string;
+    profile?: string;
+    ensureToolCall?: boolean;
+}
+export declare class Pipeline {
+    private readonly clients;
+    private readonly providers;
+    private readonly transforms;
+    constructor(clients: ClientRegistry, providers: ProviderRegistry, transforms?: Transform[]);
+    execute(options: PipelineOptions): Promise<PipelineResult>;
+    private runTransforms;
 }
-export {};

package/dist/core/pipelineControl.d.ts

@@ -1,4 +1,4 @@
-import { JsonValue } from "./types.js";
+import type { JsonValue } from "./types.js";
 export declare const PIPELINE_MAX_ATTEMPTS_KEY = "__pipelineMaxAttempts";
 export declare const PIPELINE_RETRY_FLAG_KEY = "__pipelineRetryRequested";
 export declare const SYNTHETIC_RESPONSE_FLAG_KEY = "__syntheticResponseRequested";

package/dist/core/providerAdapters.d.ts

@@ -0,0 +1,4 @@
+export { AnthropicProviderAdapter } from "./providers/anthropic.js";
+export { OpenAIProviderAdapter } from "./providers/openai.js";
+export { OpenRouterProviderAdapter } from "./providers/openrouter.js";
+export { VertexProviderAdapter } from "./providers/vertex.js";

package/dist/core/providers/anthropic.d.ts

@@ -0,0 +1,16 @@
+import { type JsonObject } from "../types.js";
+import { ProviderAdapter, ProviderResponse, Request, Response } from "../types.js";
+export interface AnthropicProviderConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+export declare class AnthropicProviderAdapter implements ProviderAdapter {
+    private readonly config;
+    key: string;
+    providerFormat: string;
+    constructor(config: AnthropicProviderConfig);
+    private resolveConfig;
+    invoke(request: Request, config?: JsonObject): Promise<ProviderResponse>;
+    toUlxResponse(payload: ProviderResponse, request: Request): Response;
+    private buildAnthropicPayload;
+}