@nyte-ai/plugin 0.0.0-stage → 0.0.18

package/dist/chunks/billing-ye3wk5r3.js

@@ -0,0 +1,205 @@
+// src/claude-code-sdk/translate.ts
+import { calculateCost, parseStreamingJson } from "@nyte-ai/ai";
+var CLAUDE_CODE_PROVIDER2 = "claude-code";
+var MIRROR_TOOL3 = "claude_code";
+var BACKGROUND_TOOL2 = "BackgroundTasks";
+var NYTE_SERVER2 = "nyte";
+var NYTE_TOOL_PREFIX2 = `mcp__${NYTE_SERVER2}__`;
+function emptyMessage3(model) {
+  return {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+    },
+    stopReason: "pending",
+    timestamp: Date.now()
+  };
+}
+function mirrorCall2(id, name, input) {
+  return { type: "toolCall", id, name: MIRROR_TOOL3, arguments: { id, name, input } };
+}
+function stopReason(reason) {
+  if (reason === "tool_use")
+    return "toolUse";
+  if (reason === "max_tokens" || reason === "model_context_window_exceeded")
+    return "length";
+  if (reason === "refusal")
+    return "error";
+  return "stop";
+}
+
+class Translator3 {
+  #blocks = new Map;
+  #model;
+  #output;
+  #stream;
+  #spent = 0;
+  #current = 0;
+  #started = false;
+  constructor(model, output, stream) {
+    this.#model = model;
+    this.#output = output;
+    this.#stream = stream;
+  }
+  apply(event) {
+    switch (event.type) {
+      case "message_start":
+        this.#started = true;
+        this.#blocks.clear();
+        this.#output.responseId = event.message.id;
+        if (event.message.model !== this.#model.id)
+          this.#output.responseModel = event.message.model;
+        this.#usage(event.message.usage);
+        return;
+      case "content_block_start":
+        this.#start(event.index, event.content_block);
+        return;
+      case "content_block_delta":
+        this.#delta(event.index, event.delta);
+        return;
+      case "content_block_stop":
+        return this.#stop(event.index);
+      case "message_delta":
+        if (event.delta.stop_reason !== null) {
+          this.#output.rawStopReason = event.delta.stop_reason;
+          this.#output.stopReason = stopReason(event.delta.stop_reason);
+          if (event.delta.stop_reason === "refusal")
+            this.#output.errorMessage = "The model refused to complete the request.";
+        }
+        this.#usage(event.usage);
+        return;
+      case "message_stop":
+        this.#spent += this.#current;
+        this.#current = 0;
+        return this.#output.rawStopReason ?? "end_turn";
+      default:
+        return;
+    }
+  }
+  append(call) {
+    const contentIndex = this.#output.content.push(call) - 1;
+    this.#stream.push({ type: "toolcall_start", contentIndex, partial: this.#output });
+    this.#stream.push({
+      type: "toolcall_end",
+      contentIndex,
+      toolCall: call,
+      partial: this.#output
+    });
+  }
+  #usage(usage) {
+    const usageOutput = this.#output.usage;
+    if (this.#started) {
+      usageOutput.input = usage.input_tokens ?? usageOutput.input;
+      usageOutput.cacheRead = usage.cache_read_input_tokens ?? usageOutput.cacheRead;
+      usageOutput.cacheWrite = usage.cache_creation_input_tokens ?? usageOutput.cacheWrite;
+    }
+    this.#current = usage.output_tokens ?? this.#current;
+    usageOutput.output = this.#spent + this.#current;
+    usageOutput.totalTokens = usageOutput.input + usageOutput.output + usageOutput.cacheRead + usageOutput.cacheWrite;
+    calculateCost(this.#model, usageOutput);
+  }
+  #start(native, block) {
+    const content = block.type === "text" ? { type: "text", text: block.text } : block.type === "thinking" ? { type: "thinking", thinking: block.thinking, thinkingSignature: block.signature } : block.type === "redacted_thinking" ? {
+      type: "thinking",
+      thinking: "[Reasoning redacted]",
+      thinkingSignature: block.data,
+      redacted: true
+    } : block.type === "tool_use" ? block.name.startsWith(NYTE_TOOL_PREFIX2) ? {
+      type: "toolCall",
+      id: block.id,
+      name: block.name.slice(NYTE_TOOL_PREFIX2.length),
+      arguments: {}
+    } : mirrorCall2(block.id, block.name, {}) : undefined;
+    if (content === undefined)
+      return;
+    const index = this.#output.content.push(content) - 1;
+    this.#blocks.set(native, { index, json: "" });
+    this.#stream.push({
+      type: content.type === "text" ? "text_start" : content.type === "thinking" ? "thinking_start" : "toolcall_start",
+      contentIndex: index,
+      partial: this.#output
+    });
+  }
+  #delta(native, delta) {
+    const slot = this.#blocks.get(native);
+    if (slot === undefined)
+      return;
+    const content = this.#output.content[slot.index];
+    const contentIndex = slot.index;
+    if (delta.type === "text_delta" && content?.type === "text") {
+      content.text += delta.text;
+      this.#stream.push({
+        type: "text_delta",
+        contentIndex,
+        delta: delta.text,
+        partial: this.#output
+      });
+    } else if (delta.type === "thinking_delta" && content?.type === "thinking") {
+      content.thinking += delta.thinking;
+      this.#stream.push({
+        type: "thinking_delta",
+        contentIndex,
+        delta: delta.thinking,
+        partial: this.#output
+      });
+    } else if (delta.type === "signature_delta" && content?.type === "thinking") {
+      content.thinkingSignature = (content.thinkingSignature ?? "") + delta.signature;
+    } else if (delta.type === "input_json_delta" && content?.type === "toolCall") {
+      slot.json += delta.partial_json;
+      const input = parseStreamingJson(slot.json);
+      content.arguments = content.name === MIRROR_TOOL3 ? { ...content.arguments, input } : input;
+      this.#stream.push({
+        type: "toolcall_delta",
+        contentIndex,
+        delta: delta.partial_json,
+        partial: this.#output
+      });
+    }
+  }
+  #stop(native) {
+    const slot = this.#blocks.get(native);
+    if (slot === undefined)
+      return;
+    this.#blocks.delete(native);
+    const content = this.#output.content[slot.index];
+    const contentIndex = slot.index;
+    if (content?.type === "text")
+      this.#stream.push({
+        type: "text_end",
+        contentIndex,
+        content: content.text,
+        partial: this.#output
+      });
+    else if (content?.type === "thinking")
+      this.#stream.push({
+        type: "thinking_end",
+        contentIndex,
+        content: content.thinking,
+        partial: this.#output
+      });
+    else if (content?.type === "toolCall") {
+      this.#stream.push({
+        type: "toolcall_end",
+        contentIndex,
+        toolCall: content,
+        partial: this.#output
+      });
+      if (content.name !== MIRROR_TOOL3) {
+        this.#output.stopReason = "toolUse";
+        return "tool_use";
+      }
+    }
+    return;
+  }
+}
+
+export { CLAUDE_CODE_PROVIDER2, MIRROR_TOOL3, BACKGROUND_TOOL2, NYTE_SERVER2, NYTE_TOOL_PREFIX2, emptyMessage3, mirrorCall2, Translator3 };

