@nyte-ai/plugin 0.0.0-stage → 0.0.18

package/dist/src/codemode.js

@@ -0,0 +1,170 @@
+// src/codemode.ts
+import { CodemodeSandbox } from "@earendil-works/pi-codemode";
+import { renderToolSample } from "@earendil-works/pi-codemode/declarations";
+import { CODEMODE_SOURCE_GRAMMAR, parseCodemodeSource } from "@earendil-works/pi-codemode/source";
+import { dev } from "@nyte-ai/core";
+import { isJson, isJsonObject, SdkError, standard } from "@nyte-ai/schema";
+import { Type } from "typebox";
+var DESCRIPTION = `Run JavaScript that calls other tools. The input is raw JavaScript (not JSON, no code fence), run as an async function body in a QuickJS sandbox: top-level \`await\` and \`return\` work. No Node, file system, network, or timers.
+- \`await tools.<name>({ ...args })\` resolves to the tool's output, or its text, and rejects with an Error on failure.
+- Optional first line: \`// @options: {"timeout_ms": 60000}\`
+- \`text(value)\`, \`console.log(...)\` and \`return\` add output; \`store(key, value)\` and \`load(key)\` keep JSON values across codemode calls in this session.
+- \`ALL_TOOLS\`, \`searchTools(query, { limit?, namespace? })\` and \`describeTool(name)\` find tools and their declarations.`;
+var SUMMARY_CHARS = 160;
+var parameters = standard(Type.Object({ code: Type.String({ description: "Raw JavaScript source." }) }));
+function codemodePlugin(runtime) {
+  return {
+    id: "codemode",
+    activate(api) {
+      api.contribute.tools.add(codemode(api, runtime));
+      api.contribute.prompt.add((draft, siblings) => {
+        const reachable = siblings.tools.list().flatMap((tool) => tool.exposure === "code" || tool.exposure === "deferred" ? [`- ${tool.name}: ${summarize(tool.description)}`] : []).toSorted();
+        if (reachable.length === 0)
+          return;
+        draft.set("codemode", {
+          id: "codemode",
+          order: 96,
+          text: [
+            "Tools you reach only from a codemode script, as `await tools.<name>(args)`; `describeTool(name)` inside a script returns a tool's arguments:",
+            ...reachable
+          ].join(`
+`)
+        });
+      });
+    }
+  };
+}
+function summarize(description) {
+  const [line = ""] = description.trim().split(`
+`);
+  return line.length > SUMMARY_CHARS ? `${line.slice(0, SUMMARY_CHARS)}…` : line;
+}
+function codemode(api, runtime) {
+  return {
+    name: "codemode",
+    description: DESCRIPTION,
+    parameters,
+    grammar: { kind: "lark", source: CODEMODE_SOURCE_GRAMMAR },
+    class: () => ({ kind: "custom", label: "Running a script" }),
+    effects: "none",
+    approval: "never",
+    replay: "never",
+    async execute(args, invocation) {
+      const { code, options } = parseCodemodeSource(args.code);
+      const callable = invocation.tools.list().filter((info) => info.name !== "codemode" && info.exposure !== "hidden");
+      const stored = await api.storage.get("store");
+      if (stored !== undefined && !isJsonObject(stored))
+        throw new SdkError("internal", "Codemode's stored values are not a JSON object.");
+      const sandbox = new CodemodeSandbox({
+        ...runtime,
+        tools: callable.map((info) => bridge(info, invocation)),
+        globals: discovery(callable),
+        timeoutMs: options.timeoutMs ?? 300000,
+        memoryLimitBytes: 256 * 1024 * 1024
+      });
+      dev("codemode", "run", { call: invocation.call, tools: callable.length });
+      let result;
+      try {
+        result = await sandbox.execute(code, { signal: invocation.signal, store: stored ?? {} });
+      } finally {
+        await sandbox.close();
+      }
+      dev("codemode", "end", { call: invocation.call, ok: result.ok, calls: result.calls.length });
+      if (!result.ok)
+        throw new Error(`${result.error.kind === "script" ? result.error.stack ?? result.error.message : `Script ${result.error.kind}: ${result.error.message}`}
+${calls(result)}`);
+      const writes = Object.entries(result.storeWrites.set).flatMap(([key, value]) => isJson(value) ? [[key, value]] : []);
+      if (writes.length > 0 || result.storeWrites.delete.length > 0) {
+        const next = { ...stored, ...Object.fromEntries(writes) };
+        for (const key of result.storeWrites.delete)
+          delete next[key];
+        await api.storage.set("store", next);
+      }
+      const content = [];
+      for (const item of result.output) {
+        if (item.type === "text")
+          content.push({ kind: "text", text: item.text });
+        else
+          content.push({
+            kind: "file",
+            blob: await invocation.env.files.upload(once(Uint8Array.fromBase64(item.data))),
+            mime: item.mimeType
+          });
+      }
+      if (result.value !== undefined)
+        content.push({
+          kind: "text",
+          text: typeof result.value === "string" ? result.value : JSON.stringify(result.value)
+        });
+      return {
+        content: content.length === 0 ? [{ kind: "text", text: "The script produced no output." }] : content
+      };
+    }
+  };
+}
+function bridge(info, invocation) {
+  let sequence = 0;
+  return {
+    name: info.name,
+    description: info.description,
+    inputSchema: info.parameters,
+    outputSchema: info.output ?? { type: "string" },
+    async execute(args, { signal }) {
+      const key = `codemode:${info.name}:${sequence++}`;
+      return unwrapToolOutcome(await invocation.tools.execute(info.name, isJson(args) ? args : null, { key, signal }));
+    }
+  };
+}
+function unwrapToolOutcome(outcome) {
+  if (outcome.kind === "ok")
+    return outcome.output ?? outcome.content.flatMap((item) => item.kind === "text" ? [item.text] : []).join(`
+`);
+  throw new Error(outcome.kind === "failed" ? outcome.message : outcome.kind === "rejected" ? `Rejected: ${outcome.reason}` : `The call was ${outcome.kind}.`);
+}
+function discovery(tools) {
+  return [
+    {
+      name: "searchTools",
+      spread: true,
+      execute(args) {
+        const [query, options] = Array.isArray(args) ? args : [];
+        const words = new Set(String(query).toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length > 1));
+        const limit = typeof options === "object" && options !== null && "limit" in options && typeof options.limit === "number" ? options.limit : 8;
+        const namespace = typeof options === "object" && options !== null && "namespace" in options && typeof options.namespace === "string" ? options.namespace : null;
+        return tools.filter((info) => namespace === null || info.namespace === namespace).map((info) => ({
+          info,
+          score: `${info.name} ${info.description}`.toLowerCase().split(/[^a-z0-9]+/).filter((word) => words.has(word)).length
+        })).filter((entry) => entry.score > 0).toSorted((left, right) => right.score - left.score).slice(0, limit).map(({ info }) => ({
+          name: info.name,
+          namespace: info.namespace,
+          description: info.description
+        }));
+      }
+    },
+    {
+      name: "describeTool",
+      execute(name) {
+        const info = tools.find((candidate) => candidate.name === name);
+        if (info === undefined)
+          throw new Error(`No tool is named ${String(name)}.`);
+        return renderToolSample({
+          name: info.name,
+          description: info.description,
+          inputSchema: info.parameters,
+          outputSchema: info.output ?? { type: "string" }
+        });
+      }
+    }
+  ];
+}
+function calls(result) {
+  return result.calls.length === 0 ? "No tool calls were made." : `Tool calls made before the failure (not undone): ${result.calls.map((call) => `${call.name} (${call.status})`).join(", ")}`;
+}
+async function* once(bytes) {
+  yield bytes;
+}
+var codemode_default = codemodePlugin({});
+export {
+  codemodePlugin,
+  codemode_default as default
+};

