raysurfer 0.4.2 → 0.5.0

package/README.md

@@ -20,107 +20,117 @@ Get your key from the [dashboard](https://raysurfer.com/dashboard/api-keys).
 
 ## Usage
 
-Swap your client class and method names. Options come directly from `@anthropic-ai/claude-agent-sdk`:
+Swap your import — everything else stays the same:
 
 ```typescript
 // Before
-import { ClaudeSDKClient, ClaudeAgentOptions } from "@anthropic-ai/claude-agent-sdk";
+import { query } from "@anthropic-ai/claude-agent-sdk";
 
 // After
-import { RaysurferClient } from "raysurfer";
-import { ClaudeAgentOptions } from "@anthropic-ai/claude-agent-sdk";
-
-const options: ClaudeAgentOptions = {
-  allowedTools: ["Read", "Write", "Bash"],
-  systemPrompt: "You are a helpful assistant.",
-};
-
-const client = new RaysurferClient(options);
-
-for await (const msg of client.raysurferQuery("Generate quarterly report")) {
-  console.log(msg);
+import { query } from "raysurfer";
+
+for await (const message of query({
+  prompt: "Fetch data from GitHub API",
+  options: {
+    model: "claude-opus-4-5-20250514",
+    systemPrompt: "You are a helpful assistant.",
+  },
+})) {
+  console.log(message);
 }
 ```
 
-## Method Mapping
+All Claude SDK types are re-exported from `raysurfer`, so you don't need a separate import:
 
-| Claude SDK | Raysurfer |
-|------------|-----------|
-| `new ClaudeSDKClient(options)` | `new RaysurferClient(options)` |
-| `client.query(prompt)` | `client.raysurferQuery(prompt)` |
+```typescript
+import { query, type Options, type SDKMessage, type Query } from "raysurfer";
+```
 
 ## How It Works
 
-1. **On `raysurferQuery()`**: Retrieves cached code blocks matching your task
-2. **Downloads to sandbox**: Files ready for the agent to execute
-3. **Injects into prompt**: Agent sees proven code snippets
-4. **After success**: New code is cached for next time
-
-Caching is enabled automatically when `RAYSURFER_API_KEY` is set.
+1. **On query**: Retrieves cached code blocks matching your task
+2. **Injects into prompt**: Agent sees proven code snippets
+3. **After success**: New code is cached for next time
 
-## Snippet Retrieval Scope
+Caching is enabled automatically when `RAYSURFER_API_KEY` is set. Without it, behaves exactly like the original SDK.
 
-Control which cached snippets are retrieved using `publicSnips` and `snipsDesired`:
+## Class-based API
 
 ```typescript
-import { RaysurferClient } from "raysurfer";
-import { ClaudeAgentOptions } from "@anthropic-ai/claude-agent-sdk";
+import { ClaudeSDKClient } from "raysurfer";
 
-const options: ClaudeAgentOptions = {
-  allowedTools: ["Read", "Write", "Bash"],
-};
-
-// Include both public and company snippets
-const client = new RaysurferClient(options, {
-  publicSnips: true,        // Include public/shared snippets
-  snipsDesired: "company",  // Also include company-level snippets
+const client = new ClaudeSDKClient({
+  model: "claude-opus-4-5-20250514",
+  systemPrompt: "You are a helpful assistant.",
 });
 
-// Enterprise: Retrieve client-specific snippets only
-const enterpriseClient = new RaysurferClient(options, {
-  snipsDesired: "client",   // Client workspace snippets (Enterprise only)
-});
+for await (const msg of client.query("Fetch data from GitHub API")) {
+  console.log(msg);
+}
 ```
 
-| Configuration | Required Tier |
-|--------------|---------------|
-| `publicSnips: true` only | FREE (default) |
-| `snipsDesired: "company"` | TEAM or ENTERPRISE |
-| `snipsDesired: "client"` | ENTERPRISE only |
+## System Prompt Preset
 
-## Full Example
+Use the Claude Code preset system prompt with appended instructions:
 
 ```typescript
-import { RaysurferClient } from "raysurfer";
-import { ClaudeAgentOptions } from "@anthropic-ai/claude-agent-sdk";
+for await (const message of query({
+  prompt: "Refactor the auth module",
+  options: {
+    systemPrompt: {
+      type: "preset",
+      preset: "claude_code",
+      append: "Always explain your reasoning.",
+    },
+  },
+})) {
+  console.log(message);
+}
+```
 
-process.env.RAYSURFER_API_KEY = "your_api_key";
+## Query Control Methods
 
-const options: ClaudeAgentOptions = {
-  allowedTools: ["Read", "Write", "Bash"],
-  systemPrompt: "You are a helpful assistant.",
-};
+The `query()` function returns a `Query` object with full control methods:
 
-const client = new RaysurferClient(options);
+```typescript
+const q = query({ prompt: "Build a REST API" });
+
+await q.interrupt();
+await q.setPermissionMode("acceptEdits");
+await q.setModel("claude-sonnet-4-5-20250929");
+await q.setMaxThinkingTokens(4096);
+const models = await q.supportedModels();
+const info = await q.accountInfo();
+q.close();
+```
 
-// First run: generates and caches code
-for await (const msg of client.raysurferQuery("Fetch GitHub trending repos")) {
-  console.log(msg);
-}
+## Snippet Retrieval Scope
 
-// Second run: retrieves from cache (instant)
-for await (const msg of client.raysurferQuery("Fetch GitHub trending repos")) {
-  console.log(msg);
-}
-```
+Control which cached snippets are retrieved:
+
+```typescript
+import { ClaudeSDKClient } from "raysurfer";
 
-## Without Caching
+// Include company-level snippets (Team/Enterprise)
+const client = new ClaudeSDKClient({
+  snipsDesired: "company",
+});
 
-If `RAYSURFER_API_KEY` is not set, `RaysurferClient` behaves exactly like `ClaudeSDKClient` — no caching, just a pass-through wrapper.
+// Enterprise: client-specific snippets only
+const enterpriseClient = new ClaudeSDKClient({
+  snipsDesired: "client",
+});
+```
+
+| Configuration | Required Tier |
+|--------------|---------------|
+| Default (public only) | FREE |
+| `snipsDesired: "company"` | TEAM or ENTERPRISE |
+| `snipsDesired: "client"` | ENTERPRISE only |
 
 ## Low-Level API
 
-For custom integrations, use the `RaySurfer` client directly with three core methods:
+For custom integrations, use the `RaySurfer` client directly:
 
 ```typescript
 import { RaySurfer } from "raysurfer";
@@ -150,14 +160,6 @@ await client.voteCodeSnip({
 });
 ```
 
-### Method Reference
-
-| Method | Description |
-|--------|-------------|
-| `getCodeSnips({ task, topK?, minVerdictScore? })` | Retrieve cached code snippets by semantic search |
-| `uploadNewCodeSnips(task, filesWritten, succeeded)` | Store new code files for future reuse |
-| `voteCodeSnip({ task, codeBlockId, codeBlockName, codeBlockDescription, succeeded })` | Vote on snippet usefulness |
-
 ## License
 
 MIT

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 /**
  * RaySurfer SDK client
  */
-export declare const VERSION = "0.4.2";
+export declare const VERSION = "0.5.0";
 import type { AgentReview, AgentVerdict, AutoReviewParams, AutoReviewResponse, ExecutionState, FewShotExample, FileWritten, GetCodeFilesResponse, GetExecutionsParams, RetrieveBestResponse, RetrieveCodeBlockResponse, RetrieveExecutionsResponse, SnipsDesired, StoreCodeBlockResponse, StoreExecutionResponse, SubmitExecutionResultResponse, TaskPattern } from "./types";
 export interface RaySurferOptions {
     /** RaySurfer API key */

package/dist/index.d.ts

@@ -14,8 +14,10 @@
 export type { GetCodeFilesParams, GetTaskPatternsParams, RaySurferOptions, RetrieveParams, StoreCodeBlockParams, StoreExecutionParams, } from "./client";
 export { default as RaySurferDefault, RaySurfer, VERSION } from "./client";
 export { APIError, AuthenticationError, CacheUnavailableError, RateLimitError, RaySurferError, ValidationError, } from "./errors";
-export type { QueryOptions, QueryParams, RaysurferAgentOptions, } from "./sdk-client";
+export type { QueryOptions, QueryParams, RaysurferAgentOptions, RaysurferExtras, RaysurferQueryOptions, } from "./sdk-client";
 export { ClaudeSDKClient, default as queryDefault, query, RaysurferClient, } from "./sdk-client";
 export type { AgentReview, AlternativeCandidate, BestMatch, CodeBlock, CodeBlockMatch, CodeFile, ExecutionIO, ExecutionRecord, FewShotExample, FileWritten, GetCodeFilesResponse, RetrieveBestResponse, RetrieveCodeBlockResponse, RetrieveExecutionsResponse, StoreCodeBlockResponse, StoreExecutionResponse, SubmitExecutionResultRequest, SubmitExecutionResultResponse, TaskPattern, VoteCodeSnipParams, VoteCodeSnipResponse, } from "./types";
 export { AgentVerdict, ExecutionState } from "./types";
+export type { AccountInfo, AgentDefinition, AgentMcpServerSpec, AnyZodRawShape, ApiKeySource, AsyncHookJSONOutput, BaseHookInput, BaseOutputFormat, CanUseTool, ConfigScope, ExitReason, HookCallback, HookCallbackMatcher, HookEvent, HookInput, HookJSONOutput, InferShape, JsonSchemaOutputFormat, McpHttpServerConfig, McpSdkServerConfig, McpSdkServerConfigWithInstance, McpServerConfig, McpServerConfigForProcessTransport, McpServerStatus, McpSetServersResult, McpSSEServerConfig, McpStdioServerConfig, ModelInfo, ModelUsage, NonNullableUsage, NotificationHookInput, NotificationHookSpecificOutput, Options, OutputFormat, OutputFormatType, PermissionBehavior, PermissionMode, PermissionRequestHookInput, PermissionRequestHookSpecificOutput, PermissionResult, PermissionRuleValue, PermissionUpdate, PermissionUpdateDestination, PostToolUseFailureHookInput, PostToolUseFailureHookSpecificOutput, PostToolUseHookInput, PostToolUseHookSpecificOutput, PreCompactHookInput, PreToolUseHookInput, PreToolUseHookSpecificOutput, Query, RewindFilesResult, SandboxIgnoreViolations, SandboxNetworkConfig, SandboxSettings, SDKAssistantMessage, SDKAssistantMessageError, SDKAuthStatusMessage, SDKCompactBoundaryMessage, SDKHookProgressMessage, SDKHookResponseMessage, SDKHookStartedMessage, SDKMessage, SDKPartialAssistantMessage, SDKPermissionDenial, SDKResultError, SDKResultMessage, SDKResultSuccess, SDKStatus, SDKStatusMessage, SDKSystemMessage, SDKTaskNotificationMessage, SDKToolProgressMessage, SDKToolUseSummaryMessage, SDKUserMessage, SDKUserMessageReplay, SdkBeta, SdkMcpToolDefinition, SdkPluginConfig, SessionEndHookInput, SessionStartHookInput, SessionStartHookSpecificOutput, SettingSource, SetupHookInput, SetupHookSpecificOutput, SlashCommand, SpawnedProcess, SpawnOptions, StopHookInput, SubagentStartHookInput, SubagentStartHookSpecificOutput, SubagentStopHookInput, SyncHookJSONOutput, UserPromptSubmitHookInput, UserPromptSubmitHookSpecificOutput, } from "@anthropic-ai/claude-agent-sdk";
+export { AbortError, createSdkMcpServer, EXIT_REASONS, HOOK_EVENTS, tool, } from "@anthropic-ai/claude-agent-sdk";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAE3E,OAAO,EACL,QAAQ,EACR,mBAAmB,EACnB,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,eAAe,GAChB,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,YAAY,EACZ,WAAW,EACX,qBAAqB,GACtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,eAAe,EACf,OAAO,IAAI,YAAY,EACvB,KAAK,EACL,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,WAAW,EACX,oBAAoB,EACpB,SAAS,EACT,SAAS,EACT,cAAc,EACd,QAAQ,EACR,WAAW,EACX,eAAe,EACf,cAAc,EACd,WAAW,EACX,oBAAoB,EACpB,oBAAoB,EACpB,yBAAyB,EACzB,0BAA0B,EAC1B,sBAAsB,EACtB,sBAAsB,EACtB,4BAA4B,EAC5B,6BAA6B,EAC7B,WAAW,EACX,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -69,7 +69,7 @@ class ValidationError extends RaySurferError {
 }
 
 // src/client.ts
-var VERSION = "0.4.2";
+var VERSION = "0.5.0";
 var DEFAULT_BASE_URL = "https://api.raysurfer.com";
 var MAX_RETRIES = 3;
 var RETRY_BASE_DELAY = 500;
@@ -552,31 +552,152 @@ var createDebugLogger = (enabled) => ({
   group: (label) => enabled && console.group(`[raysurfer] ${label}`),
   groupEnd: () => enabled && console.groupEnd()
 });
-async function* query(params) {
-  const { prompt, options = {} } = params;
-  const debugEnabled = options.debug || process.env.RAYSURFER_DEBUG === "true";
-  const debug = createDebugLogger(debugEnabled);
-  debug.group("Raysurfer Query Started");
-  debug.log("Prompt:", prompt);
-  debug.log("Options:", {
-    ...options,
-    systemPrompt: options.systemPrompt || undefined
-  });
-  const apiKey = process.env.RAYSURFER_API_KEY;
-  const baseUrl = process.env.RAYSURFER_BASE_URL || DEFAULT_RAYSURFER_URL;
-  const cacheEnabled = !!apiKey;
-  if (!cacheEnabled) {
-    console.warn("[raysurfer] RAYSURFER_API_KEY not set - caching disabled");
-  }
-  debug.log("Cache enabled:", cacheEnabled);
-  debug.log("Base URL:", baseUrl);
-  let raysurfer = null;
-  let cachedFiles = [];
-  const modifiedFilePaths = new Set;
-  const bashGeneratedFiles = new Set;
-  const executionLogs = [];
-  let taskSucceeded = false;
-  const extractBashOutputFiles = (command) => {
+function augmentSystemPrompt(systemPrompt, addition) {
+  if (!addition)
+    return systemPrompt;
+  if (typeof systemPrompt === "string")
+    return systemPrompt + addition;
+  if (systemPrompt?.type === "preset") {
+    return { ...systemPrompt, append: (systemPrompt.append ?? "") + addition };
+  }
+  return addition;
+}
+function splitOptions(options) {
+  const { snipsDesired, namespace, debug, workingDirectory, ...sdkOptions } = options;
+  return {
+    sdkOptions,
+    extras: { snipsDesired, namespace, debug, workingDirectory }
+  };
+}
+
+class RaysurferQuery {
+  _inner = null;
+  _initPromise = null;
+  _raysurfer = null;
+  _cachedFiles = [];
+  _modifiedFilePaths = new Set;
+  _bashGeneratedFiles = new Set;
+  _executionLogs = [];
+  _taskSucceeded = false;
+  _generatedCodeBlocks = [];
+  _cacheUploadDone = false;
+  _messageCount = 0;
+  _startTime = 0;
+  _promptText;
+  _params;
+  _debug;
+  _cacheEnabled;
+  _workDir;
+  _apiKey;
+  _baseUrl;
+  _extras;
+  _sdkOptions;
+  constructor(params) {
+    this._params = params;
+    const options = params.options ?? {};
+    const { sdkOptions, extras } = splitOptions(options);
+    this._sdkOptions = sdkOptions;
+    this._extras = extras;
+    this._promptText = typeof params.prompt === "string" ? params.prompt : null;
+    const debugEnabled = extras.debug || process.env.RAYSURFER_DEBUG === "true";
+    this._debug = createDebugLogger(debugEnabled);
+    this._apiKey = process.env.RAYSURFER_API_KEY;
+    this._baseUrl = process.env.RAYSURFER_BASE_URL || DEFAULT_RAYSURFER_URL;
+    this._cacheEnabled = !!this._apiKey;
+    if (extras.workingDirectory && !sdkOptions.cwd) {
+      console.warn("[raysurfer] workingDirectory is deprecated, use cwd instead");
+      this._sdkOptions.cwd = extras.workingDirectory;
+    }
+    this._workDir = this._sdkOptions.cwd || process.cwd();
+  }
+  async _initialize() {
+    this._debug.group("Raysurfer Query Started");
+    this._debug.log("Prompt:", this._promptText ?? "<stream>");
+    this._debug.log("Cache enabled:", this._cacheEnabled);
+    this._debug.log("Base URL:", this._baseUrl);
+    if (!this._cacheEnabled) {
+      console.warn("[raysurfer] RAYSURFER_API_KEY not set - caching disabled");
+    }
+    let addToLlmPrompt = "";
+    if (this._cacheEnabled && this._promptText) {
+      this._raysurfer = new RaySurfer({
+        apiKey: this._apiKey,
+        baseUrl: this._baseUrl,
+        snipsDesired: this._extras.snipsDesired,
+        namespace: this._extras.namespace
+      });
+      try {
+        this._debug.time("Cache lookup");
+        const cacheDir = join(this._workDir, CACHE_DIR);
+        const response = await this._raysurfer.getCodeFiles({
+          task: this._promptText,
+          topK: 5,
+          minVerdictScore: 0.3,
+          preferComplete: true,
+          cacheDir
+        });
+        this._debug.timeEnd("Cache lookup");
+        this._cachedFiles = response.files;
+        addToLlmPrompt = response.addToLlmPrompt;
+        this._debug.log(`Found ${this._cachedFiles.length} cached files:`);
+        console.log("[raysurfer] Cache hit:", this._cachedFiles.length, "snippets retrieved");
+        if (this._cachedFiles.length > 0) {
+          this._debug.table(this._cachedFiles.map((f) => ({
+            filename: f.filename,
+            similarity: `${Math.round(f.similarityScore * 100)}%`,
+            verdict: `${Math.round(f.verdictScore * 100)}%`,
+            combined: `${Math.round(f.combinedScore * 100)}%`,
+            thumbs: `${f.thumbsUp}/${f.thumbsDown}`,
+            sourceLength: `${f.source.length} chars`
+          })));
+          try {
+            mkdirSync(cacheDir, { recursive: true });
+            for (const file of this._cachedFiles) {
+              const filePath = join(cacheDir, file.filename);
+              writeFileSync(filePath, file.source, "utf-8");
+              this._debug.log(`  → Wrote cached file: ${filePath}`);
+              this._modifiedFilePaths.add(filePath);
+            }
+          } catch (writeErr) {
+            this._debug.log("Failed to write cached files:", writeErr);
+          }
+        }
+      } catch (error) {
+        this._debug.log("Cache lookup failed:", error);
+        console.warn("[raysurfer] Cache unavailable:", error instanceof Error ? error.message : error);
+      }
+    }
+    const augmented = augmentSystemPrompt(this._sdkOptions.systemPrompt, addToLlmPrompt);
+    const augmentedOptions = {
+      ...this._sdkOptions,
+      systemPrompt: augmented
+    };
+    this._debug.log("Augmented prompt addition:", addToLlmPrompt.length, "chars");
+    let sdkQueryFn;
+    try {
+      const sdk = await import("@anthropic-ai/claude-agent-sdk");
+      sdkQueryFn = sdk.query;
+    } catch {
+      throw new Error("Could not import @anthropic-ai/claude-agent-sdk. Install it with: npm install @anthropic-ai/claude-agent-sdk");
+    }
+    this._debug.time("Claude API call");
+    this._debug.log("Calling Claude Agent SDK...");
+    this._startTime = Date.now();
+    this._inner = sdkQueryFn({
+      prompt: this._params.prompt,
+      options: augmentedOptions
+    });
+  }
+  async _ensureInit() {
+    if (!this._inner) {
+      if (!this._initPromise) {
+        this._initPromise = this._initialize();
+      }
+      await this._initPromise;
+    }
+    return this._inner;
+  }
+  _extractBashOutputFiles(command) {
     for (const pattern of BASH_OUTPUT_PATTERNS) {
       pattern.lastIndex = 0;
       let match = pattern.exec(command);
@@ -585,103 +706,23 @@ async function* query(params) {
         if (filePath && filePath.length > 0) {
           const ext = filePath.substring(filePath.lastIndexOf(".")).toLowerCase();
           if (TRACKABLE_EXTENSIONS.has(ext)) {
-            bashGeneratedFiles.add(filePath);
-            debug.log(`  → Bash output file detected: ${filePath}`);
+            this._bashGeneratedFiles.add(filePath);
+            this._debug.log(`  → Bash output file detected: ${filePath}`);
           }
         }
         match = pattern.exec(command);
       }
     }
-  };
-  const workDir = options.workingDirectory || process.cwd();
-  let addToLlmPrompt = "";
-  if (cacheEnabled) {
-    raysurfer = new RaySurfer({
-      apiKey,
-      baseUrl,
-      snipsDesired: options.snipsDesired,
-      namespace: options.namespace
-    });
-    try {
-      debug.time("Cache lookup");
-      const cacheDir = join(workDir, CACHE_DIR);
-      const response2 = await raysurfer.getCodeFiles({
-        task: prompt,
-        topK: 5,
-        minVerdictScore: 0.3,
-        preferComplete: true,
-        cacheDir
-      });
-      debug.timeEnd("Cache lookup");
-      cachedFiles = response2.files;
-      addToLlmPrompt = response2.addToLlmPrompt;
-      debug.log(`Found ${cachedFiles.length} cached files:`);
-      console.log("[raysurfer] Cache hit:", cachedFiles.length, "snippets retrieved");
-      if (cachedFiles.length > 0) {
-        debug.table(cachedFiles.map((f) => ({
-          filename: f.filename,
-          similarity: `${Math.round(f.similarityScore * 100)}%`,
-          verdict: `${Math.round(f.verdictScore * 100)}%`,
-          combined: `${Math.round(f.combinedScore * 100)}%`,
-          thumbs: `${f.thumbsUp}/${f.thumbsDown}`,
-          sourceLength: `${f.source.length} chars`
-        })));
-        try {
-          mkdirSync(cacheDir, { recursive: true });
-          for (const file of cachedFiles) {
-            const filePath = join(cacheDir, file.filename);
-            writeFileSync(filePath, file.source, "utf-8");
-            debug.log(`  → Wrote cached file: ${filePath}`);
-            modifiedFilePaths.add(filePath);
-          }
-        } catch (writeErr) {
-          debug.log("Failed to write cached files:", writeErr);
-        }
-      }
-    } catch (error) {
-      debug.log("Cache lookup failed:", error);
-      console.warn("[raysurfer] Cache unavailable:", error instanceof Error ? error.message : error);
-    }
-  }
-  const augmentedPrompt = (options.systemPrompt ?? "") + addToLlmPrompt;
-  debug.log("System prompt length:", options.systemPrompt?.length ?? 0, "chars");
-  debug.log("Augmented prompt length:", augmentedPrompt.length, "chars");
-  debug.log("Added from cache:", addToLlmPrompt.length, "chars");
-  if (addToLlmPrompt) {
-    debug.log(`
---- AUGMENTED PROMPT ADDITION ---`);
-    debug.log(addToLlmPrompt);
-    debug.log(`--- END AUGMENTED PROMPT ---
-`);
   }
-  let sdkQuery;
-  try {
-    const sdk = await import("@anthropic-ai/claude-agent-sdk");
-    sdkQuery = sdk.query;
-  } catch {
-    throw new Error("Could not import @anthropic-ai/claude-agent-sdk. Install it with: npm install @anthropic-ai/claude-agent-sdk");
-  }
-  debug.time("Claude API call");
-  debug.log("Calling Claude Agent SDK...");
-  const response = sdkQuery({
-    prompt,
-    options: {
-      ...options,
-      systemPrompt: augmentedPrompt
-    }
-  });
-  let messageCount = 0;
-  const startTime = Date.now();
-  const generatedCodeBlocks = [];
-  for await (const message of response) {
-    messageCount++;
+  _trackMessage(message) {
+    this._messageCount++;
     const msg = message;
-    const elapsed = Date.now() - startTime;
-    debug.log(`
+    const elapsed = Date.now() - this._startTime;
+    this._debug.log(`
 ═══════════════════════════════════════════════════`);
-    debug.log(`Message #${messageCount} [${elapsed}ms] type=${msg.type} subtype=${msg.subtype || "none"}`);
-    debug.log(`═══════════════════════════════════════════════════`);
-    debug.log(JSON.stringify(msg, null, 2));
+    this._debug.log(`Message #${this._messageCount} [${elapsed}ms] type=${msg.type} subtype=${msg.subtype || "none"}`);
+    this._debug.log(`═══════════════════════════════════════════════════`);
+    this._debug.log(JSON.stringify(msg, null, 2));
     if (msg.type === "assistant") {
       const content = msg.message;
       const contentBlocks = content?.content;
@@ -691,21 +732,21 @@ async function* query(params) {
             const input = block.input;
             const filePath = input?.file_path ?? input?.notebook_path;
             if (filePath) {
-              debug.log(`  → ${block.name} tool detected:`, filePath);
-              modifiedFilePaths.add(filePath);
+              this._debug.log(`  → ${block.name} tool detected:`, filePath);
+              this._modifiedFilePaths.add(filePath);
             }
           }
           if (block.type === "tool_use" && block.name === "Bash") {
             const input = block.input;
             const command = input?.command;
             if (command) {
-              extractBashOutputFiles(command);
+              this._extractBashOutputFiles(command);
             }
           }
           if (block.type === "tool_result") {
-            const content2 = block.content;
-            if (content2) {
-              executionLogs.push(content2.slice(0, 5000));
+            const resultContent = block.content;
+            if (resultContent) {
+              this._executionLogs.push(resultContent.slice(0, 5000));
             }
           }
           if (block.type === "text") {
@@ -715,8 +756,8 @@ async function* query(params) {
               for (const match of codeMatches) {
                 const code = match.replace(/```(?:typescript|javascript|ts|js)?\n?/, "").replace(/\n?```$/, "");
                 if (code.trim().length > 50) {
-                  generatedCodeBlocks.push(code.trim());
-                  debug.log(`  → Extracted code block (${code.length} chars)`);
+                  this._generatedCodeBlocks.push(code.trim());
+                  this._debug.log(`  → Extracted code block (${code.length} chars)`);
                 }
               }
             }
@@ -725,93 +766,165 @@ async function* query(params) {
       }
     }
     if (msg.type === "result" && msg.subtype === "success") {
-      taskSucceeded = true;
-      debug.timeEnd("Claude API call");
-      debug.log("Task succeeded!");
+      this._taskSucceeded = true;
+      this._debug.timeEnd("Claude API call");
+      this._debug.log("Task succeeded!");
       const result = msg;
-      debug.log("  Duration:", result.duration_ms, "ms");
-      debug.log("  Total cost:", result.total_cost_usd, "USD");
-      debug.log("  Turns:", result.num_turns);
+      this._debug.log("  Duration:", result.duration_ms, "ms");
+      this._debug.log("  Total cost:", result.total_cost_usd, "USD");
+      this._debug.log("  Turns:", result.num_turns);
     }
     if (msg.type === "result" && msg.subtype !== "success") {
-      debug.timeEnd("Claude API call");
-      debug.log("Task failed:", msg.subtype);
-    }
-    yield message;
-  }
-  debug.log("Total messages streamed:", messageCount);
-  debug.log("Modified files tracked:", modifiedFilePaths.size);
-  debug.log("Code blocks extracted:", generatedCodeBlocks.length);
-  const filesToCache = [];
-  for (const filePath of modifiedFilePaths) {
-    if (filePath.includes(CACHE_DIR)) {
-      debug.log("  → Skipping cached file:", filePath);
-      continue;
-    }
-    try {
-      if (existsSync(filePath)) {
-        const content = readFileSync(filePath, "utf-8");
-        if (content.includes("\x00")) {
-          debug.log("  → Skipping binary file:", filePath);
-          continue;
-        }
-        filesToCache.push({ path: filePath, content });
-        debug.log("  → Will cache file:", filePath, `(${content.length} chars)`);
-      } else {
-        debug.log("  → File not found:", filePath);
-      }
-    } catch (err) {
-      debug.log("  → Failed to read file:", filePath, err);
+      this._debug.timeEnd("Claude API call");
+      this._debug.log("Task failed:", msg.subtype);
     }
   }
-  for (const filePath of bashGeneratedFiles) {
-    if (modifiedFilePaths.has(filePath))
-      continue;
-    try {
-      if (existsSync(filePath)) {
-        const content = readFileSync(filePath, "utf-8");
-        if (!content.includes("\x00")) {
+  async _uploadCache() {
+    if (this._cacheUploadDone)
+      return;
+    this._cacheUploadDone = true;
+    this._debug.log("Total messages streamed:", this._messageCount);
+    this._debug.log("Modified files tracked:", this._modifiedFilePaths.size);
+    this._debug.log("Code blocks extracted:", this._generatedCodeBlocks.length);
+    const filesToCache = [];
+    for (const filePath of this._modifiedFilePaths) {
+      if (filePath.includes(CACHE_DIR)) {
+        this._debug.log("  → Skipping cached file:", filePath);
+        continue;
+      }
+      try {
+        if (existsSync(filePath)) {
+          const content = readFileSync(filePath, "utf-8");
+          if (content.includes("\x00")) {
+            this._debug.log("  → Skipping binary file:", filePath);
+            continue;
+          }
           filesToCache.push({ path: filePath, content });
-          debug.log("  → Will cache Bash-generated file:", filePath, `(${content.length} chars)`);
+          this._debug.log("  → Will cache file:", filePath, `(${content.length} chars)`);
+        } else {
+          this._debug.log("  → File not found:", filePath);
         }
+      } catch (err) {
+        this._debug.log("  → Failed to read file:", filePath, err);
       }
-    } catch {
-      debug.log("  → Failed to read Bash-generated file:", filePath);
     }
-  }
-  if (generatedCodeBlocks.length > 0) {
-    const largestBlock = generatedCodeBlocks.reduce((a, b) => a.length > b.length ? a : b);
-    filesToCache.push({
-      path: "generated-code.ts",
-      content: largestBlock
-    });
-    debug.log("  → Will cache generated code block:", `(${largestBlock.length} chars)`);
-  }
-  debug.log("Total items to cache:", filesToCache.length);
-  if (cacheEnabled && raysurfer && taskSucceeded) {
-    const cachedBlocksForVoting = cachedFiles.map((f) => ({
-      codeBlockId: f.codeBlockId,
-      filename: f.filename,
-      description: f.description
-    }));
-    if (filesToCache.length > 0 || cachedBlocksForVoting.length > 0) {
+    for (const filePath of this._bashGeneratedFiles) {
+      if (this._modifiedFilePaths.has(filePath))
+        continue;
       try {
-        debug.time("Cache upload + voting");
-        const joinedLogs = executionLogs.length > 0 ? executionLogs.join(`
+        if (existsSync(filePath)) {
+          const content = readFileSync(filePath, "utf-8");
+          if (!content.includes("\x00")) {
+            filesToCache.push({ path: filePath, content });
+            this._debug.log("  → Will cache Bash-generated file:", filePath, `(${content.length} chars)`);
+          }
+        }
+      } catch {
+        this._debug.log("  → Failed to read Bash-generated file:", filePath);
+      }
+    }
+    if (this._generatedCodeBlocks.length > 0) {
+      const largestBlock = this._generatedCodeBlocks.reduce((a, b) => a.length > b.length ? a : b);
+      filesToCache.push({
+        path: "generated-code.ts",
+        content: largestBlock
+      });
+      this._debug.log("  → Will cache generated code block:", `(${largestBlock.length} chars)`);
+    }
+    this._debug.log("Total items to cache:", filesToCache.length);
+    if (this._cacheEnabled && this._raysurfer && this._taskSucceeded && this._promptText) {
+      const cachedBlocksForVoting = this._cachedFiles.map((f) => ({
+        codeBlockId: f.codeBlockId,
+        filename: f.filename,
+        description: f.description
+      }));
+      if (filesToCache.length > 0 || cachedBlocksForVoting.length > 0) {
+        try {
+          this._debug.time("Cache upload + voting");
+          const joinedLogs = this._executionLogs.length > 0 ? this._executionLogs.join(`
 ---
 `) : undefined;
-        debug.log("Uploading", filesToCache.length, "files, voting for", cachedBlocksForVoting.length, "cached blocks,", executionLogs.length, "log entries...");
-        await raysurfer.uploadNewCodeSnips(prompt, filesToCache, true, cachedBlocksForVoting.length > 0 ? cachedBlocksForVoting : undefined, true, joinedLogs);
-        debug.timeEnd("Cache upload + voting");
-        debug.log("Cache upload successful, voting queued on backend");
-        console.log("[raysurfer] Cache upload successful:", filesToCache.length, "files stored");
-      } catch (error) {
-        debug.log("Cache upload failed:", error);
-        console.warn("[raysurfer] Cache upload failed:", error instanceof Error ? error.message : error);
+          this._debug.log("Uploading", filesToCache.length, "files, voting for", cachedBlocksForVoting.length, "cached blocks,", this._executionLogs.length, "log entries...");
+          await this._raysurfer.uploadNewCodeSnips(this._promptText, filesToCache, true, cachedBlocksForVoting.length > 0 ? cachedBlocksForVoting : undefined, true, joinedLogs);
+          this._debug.timeEnd("Cache upload + voting");
+          this._debug.log("Cache upload successful, voting queued on backend");
+          console.log("[raysurfer] Cache upload successful:", filesToCache.length, "files stored");
+        } catch (error) {
+          this._debug.log("Cache upload failed:", error);
+          console.warn("[raysurfer] Cache upload failed:", error instanceof Error ? error.message : error);
+        }
       }
     }
+    this._debug.groupEnd();
+  }
+  async next(...args) {
+    const inner = await this._ensureInit();
+    const result = await inner.next(...args);
+    if (!result.done) {
+      this._trackMessage(result.value);
+    } else {
+      await this._uploadCache();
+    }
+    return result;
+  }
+  async return(value) {
+    if (this._inner) {
+      await this._uploadCache();
+      return this._inner.return(value);
+    }
+    return { done: true, value: undefined };
+  }
+  async throw(e) {
+    if (this._inner)
+      return this._inner.throw(e);
+    throw e;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  async[Symbol.asyncDispose]() {
+    this.close();
+  }
+  async interrupt() {
+    return (await this._ensureInit()).interrupt();
+  }
+  async setPermissionMode(mode) {
+    return (await this._ensureInit()).setPermissionMode(mode);
+  }
+  async setModel(model) {
+    return (await this._ensureInit()).setModel(model);
+  }
+  async setMaxThinkingTokens(maxThinkingTokens) {
+    return (await this._ensureInit()).setMaxThinkingTokens(maxThinkingTokens);
+  }
+  async supportedCommands() {
+    return (await this._ensureInit()).supportedCommands();
+  }
+  async supportedModels() {
+    return (await this._ensureInit()).supportedModels();
+  }
+  async mcpServerStatus() {
+    return (await this._ensureInit()).mcpServerStatus();
+  }
+  async accountInfo() {
+    return (await this._ensureInit()).accountInfo();
+  }
+  async rewindFiles(userMessageId, options) {
+    return (await this._ensureInit()).rewindFiles(userMessageId, options);
+  }
+  async setMcpServers(servers) {
+    return (await this._ensureInit()).setMcpServers(servers);
+  }
+  async streamInput(stream) {
+    return (await this._ensureInit()).streamInput(stream);
+  }
+  close() {
+    if (this._inner)
+      this._inner.close();
   }
-  debug.groupEnd();
+}
+function query(params) {
+  return new RaysurferQuery(params);
 }
 
 class ClaudeSDKClient {
@@ -819,8 +932,8 @@ class ClaudeSDKClient {
   constructor(options = {}) {
     this.options = options;
   }
-  async* query(prompt) {
-    yield* query({ prompt, options: this.options });
+  query(prompt) {
+    return query({ prompt, options: this.options });
   }
 }
 var sdk_client_default = query;
@@ -838,9 +951,20 @@ var AgentVerdict;
   AgentVerdict2["THUMBS_DOWN"] = "thumbs_down";
   AgentVerdict2["PENDING"] = "pending";
 })(AgentVerdict ||= {});
+
+// src/index.ts
+import {
+  AbortError,
+  createSdkMcpServer,
+  EXIT_REASONS,
+  HOOK_EVENTS,
+  tool
+} from "@anthropic-ai/claude-agent-sdk";
 export {
+  tool,
   sdk_client_default as queryDefault,
   query,
+  createSdkMcpServer,
   ValidationError,
   VERSION,
   ClaudeSDKClient as RaysurferClient,
@@ -848,10 +972,13 @@ export {
   client_default as RaySurferDefault,
   RaySurfer,
   RateLimitError,
+  HOOK_EVENTS,
   ExecutionState,
+  EXIT_REASONS,
   ClaudeSDKClient,
   CacheUnavailableError,
   AuthenticationError,
   AgentVerdict,
+  AbortError,
   APIError
 };

package/dist/sdk-client.d.ts

@@ -11,33 +11,29 @@
  *
  * Everything else works exactly the same. Set RAYSURFER_API_KEY to enable caching.
  */
+import type { Options, Query, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { SnipsDesired } from "./types";
-/** Options for the query function - matches Claude Agent SDK */
-export interface QueryOptions {
-    model?: string;
-    workingDirectory?: string;
-    systemPrompt?: string;
-    permissionMode?: "default" | "acceptEdits" | "plan" | "bypassPermissions";
-    maxBudgetUsd?: number;
-    allowedTools?: string[];
-    disallowedTools?: string[];
-    maxTurns?: number;
-    env?: Record<string, string>;
+/** Raysurfer-specific options beyond Claude SDK Options */
+export interface RaysurferExtras {
     /** Scope of private snippets - "company" (Team/Enterprise) or "client" (Enterprise only) */
     snipsDesired?: SnipsDesired;
     /** Custom namespace for code storage/retrieval */
     namespace?: string;
     /** Enable debug logging - also enabled via RAYSURFER_DEBUG=true env var */
     debug?: boolean;
-    /** Path to Claude Code executable (required for SDK) */
-    pathToClaudeCodeExecutable?: string;
-    /** Allow dangerous permissions bypass */
-    allowDangerouslySkipPermissions?: boolean;
+    /** @deprecated Use `cwd` instead */
+    workingDirectory?: string;
 }
+/** Full query options: Claude SDK Options extended with Raysurfer extras */
+export type RaysurferQueryOptions = Options & RaysurferExtras;
+/**
+ * @deprecated Use RaysurferQueryOptions instead
+ */
+export type QueryOptions = RaysurferQueryOptions;
 /** Query parameters - matches Claude Agent SDK */
 export interface QueryParams {
-    prompt: string;
-    options?: QueryOptions;
+    prompt: string | AsyncIterable<SDKUserMessage>;
+    options?: RaysurferQueryOptions;
 }
 /**
  * Drop-in replacement for Claude Agent SDK's query function with automatic caching.
@@ -52,7 +48,7 @@ export interface QueryParams {
  *
  * Set RAYSURFER_API_KEY environment variable to enable caching.
  */
-export declare function query(params: QueryParams): AsyncGenerator<unknown>;
+export declare function query(params: QueryParams): Query;
 /**
  * ClaudeSDKClient - Class-based drop-in replacement.
  *
@@ -65,10 +61,10 @@ export declare function query(params: QueryParams): AsyncGenerator<unknown>;
  */
 export declare class ClaudeSDKClient {
     private options;
-    constructor(options?: QueryOptions);
-    query(prompt: string): AsyncGenerator<unknown>;
+    constructor(options?: RaysurferQueryOptions);
+    query(prompt: string | AsyncIterable<SDKUserMessage>): Query;
 }
 export { ClaudeSDKClient as RaysurferClient };
-export type { QueryOptions as RaysurferAgentOptions };
+export type { RaysurferQueryOptions as RaysurferAgentOptions };
 export default query;
 //# sourceMappingURL=sdk-client.d.ts.map

package/dist/sdk-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdk-client.d.ts","sourceRoot":"","sources":["../src/sdk-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAyB,YAAY,EAAE,MAAM,SAAS,CAAC;AA2DnE,gEAAgE;AAChE,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,SAAS,GAAG,aAAa,GAAG,MAAM,GAAG,mBAAmB,CAAC;IAC1E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,4FAA4F;IAC5F,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,wDAAwD;IACxD,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,yCAAyC;IACzC,+BAA+B,CAAC,EAAE,OAAO,CAAC;CAC3C;AAED,kDAAkD;AAClD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAuB,KAAK,CAAC,MAAM,EAAE,WAAW,GAAG,cAAc,CAAC,OAAO,CAAC,CAqYzE;AAED;;;;;;;;;GASG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAe;gBAElB,OAAO,GAAE,YAAiB;IAI/B,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC,OAAO,CAAC;CAGtD;AAGD,OAAO,EAAE,eAAe,IAAI,eAAe,EAAE,CAAC;AAC9C,YAAY,EAAE,YAAY,IAAI,qBAAqB,EAAE,CAAC;AAEtD,eAAe,KAAK,CAAC"}
+{"version":3,"file":"sdk-client.d.ts","sourceRoot":"","sources":["../src/sdk-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAMV,OAAO,EAEP,KAAK,EAGL,cAAc,EAEf,MAAM,gCAAgC,CAAC;AAExC,OAAO,KAAK,EAAyB,YAAY,EAAE,MAAM,SAAS,CAAC;AA2DnE,2DAA2D;AAC3D,MAAM,WAAW,eAAe;IAC9B,4FAA4F;IAC5F,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,oCAAoC;IACpC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,4EAA4E;AAC5E,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,eAAe,CAAC;AAE9D;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,qBAAqB,CAAC;AAEjD,kDAAkD;AAClD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,qBAAqB,CAAC;CACjC;AAmjBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,WAAW,GAAG,KAAK,CAEhD;AAED;;;;;;;;;GASG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAwB;gBAE3B,OAAO,GAAE,qBAA0B;IAI/C,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CAAC,cAAc,CAAC,GAAG,KAAK;CAG7D;AAGD,OAAO,EAAE,eAAe,IAAI,eAAe,EAAE,CAAC;AAC9C,YAAY,EAAE,qBAAqB,IAAI,qBAAqB,EAAE,CAAC;AAE/D,eAAe,KAAK,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raysurfer",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Drop-in replacement for Claude Agent SDK with automatic code caching - just swap your import",
   "type": "module",
   "main": "./dist/index.js",