@nyte-ai/plugin 0.0.0-stage → 0.0.19

package/dist/chunks/billing-0y7dfkp2.js

@@ -0,0 +1,146 @@
+// examples/claude-code/wire.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var recordSchema = Type.Record(Type.String(), Type.Unknown());
+var usageSchema = Type.Object({
+  input_tokens: Type.Number(),
+  output_tokens: Type.Number(),
+  cache_read_input_tokens: Type.Optional(Type.Number()),
+  cache_creation_input_tokens: Type.Optional(Type.Number()),
+  cache_creation: Type.Optional(Type.Object({ ephemeral_1h_input_tokens: Type.Optional(Type.Number()) })),
+  output_tokens_details: Type.Optional(Type.Object({ thinking_tokens: Type.Optional(Type.Number()) }))
+});
+var contentSchema = Type.Union([
+  Type.Object({ type: Type.Literal("text"), text: Type.String() }),
+  Type.Object({
+    type: Type.Literal("thinking"),
+    thinking: Type.String(),
+    signature: Type.Optional(Type.String())
+  }),
+  Type.Object({ type: Type.Literal("redacted_thinking"), data: Type.String() }),
+  Type.Object({
+    type: Type.Literal("tool_use"),
+    id: Type.String(),
+    name: Type.String(),
+    input: recordSchema
+  })
+]);
+var messageSchema2 = Type.Intersect([
+  recordSchema,
+  Type.Object({
+    id: Type.Optional(Type.String()),
+    role: Type.Literal("assistant"),
+    content: Type.Array(contentSchema),
+    usage: Type.Optional(usageSchema),
+    stop_reason: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+    stop_sequence: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+  })
+]);
+var streamEventSchema = Type.Union([
+  Type.Object({ type: Type.Literal("message_start"), message: messageSchema2 }),
+  Type.Object({
+    type: Type.Literal("content_block_start"),
+    index: Type.Integer({ minimum: 0 }),
+    content_block: contentSchema
+  }),
+  Type.Object({
+    type: Type.Literal("content_block_delta"),
+    index: Type.Integer({ minimum: 0 }),
+    delta: Type.Union([
+      Type.Object({ type: Type.Literal("text_delta"), text: Type.String() }),
+      Type.Object({ type: Type.Literal("thinking_delta"), thinking: Type.String() }),
+      Type.Object({ type: Type.Literal("signature_delta"), signature: Type.String() }),
+      Type.Object({ type: Type.Literal("input_json_delta"), partial_json: Type.String() })
+    ])
+  }),
+  Type.Object({ type: Type.Literal("content_block_stop"), index: Type.Integer({ minimum: 0 }) }),
+  Type.Object({
+    type: Type.Literal("message_delta"),
+    delta: Type.Object({
+      stop_reason: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+      stop_sequence: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+    }),
+    usage: Type.Optional(Type.Partial(usageSchema))
+  }),
+  Type.Object({ type: Type.Literal("message_stop") }),
+  Type.Object({
+    type: Type.Literal("error"),
+    error: Type.Optional(Type.Object({ type: Type.Optional(Type.String()), message: Type.Optional(Type.String()) }))
+  })
+]);
+var outputEventSchema = Type.Union([
+  Type.Object({
+    type: Type.Literal("assistant"),
+    message: messageSchema2,
+    error: Type.Optional(Type.Unknown())
+  }),
+  Type.Object({
+    type: Type.Literal("result"),
+    subtype: Type.Optional(Type.String()),
+    is_error: Type.Optional(Type.Boolean()),
+    num_turns: Type.Optional(Type.Number()),
+    usage: Type.Optional(usageSchema),
+    total_cost_usd: Type.Optional(Type.Number()),
+    modelUsage: Type.Optional(recordSchema)
+  }),
+  Type.Object({ type: Type.Literal("stream_event"), event: streamEventSchema }),
+  Type.Object({
+    type: Type.Literal("rate_limit_event"),
+    rate_limit_info: Type.Optional(Type.Object({
+      status: Type.Optional(Type.String()),
+      rateLimitType: Type.Optional(Type.String()),
+      resetsAt: Type.Optional(Type.Number()),
+      isUsingOverage: Type.Optional(Type.Boolean()),
+      overageStatus: Type.Optional(Type.String()),
+      overageDisabledReason: Type.Optional(Type.String())
+    }))
+  }),
+  Type.Object({ type: Type.Literal("control_response"), response: recordSchema })
+]);
+var requestMessageSchema = Type.Object({
+  role: Type.Optional(Type.String()),
+  content: Type.Optional(Type.Unknown())
+});
+var requestMessagesSchema = Type.Array(requestMessageSchema);
+var requestSchema = Type.Intersect([
+  recordSchema,
+  Type.Object({ messages: requestMessagesSchema, system: Type.Optional(Type.Unknown()) })
+]);
+function matchesRecord2(value) {
+  return Value.Check(recordSchema, value);
+}
+function parseRecord2(text) {
+  const value = JSON.parse(text);
+  if (!matchesRecord2(value))
+    throw new Error("Expected a JSON object");
+  return value;
+}
+function parseStreamEvent2(text) {
+  const value = JSON.parse(text);
+  if (matchesRecord2(value) && value.type === "ping")
+    return;
+  if (!Value.Check(streamEventSchema, value))
+    throw new Error("Invalid Anthropic stream event");
+  return value;
+}
+function parseOutputEvent2(text) {
+  const value = parseRecord2(text);
+  if (!["assistant", "result", "stream_event", "rate_limit_event", "control_response"].includes(String(value.type)))
+    return;
+  if (!Value.Check(outputEventSchema, value))
+    throw new Error("Invalid Claude Code output event");
+  return value;
+}
+function parseRequest2(body) {
+  const value = JSON.parse(body.toString("utf8"));
+  if (!Value.Check(requestSchema, value))
+    throw new Error("Invalid Claude Code request");
+  return value;
+}
+function parseRequestMessages2(value) {
+  if (!Value.Check(requestMessagesSchema, value))
+    throw new Error("Invalid Claude Code replay messages");
+  return value;
+}
+
+export { messageSchema2, matchesRecord2, parseRecord2, parseStreamEvent2, parseOutputEvent2, parseRequest2, parseRequestMessages2 };

