@life-ai-tools/claude-code-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 LifeAITools
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,252 @@
+# opencode-claude-toolkit
+
+Use your **Claude Max/Pro subscription** programmatically — no API key needed.
+
+This toolkit provides:
+- **`@lifeaitools/claude-code-sdk`** — TypeScript SDK for the Claude Code API (streaming, tool use, conversation management)
+- **`@lifeaitools/opencode-proxy`** — OpenAI-compatible proxy server that lets you use Claude Max/Pro in [opencode](https://github.com/opencode-ai/opencode), Cursor, or any OpenAI-compatible client
+
+> **Why this exists?** Read our [Open Letter to Anthropic](OPEN-LETTER.md) about token efficiency, developer freedom, and collaboration.
+
+---
+
+## Prerequisites
+
+Before you start, make sure you have:
+
+1. **Bun** (runtime for the proxy server):
+   ```bash
+   curl -fsSL https://bun.sh/install | bash
+   ```
+
+2. **opencode** (or any OpenAI-compatible coding client):
+   ```bash
+   # Via Go
+   go install github.com/opencode-ai/opencode@latest
+   # Or via npm
+   npm install -g opencode-ai
+   ```
+
+3. **Claude Code CLI** (needed once, to authenticate your subscription):
+   ```bash
+   # Install Claude Code CLI
+   npm install -g @anthropic-ai/claude-code
+   
+   # Log in (this creates ~/.claude/.credentials.json)
+   claude
+   # Follow the OAuth flow in your browser, then exit Claude CLI
+   ```
+
+4. **Verify credentials exist:**
+   ```bash
+   ls ~/.claude/.credentials.json
+   # Should show the file — if not, run `claude` again
+   ```
+
+---
+
+## Quick Start — One Liner
+
+```bash
+# Start proxy and launch opencode in one go
+bunx @lifeaitools/opencode-proxy &
+LOCAL_ENDPOINT=http://localhost:4040/v1 opencode
+```
+
+Or step by step:
+
+```bash
+# Terminal 1: Start the proxy
+bunx @lifeaitools/opencode-proxy --port 4040
+
+# Terminal 2: Launch opencode pointing to the proxy
+LOCAL_ENDPOINT=http://localhost:4040/v1 opencode
+```
+
+That's it. opencode will now use your Claude Max subscription for all requests.
+
+### Supported Models
+
+| Model ID | Maps to | Best for |
+|----------|---------|----------|
+| `claude-v4.6-sonnet` | Claude Sonnet 4.6 | Fast coding, daily driver |
+| `claude-v4.6-opus` | Claude Opus 4.6 | Complex reasoning, architecture |
+| `claude-v4.5-haiku` | Claude Haiku 4.5 | Quick tasks, low latency |
+
+---
+
+## opencode Configuration
+
+To make opencode always use the proxy, add to your `.opencode.json`:
+
+```json
+{
+  "provider": {
+    "id": "openai",
+    "api_key": "not-needed",
+    "model": {
+      "id": "claude-v4.6-sonnet",
+      "name": "Claude Sonnet 4.6",
+      "api_model": "claude-v4.6-sonnet",
+      "can_reason": true
+    }
+  }
+}
+```
+
+Set the environment variable permanently:
+
+```bash
+# Add to your .bashrc / .zshrc
+export LOCAL_ENDPOINT=http://localhost:4040/v1
+```
+
+---
+
+## SDK Usage
+
+```typescript
+import { ClaudeCodeSDK } from '@lifeaitools/claude-code-sdk'
+
+const sdk = new ClaudeCodeSDK()
+
+// Non-streaming
+const response = await sdk.generate({
+  model: 'claude-sonnet-4-6-20250415',
+  messages: [{ role: 'user', content: 'Hello!' }],
+  maxTokens: 1024,
+})
+console.log(response.content)
+
+// Streaming
+for await (const event of sdk.stream({
+  model: 'claude-sonnet-4-6-20250415',
+  messages: [{ role: 'user', content: 'Write a haiku about coding' }],
+  maxTokens: 1024,
+})) {
+  if (event.type === 'text_delta') {
+    process.stdout.write(event.text)
+  }
+}
+
+// Multi-turn conversation
+import { Conversation } from '@lifeaitools/claude-code-sdk'
+
+const conv = new Conversation(sdk, { model: 'claude-sonnet-4-6-20250415' })
+const reply1 = await conv.send('What is TypeScript?')
+const reply2 = await conv.send('How does it compare to JavaScript?')
+```
+
+See [`examples/`](examples/) for more usage patterns.
+
+---
+
+## Features
+
+- **Zero API key** — uses your existing Claude Max/Pro OAuth credentials from `~/.claude`
+- **Streaming** — real SSE streaming with text, thinking, and tool use events
+- **Auto-refresh** — tokens are refreshed automatically when expired
+- **Retry logic** — exponential backoff for 5xx errors, proper 429 handling
+- **Tool use** — full support for function calling
+- **Thinking** — extended thinking / chain-of-thought support
+- **Caching** — prompt caching support for cost efficiency
+- **Conversation** — stateful multi-turn conversation management
+- **OpenAI-compatible** — proxy translates OpenAI format to/from Claude
+- **Client disconnect handling** — clean abort propagation from client to API
+
+---
+
+## Troubleshooting
+
+### "No credentials found"
+```
+Error: No credentials found. Run `claude` first or provide credentials.
+```
+**Fix:** Run `claude` in your terminal, complete the OAuth login, then try again. The file `~/.claude/.credentials.json` must exist.
+
+### "Rate limited" / 429 errors
+```
+[proxy] error: Rate limited: ...
+```
+**Fix:** You've hit your subscription's usage limit. Wait for the reset window (usually resets daily). The proxy never retries 429 errors — this is by design, as subscription rate limits are window-based.
+
+### "Stream idle timeout"
+If opencode shows a timeout while waiting for a response (especially with Opus):
+- The proxy has a 255-second idle timeout and 600-second request timeout
+- Opus can take 30+ seconds for complex reasoning
+- If timeouts persist, check your network connection to `api.anthropic.com`
+
+### Proxy won't start
+```bash
+# Check if port 4040 is already in use
+lsof -i :4040
+
+# Use a different port
+bunx @lifeaitools/opencode-proxy --port 4041
+```
+
+### "Token expired" / 401 errors
+The SDK auto-refreshes tokens. If you see persistent 401 errors:
+```bash
+# Re-authenticate
+claude  # log in again
+# Restart the proxy
+```
+
+---
+
+## How It Works
+
+```
+┌─────────────┐    OpenAI format     ┌──────────────────┐    Claude API     ┌──────────────┐
+│   opencode   │ ──── SSE stream ──→ │  opencode-proxy   │ ──── SSE ──────→ │  Anthropic    │
+│   (client)   │ ←── SSE stream ──── │  (Bun.serve)      │ ←── SSE ──────── │  API          │
+└─────────────┘                      └──────────────────┘                   └──────────────┘
+                                            │
+                                     claude-code-sdk
+                                     • OAuth auth + refresh
+                                     • Request building
+                                     • SSE parsing
+                                     • Retry logic
+```
+
+The proxy translates between OpenAI's chat completion format and Claude's native API format. Streaming is end-to-end — chunks flow from Anthropic through the proxy to your client with minimal buffering.
+
+---
+
+## Project Structure
+
+```
+opencode-claude-toolkit/
+├── packages/
+│   └── opencode-proxy/         # OpenAI-compatible proxy (open source)
+│       ├── server.ts           # HTTP server (Bun.serve)
+│       ├── translate.ts        # OpenAI ↔ Claude format translation
+│       └── launch.ts           # Auto-launcher
+├── dist/                       # Compiled SDK (published to npm)
+├── examples/                   # Usage examples
+│   ├── basic-chat.ts
+│   └── conversation.ts
+├── OPEN-LETTER.md              # Our message to Anthropic
+├── REQUEST-SOURCE.md           # How to request SDK source access
+├── LICENSE                     # MIT
+└── README.md
+```
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE)
+
+## Source Access
+
+The SDK is distributed as a compiled bundle. If you need source access for auditing, contributions, or enterprise use, see [REQUEST-SOURCE.md](REQUEST-SOURCE.md).
+
+## Open Letter
+
+We built this with respect and appreciation for Anthropic's work. Read our [Open Letter to Anthropic](OPEN-LETTER.md) about why this project exists and our invitation to collaborate.
+
+---
+
+Built by [LifeAITools](https://lifeaitools.com) | [GitHub](https://github.com/LifeAITools)

package/dist/conversation.d.ts

@@ -0,0 +1,81 @@
+import type { ClaudeCodeSDK } from './sdk.js';
+import type { MessageParam, ContentBlockParam, ConversationOptions, TurnOptions, GenerateResponse, StreamEvent, TokenUsage } from './types.js';
+/**
+ * Multi-turn conversation wrapper around ClaudeCodeSDK.
+ *
+ * Accumulates messages across turns, handles prompt caching,
+ * supports tool execution loop, rewind, and branching.
+ *
+ * Pattern mirrors CLI's query loop (query.ts:204-321):
+ * messages accumulate in mutable state across iterations.
+ */
+export declare class Conversation {
+    private sdk;
+    private options;
+    private _messages;
+    private _totalUsage;
+    constructor(sdk: ClaudeCodeSDK, options: ConversationOptions);
+    /** Read-only access to conversation history */
+    get messages(): readonly MessageParam[];
+    /** Cumulative token usage across all turns */
+    get totalUsage(): TokenUsage;
+    /** Number of messages in conversation */
+    get length(): number;
+    /** Send a user message and get complete response */
+    send(content: string | ContentBlockParam[], turnOptions?: TurnOptions): Promise<GenerateResponse>;
+    /** Send a user message and stream the response */
+    stream(content: string | ContentBlockParam[], turnOptions?: TurnOptions): AsyncGenerator<StreamEvent>;
+    /**
+     * Add a tool result to the conversation.
+     * Call this after executing a tool_use returned by the model.
+     * Then call send() or stream() with the next user message (or empty)
+     * to continue the conversation.
+     */
+    addToolResult(toolUseId: string, content: string | ContentBlockParam[], isError?: boolean): void;
+    /**
+     * Add multiple tool results at once (for parallel tool execution).
+     */
+    addToolResults(results: Array<{
+        toolUseId: string;
+        content: string | ContentBlockParam[];
+        isError?: boolean;
+    }>): void;
+    /**
+     * Continue conversation after adding tool results.
+     * Sends accumulated tool results to the model.
+     */
+    continue(turnOptions?: TurnOptions): Promise<GenerateResponse>;
+    /**
+     * Continue conversation with streaming after adding tool results.
+     */
+    continueStream(turnOptions?: TurnOptions): AsyncGenerator<StreamEvent>;
+    /**
+     * Rewind conversation to a specific message index.
+     * Removes all messages at and after the index.
+     * Returns removed messages.
+     */
+    rewind(toIndex: number): MessageParam[];
+    /**
+     * Rewind to the last user message (undo last turn).
+     * Removes the last assistant + any tool results after it.
+     */
+    undoLastTurn(): MessageParam[];
+    /**
+     * Branch conversation — create new Conversation with messages up to current point.
+     * Like CLI's /branch command.
+     */
+    branch(): Conversation;
+    /**
+     * Get message history with indices for rewind UI.
+     */
+    getHistory(): Array<{
+        index: number;
+        role: string;
+        preview: string;
+    }>;
+    private appendUserMessage;
+    private appendAssistantFromResponse;
+    private buildGenerateOptions;
+    private accumulateUsage;
+}
+//# sourceMappingURL=conversation.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { ClaudeCodeSDK, FileCredentialStore, MemoryCredentialStore } from './sdk.js';
+export { Conversation } from './conversation.js';
+export { saveSession, loadSession } from './session.js';
+export type { ClaudeCodeSDKOptions, GenerateOptions, GenerateResponse, StreamEvent, TokenUsage, RateLimitInfo, CredentialsFile, MessageParam, ContentBlockParam, TextBlockParam, ToolDef, ToolChoice, SystemParam, ContentBlock, TextBlock, ThinkingBlock, ToolUseBlock, ConversationOptions, TurnOptions, CredentialStore, StoredCredentials, } from './types.js';
+export { ClaudeCodeSDKError, AuthError, APIError, RateLimitError, } from './types.js';
+export type { SessionEntry } from './session.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,6 @@
+/**
+ * claude-code-sdk — TypeScript SDK for Claude Code API
+ * (c) 2026 Kiberos. Compiled distribution.
+ * Source access: see REQUEST-SOURCE.md in the GitHub repo.
+ */
+var t=Object.defineProperty,e=(e,s)=>t(e,"name",{value:s,configurable:!0});import{createHash as s,randomBytes as i,randomUUID as r}from"crypto";import{readFileSync as n,writeFileSync as o,chmodSync as a,mkdirSync as l,statSync as h}from"fs";import{join as u}from"path";import{homedir as c}from"os";var d=class extends Error{constructor(t,e){super(t),this.cause=e,this.name="ClaudeCodeSDKError"}static{e(this,"ClaudeCodeSDKError")}},p=class extends d{static{e(this,"AuthError")}constructor(t,e){super(t,e),this.name="AuthError"}},f=class extends d{constructor(t,e,s,i){super(t,i),this.status=e,this.requestId=s,this.name="APIError"}static{e(this,"APIError")}},y=class extends d{constructor(t,e,s=429,i){super(t,i),this.rateLimitInfo=e,this.status=s,this.name="RateLimitError"}static{e(this,"RateLimitError")}},m=3e5,_=class{static{e(this,"ClaudeCodeSDK")}accessToken=null;refreshToken=null;expiresAt=null;credentialStore;sessionId;deviceId;accountUuid;version;timeout;maxRetries;lastRateLimitInfo={status:null,resetAt:null,claim:null,retryAfter:null};pending401=null;lastFailedToken=null;constructor(t={}){this.sessionId=r(),this.deviceId=t.deviceId??i(32).toString("hex"),this.accountUuid=t.accountUuid??this.readAccountUuid(),this.version=t.version??"0.1.0",this.timeout=t.timeout??6e5,this.maxRetries=t.maxRetries??3,t.credentialStore?this.credentialStore=t.credentialStore:t.accessToken?(this.accessToken=t.accessToken,this.refreshToken=t.refreshToken??null,this.expiresAt=t.expiresAt??null,this.credentialStore=new w({accessToken:t.accessToken,refreshToken:t.refreshToken??"",expiresAt:t.expiresAt??0})):this.credentialStore=new k(t.credentialsPath??u(c(),".claude",".credentials.json"))}async generate(t){let e=[];for await(let s of this.stream(t))e.push(s);return this.assembleResponse(e,t.model)}async*stream(t){await this.ensureAuth();let e,s=this.buildRequestBody(t),i=this.buildHeaders(t);for(let r=1;r<=this.maxRetries+1;r++){if(t.signal?.aborted)throw new d("Aborted");try{return void(yield*this.doStreamRequest(s,i,t.signal))}catch(s){if(e=s,s instanceof f){if(401===s.status&&r<=this.maxRetries){await this.handleAuth401(),i.Authorization=`Bearer ${this.accessToken}`;continue}if(429===s.status)throw s instanceof y?s:new y("Rate limited",this.lastRateLimitInfo,429,s);if(s.status>=500&&r<=this.maxRetries){let e=this.getRetryDelay(r,this.lastRateLimitInfo.retryAfter?.toString()??null);await this.sleep(e,t.signal);continue}}throw s}}throw e}getRateLimitInfo(){return this.lastRateLimitInfo}async*doStreamRequest(t,e,s){let i,r=new AbortController,n=setTimeout(()=>r.abort(),this.timeout);s&&s.addEventListener("abort",()=>r.abort(),{once:!0});try{i=await fetch("https://api.anthropic.com/v1/messages",{method:"POST",headers:e,body:JSON.stringify(t),signal:r.signal})}catch(t){throw clearTimeout(n),new d("Network error",t)}if(clearTimeout(n),this.lastRateLimitInfo=this.parseRateLimitHeaders(i.headers),!i.ok){let t="";try{t=await i.text()}catch{}let e=i.headers.get("request-id");throw 429===i.status?new y(`Rate limited: ${t}`,this.lastRateLimitInfo,429):new f(`API error ${i.status}: ${t}`,i.status,e)}if(!i.body)throw new d("No response body");yield*this.parseSSE(i.body,s)}async*parseSSE(t,e){let s=new TextDecoder,i=t.getReader(),r="",n=new Map,o={inputTokens:0,outputTokens:0},a=null;try{for(;;){if(e?.aborted)return void i.cancel();let{done:t,value:l}=await i.read();if(t)break;r+=s.decode(l,{stream:!0});let h=r.split("\n");r=h.pop()??"";for(let t of h){if(!t.startsWith("data: "))continue;let e,s=t.slice(6);if("[DONE]"===s)continue;try{e=JSON.parse(s)}catch{continue}let i=e.type;if("message_start"===i){let t=e.message?.usage;t&&(o={inputTokens:t.input_tokens??0,outputTokens:t.output_tokens??0,cacheCreationInputTokens:t.cache_creation_input_tokens,cacheReadInputTokens:t.cache_read_input_tokens});continue}if("content_block_start"===i){let t=e.index,s=e.content_block;"tool_use"===s.type?(n.set(t,{type:"tool_use",id:s.id,name:s.name,input:""}),yield{type:"tool_use_start",id:s.id,name:s.name}):"text"===s.type?n.set(t,{type:"text",text:""}):"thinking"===s.type&&n.set(t,{type:"thinking",thinking:""});continue}if("content_block_delta"===i){let t=e.index,s=n.get(t),i=e.delta;"text_delta"===i.type&&void 0!==i.text?(s&&(s.text=(s.text??"")+i.text),i.text&&(yield{type:"text_delta",text:i.text})):"thinking_delta"===i.type&&void 0!==i.thinking?(s&&(s.thinking=(s.thinking??"")+i.thinking),i.thinking&&(yield{type:"thinking_delta",text:i.thinking})):"input_json_delta"===i.type&&void 0!==i.partial_json&&(s&&(s.input=(s.input??"")+i.partial_json),i.partial_json&&(yield{type:"tool_use_delta",partialInput:i.partial_json}));continue}if("content_block_stop"===i){let t=e.index,s=n.get(t);if("tool_use"===s?.type&&s.id&&s.name){let t={};try{t=JSON.parse(s.input??"{}")}catch{}yield{type:"tool_use_end",id:s.id,name:s.name,input:t}}continue}if("message_delta"===i){let t=e.delta;t?.stop_reason&&(a=t.stop_reason);let s=e.usage;s?.output_tokens&&(o={...o,outputTokens:s.output_tokens});continue}"message_stop"===i&&(yield{type:"message_stop",usage:o,stopReason:a})}}}finally{i.releaseLock()}}buildHeaders(t){let e=this.buildBetas(t);return{"Content-Type":"application/json",Authorization:`Bearer ${this.accessToken}`,"anthropic-version":"2023-06-01","anthropic-beta":e.join(","),"x-app":"cli","User-Agent":`claude-code/${this.version} (external, sdk)`,"X-Claude-Code-Session-Id":this.sessionId}}buildRequestBody(t){let e,s=this.computeFingerprint(t.messages),i=`x-anthropic-billing-header: cc_version=${this.version}.${s}; cc_entrypoint=cli;`;e="string"==typeof t.system?i+"\n"+t.system:Array.isArray(t.system)?[{type:"text",text:i},...t.system]:i;let r={model:t.model,messages:t.messages,max_tokens:t.maxTokens??16384,stream:!0,system:e,metadata:{user_id:JSON.stringify({device_id:this.deviceId,account_uuid:this.accountUuid,session_id:this.sessionId})}};t.tools&&t.tools.length>0&&(r.tools=t.tools,t.toolChoice&&(r.tool_choice="string"==typeof t.toolChoice?{type:t.toolChoice}:t.toolChoice)),!1!==t.caching&&this.addCacheMarkers(r);let n=t.model.toLowerCase(),o=n.includes("opus-4-6")||n.includes("sonnet-4-6"),a="disabled"===t.thinking?.type;return!a&&o?r.thinking={type:"adaptive"}:"enabled"===t.thinking?.type&&(r.thinking={type:"enabled",budget_tokens:t.thinking.budgetTokens}),!(!a&&(o||"enabled"===t.thinking?.type))&&void 0!==t.temperature&&(r.temperature=t.temperature),void 0!==t.topP&&(r.top_p=t.topP),t.effort&&o&&(r.output_config={effort:t.effort}),t.stopSequences?.length&&(r.stop_sequences=t.stopSequences),t.fast&&(r.speed="fast"),r}addCacheMarkers(t){let e=t.system;if("string"==typeof e)t.system=[{type:"text",text:e,cache_control:{type:"ephemeral"}}];else if(Array.isArray(e)){let t=e;t.length>0&&(t[t.length-1]={...t[t.length-1],cache_control:{type:"ephemeral"}})}let s=t.messages;if(0===s.length)return;let i=s[s.length-1];if("string"==typeof i.content)i.content=[{type:"text",text:i.content,cache_control:{type:"ephemeral"}}];else if(Array.isArray(i.content)&&i.content.length>0){let t=i.content[i.content.length-1];i.content[i.content.length-1]={...t,cache_control:{type:"ephemeral"}}}}buildBetas(t){let e=[],s=t.model.toLowerCase().includes("haiku");return s||e.push("claude-code-20250219"),e.push("oauth-2025-04-20"),/\[1m\]/i.test(t.model)&&e.push("context-1m-2025-08-07"),!s&&"disabled"!==t.thinking?.type&&e.push("interleaved-thinking-2025-05-14"),t.effort&&e.push("effort-2025-11-24"),t.fast&&e.push("fast-mode-2026-02-01"),e.push("prompt-caching-scope-2026-01-05"),t.extraBetas&&e.push(...t.extraBetas),e}async ensureAuth(){this.accessToken&&!this.isTokenExpired()||this.credentialStore.hasChanged&&await this.credentialStore.hasChanged()&&(await this.loadFromStore(),this.accessToken&&!this.isTokenExpired())||!this.accessToken&&(await this.loadFromStore(),this.accessToken&&!this.isTokenExpired())||this.accessToken&&this.isTokenExpired()&&await this.refreshTokenWithTripleCheck()}async loadFromStore(){let t=await this.credentialStore.read();if(!t?.accessToken)throw new p('No OAuth tokens found. Run "claude login" first or provide credentials.');this.accessToken=t.accessToken,this.refreshToken=t.refreshToken,this.expiresAt=t.expiresAt}isTokenExpired(){return!!this.expiresAt&&Date.now()+m>=this.expiresAt}async refreshTokenWithTripleCheck(){let t=await this.credentialStore.read();if(t&&!(Date.now()+m>=t.expiresAt))return this.accessToken=t.accessToken,this.refreshToken=t.refreshToken,void(this.expiresAt=t.expiresAt);await this.doTokenRefresh()}async handleAuth401(){let t=this.accessToken;this.pending401&&this.lastFailedToken===t||(this.lastFailedToken=t,this.pending401=(async()=>{let e=await this.credentialStore.read();return e&&e.accessToken!==t?(this.accessToken=e.accessToken,this.refreshToken=e.refreshToken,this.expiresAt=e.expiresAt,!0):(await this.doTokenRefresh(),!0)})().finally(()=>{this.pending401=null,this.lastFailedToken=null})),await this.pending401}async doTokenRefresh(){if(!this.refreshToken)throw new p("Token expired and no refresh token available.");let t=await fetch("https://platform.claude.com/v1/oauth/token",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({grant_type:"refresh_token",refresh_token:this.refreshToken,client_id:"9d1c250a-e61b-44d9-88ed-5944d1962f5e"}),signal:AbortSignal.timeout(15e3)});if(!t.ok){let e=await this.credentialStore.read();if(e&&!(Date.now()+m>=e.expiresAt))return this.accessToken=e.accessToken,this.refreshToken=e.refreshToken,void(this.expiresAt=e.expiresAt);throw new p(`Token refresh failed: ${t.status} ${t.statusText}`)}let e=await t.json();this.accessToken=e.access_token,this.refreshToken=e.refresh_token??this.refreshToken,this.expiresAt=Date.now()+1e3*e.expires_in,await this.credentialStore.write({accessToken:this.accessToken,refreshToken:this.refreshToken,expiresAt:this.expiresAt})}computeFingerprint(t){let e=t.find(t=>"user"===t.role);if(!e)return this.hashFingerprint("000");let s="";"string"==typeof e.content?s=e.content:Array.isArray(e.content)&&(s=e.content.find(t=>"text"===t.type)?.text??"");let i=[4,7,20].map(t=>s[t]||"0").join("");return this.hashFingerprint(i)}hashFingerprint(t){let e=`59cf53e54c78${t}${this.version}`;return s("sha256").update(e).digest("hex").slice(0,3)}assembleResponse(t,e){let s=[],i=[],r=[],n={inputTokens:0,outputTokens:0},o=null,a="",l="";for(let e of t)switch(e.type){case"text_delta":a+=e.text;break;case"thinking_delta":l+=e.text;break;case"tool_use_end":r.push({type:"tool_use",id:e.id,name:e.name,input:e.input});break;case"message_stop":n=e.usage,o=e.stopReason;break;case"error":throw e.error}return a&&s.push({type:"text",text:a}),l&&i.push({type:"thinking",thinking:l}),s.push(...r),{content:s,thinking:i.length>0?i:void 0,toolCalls:r.length>0?r:void 0,usage:n,stopReason:o,rateLimitInfo:this.lastRateLimitInfo,model:e}}parseRateLimitHeaders(t){let e=t.get("retry-after"),s=t.get("anthropic-ratelimit-unified-reset"),i=s?Number(s):null;return{status:t.get("anthropic-ratelimit-unified-status"),resetAt:Number.isFinite(i)?i:null,claim:t.get("anthropic-ratelimit-unified-representative-claim"),retryAfter:e?parseFloat(e):null}}getRetryDelay(t,e){if(e){let t=parseInt(e,10);if(!isNaN(t))return 1e3*t}let s=Math.min(500*Math.pow(2,t-1),32e3);return s+.25*Math.random()*s}sleep(t,e){return new Promise((s,i)=>{if(e?.aborted)return void i(new d("Aborted"));let r=setTimeout(s,t);e?.addEventListener("abort",()=>{clearTimeout(r),i(new d("Aborted"))},{once:!0})})}readAccountUuid(){try{let t=u(c(),".claude","claude_code_config.json");return JSON.parse(n(t,"utf8")).oauthAccount?.accountUuid??""}catch{return""}}},k=class{constructor(t){this.path=t}static{e(this,"FileCredentialStore")}lastMtimeMs=0;async read(){try{let t=n(this.path,"utf8");return this.lastMtimeMs=this.getMtime(),JSON.parse(t).claudeAiOauth??null}catch{return null}}async write(t){let e={};try{e=JSON.parse(n(this.path,"utf8"))}catch{}e.claudeAiOauth=t;let s=u(this.path,"..");try{l(s,{recursive:!0})}catch{}o(this.path,JSON.stringify(e,null,2),"utf8"),a(this.path,384),this.lastMtimeMs=this.getMtime()}async hasChanged(){let t=this.getMtime();return t!==this.lastMtimeMs&&(this.lastMtimeMs=t,!0)}getMtime(){try{return h(this.path).mtimeMs}catch{return 0}}},w=class{static{e(this,"MemoryCredentialStore")}credentials;constructor(t){this.credentials={...t}}async read(){return this.credentials.accessToken?{...this.credentials}:null}async write(t){this.credentials={...t}}},g=class _Conversation{static{e(this,"Conversation")}sdk;options;t=[];i={inputTokens:0,outputTokens:0};constructor(t,e){this.sdk=t,this.options=e}get messages(){return this.t}get totalUsage(){return{...this.i}}get length(){return this.t.length}async send(t,e){this.appendUserMessage(t);let s=this.buildGenerateOptions(e),i=await this.sdk.generate(s);return this.appendAssistantFromResponse(i),this.accumulateUsage(i.usage),i}async*stream(t,e){this.appendUserMessage(t);let s=this.buildGenerateOptions(e),i=[],r=[],n=[],o={inputTokens:0,outputTokens:0};for await(let t of this.sdk.stream(s))switch(yield t,t.type){case"text_delta":i.push(t.text);break;case"thinking_delta":r.push(t.text);break;case"tool_use_end":n.push({type:"tool_use",id:t.id,name:t.name,input:t.input});break;case"message_stop":o=t.usage}let a=[];i.length>0&&a.push({type:"text",text:i.join("")});for(let t of n)a.push({type:"tool_use",id:t.id,name:t.name,input:t.input});a.length>0&&this.t.push({role:"assistant",content:a}),this.accumulateUsage(o)}addToolResult(t,e,s){let i={type:"tool_result",tool_use_id:t,content:e,...s&&{is_error:!0}};this.t.push({role:"user",content:[i]})}addToolResults(t){let e=t.map(t=>({type:"tool_result",tool_use_id:t.toolUseId,content:t.content,...t.isError&&{is_error:!0}}));this.t.push({role:"user",content:e})}async continue(t){let e=this.buildGenerateOptions(t),s=await this.sdk.generate(e);return this.appendAssistantFromResponse(s),this.accumulateUsage(s.usage),s}async*continueStream(t){let e=this.buildGenerateOptions(t),s=[],i=[],r={inputTokens:0,outputTokens:0};for await(let t of this.sdk.stream(e))switch(yield t,t.type){case"text_delta":s.push(t.text);break;case"tool_use_end":i.push({type:"tool_use",id:t.id,name:t.name,input:t.input});break;case"message_stop":r=t.usage}let n=[];s.length>0&&n.push({type:"text",text:s.join("")});for(let t of i)n.push({type:"tool_use",id:t.id,name:t.name,input:t.input});n.length>0&&this.t.push({role:"assistant",content:n}),this.accumulateUsage(r)}rewind(t){if(t<0||t>=this.t.length)throw new Error(`Invalid rewind index: ${t}`);return this.t.splice(t)}undoLastTurn(){for(let t=this.t.length-1;t>=0;t--){let e=this.t[t];if("user"===e.role){let s=e.content;if(!(Array.isArray(s)&&s.length>0&&"tool_result"===s[0].type))return this.rewind(t)}}return[]}branch(){let t=new _Conversation(this.sdk,{...this.options});return t.t=[...this.t],t.i={...this.i},t}getHistory(){return this.t.map((t,e)=>{let s="";if("string"==typeof t.content)s=t.content.slice(0,100);else if(Array.isArray(t.content)){let e=t.content[0];"text"===e?.type?s=e.text?.slice(0,100)??"":"tool_result"===e?.type?s=`[tool_result: ${e.tool_use_id}]`:"tool_use"===e?.type&&(s=`[tool_use: ${e.name}]`)}return{index:e,role:t.role,preview:s}})}appendUserMessage(t){this.t.push({role:"user",content:t})}appendAssistantFromResponse(t){let e=[];for(let s of t.content)"text"===s.type?e.push({type:"text",text:s.text}):"tool_use"===s.type&&e.push({type:"tool_use",id:s.id,name:s.name,input:s.input});e.length>0&&this.t.push({role:"assistant",content:e})}buildGenerateOptions(t){return{model:this.options.model,messages:[...this.t],system:this.options.system,tools:t?.tools??this.options.tools,toolChoice:t?.toolChoice??this.options.toolChoice,maxTokens:this.options.maxTokens,thinking:this.options.thinking,effort:this.options.effort,fast:this.options.fast,signal:t?.signal??this.options.signal,extraBetas:this.options.extraBetas,caching:this.options.caching}}accumulateUsage(t){this.i.inputTokens+=t.inputTokens,this.i.outputTokens+=t.outputTokens,this.i.cacheCreationInputTokens=(this.i.cacheCreationInputTokens??0)+(t.cacheCreationInputTokens??0),this.i.cacheReadInputTokens=(this.i.cacheReadInputTokens??0)+(t.cacheReadInputTokens??0)}};import{readFileSync as x,writeFileSync as b,mkdirSync as T}from"fs";import{dirname as v}from"path";import{randomUUID as S}from"crypto";function A(t,e){T(v(t),{recursive:!0});let s=null,i=[];for(let t of e){let e=S(),r={type:"user"===t.role?"user":"assistant",uuid:e,parentUuid:s,timestamp:Date.now(),content:t.content};i.push(JSON.stringify(r)),s=e}b(t,i.join("\n")+"\n","utf8")}function C(t){let e=x(t,"utf8"),s=[];for(let t of e.split("\n")){if(!t.trim())continue;let e;try{e=JSON.parse(t)}catch{continue}("user"===e.type||"assistant"===e.type)&&s.push({role:"user"===e.type?"user":"assistant",content:e.content})}return s}e(A,"saveSession"),e(C,"loadSession");export{f as APIError,p as AuthError,_ as ClaudeCodeSDK,d as ClaudeCodeSDKError,g as Conversation,k as FileCredentialStore,w as MemoryCredentialStore,y as RateLimitError,C as loadSession,A as saveSession};

