wizards 0.1.9

package/apps/runtime/dist/db/migrations/tenant/meta/_journal.json

@@ -0,0 +1,41 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1790945216913,
+      "tag": "0000_eminent_freak",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "6",
+      "when": 1791067068249,
+      "tag": "0001_salty_master_chief",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1791071240061,
+      "tag": "0002_cloudy_firebird",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1791096208798,
+      "tag": "0003_brown_warbound",
+      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "6",
+      "when": 1791129806883,
+      "tag": "0004_romantic_nocturne",
+      "breakpoints": true
+    }
+  ]
+}

package/apps/runtime/dist/db/schema.js

@@ -0,0 +1,278 @@
+import { sql } from "drizzle-orm";
+import { blob, index, integer, primaryKey, sqliteTable, text, uniqueIndex, } from "drizzle-orm/sqlite-core";
+const now = sql `(unixepoch() * 1000)`;
+const createdAt = () => integer("created_at", { mode: "timestamp_ms" }).notNull().default(now);
+const updatedAt = () => integer("updated_at", { mode: "timestamp_ms" }).notNull().default(now);
+export const project = sqliteTable("project", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    name: text("name").notNull(),
+    brand: text("brand", { mode: "json" }).$type().notNull().default({}),
+    facts: text("facts", { mode: "json" }).$type().notNull().default([]),
+    mcpServers: text("mcp_servers", { mode: "json" })
+        .$type()
+        .notNull()
+        .default([]),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (t) => [index("project_tenant").on(t.tenantId)]);
+export const wizard = sqliteTable("wizard", {
+    id: text("id").primaryKey(),
+    projectId: text("project_id")
+        .notNull()
+        .references(() => project.id, { onDelete: "cascade" }),
+    tenantId: text("tenant_id").notNull(),
+    title: text("title").notNull(),
+    draft: text("draft", { mode: "json" }).$type().notNull(),
+    publishedVersion: integer("published_version"),
+    shareToken: text("share_token").notNull(),
+    shareEnabled: integer("share_enabled", { mode: "boolean" }).notNull().default(true),
+    dailyRunLimit: integer("daily_run_limit").notNull().default(50),
+    starter: text("starter"),
+    /** The revision of the marketplace entry the wizard was made from. */
+    starterRevision: integer("starter_revision"),
+    /** Bumped on every draft write; a write carrying an older one is refused. */
+    revision: integer("revision").notNull().default(0),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (t) => [
+    uniqueIndex("wizard_share_token").on(t.shareToken),
+    index("wizard_project").on(t.projectId),
+]);
+export const wizardVersion = sqliteTable("wizard_version", {
+    id: text("id").primaryKey(),
+    wizardId: text("wizard_id")
+        .notNull()
+        .references(() => wizard.id, { onDelete: "cascade" }),
+    version: integer("version").notNull(),
+    definition: text("definition", { mode: "json" }).$type().notNull(),
+    /** The workspace as it was at publish time. */
+    files: text("files", { mode: "json" }).$type().notNull().default([]),
+    createdAt: createdAt(),
+}, (t) => [uniqueIndex("wizard_version_n").on(t.wizardId, t.version)]);
+/** The draft's workspace: widget code, libraries, reference data. Content lives in the blob store. */
+export const wizardFile = sqliteTable("wizard_file", {
+    wizardId: text("wizard_id")
+        .notNull()
+        .references(() => wizard.id, { onDelete: "cascade" }),
+    path: text("path").notNull(),
+    hash: text("hash").notNull(),
+    mime: text("mime").notNull(),
+    size: integer("size").notNull(),
+    updatedAt: updatedAt(),
+}, (t) => [primaryKey({ columns: [t.wizardId, t.path] })]);
+export const wizardMessage = sqliteTable("wizard_message", {
+    id: text("id").primaryKey(),
+    wizardId: text("wizard_id")
+        .notNull()
+        .references(() => wizard.id, { onDelete: "cascade" }),
+    role: text("role", { enum: ["user", "assistant"] }).notNull(),
+    content: text("content").notNull(),
+    /** Set on assistant turns that changed the wizard. */
+    changed: integer("changed", { mode: "boolean" }).notNull().default(false),
+    /** "mcp": written by an admin's own client (Claude Code, Cursor …) named in `client`. */
+    source: text("source", { enum: ["studio", "mcp"] })
+        .notNull()
+        .default("studio"),
+    client: text("client"),
+    createdAt: createdAt(),
+}, (t) => [index("wizard_message_wizard").on(t.wizardId, t.createdAt)]);
+export const run = sqliteTable("run", {
+    id: text("id").primaryKey(),
+    wizardId: text("wizard_id")
+        .notNull()
+        .references(() => wizard.id, { onDelete: "cascade" }),
+    tenantId: text("tenant_id").notNull(),
+    /** The definition the run started on — edits never reach a running wizard. */
+    definition: text("definition", { mode: "json" }).$type().notNull(),
+    /** The workspace the run started with. */
+    files: text("files", { mode: "json" }).$type().notNull().default([]),
+    version: integer("version"),
+    mode: text("mode", { enum: ["test", "live"] }).notNull(),
+    visitorId: text("visitor_id"),
+    userId: text("user_id"),
+    ipHash: text("ip_hash"),
+    status: text("status", {
+        enum: ["waiting_input", "running", "done", "failed", "cancelled"],
+    }).notNull(),
+    cursor: text("cursor"),
+    state: text("state", { mode: "json" }).$type().notNull(),
+    error: text("error"),
+    /** What a running step is asking the person right now (a login, a code); null = nothing. */
+    ask: text("ask", { mode: "json" }).$type(),
+    costMicros: integer("cost_micros").notNull().default(0),
+    /** Set once the result is shared: `/s/<token>` shows it read-only. */
+    shareToken: text("share_token"),
+    sharedAt: integer("shared_at", { mode: "timestamp_ms" }),
+    /** Runs without an account are deleted after this; null keeps the run. */
+    expiresAt: integer("expires_at", { mode: "timestamp_ms" }),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (t) => [
+    uniqueIndex("run_share_token").on(t.shareToken),
+    index("run_expires").on(t.expiresAt),
+    index("run_wizard").on(t.wizardId, t.createdAt),
+    index("run_visitor").on(t.visitorId, t.createdAt),
+    index("run_status").on(t.status),
+]);
+export const runEvent = sqliteTable("run_event", {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    runId: text("run_id")
+        .notNull()
+        .references(() => run.id, { onDelete: "cascade" }),
+    stepId: text("step_id"),
+    type: text("type", { enum: ["step_started", "step_done", "tool", "info", "error"] }).notNull(),
+    message: text("message").notNull(),
+    /** A picture of the run the event is about; shown while the step works. */
+    assetId: text("asset_id"),
+    createdAt: createdAt(),
+}, (t) => [index("run_event_run").on(t.runId, t.id)]);
+/** What each step of a run cost, in credit micros: the measurements estimates are made from. */
+export const runCost = sqliteTable("run_cost", {
+    runId: text("run_id")
+        .notNull()
+        .references(() => run.id, { onDelete: "cascade" }),
+    stepId: text("step_id").notNull(),
+    micros: integer("micros").notNull().default(0),
+}, (t) => [primaryKey({ columns: [t.runId, t.stepId] })]);
+export const asset = sqliteTable("asset", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    runId: text("run_id"),
+    stepId: text("step_id"),
+    kind: text("kind").notNull(),
+    mime: text("mime").notNull(),
+    name: text("name").notNull(),
+    path: text("path").notNull(),
+    size: integer("size").notNull(),
+    createdAt: createdAt(),
+}, (t) => [index("asset_run").on(t.runId)]);
+/**
+ * A service imported as a connector, from the integrations registry or a pasted OpenAPI spec /
+ * MCP endpoint. The record is engenty's: actions, auth and source, normalised at import time.
+ */
+export const projectConnector = sqliteTable("project_connector", {
+    projectId: text("project_id")
+        .notNull()
+        .references(() => project.id, { onDelete: "cascade" }),
+    id: text("id").notNull(),
+    record: text("record", { mode: "json" }).$type().notNull(),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (t) => [primaryKey({ columns: [t.projectId, t.id] })]);
+/**
+ * What a project holds for all its wizards: logos, assets (images, graphics, videos) and
+ * documents. `id` is the asset the content lives in. The first logo is the one end users see.
+ */
+export const projectFile = sqliteTable("project_file", {
+    id: text("id").primaryKey(),
+    projectId: text("project_id")
+        .notNull()
+        .references(() => project.id, { onDelete: "cascade" }),
+    kind: text("kind", { enum: ["logo", "asset", "document"] }).notNull(),
+    name: text("name").notNull(),
+    mime: text("mime").notNull(),
+    size: integer("size").notNull(),
+    description: text("description").notNull().default(""),
+    /** A web address the file was fetched from, when it was not uploaded. */
+    source: text("source"),
+    position: integer("position").notNull().default(0),
+    /** `pending` while it is read, described and indexed. */
+    status: text("status", { enum: ["pending", "ready", "failed"] })
+        .notNull()
+        .default("ready"),
+    error: text("error"),
+    /** A document's text as Markdown, in the blob store. */
+    textHash: text("text_hash"),
+    pages: integer("pages"),
+    chars: integer("chars"),
+    /** What the index holds of a document; `embeddings` includes the keywords. */
+    indexed: text("indexed", { enum: ["embeddings", "keywords"] }),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (t) => [index("project_file_project").on(t.projectId, t.kind, t.position)]);
+/**
+ * The document index: passages of a project's documents. Keywords live in the FTS5 table
+ * `project_chunk_fts`, which triggers keep in step (see the migration); `embedding` is the
+ * passage's vector as float32 bytes, compared with libSQL's `vector_distance_cos`.
+ */
+export const projectChunk = sqliteTable("project_chunk", {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    projectId: text("project_id")
+        .notNull()
+        .references(() => project.id, { onDelete: "cascade" }),
+    fileId: text("file_id")
+        .notNull()
+        .references(() => projectFile.id, { onDelete: "cascade" }),
+    idx: integer("idx").notNull(),
+    text: text("text").notNull(),
+    embedding: blob("embedding", { mode: "buffer" }),
+    /** The model the vector was made with; only vectors of one model are compared. */
+    model: text("model"),
+}, (t) => [
+    index("project_chunk_project").on(t.projectId, t.model),
+    index("project_chunk_file").on(t.fileId),
+]);
+// --- The wizard's store ------------------------------------------------------
+// What a wizard keeps between runs for one person. `holder` is that person: "u:<userId>" for a
+// signed-in admin, "v:<visitorId>" for an end user on a shared link.
+/** One (wizard, person) pair that has stored something; `usedAt` drives the clean-up. */
+export const storeHolder = sqliteTable("store_holder", {
+    wizardId: text("wizard_id")
+        .notNull()
+        .references(() => wizard.id, { onDelete: "cascade" }),
+    holder: text("holder").notNull(),
+    usedAt: integer("used_at", { mode: "timestamp_ms" }).notNull().default(now),
+}, (t) => [primaryKey({ columns: [t.wizardId, t.holder] }), index("store_holder_used").on(t.usedAt)]);
+/** A row of one of the wizard's lists. Columns are defined in the wizard, values live here. */
+export const storeRow = sqliteTable("store_row", {
+    id: text("id").primaryKey(),
+    wizardId: text("wizard_id")
+        .notNull()
+        .references(() => wizard.id, { onDelete: "cascade" }),
+    holder: text("holder").notNull(),
+    list: text("list").notNull(),
+    /** The key column's value, normalised; saving a row with a known key updates that row. */
+    key: text("key"),
+    cells: text("cells", { mode: "json" }).$type().notNull(),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (t) => [
+    uniqueIndex("store_row_key").on(t.wizardId, t.holder, t.list, t.key),
+    index("store_row_list").on(t.wizardId, t.holder, t.list, t.createdAt),
+]);
+/** A file the wizard keeps (a downloaded invoice, a scan). Content lives in the blob store. */
+export const storeFile = sqliteTable("store_file", {
+    wizardId: text("wizard_id")
+        .notNull()
+        .references(() => wizard.id, { onDelete: "cascade" }),
+    holder: text("holder").notNull(),
+    path: text("path").notNull(),
+    hash: text("hash").notNull(),
+    mime: text("mime").notNull(),
+    size: integer("size").notNull(),
+    source: text("source"),
+    updatedAt: updatedAt(),
+}, (t) => [primaryKey({ columns: [t.wizardId, t.holder, t.path] })]);
+/** A connected account or a kept browser session. `data` is encrypted. */
+export const storeSecret = sqliteTable("store_secret", {
+    id: text("id").primaryKey(),
+    wizardId: text("wizard_id")
+        .notNull()
+        .references(() => wizard.id, { onDelete: "cascade" }),
+    holder: text("holder").notNull(),
+    /** "connection:<id>" or "browser:<host>". */
+    slot: text("slot").notNull(),
+    provider: text("provider").notNull(),
+    /** Shown to the person: the account's address or the site's name. */
+    label: text("label").notNull(),
+    data: text("data").notNull(),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (t) => [uniqueIndex("store_secret_slot").on(t.wizardId, t.holder, t.slot)]);
+/** Marketplace entries starred here: the runtime keeps them for offline use. */
+export const marketplaceStar = sqliteTable("marketplace_star", {
+    tenantId: text("tenant_id").notNull(),
+    entryId: text("entry_id").notNull(),
+    createdAt: createdAt(),
+}, (t) => [primaryKey({ columns: [t.tenantId, t.entryId] })]);

package/apps/runtime/dist/documents/parse.js

@@ -0,0 +1,230 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { generateText, Output } from "ai";
+import PostalMime from "postal-mime";
+import { z } from "zod";
+import { parseCsvMatrix } from "../engenty/csv-import/csv-matrix.js";
+import { readXlsxWorkbook } from "../engenty/csv-import/xlsx-workbook.js";
+import { splitMarkdownByPageBreaks } from "../engenty/doc-converter/page-break.js";
+import { LocalProvider } from "../engenty/doc-converter/providers/local/index.js";
+import { invoiceSchema, receiptSchema } from "../engenty/document-scanner/schemas/index.js";
+import { env } from "../env.js";
+import { costOf, textModel } from "../models.js";
+import { htmlToMarkdown } from "../render/convert.js";
+export class UnreadableDocument extends Error {
+}
+const DOCX = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+const XLSX = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+const MIME_BY_EXT = {
+    pdf: "application/pdf",
+    docx: DOCX,
+    doc: "application/msword",
+    xlsx: XLSX,
+    csv: "text/csv",
+    tsv: "text/csv",
+    txt: "text/plain",
+    md: "text/markdown",
+    json: "application/json",
+    html: "text/html",
+    htm: "text/html",
+    eml: "message/rfc822",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    gif: "image/gif",
+};
+/** The type to read a file as: mail servers and browsers often only say "octet-stream". */
+export function documentMime(name, mime) {
+    const declared = mime.split(";")[0].trim().toLowerCase();
+    if (declared && declared !== "application/octet-stream") {
+        return declared;
+    }
+    return MIME_BY_EXT[name.split(".").pop()?.toLowerCase() ?? ""] ?? declared;
+}
+/**
+ * Reads scans and photos with a vision model, as an engenty doc-converter provider. Pages are
+ * marked with the converter's page-break sentinel so paged output looks like any other.
+ */
+class VisionProvider {
+    charge;
+    signal;
+    call;
+    id = "vision";
+    name = "Vision model";
+    supportedTypes = [
+        "application/pdf",
+        "image/png",
+        "image/jpeg",
+        "image/webp",
+        "image/gif",
+    ];
+    constructor(charge, signal, call) {
+        this.charge = charge;
+        this.signal = signal;
+        this.call = call;
+    }
+    canConvert(mimeType) {
+        return this.supportedTypes.includes(mimeType);
+    }
+    async convert(data, filename, mimeType, _options) {
+        // Reads scans and photos: the class it runs on must take PDFs and images.
+        const reader = await textModel("standard", this.call);
+        const result = await generateText({
+            model: reader.model,
+            abortSignal: this.signal,
+            maxOutputTokens: 16_000,
+            system: [
+                "You transcribe documents into clean Markdown, faithfully and completely.",
+                "Keep every number, date, name and amount exactly as printed. Tables become Markdown tables.",
+                "Do not summarise, do not comment, do not wrap the result in a code fence.",
+                'For a PDF with several pages, start each page with this line: <page-break number="N" total="T"></page-break>',
+                "If a part is illegible, write [unleserlich] there.",
+                "A photo that is no document (a room, an object, a damage): describe precisely what it shows instead — what is there, how many, materials, condition, visible defects — without guessing what cannot be seen.",
+            ].join("\n"),
+            messages: [
+                {
+                    role: "user",
+                    content: [
+                        { type: "file", data, mediaType: mimeType, filename: filename || "document" },
+                        { type: "text", text: "Transcribe this document." },
+                    ],
+                },
+            ],
+        });
+        await this.charge?.(costOf(reader, result.usage));
+        const markdown = result.text.trim();
+        return {
+            markdown,
+            metadata: { word_count: markdown.split(/\s+/).filter(Boolean).length },
+            source: { filename, mime_type: mimeType, size_bytes: data.byteLength },
+        };
+    }
+}
+const local = new LocalProvider();
+function tableMarkdown(columns, rows, limit = 400) {
+    const cell = (v) => v.replace(/\|/g, "\\|").replace(/\s+/g, " ").trim();
+    const head = `| ${columns.map(cell).join(" | ")} |\n|${columns.map(() => " --- ").join("|")}|`;
+    const body = rows.slice(0, limit).map((r) => `| ${r.map(cell).join(" | ")} |`);
+    const more = rows.length > limit ? [`\n… ${rows.length - limit} more rows`] : [];
+    return [head, ...body, ...more].join("\n");
+}
+async function parseMail(data) {
+    const mail = await PostalMime.parse(data);
+    const body = mail.text?.trim() || (mail.html ? htmlToMarkdown(mail.html) : "");
+    return [
+        `From: ${mail.from?.address ?? ""}`,
+        `To: ${(mail.to ?? []).map((t) => t.address).join(", ")}`,
+        `Date: ${mail.date ?? ""}`,
+        `Subject: ${mail.subject ?? ""}`,
+        mail.attachments.length
+            ? `Attachments: ${mail.attachments.map((a) => a.filename ?? "unnamed").join(", ")}`
+            : "",
+        "",
+        body,
+    ]
+        .filter((line, i) => line || i === 5)
+        .join("\n");
+}
+const CACHE_DIR = join(env.dataDir, "parsed");
+mkdirSync(CACHE_DIR, { recursive: true });
+/**
+ * Turns a file into Markdown: PDFs and Word files by their own text, scans and photos by a
+ * vision model, spreadsheets and CSV as tables, saved mails with their headers. The result is
+ * kept by content, so a file is read (and paid for) once.
+ */
+export async function parseDocument(input, opts = {}) {
+    const mime = documentMime(input.name, input.mime);
+    return kept(input.data, mime, () => read({ ...input, mime }, opts));
+}
+/** What was made of a file, kept by its content: the same bytes are never worked through twice. */
+async function kept(data, variant, make) {
+    const file = join(CACHE_DIR, `${createHash("sha256").update(data).update(variant).digest("hex")}.json`);
+    if (existsSync(file)) {
+        return JSON.parse(await readFile(file, "utf8"));
+    }
+    const made = await make();
+    await writeFile(file, JSON.stringify(made));
+    return made;
+}
+async function read(input, opts) {
+    const { data, name, mime } = input;
+    const vision = new VisionProvider(opts.charge, opts.signal, opts.call);
+    if (mime.startsWith("image/")) {
+        if (!vision.canConvert(mime)) {
+            throw new UnreadableDocument(`Bilder vom Typ ${mime} kann ich nicht lesen (PNG, JPEG, WebP gehen).`);
+        }
+        const result = await vision.convert(data, name, mime);
+        return { markdown: result.markdown, pages: 1, via: "vision" };
+    }
+    if (mime === "application/pdf") {
+        const result = await local.convert(data, name, mime);
+        const pages = result.metadata.page_count ?? null;
+        const letters = result.markdown.replace(/<page-break[^>]*><\/page-break>|\s/g, "").length;
+        // Hardly any text per page: the PDF is a scan.
+        if (letters < 60 * Math.max(1, pages ?? 1)) {
+            const seen = await vision.convert(data, name, mime);
+            return {
+                markdown: seen.markdown,
+                pages: pages ?? (splitMarkdownByPageBreaks(seen.markdown).length || null),
+                via: "vision",
+            };
+        }
+        return { markdown: result.markdown, pages, via: "text" };
+    }
+    if (local.canConvert(mime)) {
+        return { markdown: (await local.convert(data, name, mime)).markdown, pages: null, via: "text" };
+    }
+    if (mime === XLSX) {
+        const workbook = await readXlsxWorkbook(data);
+        const sheets = workbook.sheets
+            .filter((s) => s.matrix.rows.length)
+            .map((s) => `## ${s.name}\n\n${tableMarkdown(s.matrix.columns, s.matrix.rows)}`);
+        return { markdown: sheets.join("\n\n"), pages: null, via: "table" };
+    }
+    const text = () => Buffer.from(data).toString("utf8");
+    if (mime === "text/csv") {
+        const matrix = parseCsvMatrix(text());
+        return { markdown: tableMarkdown(matrix.columns, matrix.rows), pages: null, via: "table" };
+    }
+    if (mime === "text/html") {
+        return { markdown: htmlToMarkdown(text()), pages: null, via: "text" };
+    }
+    if (mime === "message/rfc822") {
+        return { markdown: await parseMail(data), pages: null, via: "mail" };
+    }
+    if (mime === "application/json" || mime.startsWith("text/")) {
+        return { markdown: text(), pages: null, via: "text" };
+    }
+    throw new UnreadableDocument(`„${name}“ (${mime}) kann ich nicht lesen.`);
+}
+// --- structured extraction -----------------------------------------------------
+/** The scanner's schemas say nothing about the currency; SaaS invoices come in several. */
+const currency = z
+    .string()
+    .nullable()
+    .describe("ISO 4217 code of the currency the amounts are printed in (EUR, USD, …)");
+const SCHEMAS = {
+    invoice: invoiceSchema.extend({ currency }),
+    receipt: receiptSchema.extend({ currency }),
+};
+/**
+ * Pulls the fields of an invoice or receipt out of a document, with engenty's document-scanner
+ * schemas (their field descriptions are the extraction instructions).
+ */
+export async function scanDocument(input, kind, opts = {}) {
+    const doc = await parseDocument(input, opts);
+    return kept(input.data, `scan:${kind}`, async () => {
+        const extractor = await textModel("classifier", opts.call);
+        const result = await generateText({
+            model: extractor.model,
+            abortSignal: opts.signal,
+            output: Output.object({ schema: SCHEMAS[kind] }),
+            prompt: `Extract the ${kind} from this document. Amounts are numbers in the document's own currency, exactly as printed; never convert or compute them.\n\nFile: ${input.name}\n\n${doc.markdown.slice(0, 30_000)}`,
+        });
+        await opts.charge?.(costOf(extractor, result.usage));
+        return result.output;
+    });
+}