@evandu/super-pi 0.1.130 → 0.1.132

package/dist/server/presentations/schema.d.ts

@@ -0,0 +1,120 @@
+/** Versioned, renderer-independent contract for structured presentation tools. */
+export declare const PRESENTATION_SPEC_VERSION: 1;
+export declare const PRESENTATION_LIMITS: {
+    readonly maxSlides: 200;
+    readonly maxElementsPerSlide: 500;
+    readonly maxTextCharacters: 100000;
+    readonly maxTableCells: 10000;
+    readonly maxChartPoints: 20000;
+};
+export type PresentationSpec = {
+    version: typeof PRESENTATION_SPEC_VERSION;
+    metadata?: {
+        title?: string;
+        subject?: string;
+        author?: string;
+        company?: string;
+        language?: string;
+    };
+    canvas: {
+        width: number;
+        height: number;
+    };
+    theme?: PresentationTheme;
+    slides: PresentationSlide[];
+};
+export type PresentationTheme = {
+    colors?: Record<string, string>;
+    fonts?: {
+        heading?: string;
+        body?: string;
+        mono?: string;
+    };
+};
+export type PresentationSlide = {
+    id: string;
+    title?: string;
+    notes?: string;
+    background?: string;
+    elements: PresentationElement[];
+};
+type Frame = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type BaseElement = Frame & {
+    id: string;
+    altText?: string;
+    name?: string;
+    hidden?: boolean;
+    rotation?: number;
+};
+export type TextElement = BaseElement & {
+    type: "text";
+    text: string;
+    fontFamily?: string;
+    fontSize?: number;
+    color?: string;
+    bold?: boolean;
+    italic?: boolean;
+    align?: "left" | "center" | "right" | "justify";
+    verticalAlign?: "top" | "middle" | "bottom";
+    link?: string;
+};
+export type ShapeElement = BaseElement & {
+    type: "shape";
+    shape: "rectangle" | "roundRectangle" | "ellipse" | "triangle" | "chevron";
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+};
+export type LineElement = BaseElement & {
+    type: "line";
+    stroke?: string;
+    strokeWidth?: number;
+    dash?: "solid" | "dash" | "dot";
+    beginArrow?: boolean;
+    endArrow?: boolean;
+};
+export type ImageElement = BaseElement & {
+    type: "image";
+    source: string;
+    fit?: "contain" | "cover" | "stretch";
+    link?: string;
+};
+export type TableElement = BaseElement & {
+    type: "table";
+    rows: Array<Array<string | number | boolean | null>>;
+    headerRows?: number;
+};
+export type ChartElement = BaseElement & {
+    type: "chart";
+    chart: "bar" | "column" | "line" | "area" | "pie" | "doughnut" | "scatter";
+    categories?: string[];
+    series: Array<{
+        name: string;
+        values: Array<number | null>;
+        xValues?: Array<number | null>;
+    }>;
+    showLegend?: boolean;
+    showValues?: boolean;
+};
+export type PresentationElement = TextElement | ShapeElement | LineElement | ImageElement | TableElement | ChartElement;
+export type PresentationDiagnostic = {
+    code: "invalid_type" | "invalid_value" | "unsupported_version" | "duplicate_id" | "limit_exceeded" | "out_of_bounds";
+    severity: "error" | "warning";
+    path: string;
+    message: string;
+};
+export type PresentationValidationResult = {
+    valid: true;
+    spec: PresentationSpec;
+    diagnostics: PresentationDiagnostic[];
+} | {
+    valid: false;
+    diagnostics: PresentationDiagnostic[];
+};
+export declare function validatePresentationSpec(input: unknown): PresentationValidationResult;
+export {};

package/dist/server/presentations/schema.js

