@nyte-ai/plugin 0.0.0-stage → 0.0.18

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
+};

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

@@ -0,0 +1,372 @@
+import { Type } from "typebox";
+import type { Static } from "typebox";
+declare const recordSchema: Type.TRecord<"^.*$", Type.TUnknown>;
+declare const usageSchema: Type.TObject<{
+    input_tokens: Type.TNumber;
+    output_tokens: Type.TNumber;
+    cache_read_input_tokens: Type.TOptional<Type.TNumber>;
+    cache_creation_input_tokens: Type.TOptional<Type.TNumber>;
+    cache_creation: Type.TOptional<Type.TObject<{
+        ephemeral_1h_input_tokens: Type.TOptional<Type.TNumber>;
+    }>>;
+    output_tokens_details: Type.TOptional<Type.TObject<{
+        thinking_tokens: Type.TOptional<Type.TNumber>;
+    }>>;
+}>;
+declare const contentSchema: Type.TUnion<[Type.TObject<{
+    type: Type.TLiteral<"text">;
+    text: Type.TString;
+}>, Type.TObject<{
+    type: Type.TLiteral<"thinking">;
+    thinking: Type.TString;
+    signature: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"redacted_thinking">;
+    data: Type.TString;
+}>, Type.TObject<{
+    type: Type.TLiteral<"tool_use">;
+    id: Type.TString;
+    name: Type.TString;
+    input: Type.TRecord<"^.*$", Type.TUnknown>;
+}>]>;
+export declare const messageSchema: Type.TIntersect<[Type.TRecord<"^.*$", Type.TUnknown>, Type.TObject<{
+    id: Type.TOptional<Type.TString>;
+    role: Type.TLiteral<"assistant">;
+    content: Type.TArray<Type.TUnion<[Type.TObject<{
+        type: Type.TLiteral<"text">;
+        text: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"thinking">;
+        thinking: Type.TString;
+        signature: Type.TOptional<Type.TString>;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"redacted_thinking">;
+        data: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"tool_use">;
+        id: Type.TString;
+        name: Type.TString;
+        input: Type.TRecord<"^.*$", Type.TUnknown>;
+    }>]>>;
+    usage: Type.TOptional<Type.TObject<{
+        input_tokens: Type.TNumber;
+        output_tokens: Type.TNumber;
+        cache_read_input_tokens: Type.TOptional<Type.TNumber>;
+        cache_creation_input_tokens: Type.TOptional<Type.TNumber>;
+        cache_creation: Type.TOptional<Type.TObject<{
+            ephemeral_1h_input_tokens: Type.TOptional<Type.TNumber>;
+        }>>;
+        output_tokens_details: Type.TOptional<Type.TObject<{
+            thinking_tokens: Type.TOptional<Type.TNumber>;
+        }>>;
+    }>>;
+    stop_reason: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    stop_sequence: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+}>]>;
+declare const streamEventSchema: Type.TUnion<[Type.TObject<{
+    type: Type.TLiteral<"message_start">;
+    message: Type.TIntersect<[Type.TRecord<"^.*$", Type.TUnknown>, Type.TObject<{
+        id: Type.TOptional<Type.TString>;
+        role: Type.TLiteral<"assistant">;
+        content: Type.TArray<Type.TUnion<[Type.TObject<{
+            type: Type.TLiteral<"text">;
+            text: Type.TString;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"thinking">;
+            thinking: Type.TString;
+            signature: Type.TOptional<Type.TString>;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"redacted_thinking">;
+            data: Type.TString;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"tool_use">;
+            id: Type.TString;
+            name: Type.TString;
+            input: Type.TRecord<"^.*$", Type.TUnknown>;
+        }>]>>;
+        usage: Type.TOptional<Type.TObject<{
+            input_tokens: Type.TNumber;
+            output_tokens: Type.TNumber;
+            cache_read_input_tokens: Type.TOptional<Type.TNumber>;
+            cache_creation_input_tokens: Type.TOptional<Type.TNumber>;
+            cache_creation: Type.TOptional<Type.TObject<{
+                ephemeral_1h_input_tokens: Type.TOptional<Type.TNumber>;
+            }>>;
+            output_tokens_details: Type.TOptional<Type.TObject<{
+                thinking_tokens: Type.TOptional<Type.TNumber>;
+            }>>;
+        }>>;
+        stop_reason: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+        stop_sequence: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    }>]>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"content_block_start">;
+    index: Type.TInteger;
+    content_block: Type.TUnion<[Type.TObject<{
+        type: Type.TLiteral<"text">;
+        text: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"thinking">;
+        thinking: Type.TString;
+        signature: Type.TOptional<Type.TString>;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"redacted_thinking">;
+        data: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"tool_use">;
+        id: Type.TString;
+        name: Type.TString;
+        input: Type.TRecord<"^.*$", Type.TUnknown>;
+    }>]>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"content_block_delta">;
+    index: Type.TInteger;
+    delta: Type.TUnion<[Type.TObject<{
+        type: Type.TLiteral<"text_delta">;
+        text: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"thinking_delta">;
+        thinking: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"signature_delta">;
+        signature: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"input_json_delta">;
+        partial_json: Type.TString;
+    }>]>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"content_block_stop">;
+    index: Type.TInteger;
+}>, Type.TObject<{
+    type: Type.TLiteral<"message_delta">;
+    delta: Type.TObject<{
+        stop_reason: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+        stop_sequence: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    }>;
+    usage: Type.TOptional<Type.TObject<{
+        input_tokens: Type.TOptional<Type.TNumber>;
+        output_tokens: Type.TOptional<Type.TNumber>;
+        cache_read_input_tokens: Type.TOptional<Type.TNumber>;
+        cache_creation_input_tokens: Type.TOptional<Type.TNumber>;
+        cache_creation: Type.TOptional<Type.TObject<{
+            ephemeral_1h_input_tokens: Type.TOptional<Type.TNumber>;
+        }>>;
+        output_tokens_details: Type.TOptional<Type.TObject<{
+            thinking_tokens: Type.TOptional<Type.TNumber>;
+        }>>;
+    }>>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"message_stop">;
+}>, Type.TObject<{
+    type: Type.TLiteral<"error">;
+    error: Type.TOptional<Type.TObject<{
+        type: Type.TOptional<Type.TString>;
+        message: Type.TOptional<Type.TString>;
+    }>>;
+}>]>;
+declare const outputEventSchema: Type.TUnion<[Type.TObject<{
+    type: Type.TLiteral<"assistant">;
+    message: Type.TIntersect<[Type.TRecord<"^.*$", Type.TUnknown>, Type.TObject<{
+        id: Type.TOptional<Type.TString>;
+        role: Type.TLiteral<"assistant">;
+        content: Type.TArray<Type.TUnion<[Type.TObject<{
+            type: Type.TLiteral<"text">;
+            text: Type.TString;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"thinking">;
+            thinking: Type.TString;
+            signature: Type.TOptional<Type.TString>;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"redacted_thinking">;
+            data: Type.TString;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"tool_use">;
+            id: Type.TString;
+            name: Type.TString;
+            input: Type.TRecord<"^.*$", Type.TUnknown>;
+        }>]>>;
+        usage: Type.TOptional<Type.TObject<{
+            input_tokens: Type.TNumber;
+            output_tokens: Type.TNumber;
+            cache_read_input_tokens: Type.TOptional<Type.TNumber>;
+            cache_creation_input_tokens: Type.TOptional<Type.TNumber>;
+            cache_creation: Type.TOptional<Type.TObject<{
+                ephemeral_1h_input_tokens: Type.TOptional<Type.TNumber>;
+            }>>;
+            output_tokens_details: Type.TOptional<Type.TObject<{
+                thinking_tokens: Type.TOptional<Type.TNumber>;
+            }>>;
+        }>>;
+        stop_reason: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+        stop_sequence: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    }>]>;
+    error: Type.TOptional<Type.TUnknown>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"result">;
+    subtype: Type.TOptional<Type.TString>;
+    is_error: Type.TOptional<Type.TBoolean>;
+    num_turns: Type.TOptional<Type.TNumber>;
+    usage: Type.TOptional<Type.TObject<{
+        input_tokens: Type.TNumber;
+        output_tokens: Type.TNumber;
+        cache_read_input_tokens: Type.TOptional<Type.TNumber>;
+        cache_creation_input_tokens: Type.TOptional<Type.TNumber>;
+        cache_creation: Type.TOptional<Type.TObject<{
+            ephemeral_1h_input_tokens: Type.TOptional<Type.TNumber>;
+        }>>;
+        output_tokens_details: Type.TOptional<Type.TObject<{
+            thinking_tokens: Type.TOptional<Type.TNumber>;
+        }>>;
+    }>>;
+    total_cost_usd: Type.TOptional<Type.TNumber>;
+    modelUsage: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"stream_event">;
+    event: Type.TUnion<[Type.TObject<{
+        type: Type.TLiteral<"message_start">;
+        message: Type.TIntersect<[Type.TRecord<"^.*$", Type.TUnknown>, Type.TObject<{
+            id: Type.TOptional<Type.TString>;
+            role: Type.TLiteral<"assistant">;
+            content: Type.TArray<Type.TUnion<[Type.TObject<{
+                type: Type.TLiteral<"text">;
+                text: Type.TString;
+            }>, Type.TObject<{
+                type: Type.TLiteral<"thinking">;
+                thinking: Type.TString;
+                signature: Type.TOptional<Type.TString>;
+            }>, Type.TObject<{
+                type: Type.TLiteral<"redacted_thinking">;
+                data: Type.TString;
+            }>, Type.TObject<{
+                type: Type.TLiteral<"tool_use">;
+                id: Type.TString;
+                name: Type.TString;
+                input: Type.TRecord<"^.*$", Type.TUnknown>;
+            }>]>>;
+            usage: Type.TOptional<Type.TObject<{
+                input_tokens: Type.TNumber;
+                output_tokens: Type.TNumber;
+                cache_read_input_tokens: Type.TOptional<Type.TNumber>;
+                cache_creation_input_tokens: Type.TOptional<Type.TNumber>;
+                cache_creation: Type.TOptional<Type.TObject<{
+                    ephemeral_1h_input_tokens: Type.TOptional<Type.TNumber>;
+                }>>;
+                output_tokens_details: Type.TOptional<Type.TObject<{
+                    thinking_tokens: Type.TOptional<Type.TNumber>;
+                }>>;
+            }>>;
+            stop_reason: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+            stop_sequence: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+        }>]>;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"content_block_start">;
+        index: Type.TInteger;
+        content_block: Type.TUnion<[Type.TObject<{
+            type: Type.TLiteral<"text">;
+            text: Type.TString;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"thinking">;
+            thinking: Type.TString;
+            signature: Type.TOptional<Type.TString>;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"redacted_thinking">;
+            data: Type.TString;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"tool_use">;
+            id: Type.TString;
+            name: Type.TString;
+            input: Type.TRecord<"^.*$", Type.TUnknown>;
+        }>]>;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"content_block_delta">;
+        index: Type.TInteger;
+        delta: Type.TUnion<[Type.TObject<{
+            type: Type.TLiteral<"text_delta">;
+            text: Type.TString;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"thinking_delta">;
+            thinking: Type.TString;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"signature_delta">;
+            signature: Type.TString;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"input_json_delta">;
+            partial_json: Type.TString;
+        }>]>;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"content_block_stop">;
+        index: Type.TInteger;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"message_delta">;
+        delta: Type.TObject<{
+            stop_reason: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+            stop_sequence: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+        }>;
+        usage: Type.TOptional<Type.TObject<{
+            input_tokens: Type.TOptional<Type.TNumber>;
+            output_tokens: Type.TOptional<Type.TNumber>;
+            cache_read_input_tokens: Type.TOptional<Type.TNumber>;
+            cache_creation_input_tokens: Type.TOptional<Type.TNumber>;
+            cache_creation: Type.TOptional<Type.TObject<{
+                ephemeral_1h_input_tokens: Type.TOptional<Type.TNumber>;
+            }>>;
+            output_tokens_details: Type.TOptional<Type.TObject<{
+                thinking_tokens: Type.TOptional<Type.TNumber>;
+            }>>;
+        }>>;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"message_stop">;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"error">;
+        error: Type.TOptional<Type.TObject<{
+            type: Type.TOptional<Type.TString>;
+            message: Type.TOptional<Type.TString>;
+        }>>;
+    }>]>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"rate_limit_event">;
+    rate_limit_info: Type.TOptional<Type.TObject<{
+        status: Type.TOptional<Type.TString>;
+        rateLimitType: Type.TOptional<Type.TString>;
+        resetsAt: Type.TOptional<Type.TNumber>;
+        isUsingOverage: Type.TOptional<Type.TBoolean>;
+        overageStatus: Type.TOptional<Type.TString>;
+        overageDisabledReason: Type.TOptional<Type.TString>;
+    }>>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"control_response">;
+    response: Type.TRecord<"^.*$", Type.TUnknown>;
+}>]>;
+export type JsonRecord = Static<typeof recordSchema>;
+export type NativeUsage = Static<typeof usageSchema>;
+export type NativeContentBlock = Static<typeof contentSchema>;
+export type NativeMessage = Static<typeof messageSchema>;
+export type AnthropicStreamEvent = Static<typeof streamEventSchema>;
+export type NativeOutputEvent = Static<typeof outputEventSchema>;
+export type NativeResult = Extract<NativeOutputEvent, {
+    type: "result";
+}>;
+export type NativeFrame = {
+    type: "user" | "assistant";
+    message: {
+        role: "user" | "assistant";
+        content: unknown[];
+    };
+    shouldQuery?: false;
+};
+export declare function matchesRecord(value: unknown): value is JsonRecord;
+export declare function parseRecord(text: string): JsonRecord;
+export declare function parseStreamEvent(text: string): AnthropicStreamEvent | undefined;
+export declare function parseOutputEvent(text: string): NativeOutputEvent | undefined;
+export declare function parseRequest(body: Buffer): Record<string, unknown> & {
+    system?: unknown;
+    messages: {
+        content?: unknown;
+        role?: string | undefined;
+    }[];
+};
+export declare function parseRequestMessages(value: unknown): {
+    content?: unknown;
+    role?: string | undefined;
+}[];
+export {};

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