package/dist/sdk.d.ts

@@ -0,0 +1,93 @@
+import type { ClaudeCodeSDKOptions, CredentialStore, StoredCredentials, GenerateOptions, GenerateResponse, StreamEvent, RateLimitInfo } from './types.js';
+export declare class ClaudeCodeSDK {
+    private accessToken;
+    private refreshToken;
+    private expiresAt;
+    private credentialStore;
+    private sessionId;
+    private deviceId;
+    private accountUuid;
+    private version;
+    private timeout;
+    private maxRetries;
+    private lastRateLimitInfo;
+    private pending401;
+    private lastFailedToken;
+    constructor(options?: ClaudeCodeSDKOptions);
+    /** Non-streaming: send messages, get full response */
+    generate(options: GenerateOptions): Promise<GenerateResponse>;
+    /** Streaming: yields events as they arrive from SSE */
+    stream(options: GenerateOptions): AsyncGenerator<StreamEvent>;
+    getRateLimitInfo(): RateLimitInfo;
+    private doStreamRequest;
+    private parseSSE;
+    /** HTTP headers — mimics getAnthropicClient() + getAuthHeaders() */
+    private buildHeaders;
+    /** Request body — mirrors paramsFromContext() in claude.ts:1699 */
+    private buildRequestBody;
+    /** Add cache_control markers to system + last message — mirrors addCacheBreakpoints() */
+    private addCacheMarkers;
+    /** Beta headers — mirrors getAllModelBetas() in betas.ts:234 */
+    private buildBetas;
+    /**
+     * Ensure valid auth token before API call.
+     * Mirrors checkAndRefreshOAuthTokenIfNeeded() from auth.ts:1427.
+     *
+     * Triple-check pattern:
+     * 1. Check cached token in memory
+     * 2. If expired, check store (another process may have refreshed)
+     * 3. If still expired, do the refresh
+     */
+    private ensureAuth;
+    /** Load credentials from the credential store */
+    private loadFromStore;
+    /** 5-minute buffer before actual expiry — from oauth/client.ts:344-353 */
+    private isTokenExpired;
+    /**
+     * Triple-check refresh — mirrors auth.ts:1472-1556.
+     * Check store again (race), then refresh, then check store on error.
+     */
+    private refreshTokenWithTripleCheck;
+    /**
+     * Handle 401 error — mirrors handleOAuth401Error() from auth.ts:1338-1392.
+     * Deduplicates concurrent 401 handlers for the same failed token.
+     */
+    handleAuth401(): Promise<void>;
+    /** POST to platform.claude.com/v1/oauth/token — from oauth/client.ts:146 */
+    private doTokenRefresh;
+    computeFingerprint(messages: {
+        role: string;
+        content: string | unknown[];
+    }[]): string;
+    private hashFingerprint;
+    private assembleResponse;
+    private parseRateLimitHeaders;
+    private getRetryDelay;
+    private sleep;
+    private readAccountUuid;
+}
+/**
+ * File-based credential store with mtime detection.
+ * Mirrors CLI's plainTextStorage.ts + invalidateOAuthCacheIfDiskChanged().
+ */
+export declare class FileCredentialStore implements CredentialStore {
+    private path;
+    private lastMtimeMs;
+    constructor(path: string);
+    read(): Promise<StoredCredentials | null>;
+    write(credentials: StoredCredentials): Promise<void>;
+    /** Detect cross-process changes via mtime — from auth.ts:1313-1336 */
+    hasChanged(): Promise<boolean>;
+    private getMtime;
+}
+/**
+ * In-memory credential store for direct token injection.
+ * No persistence — tokens live only in SDK instance.
+ */
+export declare class MemoryCredentialStore implements CredentialStore {
+    private credentials;
+    constructor(initial: StoredCredentials);
+    read(): Promise<StoredCredentials | null>;
+    write(credentials: StoredCredentials): Promise<void>;
+}
+//# sourceMappingURL=sdk.d.ts.map

