@mugwork/mug 0.1.0

package/dist/runtime/workflow.d.ts

@@ -0,0 +1,285 @@
+import type { SearchOptions, SearchResult, AskOptions, AskResult } from "./context.js";
+import type { Env } from "./types.js";
+import type { CollectOptions } from "./form-types.js";
+import type { RoutingConfig } from "./ai-router.js";
+import type { AgentCaps } from "./agent-types.js";
+import { type SourceContext, type ConnectorDef } from "./source.js";
+import type { ActionType } from "./source-types.js";
+export interface AgentInvokeOptions {
+    goal: string;
+    context?: Record<string, unknown>;
+    sessionKey?: string;
+    caps?: Partial<AgentCaps>;
+}
+export interface AgentResult {
+    response: string;
+    output?: Record<string, unknown>;
+    usage: {
+        credits: number;
+        turns: number;
+        duration: number;
+    };
+    capped?: boolean;
+    cappedReason?: string;
+    pendingApproval?: {
+        tool: string;
+        args: Record<string, unknown>;
+        sessionKey: string;
+    };
+}
+export interface WaitForOptions {
+    timeout?: string | number;
+    message?: string;
+}
+export interface WaitForResult<T = unknown> {
+    payload: T;
+    type: string;
+    timedOut: boolean;
+}
+interface AiOptions {
+    prompt: string;
+    system?: string;
+    maxTokens?: number;
+    routing?: RoutingConfig;
+    billing?: string;
+}
+interface AiResponse {
+    text: string;
+    model: string;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+    routing?: {
+        tier: string;
+        model: string;
+        provider: string;
+        reason: string;
+    };
+}
+interface NotifyOptions {
+    to: string;
+    message: string;
+    subject?: string;
+    fromName?: string;
+    cta?: {
+        label: string;
+        url: string;
+    };
+    blocks?: unknown[];
+    thread_ts?: string;
+    unfurl_links?: boolean;
+    unfurl_media?: boolean;
+}
+export interface HttpOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    throwOnError?: boolean;
+    retry?: {
+        attempts?: number;
+    } | false;
+    timeout?: number;
+    sign?: {
+        secret: string;
+        header?: string;
+    };
+}
+export interface HttpResult {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+    json: unknown;
+    ok: boolean;
+}
+export declare class HttpError extends Error {
+    status: number;
+    result: HttpResult;
+    constructor(result: HttpResult);
+}
+export interface ActionResult<T = Record<string, unknown>> {
+    connector: string;
+    table: string;
+    operation: ActionType;
+    recordId?: string;
+    data: T;
+    snapshot?: Record<string, unknown>;
+    operationId: string;
+}
+export interface StepRecord {
+    name: string;
+    type: string;
+    billable: boolean;
+    startedAt: number;
+    completedAt?: number;
+    durationMs?: number;
+    input?: string;
+    output?: string;
+    error?: string;
+    tokensUsed?: number;
+}
+export interface WorkflowResult {
+    workflow: string;
+    runId: string;
+    status: "complete" | "errored";
+    startedAt: string;
+    completedAt: string;
+    durationMs: number;
+    stepCount: number;
+    steps: StepRecord[];
+    result?: unknown;
+    error?: string;
+    webhookResponse?: WebhookResponse;
+}
+export interface WebhookResponse {
+    body: unknown;
+    status: number;
+}
+export declare class WorkflowContext {
+    private ctx;
+    private env;
+    private stepCounter;
+    private workflowBilling?;
+    private operationCount;
+    private maxOperations;
+    readonly steps: StepRecord[];
+    params: Record<string, unknown>;
+    changesetId?: string;
+    changesetSource?: string;
+    instanceId?: string;
+    _webhookResponse?: WebhookResponse;
+    get isDemo(): boolean;
+    private get demoNotify();
+    private resolveDemoRecipient;
+    constructor(env: Env, options?: WorkflowOptions);
+    secret(name: string): string;
+    /** @internal */
+    _nextStep(type: string, target: string): string;
+    /** @internal */
+    _recordStep(name: string, type: string, startedAt: number, opts?: {
+        input?: unknown;
+        output?: unknown;
+        error?: string;
+        tokensUsed?: number;
+    }): StepRecord;
+    query(database: string, sql: string, params?: (string | number | null)[]): Promise<Record<string, unknown>[]>;
+    exec(database: string, sql: string, params?: (string | number | null)[]): Promise<number>;
+    ai(model: string, options: AiOptions): Promise<AiResponse>;
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    ask(question: string, options?: AskOptions): Promise<AskResult>;
+    get notify(): {
+        sms: (options: NotifyOptions) => Promise<string>;
+        email: (options: NotifyOptions) => Promise<string>;
+        slack: (options: NotifyOptions) => Promise<string>;
+        channel: (name: string, options: NotifyOptions) => Promise<string>;
+    };
+    private sendNotification;
+    get slack(): {
+        updateMessage: (options: {
+            channel: string;
+            ts: string;
+            text?: string;
+            blocks?: unknown[];
+        }) => Promise<void>;
+        openModal: (options: {
+            triggerId: string;
+            view: Record<string, unknown>;
+        }) => Promise<void>;
+        updateModal: (options: {
+            viewId: string;
+            view: Record<string, unknown>;
+        }) => Promise<void>;
+    };
+    private slackUpdateMessage;
+    private slackOpenModal;
+    private slackUpdateModal;
+    file(path: string): Promise<ArrayBuffer>;
+    fileText(path: string): Promise<string>;
+    embed(texts: string[]): Promise<number[][]>;
+    slackApiCall(method: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    surfaceUrl(surfaceId: string, path?: string): string;
+    respond(body: unknown, status?: number): Promise<void>;
+    agent(name: string, options: AgentInvokeOptions): Promise<AgentResult>;
+    collect(options: CollectOptions): Promise<string>;
+    waitFor<T = unknown>(eventName: string, options?: WaitForOptions): Promise<WaitForResult<T>>;
+    waitForUrl(eventName: string): Promise<string>;
+    http(url: string, options?: HttpOptions): Promise<HttpResult>;
+    action(connectorName: string): ConnectorHandle;
+    rollback(actionId: string): Promise<ActionResult>;
+    rollbackRun(workflowRunId: string): Promise<{
+        rolledBack: ActionResult[];
+        failed: {
+            actionId: string;
+            error: string;
+        }[];
+    }>;
+    /** @internal */
+    _checkOpsCap(): void;
+    /** @internal */
+    _logAction(result: ActionResult, afterPayload?: unknown): Promise<void>;
+    /** @internal */
+    _makeSourceCtx(connectorName: string): SourceContext;
+}
+declare class ConnectorHandle {
+    private wfCtx;
+    private def;
+    private connectorName;
+    constructor(wfCtx: WorkflowContext, def: ConnectorDef, connectorName: string);
+    private resolveTable;
+    read(tableName: string, recordId: string): Promise<ActionResult>;
+    create(tableName: string, fields: Record<string, unknown>): Promise<ActionResult>;
+    update(tableName: string, recordId: string, fields: Record<string, unknown>): Promise<ActionResult>;
+    delete(tableName: string, recordId: string): Promise<ActionResult>;
+    upsert(tableName: string, recordId: string, fields: Record<string, unknown>): Promise<ActionResult>;
+}
+export interface TriggerConfig {
+    type?: "slack_command" | "slack_event" | "slack_shortcut" | "data";
+    source?: string;
+    table?: string;
+    on?: "insert" | "update" | "delete" | "change";
+    includeInitialSync?: boolean;
+    command?: string;
+    event?: string;
+}
+export type Weekday = "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday" | "sunday";
+export interface ScheduleConfig {
+    cron?: string;
+    weekday?: Weekday;
+    nth?: number;
+    time?: string;
+    interval?: string;
+    between?: [string, string];
+    skipHolidays?: boolean | string;
+    skipDates?: string[];
+    timezone?: string;
+}
+export interface WorkflowOptions {
+    description?: string;
+    billing?: string;
+    schedule?: string | ScheduleConfig;
+    webhook?: boolean | {
+        auth: "none" | "hmac" | "bearer";
+        secret?: string;
+    };
+    inbound?: "sms" | "email" | "slack";
+    trigger?: TriggerConfig;
+    maxOperations?: number;
+}
+export type WorkflowHandler = (ctx: WorkflowContext) => Promise<unknown>;
+export interface WorkflowDef {
+    name: string;
+    handler: WorkflowHandler;
+    options?: WorkflowOptions;
+}
+export declare function workflow(name: string, handler: WorkflowHandler, options?: WorkflowOptions): WorkflowDef;
+export declare function getWorkflow(name: string): WorkflowDef | undefined;
+export declare function allWorkflows(): WorkflowDef[];
+export declare function findTriggeredWorkflows(sourceName: string, tableName: string, event: "insert" | "update" | "delete", isInitialSync: boolean): WorkflowDef[];
+export declare function runWorkflow(name: string, env: Env, params?: Record<string, unknown>): Promise<WorkflowResult>;
+export declare function queryLogs(env: Env, workflowName?: string, limit?: number): Promise<unknown>;
+export declare function queryActions(env: Env, filters?: {
+    workflowRunId?: string;
+    connector?: string;
+    operation?: string;
+}, limit?: number): Promise<Record<string, unknown>[]>;
+export {};