@@ -0,0 +1,18 @@
+import {
+  messageSchema2,
+  matchesRecord2,
+  parseRecord2,
+  parseStreamEvent2,
+  parseOutputEvent2,
+  parseRequest2,
+  parseRequestMessages2
+} from "../../chunks/billing-0y7dfkp2.js";
+export {
+  matchesRecord2 as matchesRecord,
+  messageSchema2 as messageSchema,
+  parseOutputEvent2 as parseOutputEvent,
+  parseRecord2 as parseRecord,
+  parseRequest2 as parseRequest,
+  parseRequestMessages2 as parseRequestMessages,
+  parseStreamEvent2 as parseStreamEvent
+};

package/dist/src/acp/connection.d.ts

@@ -0,0 +1,24 @@
+import type { ExecutionEnv } from "@nyte-ai/core";
+import type { AcpAgent } from "./registry.ts";
+import { AcpThread } from "./thread.ts";
+import type { AcpApprove } from "./thread.ts";
+/**
+ * One agent process, started in a session's environment so the host's
+ * environment, sandbox and login-shell gate apply to it, and the ACP
+ * connection over its stdio. Each `open` starts an ACP session on it.
+ */
+export declare class AcpProcess {
+    #private;
+    readonly agent: AcpAgent;
+    private constructor();
+    /** Starts `agent` through `env.exec` with its stdio kept whole for the protocol, after the process environment is whole. */
+    static start(env: ExecutionEnv, agent: AcpAgent): Promise<AcpProcess>;
+    get closed(): boolean;
+    /** Whether the agent reads image blocks in a prompt. */
+    images(): Promise<boolean>;
+    /** Starts an ACP session in `cwd` whose permission asks go to `approve`; an agent that wants a sign-in first fails with how to give it one. */
+    open(cwd: string, approve: AcpApprove): Promise<AcpThread>;
+    /** Drops a thread Nyte no longer follows, cancelling its turn. */
+    forget(thread: AcpThread): void;
+    close(reason?: Error): void;
+}

