@token2chat/t2c 0.2.0-beta.1 → 0.2.1

package/dist/proxy/response.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Response utilities and error handler for proxy.
+ */
+import { type Logger } from "./types.js";
+/**
+ * Minimal response writer interface.
+ */
+export interface ResponseWriter {
+    writeHead(status: number, headers?: Record<string, string>): void;
+    end(body?: string): void;
+}
+/**
+ * Send a JSON response.
+ */
+export declare function sendJsonResponse(res: ResponseWriter, status: number, body?: unknown): void;
+/**
+ * Send an error response in OpenAI-compatible format.
+ */
+export declare function sendError(res: ResponseWriter, status: number, code: string, message: string, type?: string): void;
+/**
+ * Handle an error and send appropriate response.
+ * Supports ProxyError subclasses and standard Errors.
+ */
+export declare function handleError(res: ResponseWriter, error: unknown, logger?: Logger): void;

package/dist/proxy/response.js

@@ -0,0 +1,48 @@
+/**
+ * Response utilities and error handler for proxy.
+ */
+import { defaultLogger } from "./types.js";
+import { ProxyError } from "./errors.js";
+/**
+ * Send a JSON response.
+ */
+export function sendJsonResponse(res, status, body) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body ?? {}));
+}
+/**
+ * Send an error response in OpenAI-compatible format.
+ */
+export function sendError(res, status, code, message, type) {
+    const error = { code, message };
+    if (type)
+        error.type = type;
+    sendJsonResponse(res, status, { error });
+}
+/**
+ * Handle an error and send appropriate response.
+ * Supports ProxyError subclasses and standard Errors.
+ */
+export function handleError(res, error, logger = defaultLogger) {
+    // Handle ProxyError (and subclasses)
+    if (error instanceof ProxyError) {
+        logger.error("Proxy error:", error);
+        sendJsonResponse(res, error.httpStatus, error.toJSON());
+        return;
+    }
+    // Handle standard Error
+    if (error instanceof Error) {
+        logger.error("Proxy error:", error);
+        // Special case for body too large
+        if (error.message === "Request body too large") {
+            sendError(res, 413, "payload_too_large", "Request body too large");
+            return;
+        }
+        // Generic internal error
+        sendError(res, 500, "proxy_error", "Internal proxy error");
+        return;
+    }
+    // Handle unknown error types
+    logger.error("Proxy error:", error);
+    sendError(res, 500, "proxy_error", "Internal proxy error");
+}

package/dist/proxy/sse-parser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * SSE stream parser that extracts cashu-change events.
+ *
+ * The Gate emits change tokens via `event: cashu-change` SSE events
+ * during streaming responses. This parser intercepts those events,
+ * extracts the token, and filters them out so they are not forwarded
+ * to the AI tool.
+ */
+export interface SSEFilterResult {
+    /** The filtered stream with cashu-change events removed. */
+    filtered: ReadableStream<Uint8Array>;
+    /** Returns the extracted change token (available after stream is consumed). */
+    changeToken: () => string | undefined;
+}
+/**
+ * Create a TransformStream that filters out `event: cashu-change` SSE events
+ * and captures the token data.
+ */
+export declare function extractCashuChangeFromSSE(input: ReadableStream<Uint8Array>): SSEFilterResult;

package/dist/proxy/sse-parser.js

