@nyte-ai/plugin 0.0.0-stage → 0.0.19

package/dist/examples/claude-code/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Armin Ronacher
+
+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/dist/examples/claude-code/billing.d.ts

@@ -0,0 +1,7 @@
+import type { NativeOutputEvent } from "./wire.ts";
+export type RateLimitInfo = NonNullable<Extract<NativeOutputEvent, {
+    type: "rate_limit_event";
+}>["rate_limit_info"]>;
+export declare function usageCreditsAllowed(env: Record<string, string | undefined>): boolean;
+export declare function usageCreditsChargeError(info: RateLimitInfo): Error;
+export declare function describeUsageCreditsRejection(message: string): string | undefined;

package/dist/examples/claude-code/billing.js

@@ -0,0 +1,11 @@
+import {
+  usageCreditsAllowed2,
+  usageCreditsChargeError2,
+  describeUsageCreditsRejection2
+} from "../../chunks/billing-tzr3cebf.js";
+import"../../chunks/billing-s4rrspsk.js";
+export {
+  describeUsageCreditsRejection2 as describeUsageCreditsRejection,
+  usageCreditsAllowed2 as usageCreditsAllowed,
+  usageCreditsChargeError2 as usageCreditsChargeError
+};

package/dist/examples/claude-code/claude-cli.d.ts

@@ -0,0 +1,35 @@
+import type { RateLimitInfo } from "./billing.ts";
+import type { AnthropicStreamEvent, JsonRecord, NativeFrame, NativeMessage, NativeUsage } from "./wire.ts";
+import type { NativeSystemInjection, ToolManifestEntry } from "./transcript.ts";
+export interface RunClaudeInput {
+    model: string;
+    cwd?: string;
+    frames: NativeFrame[];
+    systemPrompt: string;
+    manifest: ToolManifestEntry[];
+    extraBody: JsonRecord;
+    toolNames: Set<string>;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    env?: Record<string, string | undefined>;
+    upstreamUrl?: string;
+    initialUserPrefix?: unknown[];
+    initialSystemMessages?: unknown[];
+    nativeSystemInjections?: NativeSystemInjection[];
+    betas?: string[];
+    onEvent?: (event: AnthropicStreamEvent) => void;
+    sessionId?: string;
+}
+export interface RunClaudeOutput {
+    message: NativeMessage;
+    usage: NativeUsage;
+    relay: {
+        upstreamRequests: number;
+        blockedRequests: number;
+        requestId?: string;
+    };
+    initialUserPrefix?: unknown[];
+    initialSystemMessages?: unknown[];
+    rateLimit?: RateLimitInfo;
+}
+export declare function runClaudeRequest(input: RunClaudeInput): Promise<RunClaudeOutput>;

package/dist/examples/claude-code/claude-cli.js

@@ -0,0 +1,15 @@
+import {
+  runClaudeRequest2
+} from "../../chunks/billing-3scqmkzb.js";
+import"../../chunks/billing-ejx2hv52.js";
+import"../../chunks/billing-a9vqn66p.js";
+import"../../chunks/billing-tzr3cebf.js";
+import"../../chunks/billing-t1qrxe16.js";
+import"../../chunks/billing-cy1rg619.js";
+import"../../chunks/billing-s4rrspsk.js";
+import"../../chunks/billing-9qc0eqh4.js";
+import"../../chunks/billing-j643d12p.js";
+import"../../chunks/billing-0y7dfkp2.js";
+export {
+  runClaudeRequest2 as runClaudeRequest
+};

package/dist/examples/claude-code/env.d.ts

@@ -0,0 +1 @@
+export declare function envFlagEnabled(value: string | undefined): boolean;

package/dist/examples/claude-code/env.js

@@ -0,0 +1,6 @@
+import {
+  envFlagEnabled2
+} from "../../chunks/billing-s4rrspsk.js";
+export {
+  envFlagEnabled2 as envFlagEnabled
+};

package/dist/examples/claude-code/index.d.ts