package/dist/session.d.ts

@@ -0,0 +1,13 @@
+import type { MessageParam } from './types.js';
+export interface SessionEntry {
+    type: 'user' | 'assistant';
+    uuid: string;
+    parentUuid: string | null;
+    timestamp: number;
+    content: MessageParam['content'];
+}
+/** Save conversation messages to JSONL file (CLI-compatible format) */
+export declare function saveSession(path: string, messages: readonly MessageParam[]): void;
+/** Load conversation messages from JSONL file */
+export declare function loadSession(path: string): MessageParam[];
+//# sourceMappingURL=session.d.ts.map

package/dist/types.d.ts

@@ -0,0 +1,244 @@
+/**
+ * Pluggable credential storage interface.
+ * Implement this to store tokens in a database, Redis, KV store, etc.
+ * Mirrors CLI's SecureStorage pattern (plainTextStorage.ts).
+ */
+export interface CredentialStore {
+    /** Read current credentials. Return null if not found. */
+    read(): Promise<StoredCredentials | null>;
+    /** Write updated credentials after refresh. */
+    write(credentials: StoredCredentials): Promise<void>;
+    /**
+     * Check if credentials changed externally (another process refreshed).
+     * Return true if stale → SDK will re-read.
+     * Optional: if not implemented, SDK always re-reads before refresh.
+     */
+    hasChanged?(): Promise<boolean>;
+}
+/** Credentials as stored/retrieved by CredentialStore */
+export interface StoredCredentials {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    scopes?: string[];
+    subscriptionType?: string | null;
+    rateLimitTier?: string | null;
+}
+/** SDK init options. Tokens can come from file OR be passed directly. */
+export interface ClaudeCodeSDKOptions {
+    /** Direct access token. If provided, skips file reading. */
+    accessToken?: string;
+    /** Direct refresh token for auto-refresh. */
+    refreshToken?: string;
+    /** Expiry timestamp (ms). Required with accessToken if you want auto-refresh. */
+    expiresAt?: number;
+    /** Path to .credentials.json. Defaults to ~/.claude/.credentials.json */
+    credentialsPath?: string;
+    /**
+     * Custom credential store (DB, Redis, etc.).
+     * If provided, overrides credentialsPath and direct token options.
+     */
+    credentialStore?: CredentialStore;
+    /** device_id for metadata. If omitted, generates random 64-byte hex. */
+    deviceId?: string;
+    /** account_uuid for metadata. If omitted, reads from ~/.claude/config.json. */
+    accountUuid?: string;
+    /** SDK version string used in fingerprint + User-Agent. */
+    version?: string;
+    /** Request timeout in ms. Default: 600_000 */
+    timeout?: number;
+    /** Max retries for 5xx/529. Default: 3. Note: 429 is NEVER retried for subscribers. */
+    maxRetries?: number;
+}
+/** What we read from ~/.claude/.credentials.json */
+export interface CredentialsFile {
+    claudeAiOauth?: {
+        accessToken: string;
+        refreshToken: string;
+        expiresAt: number;
+        scopes?: string[];
+        subscriptionType?: string | null;
+        rateLimitTier?: string | null;
+    };
+}
+/** Message param — mirrors Anthropic API */
+export interface MessageParam {
+    role: 'user' | 'assistant';
+    content: string | ContentBlockParam[];
+}
+export type ContentBlockParam = TextBlockParam | {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string | ContentBlockParam[];
+    is_error?: boolean;
+};
+export interface TextBlockParam {
+    type: 'text';
+    text: string;
+    cache_control?: {
+        type: 'ephemeral';
+        ttl?: '1h';
+        scope?: 'global';
+    };
+}
+/** Tool definition */
+export interface ToolDef {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}
+/** System prompt blocks */
+export type SystemParam = string | {
+    type: 'text';
+    text: string;
+}[];
+/** Tool choice — how the model selects tools */
+export type ToolChoice = 'auto' | 'any' | {
+    type: 'tool';
+    name: string;
+};
+/** Options for a single generate/stream call */
+export interface GenerateOptions {
+    model: string;
+    messages: MessageParam[];
+    system?: SystemParam;
+    maxTokens?: number;
+    thinking?: {
+        type: 'enabled';
+        budgetTokens: number;
+    } | {
+        type: 'disabled';
+    };
+    tools?: ToolDef[];
+    toolChoice?: ToolChoice;
+    temperature?: number;
+    topP?: number;
+    effort?: 'low' | 'medium' | 'high';
+    signal?: AbortSignal;
+    stopSequences?: string[];
+    extraBetas?: string[];
+    fast?: boolean;
+    /** Enable prompt caching. Default: true */
+    caching?: boolean;
+}
+/** Options for Conversation class */
+export interface ConversationOptions {
+    model: string;
+    system?: SystemParam;
+    tools?: ToolDef[];
+    toolChoice?: ToolChoice;
+    maxTokens?: number;
+    thinking?: {
+        type: 'enabled';
+        budgetTokens: number;
+    } | {
+        type: 'disabled';
+    };
+    effort?: 'low' | 'medium' | 'high';
+    fast?: boolean;
+    signal?: AbortSignal;
+    extraBetas?: string[];
+    /** Enable prompt caching. Default: true */
+    caching?: boolean;
+}
+/** Turn options — per-send overrides */
+export interface TurnOptions {
+    signal?: AbortSignal;
+    /** Override tools for this turn */
+    tools?: ToolDef[];
+    toolChoice?: ToolChoice;
+}
+/** Normalized stream events */
+export type StreamEvent = {
+    type: 'text_delta';
+    text: string;
+} | {
+    type: 'thinking_delta';
+    text: string;
+} | {
+    type: 'tool_use_start';
+    id: string;
+    name: string;
+} | {
+    type: 'tool_use_delta';
+    partialInput: string;
+} | {
+    type: 'tool_use_end';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'message_stop';
+    usage: TokenUsage;
+    stopReason: string | null;
+} | {
+    type: 'error';
+    error: Error;
+};
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+}
+export interface RateLimitInfo {
+    status: string | null;
+    resetAt: number | null;
+    claim: string | null;
+    retryAfter: number | null;
+}
+export interface GenerateResponse {
+    content: ContentBlock[];
+    thinking?: ThinkingBlock[];
+    toolCalls?: ToolUseBlock[];
+    usage: TokenUsage;
+    stopReason: string | null;
+    rateLimitInfo: RateLimitInfo;
+    model: string;
+}
+/** Content blocks from API response */
+export type ContentBlock = TextBlock | ThinkingBlock | ToolUseBlock;
+export interface TextBlock {
+    type: 'text';
+    text: string;
+}
+export interface ThinkingBlock {
+    type: 'thinking';
+    thinking: string;
+}
+export interface ToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: unknown;
+}
+export declare class ClaudeCodeSDKError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare class AuthError extends ClaudeCodeSDKError {
+    constructor(message: string, cause?: unknown);
+}
+export declare class APIError extends ClaudeCodeSDKError {
+    readonly status: number;
+    readonly requestId: string | null;
+    constructor(message: string, status: number, requestId: string | null, cause?: unknown);
+}
+export declare class RateLimitError extends ClaudeCodeSDKError {
+    readonly rateLimitInfo: RateLimitInfo;
+    readonly status: number;
+    constructor(message: string, rateLimitInfo: RateLimitInfo, status?: number, cause?: unknown);
+}
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@life-ai-tools/claude-code-sdk",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for Claude Code API — use your Claude Max/Pro subscription programmatically",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run scripts/build-sdk.ts",
+    "build:dev": "tsc",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "echo 'dist/ already built'"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/bun": "latest",
+    "esbuild": "^0.27.4",
+    "terser": "^5.46.1",
+    "typescript": "^5.8.0"
+  },
+  "engines": {
+    "node": ">=20.0.0",
+    "bun": ">=1.0.0"
+  },
+  "keywords": [
+    "claude",
+    "anthropic",
+    "claude-code",
+    "claude-max",
+    "sdk",
+    "openai-compatible",
+    "streaming"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LifeAITools/opencode-claude-toolkit"
+  },
+  "homepage": "https://github.com/LifeAITools/opencode-claude-toolkit",
+  "license": "MIT",
+  "files": [
+    "dist/index.js",
+    "dist/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ]
+}