package/dist/src/acp/connection.js

@@ -0,0 +1,8 @@
+import {
+  AcpProcess2
+} from "../../chunks/billing-9mfedmsh.js";
+import"../../chunks/billing-svrhh5a5.js";
+import"../../chunks/billing-9nn3yp18.js";
+export {
+  AcpProcess2 as AcpProcess
+};

package/dist/src/acp/index.d.ts

@@ -0,0 +1,54 @@
+import type { Api, Provider } from "@nyte-ai/ai";
+import type { ExecutionEnv, ToolDefinition } from "@nyte-ai/core";
+import type { AcpAgent } from "./registry.ts";
+export type { AcpAgent } from "./registry.ts";
+/**
+ * Agent Client Protocol agents as one model API: each ACP registry agent
+ * installed on this machine is a model of the `acp` provider, run as a
+ * process in the session's environment. Its text and thoughts stream as the
+ * assistant's, each of its tool calls is recorded as a hidden `acp` mirror
+ * call, and a permission it asks for waits until Nyte records that call and
+ * is then decided by `PluginApi.approve` under the call's ACP kind (a call
+ * Nyte settles without running is refused). A stopped run cancels the
+ * agent's turn. Which agents there are, and the command, arguments and
+ * environment each starts with, come from the registry list shipped in
+ * `registry-seed.json` alone, never from the network, so no remote entry
+ * picks what runs on this machine. An installed agent is listed but runs
+ * only once the user picks it, never as a default the host chooses.
+ * `agents`, when given, replaces the registry lookup, as tests do.
+ */
+export declare function acpAgents(options?: {
+    readonly agents?: () => Promise<readonly AcpAgent[]>;
+}): {
+    provider: Provider<Api>;
+    plugin: {
+        id: string;
+        contribute: {
+            tools: ToolDefinition<{
+                id: string;
+                kind: string;
+                title: string;
+                input: Record<string, unknown>;
+                thread: string;
+                paths: string[];
+            }, unknown>[];
+        };
+        activate(api: {
+            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: 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;
+    };
+};