@@ -0,0 +1,24 @@
+import type { Provider } from "@nyte-ai/ai";
+/** Returns the Anthropic provider using Claude Code's login and CLI; Nyte owns history, approvals and tool execution. */
+export declare function claudeCodeProvider(): Provider;
+declare const _default: {
+    id: string;
+    activate({ session, signal }: {
+        readonly side: "core";
+        readonly sdk: import("@nyte-ai/core").Connection;
+        readonly contribute: import("@nyte-ai/core").Registries<"core">;
+        readonly storage: import("@nyte-ai/core").PluginStorage;
+        readonly signal: AbortSignal;
+        hook<N extends "session_activated" | "before_send" | "run_started" | "transform_transcript" | "before_compaction" | "before_request" | "before_tool" | "after_tool" | "after_request" | "run_ended">(name: N, entry: import("@nyte-ai/core").HookEntry<"core", N>): import("@nyte-ai/schema").Disposer;
+        report(issue: import("@nyte-ai/schema").ValidationIssue): void;
+        reload(): void;
+    } & {
+        readonly session: import("@nyte-ai/core").Session;
+        readonly env: import("@nyte-ai/core").ExecutionEnv;
+        wrapEnv(wrap: import("@nyte-ai/core").EnvironmentWrap): import("@nyte-ai/schema").Disposer;
+        readonly inputs: import("@nyte-ai/core").Resources;
+        request<T = string>(input: import("@nyte-ai/schema").ModelRequestInput<T>): Promise<import("@nyte-ai/schema").ModelRequestOutcome<T>>;
+        approve(call: import("@nyte-ai/core").RuntimeCall, signal: AbortSignal): Promise<import("@nyte-ai/core").RuntimeVerdict>;
+    }): void;
+};
+export default _default;

package/dist/examples/claude-code/index.js

@@ -0,0 +1,149 @@
+import"../../chunks/billing-s4rrspsk.js";
+import {
+  PROVIDER_ID2,
+  API_ID2,
+  createClaudeModelCatalog2
+} from "../../chunks/billing-9qc0eqh4.js";
+import"../../chunks/billing-0y7dfkp2.js";
+import {
+  LOGIN_HINT2,
+  getClaudeStatus2,
+  discoverClaudeModels2
+} from "../../chunks/billing-cy1rg619.js";
+import"../../chunks/billing-tzr3cebf.js";
+import"../../chunks/billing-t1qrxe16.js";
+import"../../chunks/billing-j643d12p.js";
+import"../../chunks/billing-a9vqn66p.js";
+import"../../chunks/billing-ejx2hv52.js";
+import"../../chunks/billing-3scqmkzb.js";
+import {
+  streamClaudeCode2
+} from "../../chunks/billing-8rjk35gr.js";
+
+// examples/claude-code/index.ts
+import process from "node:process";
+import { acquireSessionResources, anthropicProvider } from "@nyte-ai/ai";
+var ENV_NAMES = [
+  "NYTE_CLAUDE_CODE_COMMAND",
+  "NYTE_CLAUDE_CODE_CONFIG_DIR",
+  "NYTE_CLAUDE_CODE_ALLOW_USAGE_CREDITS",
+  "CLAUDE_CONFIG_DIR"
+];
+async function providerEnvironment(ctx) {
+  const env = {};
+  for (const name of ENV_NAMES) {
+    const value = await ctx.env(name);
+    if (value !== undefined)
+      env[name] = value;
+  }
+  return env;
+}
+function claudeCodeProvider() {
+  const catalog = anthropicProvider();
+  const routes = createClaudeModelCatalog2();
+  let env = {};
+  let discovered;
+  const check = async ({
+    ctx,
+    signal
+  }) => {
+    env = await providerEnvironment(ctx);
+    const status = await getClaudeStatus2({ ...process.env, ...env }, signal);
+    if (!status.available || !status.loggedIn)
+      return;
+    return {
+      type: status.subscription ? "oauth" : "api_key",
+      source: status.subscription ? `Claude Code ${status.plan ?? "subscription"}` : "Claude Code CLI"
+    };
+  };
+  return {
+    id: PROVIDER_ID2,
+    name: "Claude Code",
+    baseUrl: "process://claude-code",
+    auth: {
+      apiKey: {
+        name: "Claude Code login",
+        check,
+        async resolve({ ctx, signal }) {
+          signal.throwIfAborted();
+          env = await providerEnvironment(ctx);
+          return { auth: {}, env, source: "Claude Code CLI" };
+        }
+      },
+      oauth: {
+        check,
+        name: "Claude Code subscription",
+        isSubscription: true,
+        async login() {
+          throw new Error("Claude Code manages its login. Run `claude auth login` in a terminal; Nyte uses it automatically.");
+        },
+        async refresh(_credential, signal) {
+          const status = await getClaudeStatus2({ ...process.env, ...env }, signal);
+          if (!status.subscription)
+            throw new Error(LOGIN_HINT2);
+          return {
+            type: "oauth",
+            access: "claude-code-external",
+            refresh: "claude-code-external",
+            expires: Date.now() + 365 * 24 * 60 * 60 * 1000
+          };
+        },
+        toAuth: async () => ({})
+      }
+    },
+    getModels() {
+      const builtins = catalog.getModels();
+      routes.restoreAnthropicModels(builtins);
+      if (discovered)
+        return discovered.map(routes.modelFromDiscovery);
+      const models = builtins.map((model) => ({
+        ...model,
+        api: API_ID2,
+        compat: undefined,
+        baseUrl: "process://claude-code"
+      }));
+      const ids = new Set(models.map((model) => model.id));
+      return [...models, ...routes.fallbackClaudeModels().filter((model) => !ids.has(model.id))];
+    },
+    async refreshModels(context) {
+      if (!context.allowNetwork) {
+        await catalog.refreshModels?.(context);
+        return;
+      }
+      const results = await Promise.allSettled([
+        catalog.refreshModels?.(context),
+        discoverClaudeModels2({ ...process.env, ...env }, context.signal).then((next) => context.publish({
+          update: () => {
+            discovered = next;
+          }
+        }))
+      ]);
+      context.signal.throwIfAborted();
+      const discovery = results[1];
+      if (discovery?.status === "rejected")
+        throw discovery.reason;
+    },
+    stream: (model, context, options) => streamClaudeCode2(model, context, {
+      signal: options?.signal,
+      env: options?.env,
+      timeoutMs: options?.timeoutMs,
+      maxTokens: options?.maxTokens,
+      sessionId: options?.sessionId,
+      cacheRetention: options?.cacheRetention
+    }, routes),
+    streamSimple: (model, context, options) => streamClaudeCode2(model, context, options, routes)
+  };
+}
+var claude_code_default = {
+  id: "claude-code",
+  activate({ session, signal }) {
+    const release = acquireSessionResources(session.id);
+    signal.addEventListener("abort", release, { once: true });
+    if (signal.aborted)
+      release();
+  }
+};
+export {
+  claudeCodeProvider,
+  claude_code_default as default
+};