@@ -0,0 +1,128 @@
+/** Versioned, renderer-independent contract for structured presentation tools. */
+export const PRESENTATION_SPEC_VERSION = 1;
+export const PRESENTATION_LIMITS = {
+    maxSlides: 200,
+    maxElementsPerSlide: 500,
+    maxTextCharacters: 100_000,
+    maxTableCells: 10_000,
+    maxChartPoints: 20_000,
+};
+const ELEMENT_TYPES = new Set(["text", "shape", "line", "image", "table", "chart"]);
+const ID_PATTERN = /^[A-Za-z][A-Za-z0-9._-]{0,127}$/;
+export function validatePresentationSpec(input) {
+    const diagnostics = [];
+    const error = (code, path, message) => diagnostics.push({ code, severity: "error", path, message });
+    if (!isObject(input)) {
+        error("invalid_type", "$", "Presentation spec must be an object.");
+        return { valid: false, diagnostics };
+    }
+    if (input.version !== PRESENTATION_SPEC_VERSION) {
+        error("unsupported_version", "$.version", `Only presentation spec version ${PRESENTATION_SPEC_VERSION} is supported.`);
+    }
+    const canvas = input.canvas;
+    if (!isObject(canvas))
+        error("invalid_type", "$.canvas", "Canvas must be an object.");
+    else {
+        positiveNumber(canvas.width, "$.canvas.width", error);
+        positiveNumber(canvas.height, "$.canvas.height", error);
+    }
+    if (!Array.isArray(input.slides)) {
+        error("invalid_type", "$.slides", "Slides must be an array.");
+    }
+    else {
+        if (input.slides.length > PRESENTATION_LIMITS.maxSlides) {
+            error("limit_exceeded", "$.slides", `A deck may contain at most ${PRESENTATION_LIMITS.maxSlides} slides.`);
+        }
+        const ids = new Set();
+        input.slides.forEach((slide, slideIndex) => validateSlide(slide, slideIndex, canvas, ids, error));
+    }
+    if (input.theme !== undefined)
+        validateTheme(input.theme, error);
+    return diagnostics.some((item) => item.severity === "error")
+        ? { valid: false, diagnostics }
+        : { valid: true, spec: input, diagnostics };
+}
+function validateSlide(slide, index, canvas, ids, error) {
+    const path = `$.slides[${index}]`;
+    if (!isObject(slide))
+        return error("invalid_type", path, "Slide must be an object.");
+    validateId(slide.id, `${path}.id`, ids, error);
+    if (!Array.isArray(slide.elements))
+        return error("invalid_type", `${path}.elements`, "Elements must be an array.");
+    if (slide.elements.length > PRESENTATION_LIMITS.maxElementsPerSlide) {
+        error("limit_exceeded", `${path}.elements`, `A slide may contain at most ${PRESENTATION_LIMITS.maxElementsPerSlide} elements.`);
+    }
+    slide.elements.forEach((element, elementIndex) => validateElement(element, `${path}.elements[${elementIndex}]`, canvas, ids, error));
+}
+function validateElement(element, path, canvas, ids, error) {
+    if (!isObject(element))
+        return error("invalid_type", path, "Element must be an object.");
+    validateId(element.id, `${path}.id`, ids, error);
+    if (typeof element.type !== "string" || !ELEMENT_TYPES.has(element.type)) {
+        error("invalid_value", `${path}.type`, "Element type is not supported.");
+        return;
+    }
+    for (const key of ["x", "y", "width", "height"])
+        positiveNumber(element[key], `${path}.${key}`, error, key === "x" || key === "y");
+    if (isObject(canvas) && finite(element.x) && finite(element.y) && finite(element.width) && finite(element.height)
+        && finite(canvas.width) && finite(canvas.height)
+        && (element.x < 0 || element.y < 0 || element.x + element.width > canvas.width || element.y + element.height > canvas.height)) {
+        error("out_of_bounds", path, "Element frame must fit within the canvas.");
+    }
+    if (element.type === "text") {
+        if (typeof element.text !== "string")
+            error("invalid_type", `${path}.text`, "Text must be a string.");
+        else if (element.text.length > PRESENTATION_LIMITS.maxTextCharacters)
+            error("limit_exceeded", `${path}.text`, "Text is too long.");
+    }
+    else if (element.type === "image") {
+        if (typeof element.source !== "string" || !element.source.trim())
+            error("invalid_value", `${path}.source`, "Image source is required.");
+        if (!element.altText)
+            error("invalid_value", `${path}.altText`, "Images require alt text.");
+    }
+    else if (element.type === "table") {
+        if (!Array.isArray(element.rows))
+            error("invalid_type", `${path}.rows`, "Table rows must be an array.");
+        else if (element.rows.reduce((sum, row) => sum + (Array.isArray(row) ? row.length : 0), 0) > PRESENTATION_LIMITS.maxTableCells)
+            error("limit_exceeded", `${path}.rows`, "Table contains too many cells.");
+    }
+    else if (element.type === "chart")
+        validateChart(element, path, error);
+}
+function validateChart(chart, path, error) {
+    if (!Array.isArray(chart.series) || chart.series.length === 0)
+        return error("invalid_value", `${path}.series`, "Chart requires at least one series.");
+    let points = 0;
+    for (const [index, series] of chart.series.entries()) {
+        if (!isObject(series) || typeof series.name !== "string" || !Array.isArray(series.values)) {
+            error("invalid_type", `${path}.series[${index}]`, "Series requires a name and numeric values.");
+            continue;
+        }
+        if (series.values.some((value) => value !== null && !finite(value)))
+            error("invalid_value", `${path}.series[${index}].values`, "Chart values must be finite numbers or null.");
+        points += series.values.length;
+    }
+    if (points > PRESENTATION_LIMITS.maxChartPoints)
+        error("limit_exceeded", `${path}.series`, "Chart contains too many data points.");
+}
+function validateTheme(theme, error) {
+    if (!isObject(theme))
+        return error("invalid_type", "$.theme", "Theme must be an object.");
+    if (theme.colors !== undefined && (!isObject(theme.colors) || Object.values(theme.colors).some((value) => typeof value !== "string"))) {
+        error("invalid_type", "$.theme.colors", "Theme colors must map token names to color strings.");
+    }
+}
+function validateId(value, path, ids, error) {
+    if (typeof value !== "string" || !ID_PATTERN.test(value))
+        return error("invalid_value", path, "ID must start with a letter and contain only letters, digits, dot, underscore, or hyphen.");
+    if (ids.has(value))
+        error("duplicate_id", path, `ID '${value}' is already used in this deck.`);
+    ids.add(value);
+}
+function positiveNumber(value, path, error, allowZero = false) {
+    if (!finite(value) || (allowZero ? value < 0 : value <= 0))
+        error("invalid_value", path, allowZero ? "Value must be a non-negative finite number." : "Value must be a positive finite number.");
+}
+function finite(value) { return typeof value === "number" && Number.isFinite(value); }
+function isObject(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }

