@decocms/runtime 0.0.1-testing-beta.1

package/dist/index-AKVjfH4b.d.ts

@@ -0,0 +1,336 @@
+import { ExecutionContext as ExecutionContext$1 } from '@cloudflare/workers-types';
+import { z } from 'zod';
+import { ToolExecutionContext, ToolAction, Tool } from '@mastra/core';
+import { RuntimeContext } from '@mastra/core/di';
+import { Q as QueryResult } from './mcp-Bv7IAgWX.js';
+import { M as MCPConnection } from './connection-DDtQYrea.js';
+import { ResourceCreateInputSchema, ResourceUpdateInputSchema, ResourceDeleteInputSchema } from './resources.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>;
+interface StreamableTool<TSchemaIn extends z.ZodSchema = z.ZodSchema> {
+    id: string;
+    inputSchema: TSchemaIn;
+    streamable?: true;
+    description?: string;
+    execute: (input: ToolExecutionContext<TSchemaIn>) => Promise<Response>;
+}
+declare function createStreamableTool<TSchemaIn extends z.ZodSchema = z.ZodSchema>(streamableTool: StreamableTool<TSchemaIn>): StreamableTool<TSchemaIn>;
+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 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> | ReturnType<typeof createStreamableTool>;
+declare function isStreamableTool(tool: CreatedTool): tool is StreamableTool;
+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[]>);
+}
+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 createMCPServer: <TEnv = any, TSchema extends z.ZodTypeAny = never>(options: CreateMCPServerOptions<TEnv, TSchema>) => MCPServer<TEnv, TSchema>;
+
+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;
+}, decocmsApiUrl?: string, appName?: string) => MCPConnection;
+
+interface WorkspaceDB {
+    query: (params: {
+        sql: string;
+        params: string[];
+    }) => Promise<{
+        result: QueryResult[];
+    }>;
+}
+interface DefaultEnv<TSchema extends z.ZodTypeAny = any> {
+    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_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>>;
+
+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 StreamableTool as S, type UserDefaultExport as U, type ViewExport as V, type WorkspaceDB as W, createRuntimeContext as a, createStreamableTool as b, createPrivateTool as c, createTool as d, type CreateMCPServerOptions as e, createMCPServer as f, WorkersMCPBindings as g, type User as h, isStreamableTool as i, type RequestContext as j, UnauthorizedError as k, withRuntime as l, type Contract as m, type Migration as n, type WranglerConfig as o, proxyConnectionForId as p, withBindings as w };