package/dist/examples/claude-code/inert-mcp.d.ts

@@ -0,0 +1 @@
+export declare const INERT_MCP_SOURCE = "#!/usr/bin/env node\nimport { readFile } from \"node:fs/promises\";\nimport { createInterface } from \"node:readline\";\n\nconst manifestPath = process.argv[2];\nif (!manifestPath) process.exit(2);\nconst tools = JSON.parse(await readFile(manifestPath, \"utf8\"));\nconst lines = createInterface({ input: process.stdin, crlfDelay: Infinity });\n\nfor await (const line of lines) {\n  let request;\n  try {\n    request = JSON.parse(line);\n  } catch {\n    continue;\n  }\n\n  let result = {};\n  if (request.method === \"initialize\") {\n    result = {\n      protocolVersion: \"2024-11-05\",\n      capabilities: { tools: {} },\n      serverInfo: { name: \"nyte-inert-tool-inventory\", version: \"1\" },\n    };\n  } else if (request.method === \"tools/list\") {\n    result = { tools };\n  } else if (request.method === \"tools/call\") {\n    result = {\n      isError: true,\n      content: [{ type: \"text\", text: \"Denied: Claude Code tools are inert; only Nyte executes tools.\" }],\n    };\n  }\n\n  if (request.id !== undefined) {\n    process.stdout.write(`${JSON.stringify({ jsonrpc: \"2.0\", id: request.id, result })}\\n`);\n  }\n}\n";

package/dist/examples/claude-code/inert-mcp.js

@@ -0,0 +1,6 @@
+import {
+  INERT_MCP_SOURCE2
+} from "../../chunks/billing-t1qrxe16.js";
+export {
+  INERT_MCP_SOURCE2 as INERT_MCP_SOURCE
+};

package/dist/examples/claude-code/model-catalog.d.ts

