zk-credits 0.1.1 → 0.1.2

package/dist/anthropic-messages.d.ts

@@ -0,0 +1,81 @@
+export interface AnthropicContentBlock {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+export interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: string | AnthropicContentBlock[];
+}
+export interface AnthropicMessagesRequest {
+    model?: string;
+    system?: string | AnthropicContentBlock[];
+    messages: AnthropicMessage[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stop_sequences?: string[];
+    stream?: boolean;
+    [key: string]: unknown;
+}
+export interface OpenAiMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface OpenAiChatRequest {
+    model: string;
+    messages: OpenAiMessage[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stop?: string[];
+    stream?: boolean;
+    [key: string]: unknown;
+}
+export interface OpenAiChatResponse {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices?: Array<{
+        index?: number;
+        message?: {
+            role?: string;
+            content?: string | null;
+        };
+        finish_reason?: string | null;
+    }>;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    };
+}
+export interface AnthropicMessageResponse {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    model: string;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | null;
+    stop_sequence: string | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+export declare function anthropicErrorType(status: number): string;
+export declare function translateAnthropicToOpenAi(request: AnthropicMessagesRequest): OpenAiChatRequest;
+export declare function translateOpenAiToAnthropic(response: OpenAiChatResponse): AnthropicMessageResponse;
+export interface StreamTransformerOptions {
+    model: string;
+    id?: string;
+}
+export interface AnthropicStreamTransformer {
+    transformChunk(chunk: unknown): string[];
+    finish(): string[];
+}
+export declare function createAnthropicStreamTransformer(options: StreamTransformerOptions): AnthropicStreamTransformer;

package/dist/anthropic-messages.js

@@ -0,0 +1,192 @@
+function normalizeContent(content) {
+    if (!content)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((block) => {
+            if (typeof block === 'string')
+                return block;
+            if (block && typeof block.text === 'string')
+                return block.text;
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    return '';
+}
+function resolveModel(requestedModel) {
+    if (!requestedModel)
+        return 'openai/gpt-4o-mini';
+    if (requestedModel.includes('/'))
+        return requestedModel;
+    return 'openai/gpt-4o-mini';
+}
+function mapFinishReason(reason) {
+    if (!reason || reason === 'stop')
+        return 'end_turn';
+    if (reason === 'length')
+        return 'max_tokens';
+    if (reason === 'tool_calls' || reason === 'function_call')
+        return 'tool_use';
+    return 'end_turn';
+}
+export function anthropicErrorType(status) {
+    switch (status) {
+        case 400:
+            return 'invalid_request_error';
+        case 401:
+            return 'authentication_error';
+        case 403:
+            return 'permission_error';
+        case 404:
+            return 'not_found_error';
+        case 413:
+            return 'request_too_large';
+        case 429:
+            return 'rate_limit_error';
+        case 529:
+            return 'overloaded_error';
+        default:
+            return status >= 500 ? 'api_error' : 'invalid_request_error';
+    }
+}
+export function translateAnthropicToOpenAi(request) {
+    const messages = [];
+    const systemContent = normalizeContent(request.system);
+    if (systemContent) {
+        messages.push({ role: 'system', content: systemContent });
+    }
+    for (const msg of request.messages || []) {
+        const content = normalizeContent(msg.content);
+        messages.push({
+            role: msg.role === 'assistant' ? 'assistant' : 'user',
+            content,
+        });
+    }
+    const openAiRequest = {
+        model: resolveModel(request.model),
+        messages,
+    };
+    if (request.max_tokens !== undefined) {
+        openAiRequest.max_tokens = request.max_tokens;
+    }
+    if (request.temperature !== undefined) {
+        openAiRequest.temperature = request.temperature;
+    }
+    if (request.top_p !== undefined) {
+        openAiRequest.top_p = request.top_p;
+    }
+    if (request.stop_sequences && request.stop_sequences.length > 0) {
+        openAiRequest.stop = request.stop_sequences;
+    }
+    if (request.stream) {
+        openAiRequest.stream = true;
+    }
+    return openAiRequest;
+}
+export function translateOpenAiToAnthropic(response) {
+    const choice = response.choices?.[0];
+    const text = choice?.message?.content ?? '';
+    const stopReason = mapFinishReason(choice?.finish_reason);
+    return {
+        id: response.id?.startsWith('msg_')
+            ? response.id
+            : `msg_${response.id || 'zk_' + Date.now()}`,
+        type: 'message',
+        role: 'assistant',
+        model: response.model || 'openai/gpt-4o-mini',
+        content: [{ type: 'text', text }],
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage: {
+            input_tokens: response.usage?.prompt_tokens ?? 0,
+            output_tokens: response.usage?.completion_tokens ?? 0,
+        },
+    };
+}
+export function createAnthropicStreamTransformer(options) {
+    const messageId = options.id || `msg_zk_${Date.now()}`;
+    const model = options.model;
+    let started = false;
+    let blockStarted = false;
+    let blockIndex = 0;
+    let promptTokens = 0;
+    let completionTokens = 0;
+    let finalStopReason = null;
+    function sse(event, data) {
+        return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    }
+    return {
+        transformChunk(rawChunk) {
+            const chunk = rawChunk;
+            const out = [];
+            if (!started) {
+                started = true;
+                out.push(sse('message_start', {
+                    type: 'message_start',
+                    message: {
+                        id: messageId,
+                        type: 'message',
+                        role: 'assistant',
+                        model,
+                        content: [],
+                        stop_reason: null,
+                        stop_sequence: null,
+                        usage: { input_tokens: 0, output_tokens: 0 },
+                    },
+                }));
+            }
+            if (chunk.usage) {
+                if (chunk.usage.prompt_tokens)
+                    promptTokens = chunk.usage.prompt_tokens;
+                if (chunk.usage.completion_tokens)
+                    completionTokens = chunk.usage.completion_tokens;
+            }
+            const choice = chunk.choices?.[0];
+            const deltaContent = choice?.delta?.content;
+            if (deltaContent) {
+                if (!blockStarted) {
+                    blockStarted = true;
+                    out.push(sse('content_block_start', {
+                        type: 'content_block_start',
+                        index: blockIndex,
+                        content_block: { type: 'text', text: '' },
+                    }));
+                }
+                out.push(sse('content_block_delta', {
+                    type: 'content_block_delta',
+                    index: blockIndex,
+                    delta: { type: 'text_delta', text: deltaContent },
+                }));
+            }
+            if (choice?.finish_reason) {
+                finalStopReason = mapFinishReason(choice.finish_reason);
+            }
+            return out;
+        },
+        finish() {
+            const out = [];
+            if (blockStarted) {
+                out.push(sse('content_block_stop', {
+                    type: 'content_block_stop',
+                    index: blockIndex,
+                }));
+            }
+            out.push(sse('message_delta', {
+                type: 'message_delta',
+                delta: {
+                    stop_reason: finalStopReason || 'end_turn',
+                    stop_sequence: null,
+                },
+                usage: { output_tokens: completionTokens },
+            }));
+            out.push(sse('message_stop', {
+                type: 'message_stop',
+            }));
+            return out;
+        },
+    };
+}

package/dist/claude-launcher.d.ts

@@ -0,0 +1,17 @@
+interface SpawnedProcess {
+    once(event: 'error', listener: (error: NodeJS.ErrnoException) => void): this;
+    once(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+}
+export type ClaudeSpawnCommand = (command: string, args: readonly string[], options: {
+    stdio: 'inherit';
+    env: NodeJS.ProcessEnv;
+}) => SpawnedProcess;
+export interface LaunchClaudeOptions {
+    args: readonly string[];
+    loopbackBaseUrl: string;
+    localToken: string;
+    stateDirectory: string;
+}
+/** Configures and launches Claude Code against the proof-aware loopback transport. */
+export declare function launchClaudeProcess(options: LaunchClaudeOptions, spawnImpl?: ClaudeSpawnCommand): Promise<number>;
+export {};

package/dist/claude-launcher.js

@@ -0,0 +1,47 @@
+import { spawn } from 'node:child_process';
+import { chmod, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+const spawnCommand = (command, args, options) => spawn(command, [...args], options);
+function anthropicBaseUrl(loopbackBaseUrl) {
+    const url = new URL(loopbackBaseUrl);
+    if (url.protocol !== 'http:' || url.hostname !== '127.0.0.1') {
+        throw new Error('Claude Code companion must use a 127.0.0.1 HTTP sidecar URL');
+    }
+    // Claude Code appends /v1/messages, so base URL must NOT have trailing /v1
+    return url.origin;
+}
+async function prepareClaudeDirectory(stateDirectory) {
+    const configDirectory = join(stateDirectory, 'claude');
+    await mkdir(configDirectory, { recursive: true, mode: 0o700 });
+    await chmod(configDirectory, 0o700);
+    return configDirectory;
+}
+function waitForClaude(child) {
+    return new Promise((resolve, reject) => {
+        child.once('error', (error) => {
+            if (error.code === 'ENOENT') {
+                reject(new Error('Claude Code CLI was not found; install it with npm install -g @anthropic-ai/claude-code before running zk-credits claude'));
+                return;
+            }
+            reject(error);
+        });
+        child.once('exit', (code) => resolve(code ?? 1));
+    });
+}
+/** Configures and launches Claude Code against the proof-aware loopback transport. */
+export async function launchClaudeProcess(options, spawnImpl = spawnCommand) {
+    const configDirectory = await prepareClaudeDirectory(options.stateDirectory);
+    const baseUrl = anthropicBaseUrl(options.loopbackBaseUrl);
+    const env = {
+        ...process.env,
+        CLAUDE_CONFIG_DIR: configDirectory,
+        ANTHROPIC_BASE_URL: baseUrl,
+        ANTHROPIC_AUTH_TOKEN: options.localToken,
+        DISABLE_TELEMETRY: '1',
+    };
+    const child = spawnImpl('claude', [...options.args], {
+        stdio: 'inherit',
+        env,
+    });
+    return waitForClaude(child);
+}

package/dist/cli-runtime.d.ts

@@ -11,6 +11,7 @@ export interface CliCommandDependencies {
     isSidecarHealthy(): Promise<boolean>;
     launchCodex(args: readonly string[]): Promise<number>;
     launchCline(args: readonly string[], localToken: string): Promise<number>;
+    launchClaude(args: readonly string[], localToken: string): Promise<number>;
 }
 /** Handles the non-server CLI commands independently from terminal I/O. */
 export declare function runCliCommand(args: readonly string[], dependencies: CliCommandDependencies): Promise<number>;

package/dist/cli-runtime.js

@@ -57,7 +57,15 @@ export async function runCliCommand(args, dependencies) {
             const localToken = await dependencies.ensureSidecar();
             return dependencies.launchCline(args.slice(1), localToken);
         }
+        case 'claude': {
+            if (!await dependencies.isIdentityConfigured()) {
+                await dependencies.importMnemonic(await dependencies.readMnemonic());
+                dependencies.write('ZK Credits identity imported into the system credential store.');
+            }
+            const localToken = await dependencies.ensureSidecar();
+            return dependencies.launchClaude(args.slice(1), localToken);
+        }
         default:
-            throw new Error('Usage: zk-credits <cline|setup codex|codex|status|token|import-mnemonic|serve|env>');
+            throw new Error('Usage: zk-credits <cline|claude|setup codex|codex|status|token|import-mnemonic|serve|env>');
     }
 }

package/dist/cli.js

@@ -3,6 +3,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { launchCodexProcess } from './codex-launcher.js';
 import { launchClineProcess } from './cline-launcher.js';
+import { launchClaudeProcess } from './claude-launcher.js';
 import { isCodexProfileInstalled, resolveCodexHome, writeCodexProfile, } from './codex-profile.js';
 import { IdentityStore } from './identity.js';
 import { createLocalProofGenerator } from './local-prover.js';
@@ -79,6 +80,7 @@ async function readHiddenMnemonic() {
 function printHelp() {
     console.log(`Usage:
   zk-credits cline [cline arguments...]
+  zk-credits claude [claude arguments...]
   zk-credits setup codex [--model <model>]
   zk-credits codex [codex arguments...]
   zk-credits status
@@ -86,9 +88,9 @@ function printHelp() {
   zk-credits serve [--port <port>]
   eval "$(zk-credits env)"
 
-"zk-credits cline" is the zero-configuration coding-agent path: it starts the
-sidecar, configures an isolated OpenAI-compatible Cline profile, and forwards
-all Cline arguments. The Codex companion remains available through setup codex.
+"zk-credits cline" and "zk-credits claude" configure and launch coding agents
+against the proof-aware loopback sidecar. The Codex companion remains available
+through setup codex.
 Set ZK_CREDITS_MNEMONIC only for a headless process; it is not persisted.`);
 }
 async function serve(args) {
@@ -173,6 +175,12 @@ async function main() {
             localToken,
             stateDirectory: sidecarHome,
         }),
+        launchClaude: (claudeArgs, localToken) => launchClaudeProcess({
+            args: claudeArgs,
+            loopbackBaseUrl: loopbackBaseUrl(),
+            localToken,
+            stateDirectory: sidecarHome,
+        }),
     });
     if (exitCode !== 0)
         process.exitCode = exitCode;

package/dist/codex-sdk-options.d.ts

@@ -0,0 +1,13 @@
+import type { CodexOptions, ThreadOptions } from '@openai/codex-sdk';
+export interface BuildCodexSdkOptionsInput {
+    loopbackBaseUrl: string;
+    token: string;
+    codexHome: string;
+    env?: Record<string, string>;
+}
+export interface BuildCodexThreadOptionsInput {
+    model?: string;
+    workingDirectory?: string;
+}
+export declare function buildCodexSdkOptions(input: BuildCodexSdkOptionsInput): CodexOptions;
+export declare function buildCodexThreadOptions(input?: BuildCodexThreadOptionsInput): ThreadOptions;

package/dist/codex-sdk-options.js

@@ -0,0 +1,33 @@
+import { DEFAULT_CODEX_MODEL } from './codex-profile.js';
+export function buildCodexSdkOptions(input) {
+    let url;
+    try {
+        url = new URL(input.loopbackBaseUrl);
+    }
+    catch {
+        throw new Error('Codex SDK provider must use a 127.0.0.1 HTTP sidecar URL with an explicit port');
+    }
+    if (url.protocol !== 'http:' || url.hostname !== '127.0.0.1' || !url.port) {
+        throw new Error('Codex SDK provider must use a 127.0.0.1 HTTP sidecar URL with an explicit port');
+    }
+    const baseUrl = `${url.origin}/v1`;
+    return {
+        baseUrl,
+        apiKey: input.token,
+        env: {
+            ...(input.env ?? process.env),
+            CODEX_HOME: input.codexHome,
+            OPENAI_BASE_URL: baseUrl,
+            OPENAI_API_KEY: input.token,
+        },
+    };
+}
+export function buildCodexThreadOptions(input) {
+    return {
+        model: input?.model ?? DEFAULT_CODEX_MODEL,
+        sandboxMode: 'read-only',
+        skipGitRepoCheck: true,
+        approvalPolicy: 'never',
+        ...(input?.workingDirectory ? { workingDirectory: input.workingDirectory } : {}),
+    };
+}

package/dist/sidecar.js

@@ -1,9 +1,21 @@
 import { createServer } from 'node:http';
+import { anthropicErrorType, createAnthropicStreamTransformer, translateAnthropicToOpenAi, translateOpenAiToAnthropic, } from './anthropic-messages.js';
 import { codexModelsResponse } from './codex-profile.js';
 const MAX_REQUEST_BYTES = 2_000_000;
 function isLoopbackAddress(address) {
     return address === '127.0.0.1' || address === '::1' || address === '::ffff:127.0.0.1';
 }
+function extractLocalToken(req) {
+    const authHeader = req.headers.authorization;
+    if (authHeader && authHeader.startsWith('Bearer ')) {
+        return authHeader.slice(7).trim();
+    }
+    const apiKeyHeader = req.headers['x-api-key'];
+    if (typeof apiKeyHeader === 'string') {
+        return apiKeyHeader.trim();
+    }
+    return null;
+}
 function sendJson(res, status, body) {
     res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
     res.end(JSON.stringify(body));
@@ -71,19 +83,144 @@ export function createSidecarServer(options) {
             sendJson(res, 200, { service: 'zk-credits-sidecar', status: 'ok' });
             return;
         }
+        const token = extractLocalToken(req);
         if (req.method === 'GET' && pathname === '/v1/models') {
-            if (req.headers.authorization !== `Bearer ${options.localToken}`) {
+            if (token !== options.localToken) {
                 sendJson(res, 401, { error: 'invalid_local_token' });
                 return;
             }
             sendJson(res, 200, codexModelsResponse());
             return;
         }
+        if (req.method === 'POST' && pathname === '/v1/messages') {
+            if (token !== options.localToken) {
+                sendJson(res, 401, { error: 'invalid_local_token' });
+                return;
+            }
+            try {
+                const body = await readJsonBody(req);
+                const anthropicReq = body.parsed;
+                const openAiReq = translateAnthropicToOpenAi(anthropicReq);
+                const rawOpenAiBody = JSON.stringify(openAiReq);
+                const reservation = await options.ledger.reserve(openAiReq);
+                const proof = await options.proofGenerator({
+                    ticketIndex: reservation.index,
+                    request: openAiReq,
+                });
+                const upstream = await gatewayFetch(`${gatewayBaseUrl}/v1/chat/completions`, {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `Bearer ${options.compatibilityKey}`,
+                        'Content-Type': 'application/json',
+                        'X-ZK-Proof': proofHeader(proof),
+                    },
+                    body: rawOpenAiBody,
+                });
+                if (upstream.status >= 200 && upstream.status < 300 && upstream.status !== 202) {
+                    await options.ledger.consume(reservation.requestDigest);
+                }
+                if (!upstream.ok) {
+                    const rawText = await upstream.text();
+                    let errorMsg = rawText.trim() || `Gateway returned HTTP ${upstream.status}`;
+                    try {
+                        const errJson = JSON.parse(rawText);
+                        if (errJson && typeof errJson === 'object') {
+                            if ('error' in errJson && typeof errJson.error === 'string') {
+                                errorMsg = errJson.error;
+                            }
+                            else if ('error' in errJson &&
+                                errJson.error &&
+                                typeof errJson.error === 'object' &&
+                                'message' in errJson.error &&
+                                typeof errJson.error.message === 'string') {
+                                errorMsg = errJson.error.message;
+                            }
+                            else if ('message' in errJson &&
+                                typeof errJson.message === 'string') {
+                                errorMsg = errJson.message;
+                            }
+                        }
+                    }
+                    catch {
+                        // rawText is preserved as errorMsg
+                    }
+                    sendJson(res, upstream.status, {
+                        type: 'error',
+                        error: {
+                            type: anthropicErrorType(upstream.status),
+                            message: errorMsg,
+                        },
+                    });
+                    return;
+                }
+                if (openAiReq.stream) {
+                    res.writeHead(upstream.status, {
+                        'Content-Type': 'text/event-stream; charset=utf-8',
+                        'Cache-Control': 'no-cache',
+                        Connection: 'keep-alive',
+                    });
+                    if (!upstream.body) {
+                        res.end();
+                        return;
+                    }
+                    const transformer = createAnthropicStreamTransformer({
+                        model: openAiReq.model,
+                    });
+                    const reader = upstream.body.getReader();
+                    const decoder = new TextDecoder();
+                    let buffer = '';
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split('\n');
+                        buffer = lines.pop() ?? '';
+                        for (const line of lines) {
+                            const trimmed = line.trim();
+                            if (trimmed.startsWith('data: ')) {
+                                const dataStr = trimmed.slice(6);
+                                if (dataStr === '[DONE]')
+                                    continue;
+                                try {
+                                    const parsedChunk = JSON.parse(dataStr);
+                                    const sseEvents = transformer.transformChunk(parsedChunk);
+                                    for (const evt of sseEvents)
+                                        res.write(evt);
+                                }
+                                catch {
+                                    // ignore non-JSON chunk
+                                }
+                            }
+                        }
+                    }
+                    const finishEvents = transformer.finish();
+                    for (const evt of finishEvents)
+                        res.write(evt);
+                    res.end();
+                }
+                else {
+                    const openAiRes = (await upstream.json());
+                    const anthropicRes = translateOpenAiToAnthropic(openAiRes);
+                    sendJson(res, upstream.status, anthropicRes);
+                }
+            }
+            catch (error) {
+                if (!res.headersSent) {
+                    const message = error instanceof Error ? error.message : 'Loopback request failed';
+                    sendJson(res, 502, { error: 'sidecar_request_failed', message });
+                }
+                else if (!res.writableEnded) {
+                    res.end();
+                }
+            }
+            return;
+        }
         if (req.method !== 'POST' || (pathname !== '/v1/chat/completions' && pathname !== '/v1/responses')) {
             sendJson(res, 404, { error: 'unsupported_openai_path' });
             return;
         }
-        if (req.headers.authorization !== `Bearer ${options.localToken}`) {
+        if (token !== options.localToken) {
             sendJson(res, 401, { error: 'invalid_local_token' });
             return;
         }

package/dist/zk-credits.js

@@ -3,7 +3,7 @@ import { createRequire as __createNodeRequire } from 'node:module'; const requir
 
 // dist/cli.js
 import { homedir } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // dist/codex-launcher.js
 import { spawn } from "node:child_process";
@@ -221,6 +221,53 @@ async function launchClineProcess(options, spawnImpl = spawnCommand2) {
   }));
 }
 
+// dist/claude-launcher.js
+import { spawn as spawn3 } from "node:child_process";
+import { chmod as chmod3, mkdir as mkdir3 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var spawnCommand3 = (command, args, options) => spawn3(command, [...args], options);
+function anthropicBaseUrl(loopbackBaseUrl2) {
+  const url = new URL(loopbackBaseUrl2);
+  if (url.protocol !== "http:" || url.hostname !== "127.0.0.1") {
+    throw new Error("Claude Code companion must use a 127.0.0.1 HTTP sidecar URL");
+  }
+  return url.origin;
+}
+async function prepareClaudeDirectory(stateDirectory2) {
+  const configDirectory = join3(stateDirectory2, "claude");
+  await mkdir3(configDirectory, { recursive: true, mode: 448 });
+  await chmod3(configDirectory, 448);
+  return configDirectory;
+}
+function waitForClaude(child) {
+  return new Promise((resolve2, reject) => {
+    child.once("error", (error) => {
+      if (error.code === "ENOENT") {
+        reject(new Error("Claude Code CLI was not found; install it with npm install -g @anthropic-ai/claude-code before running zk-credits claude"));
+        return;
+      }
+      reject(error);
+    });
+    child.once("exit", (code) => resolve2(code ?? 1));
+  });
+}
+async function launchClaudeProcess(options, spawnImpl = spawnCommand3) {
+  const configDirectory = await prepareClaudeDirectory(options.stateDirectory);
+  const baseUrl = anthropicBaseUrl(options.loopbackBaseUrl);
+  const env = {
+    ...process.env,
+    CLAUDE_CONFIG_DIR: configDirectory,
+    ANTHROPIC_BASE_URL: baseUrl,
+    ANTHROPIC_AUTH_TOKEN: options.localToken,
+    DISABLE_TELEMETRY: "1"
+  };
+  const child = spawnImpl("claude", [...options.args], {
+    stdio: "inherit",
+    env
+  });
+  return waitForClaude(child);
+}
+
 // dist/identity.js
 import * as keytar from "keytar";
 
@@ -492,7 +539,7 @@ import { resolve } from "node:path";
 // dist/artifact-manifest.js
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 var CIRCUIT_MANIFEST = [
   {
     file: "rln_nullifier.wasm",
@@ -509,7 +556,7 @@ var CIRCUIT_MANIFEST = [
 ];
 async function verifyArtifactManifest(artifactDirectory, manifest = CIRCUIT_MANIFEST) {
   for (const artifact of manifest) {
-    const content = await readFile(join3(artifactDirectory, artifact.file));
+    const content = await readFile(join4(artifactDirectory, artifact.file));
     const digest = createHash("sha256").update(content).digest("hex");
     if (digest !== artifact.sha256) {
       throw new Error(`Circuit artifact hash mismatch: ${artifact.file}`);
@@ -603,15 +650,15 @@ var MembershipClient = class {
 
 // dist/sidecar-config.js
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 function createLoopbackToken() {
   return randomBytes2(32).toString("base64url");
 }
 function sidecarStatePaths(stateDirectory2) {
   return {
-    ledgerPath: join4(stateDirectory2, "tickets.json"),
-    tokenPath: join4(stateDirectory2, "loopback-token"),
-    logPath: join4(stateDirectory2, "sidecar.log")
+    ledgerPath: join5(stateDirectory2, "tickets.json"),
+    tokenPath: join5(stateDirectory2, "loopback-token"),
+    logPath: join5(stateDirectory2, "sidecar.log")
   };
 }
 function formatOpenAiEnvironment(loopbackBaseUrl2, localToken) {
@@ -683,29 +730,37 @@ async function runCliCommand(args, dependencies) {
       const localToken = await dependencies.ensureSidecar();
       return dependencies.launchCline(args.slice(1), localToken);
     }
+    case "claude": {
+      if (!await dependencies.isIdentityConfigured()) {
+        await dependencies.importMnemonic(await dependencies.readMnemonic());
+        dependencies.write("ZK Credits identity imported into the system credential store.");
+      }
+      const localToken = await dependencies.ensureSidecar();
+      return dependencies.launchClaude(args.slice(1), localToken);
+    }
     default:
-      throw new Error("Usage: zk-credits <cline|setup codex|codex|status|token|import-mnemonic|serve|env>");
+      throw new Error("Usage: zk-credits <cline|claude|setup codex|codex|status|token|import-mnemonic|serve|env>");
   }
 }
 
 // dist/node-sidecar-lifecycle.js
-import { spawn as spawn3 } from "node:child_process";
-import { chmod as chmod4, mkdir as mkdir4, open } from "node:fs/promises";
+import { spawn as spawn4 } from "node:child_process";
+import { chmod as chmod5, mkdir as mkdir5, open } from "node:fs/promises";
 import { dirname as dirname2 } from "node:path";
 
 // dist/sidecar-state.js
-import { chmod as chmod3, mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { chmod as chmod4, mkdir as mkdir4, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname } from "node:path";
 async function writeLoopbackToken(tokenPath, token) {
   if (!token)
     throw new Error("Loopback token is required");
-  await mkdir3(dirname(tokenPath), { recursive: true, mode: 448 });
+  await mkdir4(dirname(tokenPath), { recursive: true, mode: 448 });
   const temporaryPath = `${tokenPath}.tmp`;
   await writeFile2(temporaryPath, `${token}
 `, { encoding: "utf8", mode: 384 });
-  await chmod3(temporaryPath, 384);
+  await chmod4(temporaryPath, 384);
   await rename2(temporaryPath, tokenPath);
-  await chmod3(tokenPath, 384);
+  await chmod4(tokenPath, 384);
 }
 async function readLoopbackToken(tokenPath) {
   const token = (await readFile3(tokenPath, "utf8")).trim();
@@ -716,11 +771,11 @@ async function readLoopbackToken(tokenPath) {
 
 // dist/node-sidecar-lifecycle.js
 async function startDetachedProcess(specification) {
-  await mkdir4(dirname2(specification.logPath), { recursive: true, mode: 448 });
+  await mkdir5(dirname2(specification.logPath), { recursive: true, mode: 448 });
   const log = await open(specification.logPath, "a", 384);
-  await chmod4(specification.logPath, 384);
+  await chmod5(specification.logPath, 384);
   try {
-    const child = spawn3(specification.executable, specification.args, {
+    const child = spawn4(specification.executable, specification.args, {
       detached: true,
       env: specification.env,
       stdio: ["ignore", log.fd, log.fd]
@@ -798,10 +853,215 @@ async function ensureSidecarReady(dependencies, options = {}) {
 
 // dist/sidecar.js
 import { createServer } from "node:http";
+
+// dist/anthropic-messages.js
+function normalizeContent(content) {
+  if (!content)
+    return "";
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.map((block) => {
+      if (typeof block === "string")
+        return block;
+      if (block && typeof block.text === "string")
+        return block.text;
+      return "";
+    }).filter(Boolean).join("\n");
+  }
+  return "";
+}
+function resolveModel(requestedModel) {
+  if (!requestedModel)
+    return "openai/gpt-4o-mini";
+  if (requestedModel.includes("/"))
+    return requestedModel;
+  return "openai/gpt-4o-mini";
+}
+function mapFinishReason(reason) {
+  if (!reason || reason === "stop")
+    return "end_turn";
+  if (reason === "length")
+    return "max_tokens";
+  if (reason === "tool_calls" || reason === "function_call")
+    return "tool_use";
+  return "end_turn";
+}
+function anthropicErrorType(status) {
+  switch (status) {
+    case 400:
+      return "invalid_request_error";
+    case 401:
+      return "authentication_error";
+    case 403:
+      return "permission_error";
+    case 404:
+      return "not_found_error";
+    case 413:
+      return "request_too_large";
+    case 429:
+      return "rate_limit_error";
+    case 529:
+      return "overloaded_error";
+    default:
+      return status >= 500 ? "api_error" : "invalid_request_error";
+  }
+}
+function translateAnthropicToOpenAi(request) {
+  const messages = [];
+  const systemContent = normalizeContent(request.system);
+  if (systemContent) {
+    messages.push({ role: "system", content: systemContent });
+  }
+  for (const msg of request.messages || []) {
+    const content = normalizeContent(msg.content);
+    messages.push({
+      role: msg.role === "assistant" ? "assistant" : "user",
+      content
+    });
+  }
+  const openAiRequest = {
+    model: resolveModel(request.model),
+    messages
+  };
+  if (request.max_tokens !== void 0) {
+    openAiRequest.max_tokens = request.max_tokens;
+  }
+  if (request.temperature !== void 0) {
+    openAiRequest.temperature = request.temperature;
+  }
+  if (request.top_p !== void 0) {
+    openAiRequest.top_p = request.top_p;
+  }
+  if (request.stop_sequences && request.stop_sequences.length > 0) {
+    openAiRequest.stop = request.stop_sequences;
+  }
+  if (request.stream) {
+    openAiRequest.stream = true;
+  }
+  return openAiRequest;
+}
+function translateOpenAiToAnthropic(response) {
+  const choice = response.choices?.[0];
+  const text = choice?.message?.content ?? "";
+  const stopReason = mapFinishReason(choice?.finish_reason);
+  return {
+    id: response.id?.startsWith("msg_") ? response.id : `msg_${response.id || "zk_" + Date.now()}`,
+    type: "message",
+    role: "assistant",
+    model: response.model || "openai/gpt-4o-mini",
+    content: [{ type: "text", text }],
+    stop_reason: stopReason,
+    stop_sequence: null,
+    usage: {
+      input_tokens: response.usage?.prompt_tokens ?? 0,
+      output_tokens: response.usage?.completion_tokens ?? 0
+    }
+  };
+}
+function createAnthropicStreamTransformer(options) {
+  const messageId = options.id || `msg_zk_${Date.now()}`;
+  const model = options.model;
+  let started = false;
+  let blockStarted = false;
+  let blockIndex = 0;
+  let promptTokens = 0;
+  let completionTokens = 0;
+  let finalStopReason = null;
+  function sse(event, data) {
+    return `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+  }
+  return {
+    transformChunk(rawChunk) {
+      const chunk = rawChunk;
+      const out = [];
+      if (!started) {
+        started = true;
+        out.push(sse("message_start", {
+          type: "message_start",
+          message: {
+            id: messageId,
+            type: "message",
+            role: "assistant",
+            model,
+            content: [],
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 }
+          }
+        }));
+      }
+      if (chunk.usage) {
+        if (chunk.usage.prompt_tokens)
+          promptTokens = chunk.usage.prompt_tokens;
+        if (chunk.usage.completion_tokens)
+          completionTokens = chunk.usage.completion_tokens;
+      }
+      const choice = chunk.choices?.[0];
+      const deltaContent = choice?.delta?.content;
+      if (deltaContent) {
+        if (!blockStarted) {
+          blockStarted = true;
+          out.push(sse("content_block_start", {
+            type: "content_block_start",
+            index: blockIndex,
+            content_block: { type: "text", text: "" }
+          }));
+        }
+        out.push(sse("content_block_delta", {
+          type: "content_block_delta",
+          index: blockIndex,
+          delta: { type: "text_delta", text: deltaContent }
+        }));
+      }
+      if (choice?.finish_reason) {
+        finalStopReason = mapFinishReason(choice.finish_reason);
+      }
+      return out;
+    },
+    finish() {
+      const out = [];
+      if (blockStarted) {
+        out.push(sse("content_block_stop", {
+          type: "content_block_stop",
+          index: blockIndex
+        }));
+      }
+      out.push(sse("message_delta", {
+        type: "message_delta",
+        delta: {
+          stop_reason: finalStopReason || "end_turn",
+          stop_sequence: null
+        },
+        usage: { output_tokens: completionTokens }
+      }));
+      out.push(sse("message_stop", {
+        type: "message_stop"
+      }));
+      return out;
+    }
+  };
+}
+
+// dist/sidecar.js
 var MAX_REQUEST_BYTES = 2e6;
 function isLoopbackAddress(address) {
   return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1";
 }
+function extractLocalToken(req) {
+  const authHeader = req.headers.authorization;
+  if (authHeader && authHeader.startsWith("Bearer ")) {
+    return authHeader.slice(7).trim();
+  }
+  const apiKeyHeader = req.headers["x-api-key"];
+  if (typeof apiKeyHeader === "string") {
+    return apiKeyHeader.trim();
+  }
+  return null;
+}
 function sendJson(res, status, body) {
   res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
   res.end(JSON.stringify(body));
@@ -863,19 +1123,130 @@ function createSidecarServer(options) {
       sendJson(res, 200, { service: "zk-credits-sidecar", status: "ok" });
       return;
     }
+    const token = extractLocalToken(req);
     if (req.method === "GET" && pathname === "/v1/models") {
-      if (req.headers.authorization !== `Bearer ${options.localToken}`) {
+      if (token !== options.localToken) {
         sendJson(res, 401, { error: "invalid_local_token" });
         return;
       }
       sendJson(res, 200, codexModelsResponse());
       return;
     }
+    if (req.method === "POST" && pathname === "/v1/messages") {
+      if (token !== options.localToken) {
+        sendJson(res, 401, { error: "invalid_local_token" });
+        return;
+      }
+      try {
+        const body = await readJsonBody(req);
+        const anthropicReq = body.parsed;
+        const openAiReq = translateAnthropicToOpenAi(anthropicReq);
+        const rawOpenAiBody = JSON.stringify(openAiReq);
+        const reservation = await options.ledger.reserve(openAiReq);
+        const proof = await options.proofGenerator({
+          ticketIndex: reservation.index,
+          request: openAiReq
+        });
+        const upstream = await gatewayFetch(`${gatewayBaseUrl}/v1/chat/completions`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${options.compatibilityKey}`,
+            "Content-Type": "application/json",
+            "X-ZK-Proof": proofHeader(proof)
+          },
+          body: rawOpenAiBody
+        });
+        if (upstream.status >= 200 && upstream.status < 300 && upstream.status !== 202) {
+          await options.ledger.consume(reservation.requestDigest);
+        }
+        if (!upstream.ok) {
+          const rawText = await upstream.text();
+          let errorMsg = rawText.trim() || `Gateway returned HTTP ${upstream.status}`;
+          try {
+            const errJson = JSON.parse(rawText);
+            if (errJson && typeof errJson === "object") {
+              if ("error" in errJson && typeof errJson.error === "string") {
+                errorMsg = errJson.error;
+              } else if ("error" in errJson && errJson.error && typeof errJson.error === "object" && "message" in errJson.error && typeof errJson.error.message === "string") {
+                errorMsg = errJson.error.message;
+              } else if ("message" in errJson && typeof errJson.message === "string") {
+                errorMsg = errJson.message;
+              }
+            }
+          } catch {
+          }
+          sendJson(res, upstream.status, {
+            type: "error",
+            error: {
+              type: anthropicErrorType(upstream.status),
+              message: errorMsg
+            }
+          });
+          return;
+        }
+        if (openAiReq.stream) {
+          res.writeHead(upstream.status, {
+            "Content-Type": "text/event-stream; charset=utf-8",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          });
+          if (!upstream.body) {
+            res.end();
+            return;
+          }
+          const transformer = createAnthropicStreamTransformer({
+            model: openAiReq.model
+          });
+          const reader = upstream.body.getReader();
+          const decoder = new TextDecoder();
+          let buffer = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              const trimmed = line.trim();
+              if (trimmed.startsWith("data: ")) {
+                const dataStr = trimmed.slice(6);
+                if (dataStr === "[DONE]")
+                  continue;
+                try {
+                  const parsedChunk = JSON.parse(dataStr);
+                  const sseEvents = transformer.transformChunk(parsedChunk);
+                  for (const evt of sseEvents)
+                    res.write(evt);
+                } catch {
+                }
+              }
+            }
+          }
+          const finishEvents = transformer.finish();
+          for (const evt of finishEvents)
+            res.write(evt);
+          res.end();
+        } else {
+          const openAiRes = await upstream.json();
+          const anthropicRes = translateOpenAiToAnthropic(openAiRes);
+          sendJson(res, upstream.status, anthropicRes);
+        }
+      } catch (error) {
+        if (!res.headersSent) {
+          const message = error instanceof Error ? error.message : "Loopback request failed";
+          sendJson(res, 502, { error: "sidecar_request_failed", message });
+        } else if (!res.writableEnded) {
+          res.end();
+        }
+      }
+      return;
+    }
     if (req.method !== "POST" || pathname !== "/v1/chat/completions" && pathname !== "/v1/responses") {
       sendJson(res, 404, { error: "unsupported_openai_path" });
       return;
     }
-    if (req.headers.authorization !== `Bearer ${options.localToken}`) {
+    if (token !== options.localToken) {
       sendJson(res, 401, { error: "invalid_local_token" });
       return;
     }
@@ -943,7 +1314,7 @@ function createSidecarServer(options) {
 }
 
 // dist/ticket-ledger.js
-import { mkdir as mkdir5, readFile as readFile4, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile4, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname3 } from "node:path";
 function parseLedger(raw) {
   const parsed = JSON.parse(raw);
@@ -1016,7 +1387,7 @@ var TicketLedger = class {
     }
   }
   async write(ledger) {
-    await mkdir5(dirname3(this.filePath), { recursive: true, mode: 448 });
+    await mkdir6(dirname3(this.filePath), { recursive: true, mode: 448 });
     const temporaryPath = `${this.filePath}.tmp`;
     await writeFile3(temporaryPath, JSON.stringify(ledger), { encoding: "utf8", mode: 384 });
     await rename3(temporaryPath, this.filePath);
@@ -1027,7 +1398,7 @@ var TicketLedger = class {
 var DEFAULT_GATEWAY_URL = "https://zk-credits-gateway.onrender.com";
 var DEFAULT_PORT = 3210;
 function stateDirectory() {
-  return process.env.ZK_CREDITS_HOME || join5(homedir(), ".zk-credits");
+  return process.env.ZK_CREDITS_HOME || join6(homedir(), ".zk-credits");
 }
 function loopbackBaseUrl() {
   const port = Number(process.env.ZK_CREDITS_SIDECAR_PORT || DEFAULT_PORT);
@@ -1087,6 +1458,7 @@ async function readHiddenMnemonic() {
 function printHelp() {
   console.log(`Usage:
   zk-credits cline [cline arguments...]
+  zk-credits claude [claude arguments...]
   zk-credits setup codex [--model <model>]
   zk-credits codex [codex arguments...]
   zk-credits status
@@ -1094,9 +1466,9 @@ function printHelp() {
   zk-credits serve [--port <port>]
   eval "$(zk-credits env)"
 
-"zk-credits cline" is the zero-configuration coding-agent path: it starts the
-sidecar, configures an isolated OpenAI-compatible Cline profile, and forwards
-all Cline arguments. The Codex companion remains available through setup codex.
+"zk-credits cline" and "zk-credits claude" configure and launch coding agents
+against the proof-aware loopback sidecar. The Codex companion remains available
+through setup codex.
 Set ZK_CREDITS_MNEMONIC only for a headless process; it is not persisted.`);
 }
 async function serve(args) {
@@ -1185,6 +1557,12 @@ async function main() {
       loopbackBaseUrl: loopbackBaseUrl(),
       localToken,
       stateDirectory: sidecarHome
+    }),
+    launchClaude: (claudeArgs, localToken) => launchClaudeProcess({
+      args: claudeArgs,
+      loopbackBaseUrl: loopbackBaseUrl(),
+      localToken,
+      stateDirectory: sidecarHome
     })
   });
   if (exitCode !== 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zk-credits",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Loopback proof-aware OpenAI transport for ZK Credits.",
   "type": "module",
   "engines": {
@@ -9,6 +9,12 @@
   "bin": {
     "zk-credits": "dist/zk-credits.js"
   },
+  "exports": {
+    "./codex": {
+      "types": "./dist/codex-sdk-options.d.ts",
+      "import": "./dist/codex-sdk-options.js"
+    }
+  },
   "files": [
     "dist",
     "circuits"
@@ -27,6 +33,7 @@
     "snarkjs": "^0.7.6"
   },
   "devDependencies": {
+    "@openai/codex-sdk": "^0.150.1",
     "@types/node": "^24.13.3",
     "@zk-credits/shared": "file:../zk-credits-shared",
     "esbuild": "^0.28.2",