package/dist/chunks/billing-2v3g7rd9.js

@@ -0,0 +1,190 @@
+import {
+  CLAUDE_CODE_PROVIDER2,
+  MIRROR_TOOL3,
+  BACKGROUND_TOOL2,
+  NYTE_TOOL_PREFIX2
+} from "./billing-ye3wk5r3.js";
+
+// src/claude-code-sdk/transcript.ts
+import { randomUUID } from "node:crypto";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var IMAGE_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+var mirrorArguments3 = Type.Object({
+  id: Type.String(),
+  name: Type.String(),
+  input: Type.Record(Type.String(), Type.Unknown())
+});
+function readMirrorCall(call) {
+  if (call.name !== MIRROR_TOOL3 || !Value.Check(mirrorArguments3, call.arguments))
+    return;
+  return call.arguments;
+}
+function mediaBlock(content) {
+  if (content.type === "text")
+    return { type: "text", text: content.text };
+  const mediaType = IMAGE_TYPES.find((type) => type === content.mimeType);
+  return mediaType === undefined ? { type: "text", text: `(${content.mimeType} image omitted)` } : { type: "image", source: { type: "base64", media_type: mediaType, data: content.data } };
+}
+function userBlocks3(message) {
+  return typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content.map(mediaBlock);
+}
+function text(content) {
+  return typeof content === "string" ? content : content.map((block) => block.type === "text" ? block.text : `[${block.mimeType}]`).join("");
+}
+function messageKey3(message) {
+  if (message.role === "user")
+    return `u:${text(message.content)}`;
+  if (message.role === "toolResult")
+    return `t:${message.toolCallId}`;
+  if (message.role === "system")
+    return "s";
+  return `a:${message.content.flatMap((block) => block.type === "toolCall" ? [block.id] : []).join(",")}`;
+}
+function toParams(messages, model) {
+  const params = [];
+  const claude = new Map;
+  const foreign = new Map;
+  const skipped = new Set;
+  const push = (role, content) => {
+    if (content.length === 0)
+      return;
+    const last = params.at(-1);
+    if (last?.role === role && Array.isArray(last.content))
+      last.content.push(...content);
+    else
+      params.push({ role, content: [...content] });
+  };
+  const closeCalls = () => {
+    push("user", [...claude.values()].map((id) => ({
+      type: "tool_result",
+      tool_use_id: id,
+      content: "No result provided",
+      is_error: true
+    })));
+    claude.clear();
+  };
+  for (const message of messages) {
+    if (message.role === "system")
+      continue;
+    if (message.role === "toolResult") {
+      const id = claude.get(message.toolCallId);
+      const name = foreign.get(message.toolCallId);
+      if (skipped.has(message.toolCallId))
+        continue;
+      if (id !== undefined) {
+        claude.delete(message.toolCallId);
+        push("user", [
+          {
+            type: "tool_result",
+            tool_use_id: id,
+            content: message.content.map(mediaBlock),
+            is_error: message.isError
+          }
+        ]);
+      } else {
+        push("user", [
+          { type: "text", text: `[${name ?? message.toolName} result]
+${text(message.content)}` }
+        ]);
+      }
+      continue;
+    }
+    closeCalls();
+    if (message.role === "user") {
+      push("user", userBlocks3(message));
+      continue;
+    }
+    if (message.stopReason === "error" || message.stopReason === "aborted")
+      continue;
+    const signed = message.provider === CLAUDE_CODE_PROVIDER2 && message.model === model;
+    push("assistant", message.content.flatMap((block) => {
+      if (block.type === "text")
+        return block.text.trim() === "" ? [] : [{ type: "text", text: block.text }];
+      if (block.type === "thinking") {
+        if (!signed || block.thinkingSignature === undefined || block.thinkingSignature === "")
+          return [];
+        return block.redacted === true ? [{ type: "redacted_thinking", data: block.thinkingSignature }] : [{ type: "thinking", thinking: block.thinking, signature: block.thinkingSignature }];
+      }
+      const call = readMirrorCall(block);
+      if (call?.name === BACKGROUND_TOOL2) {
+        skipped.add(block.id);
+        return [];
+      }
+      if (call !== undefined) {
+        claude.set(block.id, call.id);
+        return [{ type: "tool_use", id: call.id, name: call.name, input: call.input }];
+      }
+      if (message.provider === CLAUDE_CODE_PROVIDER2) {
+        claude.set(block.id, block.id);
+        return [
+          {
+            type: "tool_use",
+            id: block.id,
+            name: `${NYTE_TOOL_PREFIX2}${block.name}`,
+            input: block.arguments
+          }
+        ];
+      }
+      foreign.set(block.id, block.name);
+      return [{ type: "text", text: `[${block.name}]
+${JSON.stringify(block.arguments)}` }];
+    }));
+  }
+  closeCalls();
+  return params.map((param) => param.role === "user" && Array.isArray(param.content) ? {
+    ...param,
+    content: [
+      ...param.content.filter((block) => block.type === "tool_result"),
+      ...param.content.filter((block) => block.type !== "tool_result")
+    ]
+  } : param);
+}
+function sessionEntries2(messages, input) {
+  const timestamp = new Date().toISOString();
+  let parentUuid = null;
+  return toParams(messages, input.model).map((param) => {
+    const uuid = randomUUID();
+    const entry = {
+      type: param.role,
+      uuid,
+      parentUuid,
+      sessionId: input.session,
+      timestamp,
+      isSidechain: false,
+      userType: "external",
+      cwd: input.cwd,
+      message: param.role === "user" ? param : {
+        id: `msg_${uuid.replaceAll("-", "")}`,
+        type: "message",
+        role: "assistant",
+        model: input.model,
+        content: param.content,
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 }
+      }
+    };
+    parentUuid = uuid;
+    return entry;
+  });
+}
+function flatPrompt2(messages) {
+  const turns = messages.filter((message) => message.role !== "system");
+  if (turns.length === 1 && turns[0]?.role === "user")
+    return text(turns[0].content);
+  return turns.map((message) => {
+    if (message.role === "assistant")
+      return `Assistant:
+${message.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("")}`;
+    if (message.role === "toolResult")
+      return `Tool result (${message.toolName}):
+${text(message.content)}`;
+    return message.role === "user" ? `User:
+${text(message.content)}` : "";
+  }).join(`
+
+`);
+}
+
+export { mirrorArguments3, userBlocks3, messageKey3, sessionEntries2, flatPrompt2 };