@@ -0,0 +1,27 @@
+import type { Model } from "@nyte-ai/ai";
+import { Type } from "typebox";
+import type { Static } from "typebox";
+export declare const PROVIDER_ID = "anthropic";
+export declare const API_ID = "claude-code-stream-json";
+export type ClaudeCodeModel = Model<typeof API_ID>;
+export declare const discoveredModelSchema: Type.TObject<{
+    value: Type.TString;
+    resolvedModel: Type.TOptional<Type.TString>;
+    displayName: Type.TString;
+    description: Type.TString;
+    supportsEffort: Type.TOptional<Type.TBoolean>;
+    supportedEffortLevels: Type.TOptional<Type.TArray<Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"xhigh">, Type.TLiteral<"max">]>>>;
+    supportsAdaptiveThinking: Type.TOptional<Type.TBoolean>;
+    supportsFastMode: Type.TOptional<Type.TBoolean>;
+    supportsAutoMode: Type.TOptional<Type.TBoolean>;
+}>;
+export type DiscoveredClaudeModel = Static<typeof discoveredModelSchema>;
+export declare function createClaudeModelCatalog(): {
+    restoreAnthropicModels: (models: readonly Model<"anthropic-messages">[]) => void;
+    modelFromDiscovery: (info: DiscoveredClaudeModel) => ClaudeCodeModel;
+    fallbackClaudeModels: () => ClaudeCodeModel[];
+    nativeModel: (model: string) => string;
+    supportsAdaptiveThinking: (model: string) => boolean;
+    supportsNativeToolChanges: (model: string) => boolean;
+};
+export type ClaudeModelCatalog = ReturnType<typeof createClaudeModelCatalog>;

package/dist/examples/claude-code/model-catalog.js

@@ -0,0 +1,12 @@
+import {
+  PROVIDER_ID2,
+  API_ID2,
+  discoveredModelSchema2,
+  createClaudeModelCatalog2
+} from "../../chunks/billing-9qc0eqh4.js";
+export {
+  API_ID2 as API_ID,
+  PROVIDER_ID2 as PROVIDER_ID,
+  createClaudeModelCatalog2 as createClaudeModelCatalog,
+  discoveredModelSchema2 as discoveredModelSchema
+};

package/dist/examples/claude-code/process.d.ts

@@ -0,0 +1,22 @@
+import { spawn } from "node:child_process";
+import type { ChildProcess } from "node:child_process";
+import type { DiscoveredClaudeModel } from "./model-catalog.ts";
+import type { JsonRecord } from "./wire.ts";
+export declare const LOGIN_HINT = "Claude Code is installed but not logged in. Run `claude auth login` and try again.";
+export interface ClaudeStatus {
+    available: boolean;
+    loggedIn: boolean;
+    subscription: boolean;
+    authMethod?: string;
+    plan?: string;
+    detail?: string;
+    command?: string;
+}
+export declare function configuredCommand(env: Record<string, string | undefined>): string;
+export declare function getClaudeStatus(envInput?: Record<string, string | undefined>, signal?: AbortSignal): Promise<ClaudeStatus>;
+export declare function readyClaudeCommand(envInput: Record<string, string | undefined>, signal?: AbortSignal): Promise<string>;
+export declare function discoverClaudeModels(envInput?: Record<string, string | undefined>, signal?: AbortSignal, timeoutMs?: number): Promise<DiscoveredClaudeModel[]>;
+export declare function spawnCommand(command: string, args: string[], options: Parameters<typeof spawn>[2]): ChildProcess;
+export declare function childExit(child: ChildProcess): Promise<number>;
+export declare function killProcessTree(child: ChildProcess): void;
+export declare function processEnvironment(input: Record<string, string | undefined> | undefined, extraBody: JsonRecord): Record<string, string>;

package/dist/examples/claude-code/process.js

@@ -0,0 +1,25 @@
+import {
+  LOGIN_HINT2,
+  configuredCommand2,
+  getClaudeStatus2,
+  readyClaudeCommand2,
+  discoverClaudeModels2,
+  spawnCommand2,
+  childExit2,
+  killProcessTree2,
+  processEnvironment2
+} from "../../chunks/billing-cy1rg619.js";
+import"../../chunks/billing-s4rrspsk.js";
+import"../../chunks/billing-9qc0eqh4.js";
+import"../../chunks/billing-0y7dfkp2.js";
+export {
+  LOGIN_HINT2 as LOGIN_HINT,
+  childExit2 as childExit,
+  configuredCommand2 as configuredCommand,
+  discoverClaudeModels2 as discoverClaudeModels,
+  getClaudeStatus2 as getClaudeStatus,
+  killProcessTree2 as killProcessTree,
+  processEnvironment2 as processEnvironment,
+  readyClaudeCommand2 as readyClaudeCommand,
+  spawnCommand2 as spawnCommand
+};

package/dist/examples/claude-code/replay.d.ts