package/dist/src/core.d.ts

@@ -0,0 +1,43 @@
+import type { HookEntry as SideHookEntry, HookHandler as SideHookHandler, HookName as SideHookName, Plugin as CorePlugin, PluginApi as CorePluginApi } from "@nyte-ai/core";
+export { branchSummary, compaction, definePart, isPart, text, thinking, tool } from "@nyte-ai/core";
+export type { ActionContext, Agent, Command, Durable, HookTable, ModelContextPolicy, Part, PartDefinition, PartState, PromptSection, Setting, SettingDefinition, Skill, ToolDefinition, ToolInvocation, } from "@nyte-ai/core";
+export type { CompactionPlan, Decision, ModelRequest, Submission, ToolCall, Transcript, } from "@nyte-ai/schema";
+/**
+ * A core plugin: per session on the host, with tools, prompt sections,
+ * agents, parts, commands, settings and core hooks. Author one as an object
+ * literal and check it with `satisfies Plugin`.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type Plugin = CorePlugin<"core">;
+/**
+ * What a core plugin's `activate` and hook handlers receive: the session,
+ * its environment, the registries, storage and `request`.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type PluginApi = CorePluginApi<"core">;
+/**
+ * Names a hook a core plugin may handle.
+ *
+ * @category hooks
+ * @since 0.1.0
+ */
+export type HookName = SideHookName<"core">;
+/**
+ * Returns a core hook handler's signature, for a helper factored out of a
+ * plugin's `hooks`.
+ *
+ * @category hooks
+ * @since 0.1.0
+ */
+export type HookHandler<N extends HookName> = SideHookHandler<"core", N>;
+/**
+ * Returns a core hook entry: a handler, or a handler with an order.
+ *
+ * @category hooks
+ * @since 0.1.0
+ */
+export type HookEntry<N extends HookName> = SideHookEntry<"core", N>;

