@mugwork/mug 0.1.0

package/dist/src/version-check.d.ts

@@ -0,0 +1 @@
+export declare function checkCliVersion(): void;

package/dist/src/version-check.js

@@ -0,0 +1,28 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+function getVersions() {
+    const cliPkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    if (!existsSync(cliPkgPath))
+        return { current: "unknown", latest: null };
+    const cliPkg = JSON.parse(readFileSync(cliPkgPath, "utf-8"));
+    const current = cliPkg.version;
+    try {
+        const latest = execSync("npm view @mugwork/mug version 2>/dev/null", { encoding: "utf-8", timeout: 5000 }).trim();
+        return { current, latest: latest || null };
+    }
+    catch {
+        return { current, latest: null };
+    }
+}
+export function checkCliVersion() {
+    const { current, latest } = getVersions();
+    if (!latest || latest === current)
+        return;
+    const line = "━".repeat(56);
+    console.warn(`\n\x1b[33m${line}\x1b[0m`);
+    console.warn(`\x1b[33m  ⚠  Mug CLI update available: ${current} → ${latest}\x1b[0m`);
+    console.warn(`\x1b[33m     Run:  npm update -g @mugwork/mug\x1b[0m`);
+    console.warn(`\x1b[33m${line}\x1b[0m\n`);
+}

package/dist/src/workflow-parser.d.ts

@@ -0,0 +1,95 @@
+export type WorkflowStep = {
+    type: "query";
+    database: string;
+    label: string;
+    sql: string;
+    description?: string;
+} | {
+    type: "exec";
+    database: string;
+    label: string;
+    sql: string;
+    description?: string;
+} | {
+    type: "ai";
+    model: string;
+    label: string;
+    prompt: string;
+    description?: string;
+} | {
+    type: "email";
+    label: string;
+    to?: string;
+    subject?: string;
+    description?: string;
+} | {
+    type: "sms";
+    label: string;
+    to?: string;
+    description?: string;
+} | {
+    type: "slack";
+    label: string;
+    channel?: string;
+    description?: string;
+} | {
+    type: "collect";
+    label: string;
+    formTitle: string;
+    description?: string;
+} | {
+    type: "http";
+    label: string;
+    url: string;
+    method: string;
+    description?: string;
+} | {
+    type: "return";
+    label: string;
+    value?: string;
+    description?: string;
+} | {
+    type: "loop";
+    variable: string;
+    collection: string;
+    label: string;
+    steps: WorkflowStep[];
+    description?: string;
+} | {
+    type: "branch";
+    condition: string;
+    label: string;
+    if: WorkflowStep[];
+    else?: WorkflowStep[];
+    after?: WorkflowStep[];
+    description?: string;
+};
+export interface WebhookConfig {
+    auth: "none" | "hmac" | "bearer";
+    secret?: string;
+}
+export interface TriggerConfig {
+    type?: string;
+    source?: string;
+    table?: string;
+    on?: "insert" | "update" | "delete" | "change";
+    includeInitialSync?: boolean;
+    command?: string;
+    description?: string;
+    usage_hint?: string;
+    event?: string;
+    name?: string;
+    callback_id?: string;
+}
+export interface WorkflowStepTree {
+    name: string;
+    description?: string;
+    schedule?: string;
+    webhook?: boolean | WebhookConfig;
+    inbound?: "sms" | "email" | "slack";
+    trigger?: TriggerConfig;
+    sourceFile: string;
+    steps: WorkflowStep[];
+}
+export declare function countSteps(steps: WorkflowStep[]): number;
+export declare function parseWorkflowSteps(source: string, name: string, sourceFile?: string): WorkflowStepTree;

package/dist/src/workflow-parser.js