package/dist/chunks/billing-zfpm2rt0.js

@@ -0,0 +1,29 @@
+// src/canvas/canvas-libraries.ts
+var CANVAS_LIBRARIES2 = {
+  three: {
+    version: "0.186.1",
+    exports: "ACESFilmicToneMapping AddEquation AddOperation AdditiveAnimationBlendMode AdditiveBlending AgXToneMapping AlphaFormat AlwaysCompare AlwaysDepth AlwaysStencilFunc AmbientLight AnimationAction AnimationClip AnimationLoader AnimationMixer AnimationObjectGroup AnimationUtils ArcCurve ArrayCamera ArrowHelper AttachedBindMode Audio AudioAnalyser AudioContext AudioListener AudioLoader AxesHelper BackSide BasicDepthPacking BasicShadowMap BatchedMesh BezierInterpolant Bone BooleanKeyframeTrack Box2 Box3 Box3Helper BoxGeometry BoxHelper BufferAttribute BufferGeometry BufferGeometryLoader ByteType Cache Camera CameraHelper CanvasTexture CapsuleGeometry CatmullRomCurve3 CineonToneMapping CircleGeometry ClampToEdgeWrapping Clock Color ColorKeyframeTrack ColorManagement Compatibility CompressedArrayTexture CompressedCubeTexture CompressedTexture CompressedTextureLoader ConeGeometry ConstantAlphaFactor ConstantColorFactor Controls CubeCamera CubeDepthTexture CubeReflectionMapping CubeRefractionMapping CubeTexture CubeTextureLoader CubeUVReflectionMapping CubicBezierCurve CubicBezierCurve3 CubicInterpolant CullFaceBack CullFaceFront CullFaceFrontBack CullFaceNone Curve CurvePath CustomBlending CustomToneMapping CylinderGeometry Cylindrical Data3DTexture DataArrayTexture DataTexture DataTextureLoader DataUtils DecrementStencilOp DecrementWrapStencilOp DefaultLoadingManager DepthFormat DepthStencilFormat DepthTexture DetachedBindMode DirectionalLight DirectionalLightHelper DiscreteInterpolant DodecahedronGeometry DoubleSide DstAlphaFactor DstColorFactor DynamicCopyUsage DynamicDrawUsage DynamicReadUsage EdgesGeometry EllipseCurve EqualCompare EqualDepth EqualStencilFunc EquirectangularReflectionMapping EquirectangularRefractionMapping Euler EventDispatcher ExternalTexture ExtrudeGeometry FileLoader Float16BufferAttribute Float32BufferAttribute FloatType Fog FogExp2 FramebufferTexture FrontSide Frustum FrustumArray GLBufferAttribute GLSL1 GLSL3 GreaterCompare GreaterDepth GreaterEqualCompare GreaterEqualDepth GreaterEqualStencilFunc GreaterStencilFunc GridHelper Group HTMLTexture HalfFloatType HemisphereLight HemisphereLightHelper IcosahedronGeometry ImageBitmapLoader ImageLoader ImageUtils IncrementStencilOp IncrementWrapStencilOp InstancedBufferAttribute InstancedBufferGeometry InstancedInterleavedBuffer InstancedMesh Int16BufferAttribute Int32BufferAttribute Int8BufferAttribute IntType InterleavedBuffer InterleavedBufferAttribute Interpolant InterpolateBezier InterpolateDiscrete InterpolateLinear InterpolateSmooth InterpolationSamplingMode InterpolationSamplingType InvertStencilOp KeepStencilOp KeyframeTrack LOD LatheGeometry Layers LessCompare LessDepth LessEqualCompare LessEqualDepth LessEqualStencilFunc LessStencilFunc Light LightProbe LightShadow Line Line3 LineBasicMaterial LineCurve LineCurve3 LineDashedMaterial LineLoop LineSegments LinearFilter LinearInterpolant LinearMipMapLinearFilter LinearMipMapNearestFilter LinearMipmapLinearFilter LinearMipmapNearestFilter LinearSRGBColorSpace LinearToneMapping LinearTransfer Loader LoaderUtils LoadingManager LoopOnce LoopPingPong LoopRepeat MOUSE Material MaterialBlending MaterialLoader MathUtils Matrix2 Matrix3 Matrix4 MaxEquation Mesh MeshBasicMaterial MeshDepthMaterial MeshDistanceMaterial MeshLambertMaterial MeshMatcapMaterial MeshNormalMaterial MeshPhongMaterial MeshPhysicalMaterial MeshStandardMaterial MeshToonMaterial MinEquation MirroredRepeatWrapping MixOperation MultiplyBlending MultiplyOperation NearestFilter NearestMipMapLinearFilter NearestMipMapNearestFilter NearestMipmapLinearFilter NearestMipmapNearestFilter NeutralToneMapping NeverCompare NeverDepth NeverStencilFunc NoBlending NoColorSpace NoNormalPacking NoToneMapping NormalAnimationBlendMode NormalBlending NormalGAPacking NormalRGPacking NotEqualCompare NotEqualDepth NotEqualStencilFunc NumberKeyframeTrack Object3D ObjectLoader ObjectSpaceNormalMap OctahedronGeometry OneFactor OneMinusConstantAlphaFactor OneMinusConstantColorFactor OneMinusDstAlphaFactor OneMinusDstColorFactor OneMinusSrcAlphaFactor OneMinusSrcColorFactor OrthographicCamera PCFShadowMap PCFSoftShadowMap PMREMGenerator Path PerspectiveCamera Plane PlaneGeometry PlaneHelper PointLight PointLightHelper Points PointsMaterial PolarGridHelper PolyhedronGeometry PositionalAudio PropertyBinding PropertyMixer QuadraticBezierCurve QuadraticBezierCurve3 Quaternion QuaternionKeyframeTrack QuaternionLinearInterpolant R11_EAC_Format RED_GREEN_RGTC2_Format RED_RGTC1_Format REVISION RG11_EAC_Format RGBADepthPacking RGBAFormat RGBAIntegerFormat RGBA_ASTC_10x10_Format RGBA_ASTC_10x5_Format RGBA_ASTC_10x6_Format RGBA_ASTC_10x8_Format RGBA_ASTC_12x10_Format RGBA_ASTC_12x12_Format RGBA_ASTC_4x4_Format RGBA_ASTC_5x4_Format RGBA_ASTC_5x5_Format RGBA_ASTC_6x5_Format RGBA_ASTC_6x6_Format RGBA_ASTC_8x5_Format RGBA_ASTC_8x6_Format RGBA_ASTC_8x8_Format RGBA_BPTC_Format RGBA_ETC2_EAC_Format RGBA_PVRTC_2BPPV1_Format RGBA_PVRTC_4BPPV1_Format RGBA_S3TC_DXT1_Format RGBA_S3TC_DXT3_Format RGBA_S3TC_DXT5_Format RGBDepthPacking RGBFormat RGBIntegerFormat RGB_BPTC_SIGNED_Format RGB_BPTC_UNSIGNED_Format RGB_ETC1_Format RGB_ETC2_Format RGB_PVRTC_2BPPV1_Format RGB_PVRTC_4BPPV1_Format RGB_S3TC_DXT1_Format RGDepthPacking RGFormat RGIntegerFormat RawShaderMaterial Ray Raycaster RectAreaLight RedFormat RedIntegerFormat ReinhardToneMapping RenderObjectRefreshType RenderTarget RenderTarget3D RepeatWrapping ReplaceStencilOp ReverseSubtractEquation RingGeometry SIGNED_R11_EAC_Format SIGNED_RED_GREEN_RGTC2_Format SIGNED_RED_RGTC1_Format SIGNED_RG11_EAC_Format SRGBColorSpace SRGBTransfer Scene ShaderChunk ShaderLib ShaderMaterial ShadowMaterial Shape ShapeGeometry ShapePath ShapeUtils ShortType Skeleton SkeletonHelper SkinnedMesh Source Sphere SphereGeometry Spherical SphericalHarmonics3 SplineCurve SpotLight SpotLightHelper Sprite SpriteMaterial SrcAlphaFactor SrcAlphaSaturateFactor SrcColorFactor StaticCopyUsage StaticDrawUsage StaticReadUsage StereoCamera StreamCopyUsage StreamDrawUsage StreamReadUsage StringKeyframeTrack SubtractEquation SubtractiveBlending TOUCH TangentSpaceNormalMap TetrahedronGeometry Texture TextureLoader TextureSource TextureUtils Timer TimestampQuery TorusGeometry TorusKnotGeometry Triangle TriangleFanDrawMode TriangleStripDrawMode TrianglesDrawMode TubeGeometry UVMapping Uint16BufferAttribute Uint32BufferAttribute Uint8BufferAttribute Uint8ClampedBufferAttribute Uniform UniformsGroup UniformsLib UniformsUtils UnsignedByteType UnsignedInt101111Type UnsignedInt248Type UnsignedInt5999Type UnsignedIntType UnsignedShort4444Type UnsignedShort5551Type UnsignedShortType VSMShadowMap Vector2 Vector3 Vector4 VectorKeyframeTrack VideoFrameTexture VideoTexture WebGL3DRenderTarget WebGLArrayRenderTarget WebGLCoordinateSystem WebGLCubeRenderTarget WebGLRenderTarget WebGLRenderer WebGLUtils WebGPUCoordinateSystem WebXRController WireframeGeometry WrapAroundEnding ZeroCurvatureEnding ZeroFactor ZeroSlopeEnding ZeroStencilOp createCanvasElement error getConsoleFunction log setConsoleFunction warn warnOnce"
+  },
+  "d3-array": {
+    version: "3.2.4",
+    exports: "Adder InternMap InternSet ascending bin bisect bisectCenter bisectLeft bisectRight bisector blur blur2 blurImage count cross cumsum descending deviation difference disjoint every extent fcumsum filter flatGroup flatRollup fsum greatest greatestIndex group groupSort groups histogram index indexes intersection least leastIndex map max maxIndex mean median medianIndex merge min minIndex mode nice pairs permute quantile quantileIndex quantileSorted quickselect range rank reduce reverse rollup rollups scan shuffle shuffler some sort subset sum superset thresholdFreedmanDiaconis thresholdScott thresholdSturges tickIncrement tickStep ticks transpose union variance zip"
+  },
+  "d3-scale": {
+    version: "4.0.2",
+    exports: "scaleBand scaleDiverging scaleDivergingLog scaleDivergingPow scaleDivergingSqrt scaleDivergingSymlog scaleIdentity scaleImplicit scaleLinear scaleLog scaleOrdinal scalePoint scalePow scaleQuantile scaleQuantize scaleRadial scaleSequential scaleSequentialLog scaleSequentialPow scaleSequentialQuantile scaleSequentialSqrt scaleSequentialSymlog scaleSqrt scaleSymlog scaleThreshold scaleTime scaleUtc tickFormat"
+  },
+  "d3-shape": {
+    version: "3.2.0",
+    exports: "arc area areaRadial curveBasis curveBasisClosed curveBasisOpen curveBumpX curveBumpY curveBundle curveCardinal curveCardinalClosed curveCardinalOpen curveCatmullRom curveCatmullRomClosed curveCatmullRomOpen curveLinear curveLinearClosed curveMonotoneX curveMonotoneY curveNatural curveStep curveStepAfter curveStepBefore line lineRadial link linkHorizontal linkRadial linkVertical pie pointRadial radialArea radialLine stack stackOffsetDiverging stackOffsetExpand stackOffsetNone stackOffsetSilhouette stackOffsetWiggle stackOrderAppearance stackOrderAscending stackOrderDescending stackOrderInsideOut stackOrderNone stackOrderReverse symbol symbolAsterisk symbolCircle symbolCross symbolDiamond symbolDiamond2 symbolPlus symbolSquare symbolSquare2 symbolStar symbolTimes symbolTriangle symbolTriangle2 symbolWye symbolX symbols symbolsFill symbolsStroke"
+  },
+  "d3-hierarchy": {
+    version: "3.1.2",
+    exports: "Node cluster hierarchy pack packEnclose packSiblings partition stratify tree treemap treemapBinary treemapDice treemapResquarify treemapSlice treemapSliceDice treemapSquarify"
+  },
+  "d3-force": {
+    version: "3.0.0",
+    exports: "forceCenter forceCollide forceLink forceManyBody forceRadial forceSimulation forceX forceY"
+  }
+};
+
+export { CANVAS_LIBRARIES2 };

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;