@pivanov/claude-wire 0.0.4 → 0.1.0

package/README.md

@@ -20,12 +20,14 @@ console.log(result.costUsd);  // 0.0084
 ## Features
 
 - **Simple API** - `claude.ask()` returns a typed result, `claude.stream()` yields events
+- **Structured JSON** - `claude.askJson(prompt, schema)` with Standard Schema (Zod/Valibot/ArkType) validation
 - **Tool control** - allow, block, or intercept any tool at runtime
 - **Multi-turn sessions** - persistent process across multiple prompts
-- **Cost tracking** - per-request budgets with auto-abort
+- **Cost tracking** - per-request budgets with auto-abort and projection primitives
+- **Typed errors** - rate-limit, overload, context-length, retry-exhausted as `KnownError` codes
 - **Fully typed** - discriminated union events, full IntelliSense
-- **Resilient** - auto-respawn, transient error detection, AbortSignal
-- **Zero dependencies** - 25.6 kB gzipped
+- **Resilient** - auto-respawn with backoff, transient error detection, AbortSignal
+- **Zero dependencies** - ~29 kB gzipped
 
 ## Install
 
@@ -67,7 +69,7 @@ apps/examples/          interactive example runner
 
 ```bash
 bun install
-bun run test        # 192 tests
+bun run test        # 217 tests
 bun run typecheck
 bun run lint
 bun run docs:dev    # local docs server

package/dist/client.d.ts

@@ -1,9 +1,11 @@
+import { type IJsonResult, type TSchemaInput } from "./json.js";
 import type { IClaudeSession } from "./session.js";
 import type { IClaudeStream } from "./stream.js";
 import type { IClaudeOptions, ISessionOptions } from "./types/options.js";
 import type { TAskResult } from "./types/results.js";
 export interface IClaudeClient {
     ask: (prompt: string, options?: IClaudeOptions) => Promise<TAskResult>;
+    askJson: <T>(prompt: string, schema: TSchemaInput<T>, options?: IClaudeOptions) => Promise<IJsonResult<T>>;
     stream: (prompt: string, options?: IClaudeOptions) => IClaudeStream;
     session: (options?: ISessionOptions) => IClaudeSession;
     create: (defaults: IClaudeOptions) => IClaudeClient;

package/dist/client.js

@@ -1,9 +1,10 @@
+import { isStandardSchema, parseAndValidate } from "./json.js";
 import { createSession } from "./session.js";
 import { createStream } from "./stream.js";
 const mergeOptions = (defaults, overrides) => {
     const merged = { ...defaults, ...overrides };
-    if (overrides && "tools" in overrides) {
-        merged.tools = overrides.tools ? { ...defaults.tools, ...overrides.tools } : overrides.tools;
+    if (overrides && "toolHandler" in overrides) {
+        merged.toolHandler = overrides.toolHandler ? { ...defaults.toolHandler, ...overrides.toolHandler } : overrides.toolHandler;
     }
     if (overrides && "env" in overrides) {
         merged.env = overrides.env ? { ...defaults.env, ...overrides.env } : overrides.env;
@@ -16,6 +17,23 @@ export const createClient = (defaults = {}) => {
         const stream = createStream(prompt, merged);
         return stream.result();
     };
+    const askJson = async (prompt, schema, options) => {
+        const merged = mergeOptions(defaults, options);
+        // Forward the raw JSON Schema string to the CLI via --json-schema when
+        // the caller passes a string. Standard Schema objects are validated
+        // SDK-side after the response arrives.
+        if (typeof schema === "string") {
+            merged.jsonSchema = schema;
+        }
+        else if (isStandardSchema(schema)) {
+            // Extract JSON Schema representation if available for CLI-side
+            // constraint. Many Standard Schema libs expose this via toJsonSchema()
+            // but it's not part of the protocol. We validate SDK-side regardless.
+        }
+        const raw = await ask(prompt, merged);
+        const data = parseAndValidate(raw.text, schema);
+        return { data, raw };
+    };
     const stream = (prompt, options) => {
         const merged = mergeOptions(defaults, options);
         return createStream(prompt, merged);
@@ -28,5 +46,5 @@ export const createClient = (defaults = {}) => {
         const merged = mergeOptions(defaults, newDefaults);
         return createClient(merged);
     };
-    return { ask, stream, session, create };
+    return { ask, askJson, stream, session, create };
 };

package/dist/cost.d.ts

@@ -1,10 +1,16 @@
 import type { TCostSnapshot } from "./types/results.js";
 import type { TWarn } from "./warnings.js";
+export interface ICostProjection {
+    projectedUsd: number;
+}
 export interface ICostTracker {
     update: (totalCostUsd: number, totalInputTokens: number, totalOutputTokens: number) => void;
     snapshot: () => TCostSnapshot;
     checkBudget: () => void;
     reset: () => void;
+    turnCount: number;
+    averagePerTurn: number;
+    project: (remainingTurns: number) => ICostProjection;
 }
 export interface ICostTrackerOptions {
     maxCostUsd?: number;

package/dist/cost.js

@@ -5,17 +5,18 @@ export const createCostTracker = (options = {}) => {
     assertPositiveNumber(options.maxCostUsd, "maxCostUsd");
     const warn = createWarn(options.onWarning);
     let totalUsd = 0;
-    let inputTokens = 0;
-    let outputTokens = 0;
+    let input = 0;
+    let output = 0;
+    let turns = 0;
     const snapshot = () => ({
         totalUsd,
-        inputTokens,
-        outputTokens,
+        tokens: { input, output },
     });
     const update = (totalCostUsd, totalInputToks, totalOutputToks) => {
         totalUsd = totalCostUsd;
-        inputTokens = totalInputToks;
-        outputTokens = totalOutputToks;
+        input = totalInputToks;
+        output = totalOutputToks;
+        turns++;
         if (options.onCostUpdate) {
             try {
                 options.onCostUpdate(snapshot());
@@ -32,8 +33,25 @@ export const createCostTracker = (options = {}) => {
     };
     const reset = () => {
         totalUsd = 0;
-        inputTokens = 0;
-        outputTokens = 0;
+        input = 0;
+        output = 0;
+        turns = 0;
+    };
+    const project = (remainingTurns) => {
+        const avg = turns > 0 ? totalUsd / turns : 0;
+        return { projectedUsd: totalUsd + avg * remainingTurns };
+    };
+    return {
+        update,
+        snapshot,
+        checkBudget,
+        reset,
+        get turnCount() {
+            return turns;
+        },
+        get averagePerTurn() {
+            return turns > 0 ? totalUsd / turns : 0;
+        },
+        project,
     };
-    return { update, snapshot, checkBudget, reset };
 };

package/dist/errors.d.ts

@@ -16,7 +16,7 @@ export declare class ProcessError extends ClaudeError {
     readonly exitCode?: number | undefined;
     constructor(message: string, exitCode?: number | undefined);
 }
-export declare const KNOWN_ERROR_CODES: readonly ["not-authenticated", "binary-not-found", "permission-denied", "retry-exhausted"];
+export declare const KNOWN_ERROR_CODES: readonly ["not-authenticated", "binary-not-found", "permission-denied", "retry-exhausted", "rate-limit", "overloaded", "context-length-exceeded", "invalid-json-schema", "mcp-error"];
 export type TKnownErrorCode = (typeof KNOWN_ERROR_CODES)[number];
 export declare class KnownError extends ClaudeError {
     readonly code: TKnownErrorCode;
@@ -25,4 +25,7 @@ export declare class KnownError extends ClaudeError {
 export declare const isKnownError: (error: unknown) => error is KnownError;
 export declare const isTransientError: (error: unknown) => boolean;
 export declare const errorMessage: (error: unknown) => string;
-export declare const processExitedEarly: (stderr: string, exitCode?: number) => ProcessError;
+declare let stderrClassifier: ((stderr: string, exitCode?: number) => TKnownErrorCode | undefined) | undefined;
+export declare const setStderrClassifier: (fn: typeof stderrClassifier) => void;
+export declare const processExitedEarly: (stderr: string, exitCode?: number) => ProcessError | KnownError;
+export {};

package/dist/errors.js

@@ -37,7 +37,18 @@ export class ProcessError extends ClaudeError {
 // Only codes the SDK actually constructs are listed. Add a new code here
 // alongside the throw site that needs it -- aspirational entries give
 // consumers false confidence that they can pattern-match on them.
-export const KNOWN_ERROR_CODES = ["not-authenticated", "binary-not-found", "permission-denied", "retry-exhausted"];
+export const KNOWN_ERROR_CODES = [
+    "not-authenticated",
+    "binary-not-found",
+    "permission-denied",
+    "retry-exhausted",
+    // Classified from stderr by classifyStderr (src/stderr.ts):
+    "rate-limit",
+    "overloaded",
+    "context-length-exceeded",
+    "invalid-json-schema",
+    "mcp-error",
+];
 export class KnownError extends ClaudeError {
     code;
     constructor(code, message) {
@@ -74,4 +85,19 @@ export const errorMessage = (error) => {
 // case. session.ts + stream.ts both need this; the string used to be
 // duplicated verbatim, which drifted at least once. Prefix stderr when
 // available because CLI error output is the most actionable signal.
-export const processExitedEarly = (stderr, exitCode) => new ProcessError(stderr || "Process exited without completing the turn", exitCode);
+// Auto-promotes to KnownError when stderr matches a classifiable pattern.
+// The classifier is injected to avoid a circular import (stderr.ts imports
+// types from this file). Wire it at boot via `setStderrClassifier`.
+let stderrClassifier;
+export const setStderrClassifier = (fn) => {
+    stderrClassifier = fn;
+};
+export const processExitedEarly = (stderr, exitCode) => {
+    if (stderr && stderrClassifier) {
+        const code = stderrClassifier(stderr, exitCode);
+        if (code) {
+            return new KnownError(code, stderr);
+        }
+    }
+    return new ProcessError(stderr || "Process exited without completing the turn", exitCode);
+};

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 export type { IClaudeClient } from "./client.js";
 export { createClient } from "./client.js";
 export { BINARY, LIMITS, TIMEOUTS } from "./constants.js";
-export type { ICostTracker, ICostTrackerOptions } from "./cost.js";
+export type { ICostProjection, ICostTracker, ICostTrackerOptions } from "./cost.js";
 export { createCostTracker } from "./cost.js";
 export type { TKnownErrorCode } from "./errors.js";
 export { AbortError, BudgetExceededError, ClaudeError, errorMessage, isKnownError, isTransientError, KNOWN_ERROR_CODES, KnownError, ProcessError, TimeoutError, } from "./errors.js";
+export type { IJsonResult, IStandardSchema, TSchemaInput } from "./json.js";
+export { JsonValidationError, parseAndValidate, stripFences } from "./json.js";
 export { blockFingerprint, extractContent, parseDoubleEncoded } from "./parser/content.js";
 export { parseLine } from "./parser/ndjson.js";
 export type { ITranslator } from "./parser/translator.js";
@@ -15,6 +17,7 @@ export type { IReaderOptions } from "./reader.js";
 export { readNdjsonEvents } from "./reader.js";
 export type { IClaudeSession } from "./session.js";
 export { createSession } from "./session.js";
+export { classifyStderr } from "./stderr.js";
 export type { IClaudeStream } from "./stream.js";
 export { createStream } from "./stream.js";
 export type { IToolHandlerInstance, TToolDecision } from "./tools/handler.js";
@@ -24,6 +27,6 @@ export { BUILT_IN_TOOL_NAMES, BUILT_IN_TOOLS, isBuiltInTool } from "./tools/regi
 export type { TErrorEvent, TRelayEvent, TSessionMetaEvent, TTextEvent, TThinkingEvent, TToolResultEvent, TToolUseEvent, TTurnCompleteEvent, } from "./types/events.js";
 export type { IAskOptions, IClaudeOptions, ISessionOptions, IToolHandler } from "./types/options.js";
 export type { TClaudeContent, TClaudeContentType, TClaudeEvent, TClaudeEventType, TClaudeMessage, TModelUsageEntry } from "./types/protocol.js";
-export type { TAskResult, TCostSnapshot } from "./types/results.js";
+export type { TAskResult, TCostSnapshot, TTokens } from "./types/results.js";
 export { writer } from "./writer.js";
 export declare const claude: import("./client.js").IClaudeClient;

package/dist/index.js

@@ -3,14 +3,21 @@ export { createClient } from "./client.js";
 export { BINARY, LIMITS, TIMEOUTS } from "./constants.js";
 export { createCostTracker } from "./cost.js";
 export { AbortError, BudgetExceededError, ClaudeError, errorMessage, isKnownError, isTransientError, KNOWN_ERROR_CODES, KnownError, ProcessError, TimeoutError, } from "./errors.js";
+export { JsonValidationError, parseAndValidate, stripFences } from "./json.js";
 export { blockFingerprint, extractContent, parseDoubleEncoded } from "./parser/content.js";
 export { parseLine } from "./parser/ndjson.js";
 export { createTranslator } from "./parser/translator.js";
 export { buildArgs, resetResolvedEnvCache, spawnClaude } from "./process.js";
 export { readNdjsonEvents } from "./reader.js";
 export { createSession } from "./session.js";
+export { classifyStderr } from "./stderr.js";
 export { createStream } from "./stream.js";
 export { createToolHandler } from "./tools/handler.js";
 export { BUILT_IN_TOOL_NAMES, BUILT_IN_TOOLS, isBuiltInTool } from "./tools/registry.js";
 export { writer } from "./writer.js";
+// Wire the stderr classifier into the error factory at module load so
+// processExitedEarly can auto-promote ProcessError -> KnownError.
+import { setStderrClassifier } from "./errors.js";
+import { classifyStderr as _classifyStderr } from "./stderr.js";
+setStderrClassifier(_classifyStderr);
 export const claude = createClient();

package/dist/json.d.ts

@@ -0,0 +1,35 @@
+import { ClaudeError } from "./errors.js";
+export interface IStandardSchema<T = unknown> {
+    "~standard": {
+        version: 1;
+        vendor: string;
+        validate: (value: unknown) => IStandardResult<T>;
+    };
+}
+interface IStandardResult<T> {
+    value?: T;
+    issues?: ReadonlyArray<{
+        message?: string;
+        path?: ReadonlyArray<string | number>;
+    }>;
+}
+export declare class JsonValidationError extends ClaudeError {
+    readonly rawText: string;
+    readonly issues: ReadonlyArray<{
+        message?: string;
+        path?: ReadonlyArray<string | number>;
+    }>;
+    constructor(message: string, rawText: string, issues: ReadonlyArray<{
+        message?: string;
+        path?: ReadonlyArray<string | number>;
+    }>);
+}
+export interface IJsonResult<T> {
+    data: T;
+    raw: import("./types/results.js").TAskResult;
+}
+export declare const stripFences: (text: string) => string;
+export type TSchemaInput<T> = IStandardSchema<T> | string;
+export declare const isStandardSchema: <T>(schema: TSchemaInput<T>) => schema is IStandardSchema<T>;
+export declare const parseAndValidate: <T>(text: string, schema: TSchemaInput<T>) => T;
+export {};

package/dist/json.js

@@ -0,0 +1,43 @@
+import { ClaudeError } from "./errors.js";
+export class JsonValidationError extends ClaudeError {
+    rawText;
+    issues;
+    constructor(message, rawText, issues) {
+        super(message);
+        this.rawText = rawText;
+        this.issues = issues;
+        this.name = "JsonValidationError";
+    }
+}
+// Strip common fences: ```json ... ```, ``` ... ```, or bare JSON.
+const FENCE_RE = /^\s*```(?:json)?\s*\n?([\s\S]*?)\n?\s*```\s*$/;
+export const stripFences = (text) => {
+    const match = text.match(FENCE_RE);
+    return match?.[1] ?? text.trim();
+};
+export const isStandardSchema = (schema) => {
+    return typeof schema === "object" && schema !== null && "~standard" in schema;
+};
+export const parseAndValidate = (text, schema) => {
+    const stripped = stripFences(text);
+    let parsed;
+    try {
+        parsed = JSON.parse(stripped);
+    }
+    catch (err) {
+        throw new JsonValidationError(`Failed to parse JSON from Claude response: ${err instanceof Error ? err.message : String(err)}`, text, [
+            { message: "Invalid JSON" },
+        ]);
+    }
+    if (isStandardSchema(schema)) {
+        const result = schema["~standard"].validate(parsed);
+        if (result.issues && result.issues.length > 0) {
+            const summary = result.issues.map((i) => i.message ?? "validation error").join("; ");
+            throw new JsonValidationError(`Schema validation failed: ${summary}`, text, result.issues);
+        }
+        return result.value;
+    }
+    // Raw JSON Schema string -- no runtime validation, just parse. The CLI's
+    // --json-schema constrains the model output, so we trust it here.
+    return parsed;
+};

package/dist/parser/translator.js

@@ -55,7 +55,7 @@ const translateContentBlock = (block) => {
                 type: "tool_use",
                 toolUseId: block.id,
                 toolName: block.name,
-                input: typeof block.input === "string" ? block.input : JSON.stringify(block.input ?? {}),
+                input: block.input ?? {},
             };
         }
         case "tool_result": {

package/dist/pipeline.js

@@ -43,8 +43,8 @@ export const dispatchToolDecision = async (proc, toolHandler, event, onWarning)
 // wants to carry forward what previous processes already spent -- stream
 // has no such concept and passes it undefined.
 export const applyTurnComplete = (event, costTracker, offsets) => {
-    const base = offsets ?? { totalUsd: 0, inputTokens: 0, outputTokens: 0 };
-    costTracker.update(base.totalUsd + (event.costUsd ?? 0), base.inputTokens + (event.inputTokens ?? 0), base.outputTokens + (event.outputTokens ?? 0));
+    const base = offsets ?? { totalUsd: 0, tokens: { input: 0, output: 0 } };
+    costTracker.update(base.totalUsd + (event.costUsd ?? 0), base.tokens.input + (event.inputTokens ?? 0), base.tokens.output + (event.outputTokens ?? 0));
     costTracker.checkBudget();
 };
 export const extractText = (events) => {
@@ -59,7 +59,7 @@ export const buildResult = (events, costTracker, sessionId) => {
     return {
         text: extractText(events),
         costUsd: snap.totalUsd,
-        tokens: { input: snap.inputTokens, output: snap.outputTokens },
+        tokens: snap.tokens,
         duration: tc?.durationMs ?? 0,
         sessionId,
         events,

package/dist/session.d.ts

@@ -2,6 +2,7 @@ import type { IAskOptions, ISessionOptions } from "./types/options.js";
 import type { TAskResult } from "./types/results.js";
 export interface IClaudeSession extends AsyncDisposable {
     ask: (prompt: string, options?: IAskOptions) => Promise<TAskResult>;
+    askJson: <T>(prompt: string, schema: import("./json.js").TSchemaInput<T>, options?: IAskOptions) => Promise<import("./json.js").IJsonResult<T>>;
     close: () => Promise<void>;
     sessionId: string | undefined;
 }

package/dist/session.js

@@ -2,6 +2,7 @@ import { withTimeout } from "./async.js";
 import { LIMITS, MAX_BACKOFF_INDEX, RESPAWN_BACKOFF_MS, TIMEOUTS } from "./constants.js";
 import { createCostTracker } from "./cost.js";
 import { AbortError, BudgetExceededError, ClaudeError, isTransientError, KnownError, processExitedEarly, TimeoutError } from "./errors.js";
+import { parseAndValidate } from "./json.js";
 import { createTranslator } from "./parser/translator.js";
 import { applyTurnComplete, buildResult, startPipeline } from "./pipeline.js";
 import { safeKill, safeWrite } from "./process.js";
@@ -90,14 +91,14 @@ export const createSession = (options = {}) => {
     let currentSessionId;
     let consecutiveCrashes = 0;
     let turnCount = 0;
-    let costOffsets = { totalUsd: 0, inputTokens: 0, outputTokens: 0 };
+    let costOffsets = { totalUsd: 0, tokens: { input: 0, output: 0 } };
     const translator = createTranslator();
     const costTracker = createCostTracker({
         maxCostUsd: options.maxCostUsd,
         onCostUpdate: options.onCostUpdate,
         onWarning: options.onWarning,
     });
-    const toolHandler = options.tools ? createToolHandler(options.tools) : undefined;
+    const toolHandler = options.toolHandler ? createToolHandler(options.toolHandler) : undefined;
     let inFlight;
     let reader;
     const cleanupProcess = () => {
@@ -300,8 +301,14 @@ export const createSession = (options = {}) => {
         }
         cleanupProcess();
     };
+    const askJson = async (prompt, schema, askOpts) => {
+        const raw = await ask(prompt, askOpts);
+        const data = parseAndValidate(raw.text, schema);
+        return { data, raw };
+    };
     return {
         ask,
+        askJson,
         close,
         get sessionId() {
             return currentSessionId;

package/dist/stderr.d.ts

@@ -0,0 +1,10 @@
+import type { TKnownErrorCode } from "./errors.js";
+/**
+ * Attempts to classify an opaque stderr string into a typed `TKnownErrorCode`.
+ * Returns `undefined` when no pattern matches -- the caller should keep the
+ * original `ProcessError` as-is in that case.
+ *
+ * The exit code is accepted but not currently used (all classification is
+ * text-based). Reserved for future exit-code-specific rules.
+ */
+export declare const classifyStderr: (stderr: string, _exitCode?: number) => TKnownErrorCode | undefined;

package/dist/stderr.js

@@ -0,0 +1,31 @@
+// Conservative pattern table for classifying CLI stderr into typed error
+// codes. Intentionally small -- false classification is worse than no
+// classification. Documented as "may drift across CLI versions."
+//
+// Each entry: [pattern to test against stderr text, resulting code].
+const STDERR_PATTERNS = [
+    [/rate[_ -]?limit|429|too many requests/i, "rate-limit"],
+    [/overloaded|529|temporarily unavailable/i, "overloaded"],
+    [/context[_ -]?length|context[_ -]?window|too long|maximum.*tokens/i, "context-length-exceeded"],
+    [/invalid.*json[_ -]?schema|schema.*invalid|json.*schema.*error/i, "invalid-json-schema"],
+    [/mcp.*error|mcp.*fail|mcp.*server/i, "mcp-error"],
+    [/not authenticated|authentication|unauthorized|401/i, "not-authenticated"],
+    [/permission denied|forbidden|403/i, "permission-denied"],
+    [/binary.*not found|command not found|ENOENT.*claude/i, "binary-not-found"],
+];
+/**
+ * Attempts to classify an opaque stderr string into a typed `TKnownErrorCode`.
+ * Returns `undefined` when no pattern matches -- the caller should keep the
+ * original `ProcessError` as-is in that case.
+ *
+ * The exit code is accepted but not currently used (all classification is
+ * text-based). Reserved for future exit-code-specific rules.
+ */
+export const classifyStderr = (stderr, _exitCode) => {
+    for (const [pattern, code] of STDERR_PATTERNS) {
+        if (pattern.test(stderr)) {
+            return code;
+        }
+    }
+    return undefined;
+};

package/dist/stream.js

@@ -15,7 +15,7 @@ export const createStream = (prompt, options = {}) => {
     // capture config. A pre-aborted signal surfaces on the first access
     // (iterate / text / cost / result), which is when spawn would happen.
     const translator = createTranslator();
-    const toolHandler = options.tools ? createToolHandler(options.tools) : undefined;
+    const toolHandler = options.toolHandler ? createToolHandler(options.toolHandler) : undefined;
     const costTracker = createCostTracker({
         maxCostUsd: options.maxCostUsd,
         onCostUpdate: options.onCostUpdate,

package/dist/types/events.d.ts

@@ -10,7 +10,7 @@ export type TToolUseEvent = {
     type: "tool_use";
     toolUseId: string;
     toolName: string;
-    input: string;
+    input: unknown;
 };
 export type TToolResultEvent = {
     type: "tool_result";

package/dist/types/options.d.ts

@@ -16,7 +16,7 @@ export interface IClaudeOptions {
     appendSystemPrompt?: string;
     allowedTools?: TToolName[];
     disallowedTools?: TToolName[];
-    tools?: IToolHandler;
+    toolHandler?: IToolHandler;
     /**
      * SDK-side budget limit, evaluated after each turn. Throws `BudgetExceededError`
      * and kills the process when `total_cost_usd` exceeds this value. `0` means

package/dist/types/results.d.ts

@@ -1,16 +1,16 @@
 import type { TRelayEvent } from "./events.js";
+export type TTokens = {
+    input: number;
+    output: number;
+};
 export type TCostSnapshot = {
     totalUsd: number;
-    inputTokens: number;
-    outputTokens: number;
+    tokens: TTokens;
 };
 export type TAskResult = {
     text: string;
     costUsd: number;
-    tokens: {
-        input: number;
-        output: number;
-    };
+    tokens: TTokens;
     duration: number;
     sessionId?: string;
     events: TRelayEvent[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pivanov/claude-wire",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "description": "Run Claude Code programmatically. Typed SDK for spawning, streaming, and controlling the CLI.",
   "type": "module",
   "engines": {