@@ -0,0 +1,80 @@
+/**
+ * SSE stream parser that extracts cashu-change events.
+ *
+ * The Gate emits change tokens via `event: cashu-change` SSE events
+ * during streaming responses. This parser intercepts those events,
+ * extracts the token, and filters them out so they are not forwarded
+ * to the AI tool.
+ */
+/**
+ * Create a TransformStream that filters out `event: cashu-change` SSE events
+ * and captures the token data.
+ */
+export function extractCashuChangeFromSSE(input) {
+    let token;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const filtered = new ReadableStream({
+        async start() { },
+        async pull(controller) {
+            // This is handled via piping below
+        },
+        cancel() { },
+    });
+    // Use a TransformStream approach
+    const encoder = new TextEncoder();
+    let resolveReady = null;
+    const transform = new TransformStream({
+        transform(chunk, controller) {
+            buffer += decoder.decode(chunk, { stream: true });
+            // Process complete SSE blocks (separated by \n\n)
+            while (true) {
+                const blockEnd = buffer.indexOf("\n\n");
+                if (blockEnd === -1)
+                    break;
+                const block = buffer.slice(0, blockEnd + 2);
+                buffer = buffer.slice(blockEnd + 2);
+                // Check if this block is a cashu-change event
+                if (isCashuChangeBlock(block)) {
+                    // Extract the token from "data: <token>\n"
+                    const dataMatch = block.match(/^data:\s*(.+)$/m);
+                    if (dataMatch && !token) {
+                        token = dataMatch[1].trim();
+                    }
+                    // Don't forward this block
+                    continue;
+                }
+                // Forward non-cashu-change blocks
+                controller.enqueue(encoder.encode(block));
+            }
+        },
+        flush(controller) {
+            // Flush any remaining buffer
+            if (buffer.length > 0) {
+                // Check if remaining buffer is a cashu-change event
+                if (isCashuChangeBlock(buffer)) {
+                    const dataMatch = buffer.match(/^data:\s*(.+)$/m);
+                    if (dataMatch && !token) {
+                        token = dataMatch[1].trim();
+                    }
+                }
+                else {
+                    controller.enqueue(encoder.encode(buffer));
+                }
+                buffer = "";
+            }
+        },
+    });
+    const outputStream = input.pipeThrough(transform);
+    return {
+        filtered: outputStream,
+        changeToken: () => token,
+    };
+}
+/**
+ * Check if an SSE block is a cashu-change event.
+ */
+function isCashuChangeBlock(block) {
+    // An SSE block with event: cashu-change
+    return /^event:\s*cashu-change\s*$/m.test(block);
+}