package/dist/chunks/billing-3j77ss7y.js

@@ -0,0 +1,86 @@
+import {
+  answerInput2,
+  questionOutput2,
+  questionParameters2,
+  question3
+} from "./billing-6z2kgtyt.js";
+
+// src/question/question.ts
+import { definePart, dev } from "@nyte-ai/core";
+import { SdkError } from "@nyte-ai/schema";
+function normalizeAnswers(items, supplied) {
+  if (supplied.length !== items.length)
+    throw new SdkError("invalid", "Submit one answer list for each question.");
+  return items.map((item, index) => {
+    const selected = supplied[index].map((answer) => answer.trim());
+    if (selected.some((answer) => answer === ""))
+      throw new SdkError("invalid", "Answers cannot be blank.");
+    if (!item.multiple && selected.length > 1)
+      throw new SdkError("invalid", "This question accepts one answer.");
+    if (new Set(selected).size !== selected.length)
+      throw new SdkError("invalid", "Choose each answer only once.");
+    return item.multiple ? selected.toSorted() : selected;
+  });
+}
+var handlers = {
+  async answer(input, context) {
+    let accepted = false;
+    const outcome = await context.part.update((current) => {
+      const normalized = normalizeAnswers(current.questions, input.answers);
+      accepted = current.answers === null || JSON.stringify(current.answers) === JSON.stringify(normalized);
+      return current.answers === null ? { ...current, answers: normalized } : current;
+    });
+    if (outcome.kind !== "updated")
+      throw new Error(`The questions could not be answered: ${outcome.kind}.`);
+    if (!accepted)
+      throw new SdkError("invalid", "These questions were already answered.");
+  }
+};
+var question2 = definePart({
+  ...question3,
+  onAction: (action, input, context) => handlers[action](input, context)
+});
+var ask = {
+  name: "question",
+  description: "Ask the user one or more questions and wait for their answers. Give each option a short label and a description. Use multiple when several choices may apply. The user can also write their own answer.",
+  parameters: questionParameters2,
+  output: questionOutput2,
+  class: (args) => ({
+    kind: "custom",
+    label: args.questions.map((item) => item.header).join(", ")
+  }),
+  effects: "none",
+  approval: "never",
+  replay: "safe",
+  async execute(args, invocation) {
+    for (const item of args.questions) {
+      if (new Set(item.options.map((option) => option.label.trim())).size !== item.options.length)
+        throw new SdkError("invalid", "Question option labels must be distinct.");
+    }
+    const part = await invocation.session.parts.create(question2, {
+      state: { ...args, answers: null },
+      placement: { kind: "modal" }
+    });
+    dev("question", "asked", { call: invocation.call, part: part.id });
+    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;
+    const reply = checked !== undefined && checked.issues === undefined ? normalizeAnswers(args.questions, checked.value.answers) : null;
+    return {
+      content: [
+        {
+          kind: "text",
+          text: reply === null ? "The user did not answer. Continue with your best judgment and say what you assumed." : args.questions.map((item, index) => `${item.question}: ${reply[index].join(", ") || "Unanswered"}`).join(`
+`)
+        }
+      ],
+      output: { answers: reply },
+      parts: [part.id]
+    };
+  }
+};
+var question_default = {
+  id: "question",
+  contribute: { parts: [question2], tools: [ask] }
+};
+
+export { question2, question_default };