package/dist/server/runtime.d.ts

@@ -512,6 +512,19 @@ export declare const catalogKey: (selection?: ModelSelection) => string;
  * warning on a path that is genuinely optional rather than a startup crash on a build that skipped it.
  */
 export declare function taskExtensionPath(from?: string): string;
+/**
+ * The document extension's file, resolved the same way the task extension's is: two `..` segments
+ * from `import.meta.dirname` reach the repository root both after `tsc -b` and under `tsx watch`.
+ */
+export declare function documentExtensionPath(from?: string): string;
+/**
+ * The Feishu extension's file, resolved the same way the document extension's is.
+ *
+ * Named on both sides of the wire rather than imported by the extension, for the reason every one
+ * of these names is written out twice: `agents/` is loaded by Pi's module loader and `src/` by
+ * tsc, so a relative import across the two would resolve differently under each.
+ */
+export declare function feishuExtensionPath(from?: string): string;
 export declare class PiRpcRuntime implements AgentRuntime {
     private readonly sessionDir;
     /**
@@ -635,6 +648,10 @@ export declare class PiRpcRuntime implements AgentRuntime {
     private modelEpoch;
     /** Latches the "no extension on disk" warning, so it is said once rather than once per turn. */
     private warnedMissingExtension;
+    /** Latches the "the document extension is missing" warning, for the same reason. */
+    private warnedMissingDocumentExtension;
+    /** Latches the "the Feishu extension is missing" warning, for the same reason. */
+    private warnedMissingFeishuExtension;
     /** Latches the "Pi's SDK is not installed" warning, for the same reason. */
     private warnedMissingSdk;
     /**
@@ -701,6 +718,8 @@ export declare class PiRpcRuntime implements AgentRuntime {
         workflowEndpoint?: string;
         questionEndpoint?: string;
         toolsEndpoint?: string;
+        documentsEndpoint?: string;
+        scheduledTaskEndpoint?: string;
         uploadsDir?: string;
         sessionFactory?: PiSessionFactory;
         sessionMode?: "sdk" | "oneshot";
@@ -784,6 +803,28 @@ export declare class PiRpcRuntime implements AgentRuntime {
      *   knowing and worth not repeating on every keystroke.
      */
     private taskExtensionArgs;
+    /**
+     * The document extension's spawn argument.
+     *
+     * IT IS MOUNTED UNCONDITIONALLY, unlike the knowledge extension. The knowledge extension is only
+     * worth mounting when the workspace HAS documents, because its tool returns nothing otherwise; the
+     * document tools are about the files in the workspace, and a workspace with no PDF in it is exactly
+     * the workspace where an agent might be asked to WRITE one.
+     *
+     * The endpoint is the gate: without it the extension returns without registering anything, so a
+     * runtime with no document endpoint mounts nothing rather than a tool whose every call fails.
+     */
+    private documentExtensionArgs;
+    /**
+     * The Feishu extension's spawn argument.
+     *
+     * MOUNTED UNCONDITIONALLY, for the same reason the document tools are: the endpoint is the gate,
+     * and the extension registers nothing without it. The credential is NOT the gate - a user who
+     * has not configured an application yet still gets the tools, because the error those tools
+     * return is the one that tells the user what to do, and a tool that is simply absent cannot say
+     * anything at all.
+     */
+    private feishuExtensionArgs;
     /**
      * The five values the extension reads out of its own environment. See `task-tool.ts` for why they are
      * written out on both sides rather than imported.
@@ -906,7 +947,33 @@ export declare class PiRpcRuntime implements AgentRuntime {
      * because `toolFlags` treats an explicit false as outranking a host extra.
      */
     private extensionToolNames;
+    /**
+     * A TURN, WITH THE REASONING TAKEN OUT OF THE ANSWER.
+     *
+     * This is the ONE place every turn passes through, whichever path it runs on - the persistent
+     * session or a one-shot process - so it is where the model's own text is read once and read
+     * properly.
+     *
+     * WHAT IT DOES. A model that has no reasoning channel answers in one stream of text and marks its
+     * thinking up inside it with `<think>…</think>`. Pi's adapter passes that through as ordinary
+     * text, because Pi only knows the four reasoning FIELDS a provider can use and a tag is not one
+     * of them. Left alone, the reasoning would be drawn as part of the answer, unlabelled, with the
+     * tags in it.
+     *
+     * WHY IT IS HERE AND NOT IN THE USER'S `models.json`. The alternative is to tell every reader to
+     * go and set a vendor-specific switch in a file Super Pi owns but Pi reads. A user who never
+     * hears of it sees a broken transcript and has no way to find out why. Super Pi reads the tags
+     * itself, for every provider, so the transcript reads the same way whichever endpoint is behind
+     * it - and the reasoning goes where the reasoning goes: into a thinking block, over the same
+     * channel Pi's own reasoning events use, so the fold, the live indicator and the persisted
+     * transcript all work without knowing where the reasoning came from.
+     */
     answer(input: AnswerInput): AsyncIterable<string>;
+    /**
+     * THE TURN ITSELF, on whichever path it runs. See `answer`, which is the seam the reasoning is
+     * separated at.
+     */
+    private answerTurn;
     /**
      * The one-shot path: a fresh child process for a single turn.
      *