@decocms/runtime 0.24.0

package/dist/index-D_J_044C.d.ts

@@ -0,0 +1,461 @@
+import { DurableObjectNamespace as DurableObjectNamespace$1, ExecutionContext as ExecutionContext$1 } from '@cloudflare/workers-types';
+import { z } from 'zod';
+import { ToolExecutionContext, ToolAction, Tool, Workflow as Workflow$1 } from '@mastra/core';
+import { RuntimeContext } from '@mastra/core/di';
+import { createWorkflow, Step as Step$1, ExecuteFunction, DefaultEngineType } from '@mastra/core/workflows';
+import { ResourceCreateInputSchema, ResourceUpdateInputSchema, ResourceDeleteInputSchema } from './resources.js';
+import { Q as QueryResult } from './mcp-Bv7IAgWX.js';
+import { M as MCPConnection } from './connection-DDtQYrea.js';
+
+declare const createRuntimeContext: (prev?: RuntimeContext<AppContext>) => RuntimeContext<AppContext<any>>;
+/**
+ * creates a private tool that always ensure for athentication before being executed
+ */
+declare function createPrivateTool<TSchemaIn extends z.ZodSchema = z.ZodSchema, TSchemaOut extends z.ZodSchema | undefined = undefined, TSuspendSchema extends z.ZodSchema = z.ZodSchema, TResumeSchema extends z.ZodSchema = z.ZodSchema, TContext extends ToolExecutionContext<TSchemaIn> = ToolExecutionContext<TSchemaIn>, TExecute extends ToolAction<TSchemaIn, TSchemaOut, any, any, TContext>["execute"] = ToolAction<TSchemaIn, TSchemaOut, any, any, TContext>["execute"]>(opts: ToolAction<TSchemaIn, TSchemaOut, TSuspendSchema, TResumeSchema, TContext> & {
+    execute?: TExecute;
+}): [TSchemaIn, TSchemaOut, TSuspendSchema, TResumeSchema, TExecute] extends [
+    z.ZodSchema,
+    z.ZodSchema,
+    z.ZodSchema,
+    z.ZodSchema,
+    Function
+] ? Tool<TSchemaIn, TSchemaOut, TSuspendSchema, TResumeSchema, TContext> & {
+    inputSchema: TSchemaIn;
+    outputSchema: TSchemaOut;
+    execute: (context: TContext) => Promise<any>;
+} : Tool<TSchemaIn, TSchemaOut, TSuspendSchema, TResumeSchema, TContext>;
+declare function createTool<TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TSuspendSchema extends z.ZodSchema = z.ZodSchema, TResumeSchema extends z.ZodSchema = z.ZodSchema, TContext extends ToolExecutionContext<TSchemaIn, TSuspendSchema, TResumeSchema> = ToolExecutionContext<TSchemaIn, TSuspendSchema, TResumeSchema>, TExecute extends ToolAction<TSchemaIn, TSchemaOut, TSuspendSchema, TResumeSchema, TContext>["execute"] = ToolAction<TSchemaIn, TSchemaOut, TSuspendSchema, TResumeSchema, TContext>["execute"]>(opts: ToolAction<TSchemaIn, TSchemaOut, TSuspendSchema, TResumeSchema, TContext> & {
+    execute?: TExecute;
+}): [TSchemaIn, TSchemaOut, TSuspendSchema, TResumeSchema, TExecute] extends [
+    z.ZodSchema,
+    z.ZodSchema,
+    z.ZodSchema,
+    z.ZodSchema,
+    Function
+] ? Tool<TSchemaIn, TSchemaOut, TSuspendSchema, TResumeSchema, TContext> & {
+    inputSchema: TSchemaIn;
+    outputSchema: TSchemaOut;
+    execute: (context: TContext) => Promise<any>;
+} : Tool<TSchemaIn, TSchemaOut, TSuspendSchema, TResumeSchema, TContext>;
+type ExecWithContext<TF extends (...args: any[]) => any> = (input: Omit<Parameters<TF>[0], "runtimeContext"> & {
+    runtimeContext: RuntimeContext<AppContext>;
+}) => ReturnType<TF>;
+interface Step<TStepId extends string = string, TState extends z.ZodObject<any> = z.ZodObject<any, z.$strip>, TSchemaIn extends z.ZodType<any> = z.ZodType<any>, TSchemaOut extends z.ZodType<any> = z.ZodType<any>, TResumeSchema extends z.ZodType<any> = z.ZodType<any>, TSuspendSchema extends z.ZodType<any> = z.ZodType<any>, TEngineType = any> extends Omit<Step$1<TStepId, TState, TSchemaIn, TSchemaOut, TResumeSchema, TSuspendSchema, TEngineType>, "execute"> {
+    execute: ExecWithContext<ExecuteFunction<z.infer<TState>, z.infer<TSchemaIn>, z.infer<TSchemaOut>, z.infer<TResumeSchema>, z.infer<TSuspendSchema>, TEngineType>>;
+}
+declare function createStepFromTool<TSchemaIn extends z.ZodType<any>, TSchemaOut extends z.ZodType<any>, TSuspendSchema extends z.ZodType<any>, TResumeSchema extends z.ZodType<any>, TContext extends ToolExecutionContext<TSchemaIn, TSuspendSchema, TResumeSchema>>(tool: Tool<TSchemaIn, TSchemaOut, TSuspendSchema, TResumeSchema, TContext> & {
+    inputSchema: TSchemaIn;
+    outputSchema: TSchemaOut;
+    execute: (context: TContext) => Promise<any>;
+}): Step<string, TSchemaIn, TSchemaOut, z.ZodType<any>, z.ZodType<any>, DefaultEngineType>;
+declare function createStep<TStepId extends string, TStepInput extends z.ZodType<any>, TStepOutput extends z.ZodType<any>, TResumeSchema extends z.ZodType<any>, TSuspendSchema extends z.ZodType<any>>(opts: {
+    id: TStepId;
+    description?: string;
+    inputSchema: TStepInput;
+    outputSchema: TStepOutput;
+    resumeSchema?: TResumeSchema;
+    suspendSchema?: TSuspendSchema;
+    execute: ExecWithContext<ExecuteFunction<z.infer<TStepInput>, z.infer<TStepOutput>, z.infer<TResumeSchema>, z.infer<TSuspendSchema>, DefaultEngineType>>;
+}): Step<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema, DefaultEngineType>;
+interface ViewExport {
+    title: string;
+    icon: string;
+    url: string;
+    tools?: string[];
+    rules?: string[];
+    installBehavior?: "none" | "open" | "autoPin";
+}
+type Resources<Env = any, TSchema extends z.ZodTypeAny = never> = Array<(env: Env & DefaultEnv<TSchema>) => {
+    name: string;
+    icon: string;
+    title: string;
+    description?: string;
+    tools: {
+        read: (args: {
+            uri: string;
+        }) => Promise<unknown>;
+        search: (args: {
+            term: string;
+            cursor?: string;
+            limit?: number;
+        }) => Promise<unknown>;
+        create?: (args: z.infer<typeof ResourceCreateInputSchema>) => Promise<unknown>;
+        update?: (args: z.infer<typeof ResourceUpdateInputSchema>) => Promise<unknown>;
+        delete?: (args: z.infer<typeof ResourceDeleteInputSchema>) => Promise<unknown>;
+    };
+    views?: {
+        list?: {
+            url?: string;
+            tools?: string[];
+            rules?: string[];
+        };
+        detail?: {
+            url?: string;
+            mimeTypePattern?: string;
+            resourceName?: string;
+            tools?: string[];
+            rules?: string[];
+        };
+    };
+}>;
+interface Integration {
+    id: string;
+    appId: string;
+}
+type CreatedTool = ReturnType<typeof createTool>;
+interface CreateMCPServerOptions<Env = any, TSchema extends z.ZodTypeAny = never> {
+    before?: (env: Env & DefaultEnv<TSchema>) => Promise<void> | void;
+    oauth?: {
+        state?: TSchema;
+        scopes?: string[];
+    };
+    views?: (env: Env & DefaultEnv<TSchema>) => Promise<ViewExport[]> | ViewExport[];
+    resources?: Resources<Env, TSchema>;
+    tools?: Array<(env: Env & DefaultEnv<TSchema>) => Promise<CreatedTool> | CreatedTool | CreatedTool[] | Promise<CreatedTool[]>> | ((env: Env & DefaultEnv<TSchema>) => CreatedTool[] | Promise<CreatedTool[]>);
+    workflows?: Array<(env: Env & DefaultEnv<TSchema>) => Promise<{
+        workflow: ReturnType<typeof createWorkflow>;
+    }> | ReturnType<typeof createWorkflow>>;
+}
+type Fetch<TEnv = any> = (req: Request, env: TEnv, ctx: ExecutionContext) => Promise<Response> | Response;
+interface AppContext<TEnv = any> {
+    env: TEnv;
+    ctx: {
+        waitUntil: (promise: Promise<any>) => void;
+    };
+    req?: Request;
+}
+type CallTool = (opts: {
+    toolCallId: string;
+    toolCallInput: any;
+}) => Promise<any>;
+type MCPServer<TEnv = any, TSchema extends z.ZodTypeAny = never> = {
+    fetch: Fetch<TEnv & DefaultEnv<TSchema>>;
+    callTool: CallTool;
+};
+declare const isWorkflow: (value: any) => value is Workflow$1;
+declare const createMCPServer: <TEnv = any, TSchema extends z.ZodTypeAny = never>(options: CreateMCPServerOptions<TEnv, TSchema>) => MCPServer<TEnv, TSchema>;
+
+interface StartWorkflowArgs {
+    workflowId: string;
+    args: unknown;
+    runId?: string;
+    ctx: RequestContext;
+}
+interface CancelWorkflowArgs {
+    workflowId: string;
+    runId?: string;
+    ctx: RequestContext;
+}
+interface ResumeWorkflowArgs {
+    workflowId: string;
+    runId?: string;
+    resumeData: unknown;
+    stepId: string;
+    ctx: RequestContext;
+}
+interface WorkflowDO extends Rpc.DurableObjectBranded {
+    start: (args: StartWorkflowArgs) => Promise<{
+        runId: string;
+    }>;
+    cancel: (args: CancelWorkflowArgs) => Promise<{
+        cancelled: boolean;
+    }>;
+    resume: (args: ResumeWorkflowArgs) => Promise<{
+        resumed: boolean;
+    }>;
+}
+declare const Workflow: (server: MCPServer<any, any>, workflows?: CreateMCPServerOptions["workflows"]) => {
+    new (ctx: DurableObjectState<{}>, env: DefaultEnv): {
+        ctx: DurableObjectState<{}>;
+        env: DefaultEnv;
+        bindings(ctx: RequestContext): DefaultEnv<any>;
+        runWithContext<T>(ctx: RequestContext, f: (ctx: DefaultEnv) => Promise<T>): Promise<T>;
+        "__#private@#getWorkflow"(workflowId: string, bindings: DefaultEnv): Promise<{
+            workflow: Workflow$1;
+        }>;
+        start({ workflowId, runId, args, ctx }: StartWorkflowArgs): Promise<{
+            runId: string;
+        }>;
+        cancel({ workflowId, runId, ctx }: CancelWorkflowArgs): Promise<{
+            cancelled: boolean;
+        }>;
+        resume({ workflowId, runId, resumeData, stepId, ctx }: ResumeWorkflowArgs): Promise<{
+            resumed: boolean;
+        }>;
+        fetch?(request: Request): Response | Promise<Response>;
+        alarm?(alarmInfo?: AlarmInvocationInfo): void | Promise<void>;
+        webSocketMessage?(ws: WebSocket, message: string | ArrayBuffer): void | Promise<void>;
+        webSocketClose?(ws: WebSocket, code: number, reason: string, wasClean: boolean): void | Promise<void>;
+        webSocketError?(ws: WebSocket, error: unknown): void | Promise<void>;
+        __DURABLE_OBJECT_BRAND: never;
+    };
+};
+
+interface DeprecatedEnv<TSchema extends z.ZodTypeAny = any> {
+    /**
+     * @deprecated Use DECO_REQUEST_CONTEXT instead
+     */
+    DECO_CHAT_REQUEST_CONTEXT: RequestContext<TSchema>;
+    /**
+     * @deprecated Use DECO_APP_NAME instead
+     */
+    DECO_CHAT_APP_NAME: string;
+    /**
+     * @deprecated Use DECO_APP_SLUG instead
+     */
+    DECO_CHAT_APP_SLUG: string;
+    /**
+     * @deprecated Use DECO_APP_ENTRYPOINT instead
+     */
+    DECO_CHAT_APP_ENTRYPOINT: string;
+    /**
+     * @deprecated Use DECO_API_URL instead
+     */
+    DECO_CHAT_API_URL?: string;
+    /**
+     * @deprecated Use DECO_WORKSPACE instead
+     */
+    DECO_CHAT_WORKSPACE: string;
+    /**
+     * @deprecated Use DECO_API_JWT_PUBLIC_KEY instead
+     */
+    DECO_CHAT_API_JWT_PUBLIC_KEY: string;
+    /**
+     * @deprecated Use DECO_APP_DEPLOYMENT_ID instead
+     */
+    DECO_CHAT_APP_DEPLOYMENT_ID: string;
+    /**
+     * @deprecated Use DECO_BINDINGS instead
+     */
+    DECO_CHAT_BINDINGS: string;
+    /**
+     * @deprecated Use DECO_API_TOKEN instead
+     */
+    DECO_CHAT_API_TOKEN: string;
+    /**
+     * @deprecated Use DECO_WORKFLOW_DO instead
+     */
+    DECO_CHAT_WORKFLOW_DO: DurableObjectNamespace$1<WorkflowDO>;
+    /**
+     * @deprecated Use DECO_WORKSPACE_DB instead
+     */
+    DECO_CHAT_WORKSPACE_DB: WorkspaceDB & {
+        forContext: (ctx: RequestContext) => WorkspaceDB;
+    };
+}
+
+interface BindingBase {
+    name: string;
+}
+interface MCPIntegrationIdBinding extends BindingBase {
+    type: "mcp";
+    /**
+     * If not provided, will return a function that takes the integration id and return the binding implementation..
+     */
+    integration_id: string;
+}
+interface MCPIntegrationNameBinding extends BindingBase {
+    type: "mcp";
+    /**
+     * The name of the integration to bind.
+     */
+    integration_name: string;
+}
+interface ContractClause {
+    id: string;
+    price: string | number;
+    description?: string;
+}
+interface Contract {
+    body: string;
+    clauses: ContractClause[];
+}
+interface ContractBinding extends BindingBase {
+    type: "contract";
+    /**
+     * The clauses of this contract
+     */
+    contract: Contract;
+}
+type MCPBinding = MCPIntegrationIdBinding | MCPIntegrationNameBinding;
+type Binding = MCPBinding | ContractBinding;
+interface MigrationBase {
+    tag: string;
+}
+interface NewClassMigration extends MigrationBase {
+    new_classes?: string[];
+    new_sqlite_classes?: string[];
+}
+interface DeletedClassMigration extends MigrationBase {
+    deleted_classes: string[];
+}
+interface RenamedClassMigration extends MigrationBase {
+    renamed_classes: {
+        from: string;
+        to: string;
+    }[];
+}
+type Migration = NewClassMigration | DeletedClassMigration | RenamedClassMigration;
+interface KVNamespace {
+    binding: string;
+    id: string;
+}
+interface Triggers {
+    crons: string[];
+}
+interface Route {
+    pattern: string;
+    custom_domain?: boolean;
+}
+interface WranglerConfig {
+    name: string;
+    main?: string;
+    scope?: string;
+    main_module?: string;
+    routes?: Route[];
+    compatibility_date?: string;
+    compatibility_flags?: string[];
+    vars?: Record<string, string>;
+    kv_namespaces?: KVNamespace[];
+    triggers?: Triggers;
+    ai?: {
+        binding: string;
+    };
+    browser?: {
+        binding: string;
+    };
+    durable_objects?: {
+        bindings?: {
+            name: string;
+            class_name: string;
+        }[];
+    };
+    hyperdrive?: {
+        binding: string;
+        id: string;
+        localConnectionString: string;
+    }[];
+    d1_databases?: {
+        database_name: string;
+        database_id?: string;
+        binding: string;
+    }[];
+    queues?: {
+        consumers?: {
+            queue: string;
+            max_batch_timeout: number;
+        }[];
+        producers?: {
+            queue: string;
+            binding: string;
+        }[];
+    };
+    workflows?: {
+        name: string;
+        binding: string;
+        class_name?: string;
+        script_name?: string;
+    }[];
+    migrations?: Migration[];
+    assets?: {
+        directory?: string;
+        binding?: string;
+        jwt?: string;
+        not_found_handling?: "none" | "404-page" | "single-page-application";
+        run_worker_first?: boolean;
+    };
+    keep_assets?: boolean;
+    deco?: {
+        enable_workflows?: boolean;
+        workspace?: string;
+        local?: boolean;
+        integration?: {
+            friendlyName?: string;
+            icon?: string;
+            description?: string;
+        };
+        bindings?: Binding[];
+    };
+}
+
+type WorkspaceClientContext = Omit<RequestContext, "ensureAuthenticated" | "state" | "fetchIntegrationMetadata">;
+declare const proxyConnectionForId: (integrationId: string, ctx: Omit<WorkspaceClientContext, "token"> & {
+    token?: string;
+    cookie?: string;
+}, decoChatApiUrl?: string, appName?: string) => MCPConnection;
+
+interface WorkspaceDB {
+    query: (params: {
+        sql: string;
+        params: string[];
+    }) => Promise<{
+        result: QueryResult[];
+    }>;
+}
+interface DefaultEnv<TSchema extends z.ZodTypeAny = any> extends DeprecatedEnv<TSchema> {
+    DECO_REQUEST_CONTEXT: RequestContext<TSchema>;
+    DECO_APP_NAME: string;
+    DECO_APP_SLUG: string;
+    DECO_APP_ENTRYPOINT: string;
+    DECO_API_URL?: string;
+    DECO_WORKSPACE: string;
+    DECO_API_JWT_PUBLIC_KEY: string;
+    DECO_APP_DEPLOYMENT_ID: string;
+    DECO_BINDINGS: string;
+    DECO_API_TOKEN: string;
+    DECO_WORKFLOW_DO: DurableObjectNamespace<WorkflowDO>;
+    DECO_WORKSPACE_DB: WorkspaceDB & {
+        forContext: (ctx: RequestContext) => WorkspaceDB;
+    };
+    IS_LOCAL: boolean;
+    [key: string]: unknown;
+}
+interface BindingsObject {
+    bindings?: Binding[];
+}
+declare const WorkersMCPBindings: {
+    parse: (bindings?: string) => Binding[];
+    stringify: (bindings: Binding[]) => string;
+};
+interface UserDefaultExport<TUserEnv = Record<string, unknown>, TSchema extends z.ZodTypeAny = never, TEnv = TUserEnv & DefaultEnv<TSchema>> extends CreateMCPServerOptions<TEnv, TSchema> {
+    fetch?: (req: Request, env: TEnv, ctx: ExecutionContext$1) => Promise<Response> | Response;
+}
+interface User {
+    id: string;
+    email: string;
+    workspace: string;
+    user_metadata: {
+        avatar_url: string;
+        full_name: string;
+        picture: string;
+        [key: string]: unknown;
+    };
+}
+interface RequestContext<TSchema extends z.ZodTypeAny = any> {
+    state: z.infer<TSchema>;
+    branch?: string;
+    token: string;
+    workspace: string;
+    ensureAuthenticated: (options?: {
+        workspaceHint?: string;
+    }) => User | undefined;
+    callerApp?: string;
+    integrationId?: string;
+}
+declare class UnauthorizedError extends Error {
+    redirectTo: URL;
+    constructor(message: string, redirectTo: URL);
+}
+declare const withBindings: <TEnv>({ env: _env, server, tokenOrContext, origin, url, branch, }: {
+    env: TEnv;
+    server: MCPServer<TEnv, any>;
+    tokenOrContext?: string | RequestContext;
+    origin?: string | null;
+    url?: string;
+    branch?: string | null;
+}) => TEnv;
+declare const withRuntime: <TEnv, TSchema extends z.ZodTypeAny = never>(userFns: UserDefaultExport<TEnv, TSchema>) => ExportedHandler<TEnv & DefaultEnv<TSchema>> & {
+    Workflow: ReturnType<typeof Workflow>;
+};
+
+export { type AppContext as A, type BindingsObject as B, type CreatedTool as C, type DefaultEnv as D, type ExecWithContext as E, type Fetch as F, type Integration as I, type MCPServer as M, type Resources as R, type Step as S, type UserDefaultExport as U, type ViewExport as V, type WorkspaceDB as W, createRuntimeContext as a, createTool as b, createPrivateTool as c, createStepFromTool as d, createStep as e, type CreateMCPServerOptions as f, createMCPServer as g, WorkersMCPBindings as h, isWorkflow as i, type User as j, type RequestContext as k, UnauthorizedError as l, withRuntime as m, type Contract as n, type Migration as o, proxyConnectionForId as p, type WranglerConfig as q, withBindings as w };

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import '@cloudflare/workers-types';
+import 'zod';
+export { B as BindingsObject, n as Contract, D as DefaultEnv, o as Migration, k as RequestContext, l as UnauthorizedError, j as User, U as UserDefaultExport, h as WorkersMCPBindings, W as WorkspaceDB, q as WranglerConfig, p as proxyConnectionForId, w as withBindings, m as withRuntime } from './index-D_J_044C.js';
+export { C as CreateStubAPIOptions, T as ToolBinder, c as createMCPFetchStub } from './mcp-Bv7IAgWX.js';
+import '@mastra/core';
+import '@mastra/core/di';
+import '@mastra/core/workflows';
+import './resources.js';
+import './connection-DDtQYrea.js';