@nyte-ai/plugin 0.0.0-stage → 0.0.18

package/dist/src/claude-code-sdk/index.js

@@ -0,0 +1,368 @@
+import {
+  answerInput2
+} from "../../chunks/billing-6z2kgtyt.js";
+import {
+  question2
+} from "../../chunks/billing-3j77ss7y.js";
+import {
+  CLAUDE_CODE_PROVIDER2,
+  MIRROR_TOOL3,
+  BACKGROUND_TOOL2,
+  emptyMessage3,
+  Translator3
+} from "../../chunks/billing-ye3wk5r3.js";
+import {
+  ClaudeCodeSession2
+} from "../../chunks/billing-wmkxkypm.js";
+import {
+  mirrorArguments3,
+  userBlocks3,
+  messageKey3,
+  sessionEntries2,
+  flatPrompt2
+} from "../../chunks/billing-2v3g7rd9.js";
+
+// src/claude-code-sdk/index.ts
+import { randomUUID } from "node:crypto";
+import { access } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import {
+  acquireSessionResources,
+  anthropicProvider,
+  clampThinkingLevel,
+  createAssistantMessageEventStream,
+  getCurrentTools,
+  getCurrentSystemPrompt,
+  lazyStream,
+  registerSessionResourceCleanup
+} from "@nyte-ai/ai";
+import { processEnvironment } from "@nyte-ai/core";
+import { standard } from "@nyte-ai/schema";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var API = "claude-agent-sdk";
+var EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+var NOT_RUNNING = "Claude Code is no longer running this turn. Send a message to continue.";
+var CLAUDE_CODE_HAS_ITS_OWN = new Set([
+  "read",
+  "write",
+  "edit",
+  "list",
+  "bash",
+  "web_search",
+  "question"
+]);
+var ultracodeSetting = {
+  id: "claude_code.ultracode",
+  label: "Claude Code ultracode",
+  schema: standard(Type.Boolean()),
+  choices: [
+    { value: false, label: "Off" },
+    { value: true, label: "On", badge: "ultracode" }
+  ],
+  default: false,
+  scope: "session"
+};
+function effortFor(model, reasoning) {
+  if (reasoning === undefined)
+    return;
+  const level = clampThinkingLevel(model, reasoning);
+  if (level === "off")
+    return;
+  const mapped = model.thinkingLevelMap?.[level] ?? level;
+  return EFFORTS.find((effort) => effort === mapped) ?? (level === "minimal" ? "low" : undefined);
+}
+async function claudeCodeConfigured() {
+  try {
+    await access(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function answerOnce(start, model, context, options) {
+  const stream = createAssistantMessageEventStream();
+  const output = emptyMessage3(model);
+  const translator = new Translator3(model, output, stream);
+  const controller = new AbortController;
+  const abort = () => controller.abort();
+  options?.signal?.addEventListener("abort", abort, { once: true });
+  (async () => {
+    try {
+      stream.push({ type: "start", partial: output });
+      await processEnvironment();
+      for await (const message of start({
+        prompt: flatPrompt2(context.messages),
+        options: {
+          model: model.id,
+          abortController: controller,
+          systemPrompt: getCurrentSystemPrompt(context.messages),
+          tools: [],
+          settingSources: [],
+          strictMcpConfig: true,
+          maxTurns: 1,
+          persistSession: false,
+          includePartialMessages: true,
+          thinking: { type: "disabled" },
+          env: { ...process.env, ...options?.env }
+        }
+      })) {
+        if (message.type === "stream_event" && message.parent_tool_use_id === null)
+          translator.apply(message.event);
+        else if (message.type === "result" && message.subtype !== "success")
+          throw new Error(message.errors.join(`
+`) || `Claude Code failed: ${message.subtype}`);
+      }
+      if (output.stopReason === "pending" || output.stopReason === "aborted")
+        throw new Error("Claude Code ended without a response.");
+      if (output.stopReason === "error")
+        throw new Error(output.errorMessage ?? "Claude Code failed.");
+      stream.push({ type: "done", reason: output.stopReason, message: output });
+    } catch (error) {
+      output.stopReason = options?.signal?.aborted === true ? "aborted" : "error";
+      output.errorMessage = error instanceof Error ? error.message : String(error);
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+    } finally {
+      options?.signal?.removeEventListener("abort", abort);
+      stream.end();
+    }
+  })();
+  return stream;
+}
+var nonEmpty = Type.String({ minLength: 1 });
+function field(input, key) {
+  const value = input[key];
+  return Value.Check(nonEmpty, value) ? value : undefined;
+}
+var claudeQuestions = Type.Array(Type.Object({
+  question: Type.String(),
+  header: Type.String(),
+  options: Type.Array(Type.Object({ label: Type.String(), description: Type.String() })),
+  multiSelect: Type.Optional(Type.Boolean())
+}));
+async function askUser(session, id, input, invocation) {
+  if (!Value.Check(claudeQuestions, input.questions))
+    return { answers: null, part: null };
+  const questions = input.questions.map((item) => ({
+    question: item.question,
+    header: item.header.slice(0, 30),
+    options: item.options.map(({ label, description }) => ({ label, description })),
+    multiple: item.multiSelect === true
+  }));
+  const part = await invocation.session.parts.create(question2, {
+    state: { questions, answers: null },
+    placement: { kind: "modal" }
+  });
+  const outcome = await invocation.wait({ kind: "part", part: part.id });
+  const checked = outcome.kind === "part" && outcome.answer?.action === "answer" ? await answerInput2["~standard"].validate(outcome.answer.input) : undefined;
+  if (checked === undefined || checked.issues !== undefined)
+    return { answers: null, part: part.id };
+  const answers = questions.flatMap((item, index) => {
+    const chosen = checked.value.answers[index]?.join(", ") ?? "";
+    return chosen === "" ? [] : [[item.question, chosen]];
+  });
+  return { answers: answers.length === 0 ? null : Object.fromEntries(answers), part: part.id };
+}
+function classifyClaudeTool(name, input) {
+  const path = field(input, "file_path") ?? field(input, "notebook_path");
+  const command = field(input, "command");
+  const description = field(input, "description");
+  switch (name) {
+    case "Read":
+      return path === undefined ? { kind: "custom", label: name } : { kind: "read", path };
+    case "Edit":
+    case "MultiEdit":
+    case "Write":
+    case "NotebookEdit":
+      return path === undefined ? { kind: "custom", label: name } : { kind: "edit", path };
+    case "Bash":
+      if (command === undefined)
+        return { kind: "custom", label: name };
+      return description === undefined ? { kind: "shell", command } : { kind: "shell", command, description };
+    case "Agent":
+    case "Task":
+      return {
+        kind: "delegate",
+        child: null,
+        role: "task",
+        title: description ?? null
+      };
+    case "Skill":
+      return { kind: "custom", label: `Skill ${field(input, "skill") ?? ""}`.trim() };
+    case "Workflow":
+      return {
+        kind: "custom",
+        label: `Workflow ${field(input, "title") ?? field(input, "name") ?? ""}`.trim()
+      };
+    case "AskUserQuestion": {
+      const headers = Value.Check(claudeQuestions, input.questions) ? input.questions.map((item) => item.header).join(", ") : "";
+      return { kind: "custom", label: `Asking ${headers}`.trim() };
+    }
+    case BACKGROUND_TOOL2:
+      return { kind: "custom", label: "Waiting for background work" };
+    default: {
+      const subject = field(input, "pattern") ?? field(input, "url") ?? field(input, "query");
+      return { kind: "custom", label: subject === undefined ? name : `${name} ${subject}` };
+    }
+  }
+}
+function mirrorTool(sessions) {
+  return {
+    name: MIRROR_TOOL3,
+    description: "A tool Claude Code ran. Claude Code reports the result; Nyte records it.",
+    parameters: standard(mirrorArguments3),
+    exposure: "hidden",
+    approval: "runtime",
+    replay: "safe",
+    class: ({ name, input }) => classifyClaudeTool(name, input),
+    async execute({ id, name, input }, invocation) {
+      const session = sessions.get(invocation.session.id);
+      if (session === undefined || session.closed)
+        throw new Error(NOT_RUNNING);
+      if (name === BACKGROUND_TOOL2)
+        return { content: [{ kind: "text", text: await session.background(invocation.signal) }] };
+      session.recording(id);
+      let parts = [];
+      if (name === "AskUserQuestion") {
+        const asked = await askUser(session, id, input, invocation);
+        session.answer(id, asked.answers);
+        parts = asked.part === null ? [] : [asked.part];
+      }
+      const output = await session.result(id, invocation.signal);
+      if (output.isError)
+        throw new Error(output.text);
+      return { content: [{ kind: "text", text: output.text }], parts };
+    }
+  };
+}
+function claudeCodeSdk(start = query) {
+  const catalog = anthropicProvider();
+  const sessions = new Map;
+  const bindings = new Map;
+  registerSessionResourceCleanup((id) => {
+    for (const [key, session] of sessions) {
+      if (id !== undefined && key !== id)
+        continue;
+      sessions.delete(key);
+      session.close();
+    }
+  });
+  async function respond(model, context, options) {
+    const id = options?.sessionId;
+    const binding = id === undefined ? undefined : bindings.get(id);
+    if (id === undefined || binding === undefined)
+      throw new Error("Claude Code answers inside a Nyte session with the claude-code-sdk plugin.");
+    const effort = effortFor(model, options?.reasoning);
+    const ultracode = await binding.ultracode();
+    const key = JSON.stringify([model.id, binding.cwd, options?.reasoning !== undefined]);
+    const messages = context.messages.filter((message) => message.role !== "system");
+    const keys = messages.map(messageKey3);
+    const tools = getCurrentTools(context.messages).filter((tool) => !CLAUDE_CODE_HAS_ITS_OWN.has(tool.name));
+    let session = sessions.get(id);
+    const continues = session !== undefined && !session.closed && !session.asking && session.key === key && session.known.length < keys.length && session.known.every((known, index) => keys[index] === known);
+    const prompt = messages.slice(messages.findLastIndex((message) => message.role !== "user") + 1);
+    if (!continues) {
+      session?.close();
+      if (prompt.length === 0)
+        throw new Error(NOT_RUNNING);
+      await processEnvironment();
+      const claudeSession = randomUUID();
+      session = new ClaudeCodeSession2({
+        key,
+        model: model.id,
+        cwd: binding.cwd,
+        thinking: options?.reasoning !== undefined,
+        effort,
+        ultracode,
+        env: options?.env,
+        session: claudeSession,
+        history: sessionEntries2(messages.slice(0, -prompt.length), {
+          session: claudeSession,
+          model: model.id,
+          cwd: binding.cwd
+        }),
+        tools,
+        query: start,
+        approve: binding.approve
+      });
+      sessions.set(id, session);
+    }
+    if (session === undefined)
+      throw new Error(NOT_RUNNING);
+    session.expose(tools);
+    session.deliver(messages);
+    await session.configure(effort, ultracode);
+    if (prompt.length > 0)
+      session.send(prompt.flatMap((message) => message.role === "user" ? userBlocks3(message) : []));
+    const live = session;
+    const stream = live.respond(model, options?.signal);
+    stream.result().then((message) => {
+      live.known = message.stopReason === "error" || message.stopReason === "aborted" ? [] : [...keys, messageKey3(message)];
+    });
+    return stream;
+  }
+  const stream = (model, context, options) => getCurrentTools(context.messages).length === 0 ? answerOnce(start, model, context, options) : lazyStream(model, () => respond(model, context, options));
+  const provider = {
+    id: CLAUDE_CODE_PROVIDER2,
+    name: "Claude Code",
+    baseUrl: "process://claude-code",
+    capabilities: { steer: true },
+    auth: {
+      apiKey: {
+        name: "Claude Code login",
+        resolve: async ({ signal }) => {
+          signal.throwIfAborted();
+          return await claudeCodeConfigured() ? { auth: {}, source: "Claude Code login" } : undefined;
+        }
+      }
+    },
+    getModels: () => catalog.getModels().map(({ compat: _compat, ...model }) => ({
+      ...model,
+      provider: CLAUDE_CODE_PROVIDER2,
+      api: API,
+      baseUrl: "process://claude-code"
+    })),
+    refreshModels: async (context) => {
+      await catalog.refreshModels?.(context);
+    },
+    stream: (model, context, options) => stream(model, context, {
+      signal: options?.signal,
+      sessionId: options?.sessionId,
+      env: options?.env
+    }),
+    streamSimple: stream
+  };
+  const plugin = {
+    id: "claude-code-sdk",
+    contribute: { tools: [mirrorTool(sessions)], settings: [ultracodeSetting] },
+    activate(api) {
+      const id = api.session.id;
+      const binding = {
+        cwd: api.env.cwd,
+        ultracode: async () => await api.contribute.settings.value(ultracodeSetting.id) === true,
+        approve: async (name, input, signal) => {
+          const verdict = await api.approve({ name, class: classifyClaudeTool(name, input) }, signal);
+          return verdict.kind === "allow" ? { behavior: "allow" } : { behavior: "deny", message: verdict.reason };
+        }
+      };
+      const release = acquireSessionResources(id);
+      bindings.set(id, binding);
+      const unbind = () => {
+        if (bindings.get(id) === binding)
+          bindings.delete(id);
+        release();
+      };
+      if (api.signal.aborted)
+        unbind();
+      else
+        api.signal.addEventListener("abort", unbind, { once: true });
+    }
+  };
+  return { provider, plugin };
+}
+export {
+  claudeCodeSdk,
+  ultracodeSetting
+};

package/dist/src/claude-code-sdk/session.d.ts

@@ -0,0 +1,48 @@
+import type { CanUseTool, EffortLevel, PermissionResult, Query, SDKMessage, SessionStoreEntry, query } from "@anthropic-ai/claude-agent-sdk";
+import type { Api, AssistantMessageEventStream, Message, Model, Tool } from "@nyte-ai/ai";
+import type { ContentBlock } from "./transcript.ts";
+interface Launch {
+    readonly key: string;
+    readonly model: string;
+    readonly cwd: string;
+    readonly thinking: boolean;
+    readonly effort: EffortLevel | undefined;
+    readonly ultracode: boolean;
+    readonly env: Record<string, string | undefined> | undefined;
+    readonly session: string;
+    readonly history: readonly SessionStoreEntry[];
+    readonly tools: readonly Tool[];
+    readonly query: StartQuery;
+    readonly approve: Approve;
+}
+/** Decides a call Claude Code asks to run under Nyte's permissions policy, by the tool's own name. */
+export type Approve = (name: string, input: Parameters<CanUseTool>[1], signal: AbortSignal) => Promise<PermissionResult>;
+/** Starts Claude Code: the Agent SDK's `query`, or a stand-in with the parts of its `Query` a session uses. */
+export type StartQuery = (params: Parameters<typeof query>[0]) => AsyncIterable<SDKMessage> & Pick<Query, "applyFlagSettings" | "close">;
+export type QuestionAnswers = Record<string, string> | null;
+interface ClaudeToolOutput {
+    readonly text: string;
+    readonly isError: boolean;
+}
+export declare class ClaudeCodeSession {
+    #private;
+    readonly key: string;
+    known: readonly string[];
+    constructor(launch: Launch);
+    get closed(): boolean;
+    configure(effort: EffortLevel | undefined, ultracode: boolean): Promise<void>;
+    /** Serves `tools` as the Nyte MCP server's tools from now on, telling Claude Code when they changed. */
+    expose(tools: readonly Tool[]): void;
+    /** Answers Claude Code from Nyte's tool results: a Nyte tool call gets its result, and a call Claude Code asked to run but Nyte settled without running it is denied with that result. */
+    deliver(messages: readonly Message[]): void;
+    /** Lets Claude Code's call `id` go on to its approval now that Nyte records it (so the workspace snapshot before it is taken), and denies the calls before it in the same message that Nyte settled without running. */
+    recording(id: string): void;
+    send(content: readonly ContentBlock[]): void;
+    respond(model: Model<Api>, signal: AbortSignal | undefined): AssistantMessageEventStream;
+    get asking(): boolean;
+    answer(id: string, answers: QuestionAnswers): void;
+    result(id: string, signal: AbortSignal): Promise<ClaudeToolOutput>;
+    background(signal: AbortSignal): Promise<string>;
+    close(reason?: Error): void;
+}
+export {};

package/dist/src/claude-code-sdk/session.js

@@ -0,0 +1,7 @@
+import {
+  ClaudeCodeSession2
+} from "../../chunks/billing-wmkxkypm.js";
+import"../../chunks/billing-ye3wk5r3.js";
+export {
+  ClaudeCodeSession2 as ClaudeCodeSession
+};

package/dist/src/claude-code-sdk/transcript.d.ts

@@ -0,0 +1,19 @@
+import type { SDKUserMessage, SessionStoreEntry } from "@anthropic-ai/claude-agent-sdk";
+import type { Message, UserMessage } from "@nyte-ai/ai";
+import { Type } from "typebox";
+type MessageParam = SDKUserMessage["message"];
+export type ContentBlock = Exclude<MessageParam["content"], string>[number];
+export declare const mirrorArguments: Type.TObject<{
+    id: Type.TString;
+    name: Type.TString;
+    input: Type.TRecord<"^.*$", Type.TUnknown>;
+}>;
+export declare function userBlocks(message: UserMessage): ContentBlock[];
+export declare function messageKey(message: Message): string;
+export declare function sessionEntries(messages: readonly Message[], input: {
+    readonly session: string;
+    readonly model: string;
+    readonly cwd: string;
+}): SessionStoreEntry[];
+export declare function flatPrompt(messages: readonly Message[]): string;
+export {};

package/dist/src/claude-code-sdk/transcript.js

@@ -0,0 +1,15 @@
+import {
+  mirrorArguments3,
+  userBlocks3,
+  messageKey3,
+  sessionEntries2,
+  flatPrompt2
+} from "../../chunks/billing-2v3g7rd9.js";
+import"../../chunks/billing-ye3wk5r3.js";
+export {
+  flatPrompt2 as flatPrompt,
+  messageKey3 as messageKey,
+  mirrorArguments3 as mirrorArguments,
+  sessionEntries2 as sessionEntries,
+  userBlocks3 as userBlocks
+};

package/dist/src/claude-code-sdk/translate.d.ts

@@ -0,0 +1,18 @@
+import type { SDKPartialAssistantMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { Api, AssistantMessage, AssistantMessageEventStream, Model, ToolCall } from "@nyte-ai/ai";
+type StreamEvent = SDKPartialAssistantMessage["event"];
+export declare const CLAUDE_CODE_PROVIDER = "claude-code";
+export declare const MIRROR_TOOL = "claude_code";
+export declare const BACKGROUND_TOOL = "BackgroundTasks";
+export declare const NYTE_SERVER = "nyte";
+export declare const NYTE_TOOL_PREFIX = "mcp__nyte__";
+export declare function emptyMessage(model: Model<Api>): AssistantMessage;
+export declare function mirrorCall(id: string, name: string, input: Record<string, unknown>): ToolCall;
+export declare class Translator {
+    #private;
+    constructor(model: Model<Api>, output: AssistantMessage, stream: AssistantMessageEventStream);
+    /** Applies one stream event. Returns the raw stop reason at a message's end, and `"tool_use"` as soon as a Nyte tool call's input is complete: Claude Code waits for Nyte to run it before it runs the message's later calls. */
+    apply(event: StreamEvent): string | undefined;
+    append(call: ToolCall): void;
+}
+export {};

package/dist/src/claude-code-sdk/translate.js

@@ -0,0 +1,20 @@
+import {
+  CLAUDE_CODE_PROVIDER2,
+  MIRROR_TOOL3,
+  BACKGROUND_TOOL2,
+  NYTE_SERVER2,
+  NYTE_TOOL_PREFIX2,
+  emptyMessage3,
+  mirrorCall2,
+  Translator3
+} from "../../chunks/billing-ye3wk5r3.js";
+export {
+  BACKGROUND_TOOL2 as BACKGROUND_TOOL,
+  CLAUDE_CODE_PROVIDER2 as CLAUDE_CODE_PROVIDER,
+  MIRROR_TOOL3 as MIRROR_TOOL,
+  NYTE_SERVER2 as NYTE_SERVER,
+  NYTE_TOOL_PREFIX2 as NYTE_TOOL_PREFIX,
+  Translator3 as Translator,
+  emptyMessage3 as emptyMessage,
+  mirrorCall2 as mirrorCall
+};

package/dist/src/client/mount.d.ts

@@ -0,0 +1,44 @@
+import type { Connection, Session } from "@nyte-ai/core";
+import type { Decision, Placement, SessionInfo, SubmitDraft } from "@nyte-ai/schema";
+import type { Plugin, PluginApi } from "../client.ts";
+import type { PartMessage } from "./presentation.ts";
+type Notification = Parameters<PluginApi["ui"]["notify"]>[0];
+/**
+ * What a client hands the plugins it mounts: its connection, the frameworks
+ * it draws, the session on screen, and where notices and plugin errors go.
+ *
+ * @category plugins
+ */
+export interface MountOptions {
+    readonly connection: Connection;
+    readonly plugins: readonly Plugin[];
+    readonly client: PluginApi["client"];
+    readonly session: () => Session | null;
+    readonly notify: (input: Notification) => void;
+    readonly report: (plugin: string, message: string) => void;
+}
+/**
+ * The mounted client plugins: their renderers and the hooks a client fires.
+ *
+ * @category plugins
+ */
+export interface ClientPlugins {
+    readonly ids: readonly string[];
+    /** The view a plugin renderer draws for a part, or undefined when none draws its kind. */
+    draw(session: Session, message: PartMessage, placement: Placement): unknown;
+    /** Feeds the session directory; each run that ends after the first list fires `run_ended_anywhere`. */
+    sessionsChanged(sessions: readonly SessionInfo[]): void;
+    switched(previous: Session | null, next: Session): Promise<void>;
+    beforeSubmit(draft: SubmitDraft): Promise<Decision<SubmitDraft>>;
+    dispose(): Promise<void>;
+}
+/**
+ * Activates client plugins once per app, all at once: their registries, hooks
+ * and the first renderer per part kind, in plugin order, among the frameworks
+ * the client draws. A plugin whose activation fails is reported and the rest
+ * still mount.
+ *
+ * @category plugins
+ */
+export declare function mountClientPlugins(options: MountOptions): Promise<ClientPlugins>;
+export {};