@@ -0,0 +1,526 @@
+import * as acorn from "acorn";
+import * as walk from "acorn-walk";
+import { transformSync } from "esbuild";
+export function countSteps(steps) {
+    let count = 0;
+    for (const step of steps) {
+        count++;
+        if (step.type === "loop")
+            count += countSteps(step.steps);
+        if (step.type === "branch") {
+            count += countSteps(step.if);
+            if (step.else)
+                count += countSteps(step.else);
+            if (step.after)
+                count += countSteps(step.after);
+        }
+    }
+    return count;
+}
+function extractCommentAnnotations(originalSource) {
+    const lines = originalSource.split("\n");
+    const annotations = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        let method = null;
+        const notifyMatch = line.match(/ctx\.notify\.(email|sms|slack)\s*\(/);
+        if (notifyMatch) {
+            method = `ctx.notify.${notifyMatch[1]}`;
+        }
+        else {
+            const ctxMatch = line.match(/ctx\.(query|exec|ai|collect|http)\s*\(/);
+            if (ctxMatch)
+                method = `ctx.${ctxMatch[1]}`;
+        }
+        if (!method && /\breturn[\s({;]/.test(line)) {
+            method = "return";
+        }
+        if (!method)
+            continue;
+        const commentLines = [];
+        for (let j = i - 1; j >= 0; j--) {
+            const prev = lines[j].trim();
+            if (prev === "")
+                continue;
+            if (prev.startsWith("//")) {
+                commentLines.unshift(prev.replace(/^\/\/\s*/, ""));
+            }
+            else {
+                break;
+            }
+        }
+        annotations.push({ method, comment: commentLines.length > 0 ? commentLines.join(" ") : "" });
+    }
+    return annotations;
+}
+export function parseWorkflowSteps(source, name, sourceFile) {
+    const commentAnnotations = extractCommentAnnotations(source);
+    const js = transformSync(source, { loader: "ts", target: "es2022" }).code;
+    const ast = acorn.parse(js, { ecmaVersion: 2022, sourceType: "module" });
+    let schedule;
+    let webhook;
+    let inbound;
+    let trigger;
+    let description;
+    let handlerBody = null;
+    walk.simple(ast, {
+        CallExpression(node) {
+            if (node.callee?.name !== "workflow")
+                return;
+            const args = node.arguments;
+            if (args.length < 2)
+                return;
+            const handler = args[1];
+            if (handler.type === "ArrowFunctionExpression" || handler.type === "FunctionExpression") {
+                handlerBody = handler.body;
+            }
+            if (args.length >= 3 && args[2].type === "ObjectExpression") {
+                for (const prop of args[2].properties) {
+                    if (prop.key?.name === "schedule" && prop.value?.type === "Literal") {
+                        schedule = prop.value.value;
+                    }
+                    if (prop.key?.name === "webhook") {
+                        if (prop.value?.type === "Literal") {
+                            webhook = prop.value.value;
+                        }
+                        else if (prop.value?.type === "ObjectExpression") {
+                            const wh = { auth: "none" };
+                            for (const whProp of prop.value.properties ?? []) {
+                                if (whProp.key?.name === "auth" && whProp.value?.type === "Literal") {
+                                    wh.auth = whProp.value.value;
+                                }
+                                if (whProp.key?.name === "secret" && whProp.value?.type === "Literal") {
+                                    wh.secret = whProp.value.value;
+                                }
+                            }
+                            webhook = wh;
+                        }
+                    }
+                    if (prop.key?.name === "inbound" && prop.value?.type === "Literal") {
+                        inbound = prop.value.value;
+                    }
+                    if (prop.key?.name === "trigger" && prop.value?.type === "ObjectExpression") {
+                        const t = {};
+                        for (const tp of prop.value.properties ?? []) {
+                            if (tp.value?.type !== "Literal")
+                                continue;
+                            const key = tp.key?.name;
+                            const val = tp.value.value;
+                            if (key === "type")
+                                t.type = val;
+                            else if (key === "source")
+                                t.source = val;
+                            else if (key === "table")
+                                t.table = val;
+                            else if (key === "on")
+                                t.on = val;
+                            else if (key === "includeInitialSync")
+                                t.includeInitialSync = val;
+                            else if (key === "command")
+                                t.command = val;
+                            else if (key === "description")
+                                t.description = val;
+                            else if (key === "usage_hint")
+                                t.usage_hint = val;
+                            else if (key === "event")
+                                t.event = val;
+                            else if (key === "name")
+                                t.name = val;
+                            else if (key === "callback_id")
+                                t.callback_id = val;
+                        }
+                        if (t.source || t.type)
+                            trigger = t;
+                    }
+                    if (prop.key?.name === "description" && prop.value?.type === "Literal") {
+                        description = prop.value.value;
+                    }
+                }
+            }
+        },
+    });
+    if (!handlerBody) {
+        return { name, description, schedule, webhook, inbound, trigger, sourceFile: sourceFile ?? "", steps: [] };
+    }
+    const commentCursors = new Map();
+    const steps = extractSteps(handlerBody, js, commentAnnotations, commentCursors);
+    const nested = nestAfterBranches(steps);
+    return { name, description, schedule, webhook, inbound, trigger, sourceFile: sourceFile ?? "", steps: nested };
+}
+function branchEndsWithReturn(steps) {
+    if (steps.length === 0)
+        return false;
+    const last = steps[steps.length - 1];
+    if (last.type === "return")
+        return true;
+    if (last.type === "branch") {
+        const hasIfReturn = branchEndsWithReturn(last.if);
+        const hasElseReturn = last.else ? branchEndsWithReturn(last.else) : false;
+        return hasIfReturn && hasElseReturn;
+    }
+    return false;
+}
+function nestAfterBranches(steps) {
+    const firstBranchIdx = steps.findIndex((s) => s.type === "branch");
+    if (firstBranchIdx === -1)
+        return steps;
+    const before = steps.slice(0, firstBranchIdx);
+    const branch = { ...steps[firstBranchIdx] };
+    const remaining = steps.slice(firstBranchIdx + 1);
+    branch.if = nestAfterBranches(branch.if);
+    if (branch.else)
+        branch.else = nestAfterBranches(branch.else);
+    if (remaining.length > 0) {
+        const nestedRemaining = nestAfterBranches(remaining);
+        if (!branch.else && branchEndsWithReturn(branch.if)) {
+            branch.else = nestedRemaining;
+        }
+        else {
+            branch.after = nestedRemaining;
+        }
+    }
+    return [...before, branch];
+}
+function extractSteps(block, source, annotations, cursors) {
+    const statements = block.type === "BlockStatement" ? block.body : [block];
+    const steps = [];
+    for (const stmt of statements) {
+        const extracted = extractFromStatement(stmt, source, annotations, cursors);
+        if (extracted)
+            steps.push(...extracted);
+    }
+    return steps;
+}
+function popComment(method, annotations, cursors) {
+    const cursor = cursors.get(method) ?? 0;
+    for (let i = cursor; i < annotations.length; i++) {
+        if (annotations[i].method === method) {
+            cursors.set(method, i + 1);
+            return annotations[i].comment || undefined;
+        }
+    }
+    return undefined;
+}
+function extractFromStatement(stmt, source, annotations, cursors) {
+    if (stmt.type === "ExpressionStatement") {
+        return extractFromExpression(stmt.expression, source, annotations, cursors);
+    }
+    if (stmt.type === "VariableDeclaration") {
+        for (const decl of stmt.declarations) {
+            if (decl.init) {
+                const result = extractFromExpression(decl.init, source, annotations, cursors);
+                if (result)
+                    return result;
+            }
+        }
+        return null;
+    }
+    if (stmt.type === "ReturnStatement") {
+        const value = stmt.argument ? source.slice(stmt.argument.start, stmt.argument.end) : undefined;
+        const brief = value && value.length > 80 ? value.slice(0, 77) + "..." : value;
+        const desc = popComment("return", annotations, cursors);
+        const step = { type: "return", label: generateReturnLabel(brief), value: brief };
+        if (desc)
+            step.description = desc;
+        return [step];
+    }
+    if (stmt.type === "ForStatement" || stmt.type === "ForOfStatement" || stmt.type === "ForInStatement") {
+        return extractLoop(stmt, source, annotations, cursors);
+    }
+    if (stmt.type === "IfStatement") {
+        return extractBranch(stmt, source, annotations, cursors);
+    }
+    if (stmt.type === "TryStatement") {
+        const trySteps = extractSteps(stmt.block, source, annotations, cursors);
+        if (trySteps.length > 0)
+            return trySteps;
+        return null;
+    }
+    return null;
+}
+function extractFromExpression(expr, source, annotations, cursors) {
+    if (expr.type === "AwaitExpression") {
+        return extractFromExpression(expr.argument, source, annotations, cursors);
+    }
+    if (expr.type === "AssignmentExpression") {
+        return extractFromExpression(expr.right, source, annotations, cursors);
+    }
+    if (expr.type !== "CallExpression")
+        return null;
+    const method = resolveCtxMethod(expr);
+    if (!method)
+        return null;
+    let step = null;
+    switch (method) {
+        case "ctx.query":
+            step = makeQueryStep(expr, source);
+            break;
+        case "ctx.exec":
+            step = makeExecStep(expr, source);
+            break;
+        case "ctx.ai":
+            step = makeAiStep(expr, source);
+            break;
+        case "ctx.notify.email":
+            step = makeEmailStep(expr, source);
+            break;
+        case "ctx.notify.sms":
+            step = makeSmsStep(expr, source);
+            break;
+        case "ctx.notify.slack":
+            step = makeSlackStep(expr, source);
+            break;
+        case "ctx.collect":
+            step = makeCollectStep(expr, source);
+            break;
+        case "ctx.http":
+            step = makeHttpStep(expr, source);
+            break;
+        default:
+            return null;
+    }
+    if (step) {
+        const desc = popComment(method, annotations, cursors);
+        if (desc)
+            step.description = desc;
+        return [step];
+    }
+    return null;
+}
+function resolveCtxMethod(node) {
+    const c = node.callee;
+    if (!c)
+        return null;
+    // ctx.method()
+    if (c.type === "MemberExpression" && c.object?.name === "ctx" && c.property?.name) {
+        return `ctx.${c.property.name}`;
+    }
+    // ctx.notify.email() etc
+    if (c.type === "MemberExpression" &&
+        c.object?.type === "MemberExpression" &&
+        c.object.object?.name === "ctx" &&
+        c.object.property?.name === "notify" &&
+        c.property?.name) {
+        return `ctx.notify.${c.property.name}`;
+    }
+    return null;
+}
+// --- Step constructors ---
+function makeQueryStep(expr, source) {
+    const args = expr.arguments ?? [];
+    const database = getStringArg(args[0], source) ?? "unknown";
+    const sql = getStringArg(args[1], source) ?? "";
+    return { type: "query", database, label: generateSqlLabel("query", sql, database), sql };
+}
+function makeExecStep(expr, source) {
+    const args = expr.arguments ?? [];
+    const database = getStringArg(args[0], source) ?? "unknown";
+    const sql = getStringArg(args[1], source) ?? "";
+    return { type: "exec", database, label: generateSqlLabel("exec", sql, database), sql };
+}
+function makeAiStep(expr, source) {
+    const args = expr.arguments ?? [];
+    const model = getStringArg(args[0], source) ?? "auto";
+    let prompt = "";
+    if (args[1]?.type === "ObjectExpression") {
+        prompt = getObjectStringProp(args[1], "prompt", source) ?? "";
+    }
+    const label = prompt ? truncateClean(prompt, 80) : `AI call (${model})`;
+    return { type: "ai", model, label, prompt };
+}
+function makeEmailStep(expr, source) {
+    const args = expr.arguments ?? [];
+    let to;
+    let subject;
+    if (args[0]?.type === "ObjectExpression") {
+        to = getObjectStringProp(args[0], "to", source);
+        subject = getObjectStringProp(args[0], "subject", source);
+    }
+    const label = subject ? `Send email: ${truncateClean(subject, 60)}` : to ? `Send email to ${to}` : "Send email";
+    return { type: "email", label, to, subject };
+}
+function makeSmsStep(expr, source) {
+    const args = expr.arguments ?? [];
+    let to;
+    if (args[0]?.type === "ObjectExpression") {
+        to = getObjectStringProp(args[0], "to", source);
+    }
+    const label = to ? `Send SMS to ${to}` : "Send SMS";
+    return { type: "sms", label, to };
+}
+function makeSlackStep(expr, source) {
+    const args = expr.arguments ?? [];
+    let channel;
+    if (args[0]?.type === "ObjectExpression") {
+        channel = getObjectStringProp(args[0], "to", source);
+    }
+    const label = channel ? `Send Slack message to ${channel}` : "Send Slack message";
+    return { type: "slack", label, channel };
+}
+function makeCollectStep(expr, source) {
+    const args = expr.arguments ?? [];
+    let formTitle = "";
+    if (args[0]?.type === "ObjectExpression") {
+        formTitle = getObjectStringProp(args[0], "title", source) ?? "";
+    }
+    const label = formTitle ? `Collect: ${formTitle}` : "Collect form data";
+    return { type: "collect", label, formTitle };
+}
+function makeHttpStep(expr, source) {
+    const args = expr.arguments ?? [];
+    const url = getStringArg(args[0], source) ?? "unknown";
+    let method = "GET";
+    if (args[1]?.type === "ObjectExpression") {
+        method = (getObjectStringProp(args[1], "method", source) ?? "GET").toUpperCase();
+    }
+    const urlDisplay = url.length > 60 ? url.slice(0, 57) + "..." : url;
+    const label = `HTTP ${method} ${urlDisplay}`;
+    return { type: "http", label, url, method };
+}
+// --- Loop and branch extraction ---
+function extractLoop(stmt, source, annotations, cursors) {
+    let variable = "item";
+    let collection = "items";
+    if (stmt.type === "ForOfStatement" || stmt.type === "ForInStatement") {
+        if (stmt.left?.type === "VariableDeclaration" && stmt.left.declarations?.[0]) {
+            variable = stmt.left.declarations[0].id?.name ?? "item";
+        }
+        collection = source.slice(stmt.right.start, stmt.right.end);
+    }
+    else if (stmt.type === "ForStatement") {
+        if (stmt.init?.declarations?.[0]?.id?.name) {
+            variable = "i";
+        }
+        collection = source.slice(stmt.init?.start ?? stmt.start, stmt.update?.end ?? stmt.test?.end ?? stmt.start);
+    }
+    const bodySteps = extractSteps(stmt.body, source, annotations, cursors);
+    if (bodySteps.length === 0)
+        return null;
+    return [{
+            type: "loop",
+            variable,
+            collection: truncateClean(collection, 60),
+            label: `For each ${variable} in ${truncateClean(collection, 40)}`,
+            steps: bodySteps,
+        }];
+}
+function extractBranch(stmt, source, annotations, cursors) {
+    const condition = source.slice(stmt.test.start, stmt.test.end);
+    const ifSteps = extractSteps(stmt.consequent, source, annotations, cursors);
+    let elseSteps;
+    if (stmt.alternate) {
+        if (stmt.alternate.type === "IfStatement") {
+            const nested = extractBranch(stmt.alternate, source, annotations, cursors);
+            elseSteps = nested ?? undefined;
+        }
+        else {
+            const es = extractSteps(stmt.alternate, source, annotations, cursors);
+            elseSteps = es.length > 0 ? es : undefined;
+        }
+    }
+    if (ifSteps.length === 0 && (!elseSteps || elseSteps.length === 0))
+        return null;
+    return [{
+            type: "branch",
+            condition,
+            label: `If ${simplifyCondition(condition)}`,
+            if: ifSteps,
+            else: elseSteps,
+        }];
+}
+// --- Label generation ---
+function generateSqlLabel(stepType, sql, database) {
+    const normalized = sql.replace(/\s+/g, " ").trim().toUpperCase();
+    if (normalized.startsWith("CREATE TABLE IF NOT EXISTS")) {
+        const table = extractTableName(sql, /CREATE\s+TABLE\s+IF\s+NOT\s+EXISTS\s+(\w+)/i);
+        return table ? `Ensure ${table} table exists` : `Create table in ${database}`;
+    }
+    if (normalized.startsWith("CREATE TABLE")) {
+        const table = extractTableName(sql, /CREATE\s+TABLE\s+(\w+)/i);
+        return table ? `Create ${table} table` : `Create table in ${database}`;
+    }
+    if (normalized.startsWith("SELECT")) {
+        const table = extractTableName(sql, /FROM\s+(\w+)/i);
+        const where = sql.match(/WHERE\s+([\s\S]+?)(?:\s+ORDER|\s+LIMIT|\s+GROUP|$)/i);
+        if (table && where)
+            return `Get ${table} where ${truncateClean(where[1].trim(), 40)}`;
+        if (table)
+            return `Get all ${table}`;
+        return `Query ${database}`;
+    }
+    if (normalized.startsWith("INSERT")) {
+        const table = extractTableName(sql, /INSERT\s+(?:OR\s+\w+\s+)?INTO\s+(\w+)/i);
+        return table ? `Insert into ${table}` : `Insert into ${database}`;
+    }
+    if (normalized.startsWith("UPDATE")) {
+        const table = extractTableName(sql, /UPDATE\s+(\w+)/i);
+        return table ? `Update ${table}` : `Update ${database}`;
+    }
+    if (normalized.startsWith("DELETE")) {
+        const table = extractTableName(sql, /DELETE\s+FROM\s+(\w+)/i);
+        return table ? `Delete from ${table}` : `Delete from ${database}`;
+    }
+    return stepType === "query" ? `Query ${database}` : `Execute on ${database}`;
+}
+function extractTableName(sql, pattern) {
+    const m = sql.match(pattern);
+    return m ? m[1] : null;
+}
+function generateReturnLabel(value) {
+    if (!value)
+        return "Return result";
+    if (value.startsWith("{"))
+        return "Return result object";
+    return `Return ${truncateClean(value, 50)}`;
+}
+function simplifyCondition(condition) {
+    // urgency === "high" → urgency is high
+    const eqMatch = condition.match(/^(\w+)\s*===?\s*["']([^"']+)["']$/);
+    if (eqMatch)
+        return `${eqMatch[1]} is "${eqMatch[2]}"`;
+    // urgency !== "high" → urgency is not high
+    const neqMatch = condition.match(/^(\w+)\s*!==?\s*["']([^"']+)["']$/);
+    if (neqMatch)
+        return `${neqMatch[1]} is not "${neqMatch[2]}"`;
+    // x > 0, x >= 5, x < 10, x <= 3
+    const cmpMatch = condition.match(/^(\w+)\s*(>=?|<=?)\s*(\d+)$/);
+    if (cmpMatch) {
+        const op = cmpMatch[2] === ">" ? "greater than" : cmpMatch[2] === ">=" ? "at least" : cmpMatch[2] === "<" ? "less than" : "at most";
+        return `${cmpMatch[1]} is ${op} ${cmpMatch[3]}`;
+    }
+    // x.length > 0 → x has items
+    const lenMatch = condition.match(/^(\w+)\.length\s*>\s*0$/);
+    if (lenMatch)
+        return `${lenMatch[1]} has items`;
+    // x.length === 0 → x is empty
+    const emptyMatch = condition.match(/^(\w+)\.length\s*===?\s*0$/);
+    if (emptyMatch)
+        return `${emptyMatch[1]} is empty`;
+    return truncateClean(condition, 50);
+}
+// --- Helpers ---
+function getStringArg(node, source) {
+    if (!node)
+        return undefined;
+    if (node.type === "Literal" && typeof node.value === "string")
+        return node.value;
+    if (node.type === "TemplateLiteral") {
+        return source.slice(node.start + 1, node.end - 1);
+    }
+    return undefined;
+}
+function getObjectStringProp(objNode, propName, source) {
+    for (const prop of objNode.properties ?? []) {
+        if (prop.type === "SpreadElement")
+            continue;
+        const key = prop.key?.name ?? prop.key?.value;
+        if (key === propName) {
+            return getStringArg(prop.value, source);
+        }
+    }
+    return undefined;
+}
+function truncateClean(s, max) {
+    const clean = s.replace(/\s+/g, " ").trim();
+    return clean.length > max ? clean.slice(0, max - 3) + "..." : clean;
+}

package/dist/worker/src/agent-types.d.ts

@@ -0,0 +1,27 @@
+export type AgentModel = "claude-sonnet" | "claude-haiku" | "claude-opus" | "gpt-4o" | "gpt-4o-mini" | "gpt-4.1-nano" | "gpt-4.1-mini" | "gpt-4.1" | (string & {});
+export interface AgentTierRouting {
+    fast?: string;
+    balanced?: string;
+    powerful?: string;
+}
+export interface AgentMemory {
+    entities?: boolean;
+    outcomes?: boolean;
+    struggles?: boolean;
+}
+export type AgentToolGrant = "query" | "search" | "ask" | "notify" | "http" | "workspace" | "ai" | (string & {});
+export interface AgentCaps {
+    maxTurns?: number;
+    maxCredits?: number;
+    maxDuration?: number;
+}
+export interface AgentConfig {
+    name: string;
+    model: AgentModel | AgentTierRouting;
+    instructions?: string;
+    tools?: AgentToolGrant[];
+    memory?: AgentMemory;
+    caps?: AgentCaps;
+    requireApproval?: string[];
+}
+export declare function agent(config: AgentConfig): AgentConfig;

package/dist/worker/src/agent-types.js

@@ -0,0 +1,3 @@
+export function agent(config) {
+    return config;
+}