@@ -0,0 +1,4 @@
+import type { NativeSystemInjection } from "./transcript.ts";
+export declare function deriveInitialUserPrefix(body: Buffer | undefined, canonicalContent: unknown[]): unknown[] | undefined;
+export declare function deriveInitialSystemMessages(body: Buffer | undefined): unknown[] | undefined;
+export declare function rewriteInitialRequest(body: Buffer, prefix: unknown[] | undefined, canonicalContent: unknown[], initialSystemMessages: unknown[] | undefined, nativeSystemInjections?: NativeSystemInjection[]): Buffer;

package/dist/examples/claude-code/replay.js

@@ -0,0 +1,11 @@
+import {
+  deriveInitialUserPrefix2,
+  deriveInitialSystemMessages2,
+  rewriteInitialRequest2
+} from "../../chunks/billing-j643d12p.js";
+import"../../chunks/billing-0y7dfkp2.js";
+export {
+  deriveInitialSystemMessages2 as deriveInitialSystemMessages,
+  deriveInitialUserPrefix2 as deriveInitialUserPrefix,
+  rewriteInitialRequest2 as rewriteInitialRequest
+};

package/dist/examples/claude-code/stream.d.ts

@@ -0,0 +1,3 @@
+import type { Api, AssistantMessageEventStream, Model, SimpleStreamOptions, TranscriptContext } from "@nyte-ai/ai";
+import type { ClaudeModelCatalog } from "./model-catalog.ts";
+export declare function streamClaudeCode(model: Model<Api>, context: TranscriptContext, options: SimpleStreamOptions | undefined, catalog: ClaudeModelCatalog): AssistantMessageEventStream;

package/dist/examples/claude-code/stream.js

@@ -0,0 +1,16 @@
+import {
+  streamClaudeCode2
+} from "../../chunks/billing-8rjk35gr.js";
+import"../../chunks/billing-3scqmkzb.js";
+import"../../chunks/billing-ejx2hv52.js";
+import"../../chunks/billing-a9vqn66p.js";
+import"../../chunks/billing-tzr3cebf.js";
+import"../../chunks/billing-t1qrxe16.js";
+import"../../chunks/billing-cy1rg619.js";
+import"../../chunks/billing-s4rrspsk.js";
+import"../../chunks/billing-9qc0eqh4.js";
+import"../../chunks/billing-j643d12p.js";
+import"../../chunks/billing-0y7dfkp2.js";
+export {
+  streamClaudeCode2 as streamClaudeCode
+};

package/dist/examples/claude-code/transcript.d.ts

@@ -0,0 +1,83 @@
+import type { JsonRecord } from "./wire.ts";
+import type { AssistantMessage, Message, SimpleStreamOptions, Tool } from "@nyte-ai/ai";
+import type { NativeFrame, NativeMessage } from "./wire.ts";
+export declare const TOOL_PREFIX = "mcp__nyte__";
+export declare const NATIVE_TOOL_CHANGES_BETA = "mid-conversation-tool-changes-2026-07-01";
+export interface NativeSystemInjection {
+    beforeAssistant: number | null;
+    content: Array<JsonRecord>;
+}
+export interface NativeTranscriptPlan {
+    requestTools: Array<JsonRecord>;
+    systemInjections: NativeSystemInjection[];
+}
+interface AssistantProjection {
+    text: string;
+    toolCalls: Array<{
+        id: string;
+        name: string;
+        input: JsonRecord;
+    }>;
+}
+export declare function getInitialUserPrefix(messages: Message[]): unknown[] | undefined;
+export declare function getInitialSystemMessages(messages: Message[]): unknown[] | undefined;
+export declare function prepareFrames(messages: Message[]): NativeFrame[];
+export interface ToolManifestEntry {
+    name: string;
+    description: string;
+    inputSchema: JsonRecord;
+}
+export declare function prepareTools(tools: Tool[]): {
+    manifest: ToolManifestEntry[];
+    nativeTools: Array<JsonRecord>;
+    names: Set<string>;
+};
+export declare function prepareNativeTranscript(messages: Message[], supported: boolean): NativeTranscriptPlan | undefined;
+export declare function buildExtraBody(nativeTools: Array<JsonRecord>, options: SimpleStreamOptions | undefined, adaptive: boolean): JsonRecord;
+export declare function makeReplayDiagnostic(message: NativeMessage, output: AssistantMessage, initialUserPrefix?: unknown[], initialSystemMessages?: unknown[]): {
+    type: string;
+    timestamp: number;
+    details: {
+        carrier: {
+            initialSystemMessages?: unknown[] | undefined;
+            initialUserPrefix?: unknown[] | undefined;
+            version: number;
+            message: Record<string, unknown> & {
+                id?: string | undefined;
+                usage?: {
+                    cache_creation?: {
+                        ephemeral_1h_input_tokens?: number | undefined;
+                    } | undefined;
+                    cache_read_input_tokens?: number | undefined;
+                    cache_creation_input_tokens?: number | undefined;
+                    output_tokens_details?: {
+                        thinking_tokens?: number | undefined;
+                    } | undefined;
+                    input_tokens: number;
+                    output_tokens: number;
+                } | undefined;
+                stop_sequence?: string | null | undefined;
+                stop_reason?: string | null | undefined;
+                content: ({
+                    type: "text";
+                    text: string;
+                } | {
+                    signature?: string | undefined;
+                    thinking: string;
+                    type: "thinking";
+                } | {
+                    type: "redacted_thinking";
+                    data: string;
+                } | {
+                    id: string;
+                    name: string;
+                    type: "tool_use";
+                    input: Record<string, unknown>;
+                })[];
+                role: "assistant";
+            };
+            projection: AssistantProjection;
+        };
+    };
+};
+export {};