package/dist/proxy/types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Shared type definitions for the proxy module.
+ */
+/**
+ * Logger interface for proxy operations.
+ */
+export interface Logger {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+/**
+ * Default console logger.
+ */
+export declare const defaultLogger: Logger;
+/**
+ * Known provider prefixes for model ID transformation.
+ * We use `-` as separator in OpenClaw to avoid double-slash issue,
+ * but Gate/OpenRouter expects `/` as separator.
+ */
+export declare const MODEL_PROVIDER_PREFIXES: readonly ["openai", "anthropic", "google", "deepseek", "qwen", "moonshotai", "mistralai", "meta-llama", "nvidia", "cohere", "perplexity"];
+/**
+ * Transform model ID from dash format to slash format.
+ * e.g., "anthropic-claude-sonnet-4.5" → "anthropic/claude-sonnet-4.5"
+ */
+export declare function transformModelId(model: string): string;
+/**
+ * Parse Retry-After header value.
+ * Returns milliseconds to wait, or null if invalid.
+ */
+export declare function parseRetryAfter(value: string | null): number | null;
+/**
+ * Result from a proxy request.
+ */
+export interface ProxyResult {
+    status: number;
+    headers: Record<string, string>;
+    body: ReadableStream<Uint8Array> | string;
+}
+/**
+ * OpenAI chat completion request (minimal).
+ */
+export interface CompletionRequest {
+    model: string;
+    messages: Array<{
+        role: string;
+        content: string | unknown[];
+    }>;
+    stream?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Model info in OpenAI format.
+ */
+export interface ModelInfo {
+    id: string;
+    object: "model";
+    created: number;
+    owned_by: string;
+}
+/**
+ * Proxy handle returned by startProxy.
+ */
+export interface ProxyHandle {
+    stop: () => void;
+    proxySecret: string;
+}
+/**
+ * Payment result from token selection.
+ */
+export interface PaymentResult {
+    token: string;
+    priceSpent: number;
+    balanceAfter: number;
+}
+/**
+ * Change/refund received from Gate.
+ */
+export interface TokenReceiveResult {
+    amount: number;
+    type: "change" | "refund";
+}
+/**
+ * Proxy request metrics for a single request.
+ */
+export interface RequestMetrics {
+    txId: string;
+    model: string;
+    priceSat: number;
+    changeSat: number;
+    refundSat: number;
+    gateStatus: number;
+    balanceBefore: number;
+    balanceAfter: number;
+    durationMs: number;
+    error?: string;
+}
+/**
+ * Maximum request body size (10 MB).
+ */
+export declare const MAX_BODY_SIZE: number;
+/**
+ * Maximum retry delay (30 seconds).
+ */
+export declare const MAX_RETRY_DELAY_MS = 30000;
+/**
+ * Default retry configuration.
+ */
+export declare const DEFAULT_RETRY_CONFIG: {
+    readonly maxRetries: 2;
+    readonly baseDelayMs: 2000;
+    readonly maxDelayMs: 30000;
+};

package/dist/proxy/types.js

@@ -0,0 +1,74 @@
+/**
+ * Shared type definitions for the proxy module.
+ */
+/**
+ * Default console logger.
+ */
+export const defaultLogger = {
+    info: (...args) => console.log("[t2c]", ...args),
+    warn: (...args) => console.warn("[t2c]", ...args),
+    error: (...args) => console.error("[t2c]", ...args),
+};
+/**
+ * Known provider prefixes for model ID transformation.
+ * We use `-` as separator in OpenClaw to avoid double-slash issue,
+ * but Gate/OpenRouter expects `/` as separator.
+ */
+export const MODEL_PROVIDER_PREFIXES = [
+    "openai",
+    "anthropic",
+    "google",
+    "deepseek",
+    "qwen",
+    "moonshotai",
+    "mistralai",
+    "meta-llama",
+    "nvidia",
+    "cohere",
+    "perplexity",
+];
+/**
+ * Transform model ID from dash format to slash format.
+ * e.g., "anthropic-claude-sonnet-4.5" → "anthropic/claude-sonnet-4.5"
+ */
+export function transformModelId(model) {
+    for (const prefix of MODEL_PROVIDER_PREFIXES) {
+        if (model.startsWith(`${prefix}-`)) {
+            return `${prefix}/${model.slice(prefix.length + 1)}`;
+        }
+    }
+    return model;
+}
+/**
+ * Parse Retry-After header value.
+ * Returns milliseconds to wait, or null if invalid.
+ */
+export function parseRetryAfter(value) {
+    if (!value)
+        return null;
+    const seconds = parseFloat(value);
+    if (!isNaN(seconds) && isFinite(seconds)) {
+        return Math.max(0, Math.ceil(seconds * 1000));
+    }
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+        return Math.max(0, date.getTime() - Date.now());
+    }
+    return null;
+}
+/**
+ * Maximum request body size (10 MB).
+ */
+export const MAX_BODY_SIZE = 10 * 1024 * 1024;
+/**
+ * Maximum retry delay (30 seconds).
+ */
+export const MAX_RETRY_DELAY_MS = 30_000;
+/**
+ * Default retry configuration.
+ */
+export const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 2,
+    baseDelayMs: 2000,
+    maxDelayMs: MAX_RETRY_DELAY_MS,
+};

package/dist/proxy.d.ts

@@ -1,11 +1,4 @@
 import { type T2CConfig } from "./config.js";
-export interface Logger {
-    info: (...args: unknown[]) => void;
-    warn: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-}
-export interface ProxyHandle {
-    stop: () => void;
-    proxySecret: string;
-}
+import { type Logger, type ProxyHandle, transformModelId, parseRetryAfter } from "./proxy/index.js";
+export { transformModelId, parseRetryAfter, type Logger, type ProxyHandle };
 export declare function startProxy(config: T2CConfig, logger?: Logger): Promise<ProxyHandle>;