@nyte-ai/plugin 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,101 @@
+import type { Infer, PartId, SessionView } from "@nyte-ai/schema";
+declare const info: import("@nyte-ai/schema").Schema<{
+    multiple?: boolean | undefined;
+    options: {
+        description: string;
+        label: string;
+    }[];
+    question: string;
+    header: string;
+}>;
+export declare const answerInput: import("@nyte-ai/schema").Schema<{
+    answers: string[][];
+}>;
+export declare const questionOutput: import("@nyte-ai/schema").Schema<{
+    answers: string[][] | null;
+}>;
+declare const state: import("@nyte-ai/schema").Schema<{
+    answers: string[][] | null;
+    questions: {
+        multiple?: boolean | undefined;
+        options: {
+            description: string;
+            label: string;
+        }[];
+        question: string;
+        header: string;
+    }[];
+}>;
+export declare const questionParameters: import("@nyte-ai/schema").Schema<{
+    questions: {
+        multiple?: boolean | undefined;
+        options: {
+            description: string;
+            label: string;
+        }[];
+        question: string;
+        header: string;
+    }[];
+}>;
+/** A question, its described choices, and whether the user may select several. */
+export type QuestionInfo = Infer<typeof info>;
+/** One answer list per question, in request order. An empty list leaves a question unanswered. */
+export type QuestionAnswers = Infer<typeof answerInput>["answers"];
+/** A grouped question request and its first complete answer, null while waiting. */
+export type QuestionState = Infer<typeof state>;
+/**
+ * A grouped modal request. Its answer action submits all questions at once,
+ * preserving the first complete answer across retries and restarts.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const question: {
+    kind: string;
+    state: import("@nyte-ai/schema").Schema<{
+        answers: string[][] | null;
+        questions: {
+            multiple?: boolean | undefined;
+            options: {
+                description: string;
+                label: string;
+            }[];
+            question: string;
+            header: string;
+        }[];
+    }>;
+    actions: {
+        answer: {
+            input: import("@nyte-ai/schema").Schema<{
+                answers: string[][];
+            }>;
+        };
+    };
+    fallback: (current: {
+        answers: string[][] | null;
+        questions: {
+            multiple?: boolean | undefined;
+            options: {
+                description: string;
+                label: string;
+            }[];
+            question: string;
+            header: string;
+        }[];
+    }, { id }: {
+        readonly id: PartId;
+    }) => string;
+};
+/** A grouped request still waiting for the user, with the part its submission goes to. */
+export type OpenQuestion = Pick<QuestionState, "questions"> & {
+    readonly part: PartId;
+};
+/**
+ * Returns unanswered live question requests, oldest first. Requests from a
+ * stopped or failed run and parts with invalid state are omitted.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare function openQuestions(view: Pick<SessionView, "parts"> | undefined): readonly OpenQuestion[];
+export {};

package/dist/src/question/schema.js

@@ -0,0 +1,14 @@
+import {
+  answerInput2,
+  questionOutput2,
+  questionParameters2,
+  question3,
+  openQuestions2
+} from "../../chunks/billing-6z2kgtyt.js";
+export {
+  answerInput2 as answerInput,
+  openQuestions2 as openQuestions,
+  question3 as question,
+  questionOutput2 as questionOutput,
+  questionParameters2 as questionParameters
+};

package/dist/src/rename.d.ts

@@ -0,0 +1,78 @@
+import type { Command } from "@nyte-ai/plugin/core";
+/**
+ * The instruction a title request runs under: one short line in the user's
+ * language, naming what the conversation is about.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const TITLE_PROMPT = "You write the title of a conversation so the user can find it later.\nAnswer with one line of at most 50 characters and nothing else, in the language of the user's request.\nName the topic or task, keep technical terms, numbers and file names exact, and never answer the request itself.";
+/**
+ * Names an unnamed root session after its first run: one `api.request` to
+ * the session's model for a title, then `session.update({ name })`. A named
+ * session or a child keeps its name, so every later run is a no-op. The
+ * request runs past the hook's budget, bounded by the plugin's deactivation;
+ * a failure is reported and leaves the name alone. `/rename <name>` names the
+ * chat; `/rename` alone asks the model again.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: {
+    id: string;
+    contribute: {
+        commands: Command<"core">[];
+    };
+    hooks: {
+        run_ended: (_end: Readonly<{
+            readonly kind: "completed";
+            readonly usage: {
+                readonly output: number;
+                readonly input: number;
+                readonly cacheRead: number;
+                readonly cacheWrite: number;
+                readonly reasoning: number | null;
+                readonly total: number;
+                readonly cost: {
+                    readonly output: number;
+                    readonly input: number;
+                    readonly cacheRead: number;
+                    readonly cacheWrite: number;
+                    readonly total: number;
+                };
+            };
+        } | {
+            readonly kind: "stopped";
+        } | {
+            readonly kind: "failed";
+            readonly failure: {
+                readonly retryAfterMs?: number | undefined;
+                readonly message: string;
+                readonly class: "aborted" | "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "runner";
+            };
+        }>, { api }: {
+            readonly 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: 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>;
+            };
+            readonly signal: AbortSignal;
+            readonly session: import("@nyte-ai/schema").SessionId | null;
+            readonly head: import("@nyte-ai/schema").HeadName | null;
+            readonly run: import("@nyte-ai/schema").RunId | null;
+        }) => void;
+    };
+};
+export default _default;

package/dist/src/rename.js

@@ -0,0 +1,78 @@
+// src/rename.ts
+import { dev, isPart, text } from "@nyte-ai/core";
+var TITLE_PROMPT = `You write the title of a conversation so the user can find it later.
+Answer with one line of at most 50 characters and nothing else, in the language of the user's request.
+Name the topic or task, keep technical terms, numbers and file names exact, and never answer the request itself.`;
+var NAME_LIMIT = 100;
+var renameCommand = {
+  name: "rename",
+  title: "Rename chat",
+  description: "Names the chat; with no name, the chat's model titles it again.",
+  takesText: true,
+  async run(given, { api, signal }) {
+    const name = given === "" ? await requestTitle(api, signal) : given.slice(0, NAME_LIMIT);
+    await api.session.update({ name });
+    return `Renamed to ${name}.`;
+  }
+};
+var rename_default = {
+  id: "rename",
+  contribute: { commands: [renameCommand] },
+  hooks: {
+    run_ended: (_end, { api }) => {
+      nameUnnamed(api).catch((error) => api.report({
+        severity: "warning",
+        path: ["run_ended"],
+        message: `Naming the session failed: ${error instanceof Error ? error.message : String(error)}`,
+        source: { plugin: "rename" }
+      }));
+    }
+  }
+};
+async function nameUnnamed(api) {
+  const info = await api.session.info();
+  if (info.name !== null || info.parent !== null)
+    return;
+  await api.session.update({ name: await requestTitle(api, api.signal) });
+}
+async function requestTitle(api, signal) {
+  const view = await api.session.view();
+  const model = view.configuration.effective?.model;
+  const conversation = transcript(view.messages);
+  if (model === undefined)
+    throw new Error("The chat has no model to title it.");
+  if (conversation === "")
+    throw new Error("Send a message before titling the chat.");
+  const outcome = await api.request({
+    model,
+    system: TITLE_PROMPT,
+    messages: [{ role: "user", content: conversation, timestamp: Date.now() }],
+    maxOutput: 64,
+    signal
+  });
+  dev("rename", "title", { session: api.session.id, outcome: outcome.kind });
+  if (outcome.kind === "refused")
+    throw new Error(outcome.reason);
+  if (outcome.kind === "failed")
+    throw new Error(outcome.failure.message);
+  const name = outcome.value.split(`
+`).find((line) => line.trim() !== "")?.trim().slice(0, NAME_LIMIT);
+  if (name === undefined)
+    throw new Error("The model answered with no title.");
+  return name;
+}
+function transcript(messages) {
+  return messages.flatMap((message) => {
+    if (message.kind === "user") {
+      const words = typeof message.content === "string" ? message.content : message.content.flatMap((block) => block.kind === "text" ? [block.text] : []).join(" ");
+      return [`User: ${words}`];
+    }
+    return isPart(message, text) ? [`Assistant: ${message.state.markdown}`] : [];
+  }).join(`
+
+`).slice(0, 4000);
+}
+export {
+  TITLE_PROMPT,
+  rename_default as default
+};

package/dist/src/telemetry.d.ts

@@ -0,0 +1,36 @@
+import type { SettingDefinition } from "@nyte-ai/core";
+/**
+ * Exports one span per model request to an OTLP/HTTP traces endpoint, the
+ * host setting `telemetry.endpoint`; empty, the default, exports nothing.
+ * The span runs from the request's start to its settlement and carries the
+ * model, step, thinking level, session, run and token usage. Each session
+ * follows the setting as it changes, and sessions on one endpoint share one
+ * tracer provider (§48h).
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: {
+    id: string;
+    contribute: {
+        settings: SettingDefinition<string>[];
+    };
+    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: 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/src/telemetry.js

@@ -0,0 +1,84 @@
+// src/telemetry.ts
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { SimpleSpanProcessor, TracerProvider } from "@opentelemetry/sdk-trace";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+import { dev } from "@nyte-ai/core";
+import { standard } from "@nyte-ai/schema";
+import { Type } from "typebox";
+var endpoint = {
+  id: "telemetry.endpoint",
+  label: "OTLP traces endpoint",
+  schema: standard(Type.String()),
+  default: "",
+  scope: "host"
+};
+var providers = new Map;
+function hold(url) {
+  const known = providers.get(url);
+  const provider = known?.provider ?? new TracerProvider({
+    resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: "nyte" }),
+    spanProcessors: [new SimpleSpanProcessor({ exporter: new OTLPTraceExporter({ url }) })]
+  });
+  const held = known ?? {
+    provider,
+    tracer: provider.getTracer("@nyte-ai/plugin/core/telemetry"),
+    holders: 0
+  };
+  held.holders += 1;
+  providers.set(url, held);
+  let released = false;
+  return {
+    tracer: held.tracer,
+    release() {
+      if (released)
+        return;
+      released = true;
+      held.holders -= 1;
+      if (held.holders > 0)
+        return;
+      providers.delete(url);
+      held.provider.shutdown();
+    }
+  };
+}
+var telemetry_default = {
+  id: "telemetry",
+  contribute: { settings: [endpoint] },
+  activate(api) {
+    let current = null;
+    api.hook("after_request", (event, { session, run }) => {
+      const end = Date.now();
+      current?.tracer.startSpan(`${event.step} ${event.model.provider}/${event.model.id}`, {
+        startTime: end - event.durationMs,
+        attributes: {
+          "gen_ai.provider.name": event.model.provider,
+          "gen_ai.request.model": event.model.id,
+          "gen_ai.usage.input_tokens": event.usage.input,
+          "gen_ai.usage.output_tokens": event.usage.output,
+          "nyte.step": event.step,
+          "nyte.thinking": event.thinking,
+          "nyte.session": session ?? "",
+          "nyte.run": run ?? "",
+          "nyte.cost": event.usage.cost.total
+        }
+      }).end(end);
+    });
+    (async () => {
+      for await (const url of api.contribute.settings.watch(endpoint.id)) {
+        current?.release();
+        current = typeof url === "string" && url !== "" ? hold(url) : null;
+        dev("telemetry", "endpoint", {
+          session: api.session.id,
+          exporting: current !== null,
+          providers: providers.size
+        });
+      }
+      current?.release();
+      current = null;
+    })();
+  }
+};
+export {
+  telemetry_default as default
+};

package/dist/src/web-search.d.ts

@@ -0,0 +1,78 @@
+import type { Command, SettingDefinition } from "@nyte-ai/core";
+/**
+ * Names a search provider the `web_search` tool can route to.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type SearchProvider = (typeof PROVIDERS)[number];
+declare const PROVIDERS: readonly ["exa", "tavily", "firecrawl", "parallel"];
+/**
+ * Returns one search hit as the tool reports it.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export interface SearchResult {
+    readonly url: string;
+    readonly title: string | null;
+    readonly content: string | null;
+}
+/**
+ * Returns what one adapter call needs: the query, the provider's key or
+ * undefined for its keyless route, the fetch to send with, and a signal.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export interface SearchInput {
+    readonly query: string;
+    readonly key: string | undefined;
+    readonly fetch: typeof globalThis.fetch;
+    readonly signal: AbortSignal;
+}
+/**
+ * One adapter per provider: Tavily over its REST endpoint, the others over
+ * one stateless MCP `tools/call` to their public route. Each sends through
+ * the given fetch only and returns the hits it recognised.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const adapters: {
+    readonly [P in SearchProvider]: (input: SearchInput) => Promise<readonly SearchResult[]>;
+};
+/**
+ * Adds `web_search`, routed by the host setting `web_search.provider` to
+ * Tavily, Exa, Firecrawl or Parallel. A provider's key lives in the plugin's
+ * secrets under the provider's id, set with the `websearch-key` command; without one
+ * the provider's keyless route is used.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: {
+    id: string;
+    contribute: {
+        settings: SettingDefinition<"exa" | "tavily" | "firecrawl" | "parallel">[];
+        commands: Command<keyof import("@nyte-ai/core").SideTable>[];
+    };
+    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: 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;