package/dist/examples/claude-code/transcript.js

@@ -0,0 +1,23 @@
+import {
+  TOOL_PREFIX2,
+  NATIVE_TOOL_CHANGES_BETA2,
+  getInitialUserPrefix2,
+  getInitialSystemMessages2,
+  prepareFrames2,
+  prepareTools2,
+  prepareNativeTranscript2,
+  buildExtraBody2,
+  makeReplayDiagnostic2
+} from "../../chunks/billing-ejx2hv52.js";
+import"../../chunks/billing-0y7dfkp2.js";
+export {
+  NATIVE_TOOL_CHANGES_BETA2 as NATIVE_TOOL_CHANGES_BETA,
+  TOOL_PREFIX2 as TOOL_PREFIX,
+  buildExtraBody2 as buildExtraBody,
+  getInitialSystemMessages2 as getInitialSystemMessages,
+  getInitialUserPrefix2 as getInitialUserPrefix,
+  makeReplayDiagnostic2 as makeReplayDiagnostic,
+  prepareFrames2 as prepareFrames,
+  prepareNativeTranscript2 as prepareNativeTranscript,
+  prepareTools2 as prepareTools
+};

package/dist/examples/claude-code/turn-relay.d.ts

@@ -0,0 +1,48 @@
+import type { AnthropicStreamEvent, NativeMessage } from "./wire.ts";
+export declare class AnthropicCapture {
+    message?: NativeMessage;
+    complete: boolean;
+    error?: string;
+    private pending;
+    private readonly decoder;
+    private readonly argumentsByIndex;
+    private readonly onEvent?;
+    constructor(onEvent?: (event: AnthropicStreamEvent) => void);
+    feed(chunk: Uint8Array): void;
+    finish(): void;
+    private consumeFrames;
+    private apply;
+}
+export declare class TurnRelay {
+    capture: AnthropicCapture;
+    used: boolean;
+    denied: number;
+    status?: number;
+    requestId?: string;
+    failure?: string;
+    errorBody: Buffer<ArrayBuffer>;
+    originalRequestBody?: Buffer;
+    requestBody?: Buffer;
+    private readonly upstream;
+    private readonly prefix;
+    private readonly server;
+    private readonly sockets;
+    private readonly active;
+    private cancelled;
+    private closed;
+    private baseUrl?;
+    private transformRequest?;
+    private requestBetas;
+    private readonly timeoutMs;
+    constructor(upstream?: string, timeoutMs?: number, onEvent?: (event: AnthropicStreamEvent) => void, transformRequest?: (body: Buffer) => Buffer, requestBetas?: string[]);
+    beginTurn(onEvent?: (event: AnthropicStreamEvent) => void, transformRequest?: (body: Buffer) => Buffer, requestBetas?: string[]): void;
+    finishTurn(): void;
+    start(): Promise<string>;
+    errorText(): string;
+    abort(): void;
+    settled(): Promise<void>;
+    close(): Promise<void>;
+    private handle;
+    private waitForDrain;
+    private readBody;
+}

package/dist/examples/claude-code/turn-relay.js

@@ -0,0 +1,9 @@
+import {
+  AnthropicCapture2,
+  TurnRelay2
+} from "../../chunks/billing-a9vqn66p.js";
+import"../../chunks/billing-0y7dfkp2.js";
+export {
+  AnthropicCapture2 as AnthropicCapture,
+  TurnRelay2 as TurnRelay
+};