@mugwork/mug 0.1.0

package/dist/runtime/workflow-entrypoint.js

@@ -0,0 +1,1297 @@
+import { WorkflowEntrypoint } from "cloudflare:workers";
+import { getWorkflow, HttpError } from "./workflow.js";
+import { scoreComplexity, resolveModel, parseModelSpec, resolveBilling } from "./ai-router.js";
+import { getConnector } from "./source.js";
+function titleCase(slug) {
+    return (slug ?? "Mug").split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function isBillableStep(type) {
+    return type === "exec" || type === "http" || type.startsWith("action.");
+}
+function truncate(value, maxLen = 4096) {
+    const s = JSON.stringify(value);
+    return s.length > maxLen ? s.slice(0, maxLen) + "…" : s;
+}
+const DEFAULT_MAX_OPERATIONS = 100;
+class DurableWorkflowContext {
+    env;
+    step;
+    stepCounter = 0;
+    operationCount = 0;
+    maxOperations;
+    steps = [];
+    params = {};
+    changesetId;
+    changesetSource;
+    instanceId;
+    responded = false;
+    constructor(env, step, maxOperations) {
+        this.env = env;
+        this.step = step;
+        this.maxOperations = maxOperations ?? DEFAULT_MAX_OPERATIONS;
+    }
+    secret(name) {
+        const val = this.env[name];
+        if (typeof val !== "string")
+            throw new Error(`Secret "${name}" not found`);
+        return val;
+    }
+    get isDemo() {
+        return this.params._demo === true;
+    }
+    get demoNotify() {
+        return this.params._demoNotify ?? null;
+    }
+    resolveDemoRecipient(channel, originalTo) {
+        const cfg = this.demoNotify;
+        if (!cfg)
+            return originalTo;
+        if (cfg.overrides?.[channel])
+            return cfg.overrides[channel];
+        switch (cfg.mode) {
+            case "off":
+                return null;
+            case "demo-user": {
+                const isEmail = cfg.identity.includes("@");
+                if (channel === "email" && isEmail)
+                    return cfg.identity;
+                if (channel === "sms" && !isEmail)
+                    return cfg.identity;
+                return null;
+            }
+            case "dev": {
+                if (channel === "email" && cfg.devEmail)
+                    return cfg.devEmail;
+                return null;
+            }
+            default:
+                return null;
+        }
+    }
+    nextStep(type, target) {
+        this.stepCounter++;
+        return `${type}-${target}-${this.stepCounter}`;
+    }
+    recordStep(name, type, startMs, opts) {
+        const now = Date.now();
+        const log = {
+            step_name: name,
+            step_type: type,
+            billable: isBillableStep(type),
+            started_at: new Date(startMs).toISOString(),
+            completed_at: new Date(now).toISOString(),
+            duration_ms: now - startMs,
+        };
+        if (opts?.input != null)
+            log.input = truncate(opts.input);
+        if (opts?.output != null)
+            log.output = truncate(opts.output);
+        if (opts?.error)
+            log.error = opts.error;
+        if (opts?.tokensUsed)
+            log.tokens_used = opts.tokensUsed;
+        this.steps.push(log);
+    }
+    internalHeaders() {
+        return {
+            "Content-Type": "application/json",
+            "X-Mug-Internal": this.env.MUG_INTERNAL_SECRET ?? "",
+        };
+    }
+    async query(database, sql, params) {
+        const name = this.nextStep("query", database);
+        const start = Date.now();
+        try {
+            const rows = await this.step.do(name, async () => {
+                const res = await this.env.MUG_DATA.fetch(`https://mug-data/workspace/${this.env.WORKSPACE_ID}/db/${database}/query`, {
+                    method: "POST",
+                    body: JSON.stringify({ sql, params }),
+                    headers: this.internalHeaders(),
+                });
+                const data = (await res.json());
+                return data.rows;
+            });
+            this.recordStep(name, "query", start, { input: { sql, params }, output: `${rows.length} rows` });
+            return rows;
+        }
+        catch (e) {
+            this.recordStep(name, "query", start, { input: { sql, params }, error: e.message });
+            throw e;
+        }
+    }
+    async exec(database, sql, params) {
+        const name = this.nextStep("exec", database);
+        const start = Date.now();
+        try {
+            const changes = await this.step.do(name, async () => {
+                const headers = this.internalHeaders();
+                if (this.changesetId)
+                    headers["X-Changeset-Id"] = this.changesetId;
+                if (this.changesetSource)
+                    headers["X-Changeset-Source"] = this.changesetSource;
+                const res = await this.env.MUG_DATA.fetch(`https://mug-data/workspace/${this.env.WORKSPACE_ID}/db/${database}/exec`, {
+                    method: "POST",
+                    body: JSON.stringify({ sql, params }),
+                    headers,
+                });
+                const data = (await res.json());
+                return data.changes;
+            });
+            if (changes > 0) {
+                await this.meterIncrement("operations", 1, `workflow:exec-${database}`);
+            }
+            this.recordStep(name, "exec", start, { input: { sql, params }, output: `${changes} changes` });
+            return changes;
+        }
+        catch (e) {
+            this.recordStep(name, "exec", start, { input: { sql, params }, error: e.message });
+            throw e;
+        }
+    }
+    getWorkspaceRouting() {
+        if (!this.env.MUG_AI_ROUTING)
+            return undefined;
+        try {
+            return JSON.parse(this.env.MUG_AI_ROUTING);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    getWorkspaceBilling() {
+        if (!this.env.MUG_AI_BILLING)
+            return undefined;
+        try {
+            return JSON.parse(this.env.MUG_AI_BILLING);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async meterCheck(dimension) {
+        if (!this.env.MUG_DISPATCH)
+            return { allowed: true, used: 0, limit: 0, remaining: 0 };
+        const res = await this.env.MUG_DISPATCH.fetch(`https://mug-dispatch/meter/${this.env.WORKSPACE_ID}/check`, {
+            method: "POST",
+            body: JSON.stringify({ dimension }),
+            headers: this.internalHeaders(),
+        });
+        return res.json();
+    }
+    async meterIncrement(dimension, delta, source) {
+        if (!this.env.MUG_DISPATCH)
+            return;
+        await this.env.MUG_DISPATCH.fetch(`https://mug-dispatch/meter/${this.env.WORKSPACE_ID}/increment`, {
+            method: "POST",
+            body: JSON.stringify({ dimension, delta, source }),
+            headers: this.internalHeaders(),
+        }).catch(() => { });
+    }
+    async ai(model, options) {
+        const name = this.nextStep("ai", model);
+        const start = Date.now();
+        try {
+            const data = await this.step.do(name, { retries: { limit: 2, delay: "5 seconds", backoff: "exponential" } }, async () => {
+                if (!this.env.MUG_AI)
+                    throw new Error("AI not configured: missing MUG_AI service binding");
+                let provider;
+                let resolvedModel;
+                let tier = null;
+                let routingMeta;
+                const tierNames = ["fast", "balanced", "powerful"];
+                if (model === "auto") {
+                    const score = scoreComplexity(options.prompt, options);
+                    tier = score.tier;
+                    const resolved = resolveModel(tier, options.routing, this.getWorkspaceRouting());
+                    provider = resolved.provider;
+                    resolvedModel = resolved.model;
+                    routingMeta = { tier, model: resolvedModel, provider, reason: score.reason };
+                }
+                else if (tierNames.includes(model)) {
+                    tier = model;
+                    const resolved = resolveModel(tier, options.routing, this.getWorkspaceRouting());
+                    provider = resolved.provider;
+                    resolvedModel = resolved.model;
+                    routingMeta = { tier, model: resolvedModel, provider, reason: `tier:${tier}` };
+                }
+                else {
+                    const parsed = parseModelSpec(model);
+                    provider = parsed.provider;
+                    resolvedModel = parsed.model;
+                }
+                const billingKey = resolveBilling(tier, options.billing, undefined, this.getWorkspaceBilling());
+                const billing = billingKey !== "mug-metered"
+                    ? this.env[billingKey] ?? billingKey
+                    : billingKey;
+                const aiCheck = await this.meterCheck("ai_credits");
+                if (aiCheck.remaining === 0 && aiCheck.limit > 0) {
+                    throw new Error(`AI credit limit exceeded: ${aiCheck.used}/${aiCheck.limit}`);
+                }
+                const res = await this.env.MUG_AI.fetch("https://mug-ai/complete", {
+                    method: "POST",
+                    body: JSON.stringify({
+                        workspace: this.env.WORKSPACE_ID,
+                        provider,
+                        model: resolvedModel,
+                        prompt: options.prompt,
+                        system: options.system,
+                        maxTokens: options.maxTokens,
+                        routing: routingMeta ? { tier: routingMeta.tier, reason: routingMeta.reason } : undefined,
+                        billing,
+                        source: "workflow",
+                    }),
+                    headers: this.internalHeaders(),
+                });
+                if (!res.ok)
+                    throw new Error(`AI request failed (${res.status}): ${await res.text()}`);
+                const result = (await res.json());
+                if (routingMeta)
+                    result.routing = routingMeta;
+                // Provisional estimate using Sonnet 4.6 rates (snapshotted 2026-06-19) — cron corrects to real cost within 15 min
+                const estCost = result.usage.input_tokens * (3.00 / 1e6) + result.usage.output_tokens * (15.00 / 1e6);
+                const credits = Math.max(1, Math.ceil(estCost / 0.001));
+                if (credits > 0 && billing === "mug-metered") {
+                    await this.meterIncrement("ai_credits", credits, `workflow:ai-${resolvedModel}`);
+                }
+                return result;
+            });
+            this.recordStep(name, "ai", start, {
+                input: { prompt: options.prompt.slice(0, 200) },
+                output: data.text.slice(0, 200),
+                tokensUsed: data.usage.input_tokens + data.usage.output_tokens,
+            });
+            return data;
+        }
+        catch (e) {
+            this.recordStep(name, "ai", start, { input: { prompt: options.prompt.slice(0, 200) }, error: e.message });
+            throw e;
+        }
+    }
+    async search(query, options) {
+        const name = this.nextStep("search", options?.source ?? "all");
+        const start = Date.now();
+        try {
+            const results = await this.step.do(name, async () => {
+                if (!this.env.MUG_AI)
+                    throw new Error("Search not available — no MUG_AI binding");
+                if (!this.env.MUG_DISPATCH)
+                    throw new Error("Search not available — no MUG_DISPATCH binding");
+                const limit = Math.min(options?.limit ?? 10, 50);
+                const embedRes = await this.env.MUG_AI.fetch("https://mug-ai/embed", {
+                    method: "POST",
+                    body: JSON.stringify({ workspace: this.env.WORKSPACE_ID, texts: [query] }),
+                    headers: this.internalHeaders(),
+                });
+                if (!embedRes.ok)
+                    throw new Error(`Embed failed: ${await embedRes.text()}`);
+                const { vectors } = (await embedRes.json());
+                const filter = { ...options?.filter };
+                if (options?.source)
+                    filter.table = options.source;
+                const queryRes = await this.env.MUG_DISPATCH.fetch(`https://mug-dispatch/vector/${this.env.WORKSPACE_ID}/query`, {
+                    method: "POST",
+                    headers: this.internalHeaders(),
+                    body: JSON.stringify({
+                        vector: vectors[0],
+                        topK: limit * 2,
+                        returnMetadata: true,
+                        ...(Object.keys(filter).length > 0 ? { filter } : {}),
+                    }),
+                });
+                const queryData = await queryRes.json();
+                const matches = (queryData.result?.matches ?? queryData.matches ?? []);
+                const best = new Map();
+                for (const match of matches) {
+                    const meta = match.metadata;
+                    if (!meta?.table || !meta?.primary_key)
+                        continue;
+                    const key = `${meta.table}:${meta.primary_key}`;
+                    const existing = best.get(key);
+                    if (!existing || match.score > existing.score) {
+                        best.set(key, { score: match.score, meta });
+                    }
+                }
+                const searchResults = [];
+                for (const [, { score, meta }] of best) {
+                    if (searchResults.length >= limit)
+                        break;
+                    try {
+                        const qRes = await this.env.MUG_DATA.fetch(`https://mug-data/workspace/${this.env.WORKSPACE_ID}/db/${meta.database}/query`, {
+                            method: "POST",
+                            body: JSON.stringify({
+                                sql: `SELECT * FROM "${meta.table}" WHERE "${meta.pk_column}" = ? AND _mug_deleted_at IS NULL`,
+                                params: [meta.primary_key],
+                            }),
+                            headers: this.internalHeaders(),
+                        });
+                        const { rows } = (await qRes.json());
+                        searchResults.push({ score, table: meta.table, primaryKey: meta.primary_key, row: rows[0] ?? {} });
+                    }
+                    catch {
+                        searchResults.push({ score, table: meta.table, primaryKey: meta.primary_key, row: {} });
+                    }
+                }
+                return searchResults;
+            });
+            this.recordStep(name, "search", start, {
+                input: { query: query.slice(0, 200), source: options?.source },
+                output: `${results.length} results`,
+            });
+            return results;
+        }
+        catch (e) {
+            this.recordStep(name, "search", start, { input: { query: query.slice(0, 200) }, error: e.message });
+            throw e;
+        }
+    }
+    async ask(question, options) {
+        const name = this.nextStep("ask", options?.source ?? "all");
+        const start = Date.now();
+        try {
+            const result = await this.step.do(name, async () => {
+                const sources = await this.search(question, {
+                    source: options?.source,
+                    limit: options?.limit ?? 10,
+                });
+                const contextParts = [];
+                let tokenEstimate = 0;
+                for (const r of sources) {
+                    const entry = `[${r.table}:${r.primaryKey} score=${r.score.toFixed(3)}]\n${JSON.stringify(r.row)}`;
+                    const entryTokens = Math.ceil(entry.split(/\s+/).length * 1.3);
+                    if (tokenEstimate + entryTokens > 3000)
+                        break;
+                    contextParts.push(entry);
+                    tokenEstimate += entryTokens;
+                }
+                const baseSystem = "Answer the question based on the following business data. Cite which records informed your answer. If the data does not contain enough information, say so.";
+                const dataBlock = `\n\n--- Business Data ---\n${contextParts.join("\n\n")}`;
+                const system = (options?.system ? `${options.system}\n\n${baseSystem}` : baseSystem) + dataBlock;
+                const aiResult = await this.ai(options?.model ?? "balanced", {
+                    prompt: question,
+                    system,
+                });
+                return {
+                    answer: aiResult.text,
+                    sources,
+                    usage: {
+                        input_tokens: aiResult.usage.input_tokens,
+                        output_tokens: aiResult.usage.output_tokens,
+                        search_results: sources.length,
+                    },
+                };
+            });
+            this.recordStep(name, "ask", start, {
+                input: { question: question.slice(0, 200), source: options?.source },
+                output: result.answer.slice(0, 200),
+                tokensUsed: result.usage.input_tokens + result.usage.output_tokens,
+            });
+            return result;
+        }
+        catch (e) {
+            this.recordStep(name, "ask", start, { input: { question: question.slice(0, 200) }, error: e.message });
+            throw e;
+        }
+    }
+    async file(path) {
+        const name = this.nextStep("file", path);
+        const start = Date.now();
+        try {
+            const buffer = await this.step.do(name, async () => {
+                const res = await this.env.MUG_DATA.fetch(`https://mug-data/workspace/${this.env.WORKSPACE_ID}/files/read/${path}`, { headers: this.internalHeaders() });
+                if (!res.ok)
+                    throw new Error(`File not found: ${path} (${res.status})`);
+                return res.arrayBuffer();
+            });
+            this.recordStep(name, "file", start, { input: { path }, output: `${buffer.byteLength} bytes` });
+            return buffer;
+        }
+        catch (e) {
+            this.recordStep(name, "file", start, { input: { path }, error: e.message });
+            throw e;
+        }
+    }
+    async fileText(path) {
+        const buffer = await this.file(path);
+        return new TextDecoder().decode(buffer);
+    }
+    async embed(texts) {
+        if (texts.length === 0)
+            return [];
+        const name = this.nextStep("embed", `${texts.length} texts`);
+        const start = Date.now();
+        try {
+            const results = await this.step.do(name, async () => {
+                if (!this.env.MUG_AI)
+                    throw new Error("Embed not available — no MUG_AI binding");
+                const allVectors = [];
+                for (let i = 0; i < texts.length; i += 100) {
+                    const batch = texts.slice(i, i + 100);
+                    const res = await this.env.MUG_AI.fetch("https://mug-ai/embed", {
+                        method: "POST",
+                        body: JSON.stringify({ workspace: this.env.WORKSPACE_ID, texts: batch }),
+                        headers: this.internalHeaders(),
+                    });
+                    if (!res.ok)
+                        throw new Error(`Embed failed: ${await res.text()}`);
+                    const { vectors } = (await res.json());
+                    allVectors.push(...vectors);
+                }
+                return allVectors;
+            });
+            this.recordStep(name, "embed", start, { input: { count: texts.length }, output: `${results.length} vectors` });
+            return results;
+        }
+        catch (e) {
+            this.recordStep(name, "embed", start, { input: { count: texts.length }, error: e.message });
+            throw e;
+        }
+    }
+    async slackApiCall(method, body) {
+        const name = this.nextStep("slack.api", method);
+        const start = Date.now();
+        try {
+            const data = await this.step.do(name, async () => {
+                const token = this.env.SLACK_BOT_TOKEN;
+                if (!token)
+                    throw new Error("SLACK_BOT_TOKEN not configured");
+                const res = await fetch(`https://slack.com/api/${method}`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `Bearer ${token}`,
+                    },
+                    body: JSON.stringify(body),
+                });
+                const result = await res.json();
+                if (!result.ok)
+                    throw new Error(`Slack API ${method} failed: ${result.error ?? "unknown error"}`);
+                return result;
+            });
+            this.recordStep(name, "slack.api", start, { input: { method }, output: "ok" });
+            return data;
+        }
+        catch (e) {
+            this.recordStep(name, "slack.api", start, { input: { method }, error: e.message });
+            throw e;
+        }
+    }
+    surfaceUrl(surfaceId, path) {
+        return `https://${this.env.WORKSPACE_ID}.mug.work/${surfaceId}${path ?? ""}`;
+    }
+    getBranding() {
+        if (!this.env.MUG_BRANDING)
+            return undefined;
+        try {
+            return JSON.parse(this.env.MUG_BRANDING);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    get notify() {
+        return {
+            sms: (options) => this.sendNotification("sms", options),
+            email: (options) => this.sendNotification("email", options),
+            slack: (options) => this.sendNotification("slack", options),
+            channel: (name, options) => this.sendNotification(name, options),
+        };
+    }
+    async sendNotification(channel, options) {
+        const name = this.nextStep("notify", channel);
+        const start = Date.now();
+        if (this.isDemo) {
+            const resolved = this.resolveDemoRecipient(channel, options.to);
+            if (resolved === null) {
+                this.recordStep(name, "notify", start, { input: { to: options.to }, output: `suppressed (demo mode: ${this.demoNotify?.mode ?? "off"})` });
+                return "suppressed";
+            }
+            options = { ...options, to: resolved };
+        }
+        const smsByok = channel === "sms" && !!(this.env.TELNYX_API_KEY || this.env.TWILIO_ACCOUNT_SID);
+        try {
+            const status = await this.step.do(name, { retries: { limit: 2, delay: "5 seconds", backoff: "exponential" } }, async () => {
+                if (this.env.MUG_NOTIFY) {
+                    if ((channel === "sms" && !smsByok) || channel === "email") {
+                        const dimension = channel === "sms" ? "sms" : "email";
+                        const check = await this.meterCheck(dimension);
+                        if (!check.allowed) {
+                            throw new Error(`Usage limit exceeded for ${dimension}: ${check.used}/${check.limit}`);
+                        }
+                    }
+                    const fromName = options.fromName ?? titleCase(this.env.WORKSPACE_ID);
+                    const res = await this.env.MUG_NOTIFY.fetch("https://mug-notify/send", {
+                        method: "POST",
+                        body: JSON.stringify({
+                            workspace: this.env.WORKSPACE_ID,
+                            channel,
+                            to: options.to,
+                            message: options.message,
+                            subject: options.subject,
+                            fromName,
+                            cta: options.cta,
+                            branding: this.getBranding(),
+                            ...(channel === "slack" ? {
+                                blocks: options.blocks,
+                                thread_ts: options.thread_ts,
+                                unfurl_links: options.unfurl_links,
+                                unfurl_media: options.unfurl_media,
+                                slackBotToken: this.env.SLACK_BOT_TOKEN,
+                            } : {}),
+                            ...(channel === "sms" ? {
+                                telnyxApiKey: this.env.TELNYX_API_KEY,
+                                telnyxPhoneNumber: this.env.TELNYX_PHONE_NUMBER,
+                                twilioAccountSid: this.env.TWILIO_ACCOUNT_SID,
+                                twilioAuthToken: this.env.TWILIO_AUTH_TOKEN,
+                                twilioPhoneNumber: this.env.TWILIO_PHONE_NUMBER,
+                            } : {}),
+                        }),
+                        headers: this.internalHeaders(),
+                    });
+                    if (!res.ok) {
+                        const body = await res.text().catch(() => "");
+                        throw new Error(`Notify failed (${res.status}): ${body}`);
+                    }
+                    if ((channel === "sms" && !smsByok) || channel === "email") {
+                        await this.meterIncrement(channel === "sms" ? "sms" : "email", 1, `workflow:notify-${channel}`);
+                    }
+                    return "delivered";
+                }
+                else {
+                    console.log(`[notify:${channel}] to=${options.to} message=${options.message}`);
+                    return "logged";
+                }
+            });
+            this.recordStep(name, "notify", start, { input: { to: options.to }, output: status });
+            return status;
+        }
+        catch (e) {
+            this.recordStep(name, "notify", start, { input: { to: options.to }, error: e.message });
+            throw e;
+        }
+    }
+    get slack() {
+        return {
+            updateMessage: (options) => this.slackUpdateMessage(options),
+            openModal: (options) => this.slackOpenModal(options),
+            updateModal: (options) => this.slackUpdateModal(options),
+        };
+    }
+    async slackUpdateMessage(options) {
+        const name = this.nextStep("slack", "updateMessage");
+        const start = Date.now();
+        try {
+            await this.step.do(name, async () => {
+                const token = this.env.SLACK_BOT_TOKEN;
+                if (!token)
+                    throw new Error("SLACK_BOT_TOKEN not configured");
+                const res = await fetch("https://slack.com/api/chat.update", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `Bearer ${token}`,
+                    },
+                    body: JSON.stringify({
+                        channel: options.channel,
+                        ts: options.ts,
+                        text: options.text ?? "",
+                        ...(options.blocks ? { blocks: options.blocks } : {}),
+                    }),
+                });
+                const data = await res.json();
+                if (!data.ok)
+                    throw new Error(`Slack chat.update failed: ${data.error ?? "unknown"}`);
+            });
+            this.recordStep(name, "slack.updateMessage", start, { input: { channel: options.channel, ts: options.ts }, output: "updated" });
+        }
+        catch (e) {
+            this.recordStep(name, "slack.updateMessage", start, { input: { channel: options.channel, ts: options.ts }, error: e.message });
+            throw e;
+        }
+    }
+    async slackOpenModal(options) {
+        const name = this.nextStep("slack", "openModal");
+        const start = Date.now();
+        try {
+            await this.step.do(name, async () => {
+                const token = this.env.SLACK_BOT_TOKEN;
+                if (!token)
+                    throw new Error("SLACK_BOT_TOKEN not configured");
+                const res = await fetch("https://slack.com/api/views.open", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `Bearer ${token}`,
+                    },
+                    body: JSON.stringify({
+                        trigger_id: options.triggerId,
+                        view: options.view,
+                    }),
+                });
+                const data = await res.json();
+                if (!data.ok)
+                    throw new Error(`Slack views.open failed: ${data.error ?? "unknown"}`);
+            });
+            this.recordStep(name, "slack.openModal", start, { output: "opened" });
+        }
+        catch (e) {
+            this.recordStep(name, "slack.openModal", start, { error: e.message });
+            throw e;
+        }
+    }
+    async slackUpdateModal(options) {
+        const name = this.nextStep("slack", "updateModal");
+        const start = Date.now();
+        try {
+            await this.step.do(name, async () => {
+                const token = this.env.SLACK_BOT_TOKEN;
+                if (!token)
+                    throw new Error("SLACK_BOT_TOKEN not configured");
+                const res = await fetch("https://slack.com/api/views.update", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `Bearer ${token}`,
+                    },
+                    body: JSON.stringify({
+                        view_id: options.viewId,
+                        view: options.view,
+                    }),
+                });
+                const data = await res.json();
+                if (!data.ok)
+                    throw new Error(`Slack views.update failed: ${data.error ?? "unknown"}`);
+            });
+            this.recordStep(name, "slack.updateModal", start, { input: { viewId: options.viewId }, output: "updated" });
+        }
+        catch (e) {
+            this.recordStep(name, "slack.updateModal", start, { input: { viewId: options.viewId }, error: e.message });
+            throw e;
+        }
+    }
+    async respond(body, status) {
+        if (this.responded)
+            return;
+        this.responded = true;
+        if (!this.env.MUG_DISPATCH || !this.instanceId)
+            return;
+        await this.step.do(this.nextStep("respond", "webhook"), async () => {
+            await this.env.MUG_DISPATCH.fetch("https://mug-dispatch/_internal/webhook-respond", {
+                method: "POST",
+                headers: this.internalHeaders(),
+                body: JSON.stringify({
+                    workspace: this.env.WORKSPACE_ID,
+                    instanceId: this.instanceId,
+                    body,
+                    status: status ?? 200,
+                }),
+            });
+        });
+    }
+    async agent(name, options) {
+        const stepName = this.nextStep("agent", name);
+        const start = Date.now();
+        const sessionKey = options.sessionKey ?? `${this.changesetId ?? "run"}-${name}`;
+        try {
+            const data = await this.step.do(stepName, async () => {
+                if (!this.env.MUG_DISPATCH)
+                    throw new Error("Agent not configured: missing MUG_DISPATCH binding");
+                const res = await this.env.MUG_DISPATCH.fetch(`https://mug-dispatch/agent/${this.env.WORKSPACE_ID}/invoke`, {
+                    method: "POST",
+                    headers: this.internalHeaders(),
+                    body: JSON.stringify({ agent: name, goal: options.goal, context: options.context, sessionKey, caps: options.caps }),
+                });
+                if (!res.ok) {
+                    const errText = await res.text();
+                    throw new Error(`Agent "${name}" failed: ${errText}`);
+                }
+                return res.json();
+            });
+            if (data.status === "pending_approval" && data.pendingApproval) {
+                this.recordStep(stepName, "agent", start, {
+                    input: { goal: options.goal.slice(0, 200) },
+                    output: `pending approval: ${data.pendingApproval.tool}`,
+                });
+                const approvalEvent = `agent-approval-${sessionKey}`;
+                const callbackUrl = await this.waitForUrl(approvalEvent);
+                const approveUrl = `${callbackUrl}?action=approve`;
+                await this.step.do(this.nextStep("notify", "agent-approval"), { retries: { limit: 1, delay: "2 seconds" } }, async () => {
+                    if (this.env.MUG_NOTIFY) {
+                        await this.env.MUG_NOTIFY.fetch("https://mug-notify/send", {
+                            method: "POST",
+                            headers: this.internalHeaders(),
+                            body: JSON.stringify({
+                                workspace: this.env.WORKSPACE_ID,
+                                channel: "email",
+                                to: options.approvalNotify ?? this.env.WORKSPACE_ID,
+                                subject: `Approval needed: ${data.pendingApproval.tool}`,
+                                message: `Agent "${name}" wants to execute ${data.pendingApproval.tool}.\n\n${JSON.stringify(data.pendingApproval.args, null, 2)}`,
+                                cta: { label: "Approve", url: approveUrl },
+                            }),
+                        });
+                    }
+                });
+                const event = await this.waitFor(approvalEvent, { timeout: "24 hours" });
+                const approved = !event.timedOut && event.payload?.action === "approve";
+                if (event.timedOut) {
+                    return {
+                        response: data.response,
+                        output: data.output ?? undefined,
+                        usage: { credits: data.usage?.credits ?? 0, turns: data.usage?.turns ?? 0, duration: Date.now() - start },
+                        capped: true,
+                        cappedReason: "approval_timeout",
+                        pendingApproval: { tool: data.pendingApproval.tool, args: data.pendingApproval.args, sessionKey },
+                    };
+                }
+                const resumeData = await this.step.do(this.nextStep("agent-resume", name), async () => {
+                    const res = await this.env.MUG_DISPATCH.fetch(`https://mug-dispatch/agent/${this.env.WORKSPACE_ID}/approve`, {
+                        method: "POST",
+                        headers: this.internalHeaders(),
+                        body: JSON.stringify({ sessionKey, approved }),
+                    });
+                    if (!res.ok)
+                        throw new Error(`Agent approve failed: ${await res.text()}`);
+                    return res.json();
+                });
+                const totalCredits = (data.usage?.credits ?? 0) + (resumeData.usage?.credits ?? 0);
+                const totalTurns = (data.usage?.turns ?? 0) + (resumeData.usage?.turns ?? 0);
+                const result = {
+                    response: resumeData.response,
+                    output: resumeData.output ?? data.output ?? undefined,
+                    usage: { credits: totalCredits, turns: totalTurns, duration: Date.now() - start },
+                    capped: resumeData.capped,
+                    cappedReason: resumeData.cappedReason,
+                };
+                this.recordStep(this.nextStep("agent-complete", name), "agent", start, {
+                    input: { goal: options.goal.slice(0, 200) },
+                    output: resumeData.response?.slice(0, 200),
+                });
+                return result;
+            }
+            const duration = Date.now() - start;
+            const result = {
+                response: data.response,
+                output: data.output ?? undefined,
+                usage: { credits: data.usage?.credits ?? 0, turns: data.usage?.turns ?? 0, duration },
+                capped: data.capped,
+                cappedReason: data.cappedReason,
+            };
+            this.recordStep(stepName, "agent", start, {
+                input: { goal: options.goal.slice(0, 200) },
+                output: data.response?.slice(0, 200),
+            });
+            return result;
+        }
+        catch (e) {
+            this.recordStep(stepName, "agent", start, {
+                input: { goal: options.goal.slice(0, 200) },
+                error: e.message,
+            });
+            throw e;
+        }
+    }
+    async collect(options) {
+        const name = this.nextStep("collect", options.title);
+        return this.step.do(name, async () => {
+            const surfaceId = options.id ?? crypto.randomUUID().slice(0, 8);
+            const workspace = this.env.WORKSPACE_ID;
+            const pages = options.pages ?? [{
+                    id: "main",
+                    fields: options.fields ?? [],
+                }];
+            const access = options.access ?? { mode: "public" };
+            const schema = {
+                title: options.title,
+                description: options.description,
+                submitText: options.submitText,
+                pages,
+                access,
+                editMode: options.editMode,
+                workflow: options.workflow,
+            };
+            const surfaceConfig = { workspace, surfaceId, ...schema };
+            await fetch("https://api.mug.work/deploy-surface", {
+                method: "POST",
+                body: JSON.stringify(surfaceConfig),
+                headers: this.internalHeaders(),
+            });
+            return `https://${workspace}.mug.work/${surfaceId}`;
+        });
+    }
+    async waitFor(eventName, options) {
+        const name = this.nextStep("waitFor", eventName);
+        const start = Date.now();
+        try {
+            const timeout = options?.timeout ?? "24 hours";
+            const cfTimeout = typeof timeout === "number" ? `${timeout} seconds` : timeout;
+            const event = await this.step.waitForEvent(name, {
+                type: eventName,
+                timeout: cfTimeout,
+            });
+            const result = {
+                payload: event.payload,
+                type: event.type,
+                timedOut: false,
+            };
+            this.recordStep(name, "waitFor", start, { output: truncate(result) });
+            return result;
+        }
+        catch (e) {
+            const msg = e.message ?? "";
+            if (msg.toLowerCase().includes("timeout") || msg.toLowerCase().includes("timed out")) {
+                const result = { payload: undefined, type: eventName, timedOut: true };
+                this.recordStep(name, "waitFor", start, { output: "timed out" });
+                return result;
+            }
+            this.recordStep(name, "waitFor", start, { error: msg });
+            throw e;
+        }
+    }
+    async waitForUrl(eventName) {
+        const name = this.nextStep("callbackUrl", eventName);
+        return this.step.do(name, async () => {
+            if (!this.instanceId)
+                throw new Error("Instance ID not available — waitForUrl requires a running workflow");
+            const token = crypto.randomUUID();
+            if (this.env.MUG_DISPATCH) {
+                await this.env.MUG_DISPATCH.fetch("https://mug-dispatch/_internal/event-callback", {
+                    method: "POST",
+                    headers: this.internalHeaders(),
+                    body: JSON.stringify({
+                        token,
+                        workspace: this.env.WORKSPACE_ID,
+                        instanceId: this.instanceId,
+                        eventType: eventName,
+                    }),
+                });
+            }
+            return `https://api.mug.work/_callback/${token}`;
+        });
+    }
+    action(connectorName) {
+        const def = getConnector(connectorName);
+        if (!def)
+            throw new Error(`Connector "${connectorName}" not found`);
+        return new DurableConnectorHandle(this, def, connectorName);
+    }
+    async rollback(actionId) {
+        const rows = await this.query("_mug_ops", `SELECT * FROM actions WHERE id = ?`, [actionId]);
+        if (rows.length === 0)
+            throw new Error(`Action "${actionId}" not found`);
+        const original = rows[0];
+        if (original.rolled_back === 1) {
+            throw new Error(`Action ${actionId} has already been rolled back.`);
+        }
+        if (original.operation === "read") {
+            throw new Error(`Cannot rollback a read action.`);
+        }
+        if (!original.before_snapshot && original.operation !== "create") {
+            throw new Error(`Action ${actionId} has no before-snapshot — cannot rollback.`);
+        }
+        const connectorName = original.connector;
+        const tableName = original.table_name;
+        const recordId = original.record_id;
+        const snapshot = original.before_snapshot ? JSON.parse(original.before_snapshot) : null;
+        const confirmed = original.after_confirmed ? JSON.parse(original.after_confirmed) : null;
+        let result;
+        const handle = this.action(connectorName);
+        switch (original.operation) {
+            case "create": {
+                const createdId = confirmed?.id ?? recordId;
+                if (!createdId)
+                    throw new Error(`Cannot rollback create — no record ID available.`);
+                result = await handle.delete(tableName, createdId);
+                break;
+            }
+            case "update":
+                result = await handle.update(tableName, recordId, snapshot);
+                break;
+            case "delete":
+                result = await handle.create(tableName, snapshot);
+                break;
+            case "upsert":
+                if (snapshot) {
+                    result = await handle.update(tableName, recordId, snapshot);
+                }
+                else {
+                    result = await handle.delete(tableName, recordId);
+                }
+                break;
+            default:
+                throw new Error(`Cannot rollback operation type "${original.operation}".`);
+        }
+        await this.exec("_mug_ops", `UPDATE actions SET rolled_back = 1, rolled_back_at = ?, rollback_action_id = ? WHERE id = ?`, [new Date().toISOString(), result.operationId, actionId]);
+        return result;
+    }
+    async rollbackRun(workflowRunId) {
+        const actions = await this.query("_mug_ops", `SELECT id FROM actions WHERE workflow_run_id = ? AND operation != 'read' AND rolled_back = 0 ORDER BY created_at DESC`, [workflowRunId]);
+        const rolledBack = [];
+        const failed = [];
+        for (const action of actions) {
+            try {
+                const result = await this.rollback(action.id);
+                rolledBack.push(result);
+            }
+            catch (e) {
+                failed.push({ actionId: action.id, error: e.message });
+            }
+        }
+        return { rolledBack, failed };
+    }
+    /** @internal */
+    _checkOpsCap() {
+        this.operationCount++;
+        if (this.operationCount > this.maxOperations) {
+            throw new Error(`Workflow exceeded max operations per run (${this.maxOperations}). ` +
+                `Adjust maxOperations in workflow config to allow more.`);
+        }
+    }
+    /** @internal */
+    _makeSourceCtx(connectorName) {
+        const env = this.env;
+        return {
+            credential: async (name) => {
+                if (env.MUG_DISPATCH && env.MUG_INTERNAL_SECRET) {
+                    const provider = name ?? connectorName;
+                    const res = await env.MUG_DISPATCH.fetch(`https://mug-dispatch/credential/${env.WORKSPACE_ID}/${provider}`, { headers: { "X-Mug-Internal": env.MUG_INTERNAL_SECRET } });
+                    if (res.ok) {
+                        const data = (await res.json());
+                        return data.access_token;
+                    }
+                }
+                throw new Error(`No credentials for "${connectorName}"`);
+            },
+            fetch: (url, init) => {
+                if (url.includes("api.mug.work") && env.MUG_DISPATCH && env.MUG_INTERNAL_SECRET) {
+                    const proxyUrl = url.replace(/https?:\/\/api\.mug\.work/, "https://mug-dispatch");
+                    const headers = new Headers(init?.headers);
+                    if (!headers.has("X-Mug-Internal"))
+                        headers.set("X-Mug-Internal", env.MUG_INTERNAL_SECRET);
+                    return env.MUG_DISPATCH.fetch(proxyUrl, { ...init, headers });
+                }
+                return fetch(url, init);
+            },
+            lastSync: null,
+        };
+    }
+    /** @internal */
+    _doStep(stepName, fn) {
+        return this.step.do(stepName, fn);
+    }
+    async http(url, options) {
+        const method = (options?.method ?? "GET").toUpperCase();
+        const name = this.nextStep("http", new URL(url).hostname);
+        const start = Date.now();
+        const timeout = options?.timeout ?? 30000;
+        const throwOnError = options?.throwOnError !== false;
+        const retryConfig = options?.retry;
+        const shouldRetry = retryConfig !== false;
+        const maxAttempts = shouldRetry && typeof retryConfig === "object" && retryConfig?.attempts
+            ? retryConfig.attempts
+            : (shouldRetry ? 3 : 1);
+        try {
+            const result = await this.step.do(name, async () => {
+                const headers = { ...options?.headers };
+                let bodyStr;
+                if (options?.body != null) {
+                    bodyStr = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
+                    if (!headers["Content-Type"] && !headers["content-type"]) {
+                        headers["Content-Type"] = "application/json";
+                    }
+                }
+                if (options?.sign) {
+                    const secretValue = this.secret(options.sign.secret);
+                    const encoder = new TextEncoder();
+                    const key = await crypto.subtle.importKey("raw", encoder.encode(secretValue), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+                    const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(bodyStr ?? ""));
+                    const hex = Array.from(new Uint8Array(sig)).map(b => b.toString(16).padStart(2, "0")).join("");
+                    headers[options.sign.header ?? "X-Hub-Signature-256"] = `sha256=${hex}`;
+                }
+                // Route api.mug.work requests through MUG_DISPATCH service binding to avoid
+                // self-referential fetch (CF error 1019/522) in Workers for Platforms tenants
+                const dispatchBinding = this.env.MUG_DISPATCH;
+                const internalSecret = this.env.MUG_INTERNAL_SECRET;
+                const isDispatchUrl = url.includes("api.mug.work");
+                const useServiceBinding = isDispatchUrl && dispatchBinding && internalSecret;
+                let lastError;
+                for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                    try {
+                        const controller = new AbortController();
+                        const timer = setTimeout(() => controller.abort(), timeout);
+                        let fetchUrl = url;
+                        if (useServiceBinding) {
+                            fetchUrl = url.replace(/https?:\/\/api\.mug\.work/, "https://mug-dispatch");
+                            if (!headers["X-Mug-Internal"])
+                                headers["X-Mug-Internal"] = internalSecret;
+                        }
+                        const res = useServiceBinding
+                            ? await dispatchBinding.fetch(fetchUrl, { method, headers, body: bodyStr, signal: controller.signal })
+                            : await fetch(url, { method, headers, body: bodyStr, signal: controller.signal });
+                        clearTimeout(timer);
+                        const resHeaders = {};
+                        res.headers.forEach((v, k) => { resHeaders[k] = v; });
+                        const resBody = await res.text();
+                        let json = null;
+                        const ct = resHeaders["content-type"] ?? "";
+                        if (ct.includes("json")) {
+                            try {
+                                json = JSON.parse(resBody);
+                            }
+                            catch { }
+                        }
+                        const httpResult = {
+                            status: res.status,
+                            headers: resHeaders,
+                            body: resBody,
+                            json,
+                            ok: res.status >= 200 && res.status < 300,
+                        };
+                        if (res.status === 429 && shouldRetry && attempt < maxAttempts) {
+                            const delay = Math.min(1000 * Math.pow(2, attempt - 1), 30000);
+                            await new Promise(r => setTimeout(r, delay));
+                            continue;
+                        }
+                        return httpResult;
+                    }
+                    catch (e) {
+                        lastError = e;
+                        const isRetryable = lastError.name === "AbortError" || lastError.message?.includes("fetch failed");
+                        if (isRetryable && shouldRetry && attempt < maxAttempts) {
+                            const delay = Math.min(1000 * Math.pow(2, attempt - 1), 30000);
+                            await new Promise(r => setTimeout(r, delay));
+                            continue;
+                        }
+                        throw lastError;
+                    }
+                }
+                throw lastError ?? new Error("ctx.http() failed after retries");
+            });
+            await this.meterIncrement("operations", 1, `workflow:http-${method.toLowerCase()}`);
+            this.recordStep(name, "http", start, {
+                input: { method, url },
+                output: `${result.status} ${result.body.slice(0, 200)}`,
+            });
+            if (!result.ok && throwOnError) {
+                throw new HttpError(result);
+            }
+            return result;
+        }
+        catch (e) {
+            if (e instanceof HttpError) {
+                this.recordStep(name, "http", start, {
+                    input: { method, url },
+                    output: `${e.status} (error thrown)`,
+                });
+                throw e;
+            }
+            this.recordStep(name, "http", start, {
+                input: { method, url },
+                error: e.message,
+            });
+            throw e;
+        }
+    }
+}
+class DurableConnectorHandle {
+    wfCtx;
+    def;
+    connectorName;
+    constructor(wfCtx, def, connectorName) {
+        this.wfCtx = wfCtx;
+        this.def = def;
+        this.connectorName = connectorName;
+    }
+    resolveTable(tableName) {
+        const table = this.def.tables.find((t) => t.name === tableName);
+        if (!table)
+            throw new Error(`Table "${tableName}" not found in connector "${this.connectorName}"`);
+        return table;
+    }
+    async read(tableName, recordId) {
+        this.wfCtx._checkOpsCap();
+        const table = this.resolveTable(tableName);
+        if (!table.get)
+            throw new Error(`Connector "${this.connectorName}" table "${tableName}" has no get() method`);
+        const stepName = `action.read-${this.connectorName}.${tableName}-${Date.now()}`;
+        const start = Date.now();
+        const operationId = `action-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const sourceCtx = this.wfCtx._makeSourceCtx(this.connectorName);
+        const getFn = table.get;
+        const data = await this.wfCtx._doStep(stepName, async () => {
+            return (await getFn(sourceCtx, recordId)) ?? {};
+        });
+        return { connector: this.connectorName, table: tableName, operation: "read", recordId, data, operationId };
+    }
+    async create(tableName, fields) {
+        this.wfCtx._checkOpsCap();
+        const table = this.resolveTable(tableName);
+        if (!table.actions?.create)
+            throw new Error(`Connector "${this.connectorName}" table "${tableName}" has no create action`);
+        const stepName = `action.create-${this.connectorName}.${tableName}-${Date.now()}`;
+        const operationId = `action-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const sourceCtx = this.wfCtx._makeSourceCtx(this.connectorName);
+        const createFn = table.actions.create;
+        const data = await this.wfCtx._doStep(stepName, async () => {
+            return await createFn(sourceCtx, fields);
+        });
+        return { connector: this.connectorName, table: tableName, operation: "create", data, operationId };
+    }
+    async update(tableName, recordId, fields) {
+        this.wfCtx._checkOpsCap();
+        const table = this.resolveTable(tableName);
+        if (!table.actions?.update)
+            throw new Error(`Connector "${this.connectorName}" table "${tableName}" has no update action`);
+        const stepName = `action.update-${this.connectorName}.${tableName}-${Date.now()}`;
+        const operationId = `action-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const sourceCtx = this.wfCtx._makeSourceCtx(this.connectorName);
+        const getFn = table.get;
+        const updateFn = table.actions.update;
+        const result = await this.wfCtx._doStep(stepName, async () => {
+            let snapshot;
+            if (getFn) {
+                snapshot = (await getFn(sourceCtx, recordId)) ?? undefined;
+            }
+            const data = await updateFn(sourceCtx, recordId, fields);
+            return { data, snapshot };
+        });
+        return { connector: this.connectorName, table: tableName, operation: "update", recordId, data: result.data, snapshot: result.snapshot, operationId };
+    }
+    async delete(tableName, recordId) {
+        this.wfCtx._checkOpsCap();
+        const table = this.resolveTable(tableName);
+        if (!table.actions?.delete)
+            throw new Error(`Connector "${this.connectorName}" table "${tableName}" has no delete action`);
+        const stepName = `action.delete-${this.connectorName}.${tableName}-${Date.now()}`;
+        const operationId = `action-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const sourceCtx = this.wfCtx._makeSourceCtx(this.connectorName);
+        const getFn = table.get;
+        const deleteFn = table.actions.delete;
+        const result = await this.wfCtx._doStep(stepName, async () => {
+            let snapshot;
+            if (getFn) {
+                snapshot = (await getFn(sourceCtx, recordId)) ?? undefined;
+            }
+            const data = await deleteFn(sourceCtx, recordId);
+            return { data, snapshot };
+        });
+        return { connector: this.connectorName, table: tableName, operation: "delete", recordId, data: result.data, snapshot: result.snapshot, operationId };
+    }
+    async upsert(tableName, recordId, fields) {
+        this.wfCtx._checkOpsCap();
+        const table = this.resolveTable(tableName);
+        if (!table.actions?.upsert)
+            throw new Error(`Connector "${this.connectorName}" table "${tableName}" has no upsert action`);
+        const stepName = `action.upsert-${this.connectorName}.${tableName}-${Date.now()}`;
+        const operationId = `action-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const sourceCtx = this.wfCtx._makeSourceCtx(this.connectorName);
+        const getFn = table.get;
+        const upsertFn = table.actions.upsert;
+        const result = await this.wfCtx._doStep(stepName, async () => {
+            let snapshot;
+            if (getFn) {
+                snapshot = (await getFn(sourceCtx, recordId)) ?? undefined;
+            }
+            const data = await upsertFn(sourceCtx, recordId, fields);
+            return { data, snapshot };
+        });
+        return { connector: this.connectorName, table: tableName, operation: "upsert", recordId, data: result.data, snapshot: result.snapshot, operationId };
+    }
+}
+export class MugWorkflow extends WorkflowEntrypoint {
+    async run(event, step) {
+        const workflowName = event.payload.workflow;
+        const def = getWorkflow(workflowName);
+        if (!def)
+            throw new Error(`Workflow "${workflowName}" not registered`);
+        const workspace = this.env.WORKSPACE_ID;
+        const runId = `${workspace}-${workflowName}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const startedAt = new Date();
+        const ctx = new DurableWorkflowContext(this.env, step, def.options?.maxOperations);
+        ctx.changesetId = runId;
+        ctx.changesetSource = `workflow:${workflowName}`;
+        ctx.instanceId = event.instanceId;
+        ctx.params = event.payload;
+        let result;
+        let error;
+        let status = "complete";
+        try {
+            result = await def.handler(ctx);
+        }
+        catch (e) {
+            error = e.message;
+            status = "errored";
+        }
+        const completedAt = new Date();
+        const runLog = {
+            id: runId,
+            workflow: workflowName,
+            status,
+            started_at: startedAt.toISOString(),
+            completed_at: completedAt.toISOString(),
+            duration_ms: completedAt.getTime() - startedAt.getTime(),
+            params: JSON.stringify(event.payload),
+            result: result != null ? JSON.stringify(result) : undefined,
+            error,
+            steps: ctx.steps,
+        };
+        await step.do("ops-log", async () => {
+            const res = await fetch(`https://api.mug.work/ops/${workspace}/log-run`, {
+                method: "POST",
+                body: JSON.stringify(runLog),
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-Mug-Internal": this.env.MUG_INTERNAL_SECRET,
+                },
+            });
+            if (!res.ok)
+                console.error(`[ops] Log failed: ${res.status}`);
+        });
+        if (error)
+            throw new Error(error);
+        return result;
+    }
+}
+export default {
+    async fetch(request, env) {
+        const url = new URL(request.url);
+        if (url.pathname === "/slack-options" && request.method === "POST") {
+            const body = await request.json();
+            if (!env.MUG_DATA)
+                return Response.json({ options: [] });
+            const internalHeaders = {
+                "Content-Type": "application/json",
+                "X-Mug-Internal": env.MUG_INTERNAL_SECRET ?? "",
+            };
+            const res = await env.MUG_DATA.fetch(`https://mug-data/workspace/${env.WORKSPACE_ID}/db/${body.database}/query`, {
+                method: "POST",
+                body: JSON.stringify({ sql: body.query, params: body.params }),
+                headers: internalHeaders,
+            });
+            const data = (await res.json());
+            const options = (data.rows ?? []).map((row) => {
+                const values = Object.values(row);
+                const text = String(values[0] ?? "");
+                const value = String(values[1] ?? values[0] ?? "");
+                return { text: { type: "plain_text", text }, value };
+            });
+            return Response.json({ options });
+        }
+        if (url.pathname === "/create-workflow" && request.method === "POST") {
+            const body = await request.json();
+            const workflowName = body.workflow;
+            const workspace = env.WORKSPACE_ID;
+            const instanceId = `${workspace}-${workflowName}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const wf = env.WORKFLOWS;
+            const instance = await wf.create({
+                id: instanceId,
+                params: { workspace, workflow: workflowName, ...body },
+            });
+            return Response.json({
+                status: "created",
+                instanceId: await instance.id,
+                workspace,
+                workflow: workflowName,
+            });
+        }
+        return Response.json({ error: "Not found" }, { status: 404 });
+    },
+};