package/dist/src/core.js

@@ -0,0 +1,11 @@
+// src/core.ts
+import { branchSummary, compaction, definePart, isPart, text, thinking, tool } from "@nyte-ai/core";
+export {
+  branchSummary,
+  compaction,
+  definePart,
+  isPart,
+  text,
+  thinking,
+  tool
+};

package/dist/src/openai-astra-context.d.ts

@@ -0,0 +1,23 @@
+import type { ModelContextPolicy } from "@nyte-ai/core";
+/**
+ * The context policy of `gpt-6-astra` on OpenAI and OpenAI Codex: a window
+ * of one million tokens, compacted at 400 000.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const astra: readonly ModelContextPolicy[];
+/**
+ * Gives the astra models their context window and compaction threshold,
+ * folded into their `ModelInfo` and the sessions that run them.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: {
+    id: string;
+    contribute: {
+        modelContext: readonly ModelContextPolicy[];
+    };
+};
+export default _default;

package/dist/src/openai-astra-context.js

@@ -0,0 +1,14 @@
+// src/openai-astra-context.ts
+var astra = ["openai", "openai-codex"].map((provider) => ({
+  model: { provider, id: "gpt-6-astra" },
+  contextWindow: 1e6,
+  compactAt: 400000
+}));
+var openai_astra_context_default = {
+  id: "openai-astra-context",
+  contribute: { modelContext: astra }
+};
+export {
+  astra,
+  openai_astra_context_default as default
+};

package/dist/src/openai-compaction.d.ts

@@ -0,0 +1,15 @@
+import type { Models } from "@nyte-ai/ai";
+import type { Plugin } from "@nyte-ai/plugin/core";
+/**
+ * Returns the plugin that compacts through OpenAI's own endpoint. On
+ * `before_compaction`, when the session's model is OpenAI Responses (an API
+ * key) or OpenAI Codex Responses (a ChatGPT account), it sends the messages
+ * to summarise to the provider's compact endpoint and supplies the opaque
+ * window it returns as the plan's `material`; core writes it without a
+ * summary request. Any other model, or a provider without credentials,
+ * leaves the plan to core. `models` is the host's, for credentials.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare function openaiCompaction(models: Pick<Models, "getModel" | "getAuth">): Plugin;

package/dist/src/openai-compaction.js

@@ -0,0 +1,55 @@
+// src/openai-compaction.ts
+import {
+  compactOpenAICodexContext,
+  compactOpenAIResponsesContext,
+  providerIdentity
+} from "@nyte-ai/ai";
+function openaiCompaction(models) {
+  return {
+    id: "openai-compaction",
+    hooks: {
+      before_compaction: async (plan, { signal }) => {
+        const model = models.getModel(plan.model.provider, plan.model.id);
+        const responses = model?.provider === "openai" && model.api === "openai-responses";
+        const codex = model?.provider === "openai-codex" && model.api === "openai-codex-responses";
+        if (plan.result !== null || model === undefined || !responses && !codex)
+          return plan;
+        const auth = await models.getAuth(model, { signal });
+        if (auth === undefined)
+          return plan;
+        const base = { ...model, baseUrl: auth.auth.baseUrl ?? model.baseUrl };
+        const options = { apiKey: auth.auth.apiKey, headers: auth.auth.headers, signal };
+        const context = {
+          messages: [
+            ...plan.summarise,
+            ...plan.instructions === null ? [] : [{ role: "system", content: plan.instructions, timestamp: Date.now() }]
+          ]
+        };
+        const compacted = codex ? await compactOpenAICodexContext({ ...base, api: "openai-codex-responses" }, context, options) : await compactOpenAIResponsesContext({ ...base, api: "openai-responses" }, context, options);
+        return {
+          ...plan,
+          result: {
+            kind: "material",
+            ...providerIdentity(model),
+            data: compacted.data,
+            usage: compacted.usage === undefined ? null : sessionUsage(compacted.usage)
+          }
+        };
+      }
+    }
+  };
+}
+function sessionUsage(usage) {
+  return {
+    input: usage.input,
+    output: usage.output,
+    cacheRead: usage.cacheRead,
+    cacheWrite: usage.cacheWrite,
+    reasoning: usage.reasoning ?? null,
+    total: usage.totalTokens,
+    cost: usage.cost
+  };
+}
+export {
+  openaiCompaction
+};

package/dist/src/question/client/questions-tui.d.ts

@@ -0,0 +1,9 @@
+import type { Renderer } from "@nyte-ai/plugin/client";
+export declare const questionRenderers: readonly Renderer[];
+declare const _default: {
+    id: string;
+    contribute: {
+        renderers: readonly Renderer<import("@nyte-ai/plugin/client").PartDefinition<unknown, import("@nyte-ai/core").ActionSchemas>, unknown>[];
+    };
+};
+export default _default;

package/dist/src/question/client/questions-tui.js

@@ -0,0 +1,19 @@
+import {
+  question3
+} from "../../../chunks/billing-6z2kgtyt.js";
+
+// src/question/client/questions-tui.ts
+import { Box, Text } from "@opentui/core";
+import { defineRenderer } from "@nyte-ai/plugin/client";
+var unreadable = (kind) => Text({ content: `This ${kind} part cannot be shown.` });
+var questionRenderers = [
+  defineRenderer(question3, "tui", (state) => Box({ border: true, title: "Questions", flexDirection: "column" }, ...state.questions.map((item, index) => Box({ flexDirection: "column" }, Text({ content: `${item.header}: ${item.question}` }), ...item.options.map((option) => Text({ content: `${option.label}: ${option.description}` })), ...state.answers === null ? [] : [Text({ content: `Answer: ${state.answers[index].join(", ") || "Unanswered"}` })]))), unreadable)
+];
+var questions_tui_default = {
+  id: "questions-tui",
+  contribute: { renderers: questionRenderers }
+};
+export {
+  questions_tui_default as default,
+  questionRenderers
+};

package/dist/src/question/client/questions.d.ts

@@ -0,0 +1,9 @@
+import type { Renderer } from "@nyte-ai/plugin/client";
+export declare const questionRenderers: readonly Renderer[];
+declare const _default: {
+    id: string;
+    contribute: {
+        renderers: readonly Renderer<import("@nyte-ai/plugin/client").PartDefinition<unknown, import("@nyte-ai/core").ActionSchemas>, unknown>[];
+    };
+};
+export default _default;

package/dist/src/question/client/questions.js

@@ -0,0 +1,160 @@
+import {
+  question3
+} from "../../../chunks/billing-6z2kgtyt.js";
+
+// src/question/client/questions.tsx
+import { useId, useRef, useState } from "react";
+import { defineRenderer } from "@nyte-ai/plugin/client";
+import { jsxDEV } from "react/jsx-dev-runtime";
+var unreadable = (kind) => /* @__PURE__ */ jsxDEV("div", {
+  "data-part": kind,
+  children: [
+    "This ",
+    kind,
+    " part cannot be shown."
+  ]
+}, undefined, true, undefined, this);
+function QuestionForm({
+  questions,
+  act
+}) {
+  const id = useId();
+  const [selected, setSelected] = useState(() => questions.map(() => []));
+  const [custom, setCustom] = useState(() => questions.map(() => ""));
+  const [status, setStatus] = useState({ kind: "editing" });
+  const submitting = useRef(false);
+  const blocked = status.kind === "sending" || status.kind === "sent";
+  const submit = async () => {
+    if (blocked || submitting.current)
+      return;
+    submitting.current = true;
+    setStatus({ kind: "sending" });
+    const answers = questions.map((item, index) => {
+      const typed = custom[index].trim();
+      const choices = selected[index];
+      if (typed === "" || choices.includes(typed))
+        return choices;
+      return item.multiple ? [...choices, typed] : [typed];
+    });
+    try {
+      const outcome = await act("answer", { answers });
+      setStatus(outcome.kind === "ok" ? { kind: "sent" } : {
+        kind: "failed",
+        message: outcome.kind === "rejected" ? outcome.reason : "These questions are no longer waiting."
+      });
+    } catch {
+      setStatus({ kind: "failed", message: "Couldn't send your answers. Try again." });
+    }
+    submitting.current = false;
+  };
+  return /* @__PURE__ */ jsxDEV("form", {
+    "data-part": "ask/question",
+    "aria-label": "Questions",
+    onSubmit: (event) => {
+      event.preventDefault();
+      submit();
+    },
+    children: [
+      questions.map((item, index) => /* @__PURE__ */ jsxDEV("fieldset", {
+        disabled: blocked,
+        children: [
+          /* @__PURE__ */ jsxDEV("legend", {
+            children: item.header
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("p", {
+            children: item.question
+          }, undefined, false, undefined, this),
+          item.options.map((option) => /* @__PURE__ */ jsxDEV("label", {
+            children: [
+              /* @__PURE__ */ jsxDEV("input", {
+                type: item.multiple ? "checkbox" : "radio",
+                name: `${id}-${index}`,
+                value: option.label,
+                checked: selected[index].includes(option.label),
+                onChange: () => {
+                  setSelected((current) => current.map((choices, position) => {
+                    if (position !== index)
+                      return choices;
+                    if (!item.multiple)
+                      return [option.label];
+                    return choices.includes(option.label) ? choices.filter((choice) => choice !== option.label) : [...choices, option.label];
+                  }));
+                  if (!item.multiple)
+                    setCustom((current) => current.map((typed, position) => position === index ? "" : typed));
+                }
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV("span", {
+                children: option.label
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV("span", {
+                children: option.description
+              }, undefined, false, undefined, this)
+            ]
+          }, option.label, true, undefined, this)),
+          /* @__PURE__ */ jsxDEV("label", {
+            children: [
+              "Type your own answer",
+              /* @__PURE__ */ jsxDEV("textarea", {
+                value: custom[index],
+                onChange: ({ currentTarget }) => {
+                  const typed = currentTarget.value;
+                  setCustom((current) => current.map((value, position) => position === index ? typed : value));
+                  if (!item.multiple && typed.trim() !== "")
+                    setSelected((current) => current.map((choices, position) => position === index ? [] : choices));
+                }
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, index, true, undefined, this)),
+      /* @__PURE__ */ jsxDEV("button", {
+        type: "submit",
+        disabled: blocked,
+        children: status.kind === "sending" ? "Sending answers…" : "Submit answers"
+      }, undefined, false, undefined, this),
+      status.kind === "failed" && /* @__PURE__ */ jsxDEV("p", {
+        role: "alert",
+        children: status.message
+      }, undefined, false, undefined, this),
+      status.kind === "sent" && /* @__PURE__ */ jsxDEV("p", {
+        role: "status",
+        children: "Answers sent."
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+var questionRenderers = [
+  defineRenderer(question3, "react", (state, act) => {
+    const answers = state.answers;
+    if (answers !== null)
+      return /* @__PURE__ */ jsxDEV("div", {
+        "data-part": "ask/question",
+        "aria-label": "Answers",
+        children: state.questions.map((item, index) => /* @__PURE__ */ jsxDEV("section", {
+          children: [
+            /* @__PURE__ */ jsxDEV("h3", {
+              children: item.header
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV("p", {
+              children: item.question
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV("p", {
+              children: [
+                "Answer: ",
+                answers[index].join(", ") || "Unanswered"
+              ]
+            }, undefined, true, undefined, this)
+          ]
+        }, index, true, undefined, this))
+      }, undefined, false, undefined, this);
+    return /* @__PURE__ */ jsxDEV(QuestionForm, {
+      questions: state.questions,
+      act
+    }, JSON.stringify(state.questions), false, undefined, this);
+  }, unreadable)
+];
+var questions_default = { id: "questions", contribute: { renderers: questionRenderers } };
+export {
+  questions_default as default,
+  questionRenderers
+};

package/dist/src/question/question.d.ts

@@ -0,0 +1,63 @@
+import type { ToolDefinition } from "@nyte-ai/core";
+export declare const question: import("@nyte-ai/core").PartDefinition<{
+    answers: string[][] | null;
+    questions: {
+        multiple?: boolean | undefined;
+        options: {
+            description: string;
+            label: string;
+        }[];
+        question: string;
+        header: string;
+    }[];
+}, {
+    answer: {
+        input: import("@nyte-ai/schema").Schema<{
+            answers: string[][];
+        }>;
+    };
+}>;
+/**
+ * Contributes the question tool and its grouped modal. The durable wait
+ * resumes after one complete submission from any client.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: {
+    id: string;
+    contribute: {
+        parts: import("@nyte-ai/core").PartDefinition<{
+            answers: string[][] | null;
+            questions: {
+                multiple?: boolean | undefined;
+                options: {
+                    description: string;
+                    label: string;
+                }[];
+                question: string;
+                header: string;
+            }[];
+        }, {
+            answer: {
+                input: import("@nyte-ai/schema").Schema<{
+                    answers: string[][];
+                }>;
+            };
+        }>[];
+        tools: ToolDefinition<{
+            questions: {
+                multiple?: boolean | undefined;
+                options: {
+                    description: string;
+                    label: string;
+                }[];
+                question: string;
+                header: string;
+            }[];
+        }, {
+            answers: string[][] | null;
+        }>[];
+    };
+};
+export default _default;

package/dist/src/question/question.js

@@ -0,0 +1,9 @@
+import {
+  question2,
+  question_default
+} from "../../chunks/billing-3j77ss7y.js";
+import"../../chunks/billing-6z2kgtyt.js";
+export {
+  question_default as default,
+  question2 as question
+};