@drumcode/runner 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,192 @@
+import { Tool } from '@drumcode/core';
+import { z } from 'zod';
+
+declare const runnerOptionsSchema: z.ZodObject<{
+    token: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    registryUrl: z.ZodDefault<z.ZodString>;
+    cacheEnabled: z.ZodDefault<z.ZodBoolean>;
+    logLevel: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
+    transport: z.ZodDefault<z.ZodEnum<["stdio", "sse"]>>;
+    /**
+     * Client mode affects how tools are exposed:
+     * - 'polyfill': Only expose core meta-tools (search + get_schema) - default for generic clients
+     * - 'full': Expose full manifest from registry - for clients that support large tool lists
+     */
+    clientMode: z.ZodDefault<z.ZodEnum<["polyfill", "full"]>>;
+    /**
+     * Port for SSE server (only used when transport is 'sse')
+     */
+    port: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Host for SSE server (only used when transport is 'sse')
+     */
+    host: z.ZodDefault<z.ZodString>;
+    /**
+     * Integration base URLs for registry tools (keyed by integration name)
+     */
+    integrationBaseUrls: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /**
+     * Integration headers for registry tools (keyed by integration name)
+     */
+    integrationHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, "strip", z.ZodTypeAny, {
+    registryUrl: string;
+    cacheEnabled: boolean;
+    logLevel: "info" | "debug" | "warn" | "error";
+    transport: "stdio" | "sse";
+    clientMode: "polyfill" | "full";
+    port: number;
+    host: string;
+    token?: string | undefined;
+    project?: string | undefined;
+    integrationBaseUrls?: Record<string, string> | undefined;
+    integrationHeaders?: Record<string, Record<string, string>> | undefined;
+}, {
+    token?: string | undefined;
+    project?: string | undefined;
+    registryUrl?: string | undefined;
+    cacheEnabled?: boolean | undefined;
+    logLevel?: "info" | "debug" | "warn" | "error" | undefined;
+    transport?: "stdio" | "sse" | undefined;
+    clientMode?: "polyfill" | "full" | undefined;
+    port?: number | undefined;
+    host?: string | undefined;
+    integrationBaseUrls?: Record<string, string> | undefined;
+    integrationHeaders?: Record<string, Record<string, string>> | undefined;
+}>;
+type RunnerOptions = z.infer<typeof runnerOptionsSchema>;
+interface ToolCallRequest {
+    name: string;
+    arguments: Record<string, unknown>;
+}
+interface ToolCallResult {
+    content: Array<{
+        type: 'text' | 'image' | 'resource';
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+    isError?: boolean;
+}
+interface TokenValidationResponse {
+    valid: boolean;
+    project?: {
+        id: string;
+    };
+    token?: {
+        id: string;
+        name: string | null;
+        profileId: string | null;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface AuthenticatedContext {
+    isAuthenticated: boolean;
+    projectId: string | null;
+    tokenId: string | null;
+    tokenName: string | null;
+    profileId: string | null;
+}
+type ClientType = 'anthropic' | 'openai' | 'cursor' | 'langchain' | 'unknown';
+interface ClientCapabilities {
+    type: ClientType;
+    supportsAdvancedToolUse: boolean;
+    supportsDeferredLoading: boolean;
+}
+
+declare class DrumcodeRunner {
+    private options;
+    private toolCache;
+    private skillCache;
+    private manifestCache;
+    private authContext;
+    private authInitialized;
+    constructor(options: RunnerOptions);
+    /**
+     * Initialize authentication by validating the token with the registry
+     * This should be called before processing any requests
+     */
+    initializeAuth(): Promise<AuthenticatedContext>;
+    /**
+     * Get the current authentication context
+     */
+    getAuthContext(): AuthenticatedContext;
+    /**
+     * Check if the runner is authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Get the list of tools to expose to the client
+     * Uses Polyfill strategy for non-Anthropic clients
+     */
+    getToolList(capabilities: ClientCapabilities): Promise<Tool[]>;
+    /**
+     * Fetch the full tool manifest from the Registry
+     */
+    private getFullManifest;
+    /**
+     * Execute a tool call
+     */
+    executeTool(request: ToolCallRequest): Promise<ToolCallResult>;
+    /**
+     * Handle drumcode_search_tools meta-tool
+     */
+    private handleSearchTools;
+    /**
+     * Handle drumcode_get_tool_schema meta-tool
+     */
+    private handleGetToolSchema;
+    private fetchRegistryToolSchema;
+    /**
+     * Execute a regular (non-meta) tool
+     */
+    private executeRegularTool;
+    private executeRegistryTool;
+    /**
+     * Fetch skill definition from registry
+     */
+    private fetchSkill;
+    /**
+     * Execute a skill (validator or workflow)
+     */
+    private executeSkill;
+    /**
+     * Evaluate a policy rule against context
+     * Simple expression evaluator for rules like "input.query && input.query.length >= 2"
+     */
+    private evaluateRule;
+    /**
+     * Evaluate an argument mapping expression
+     * Supports expressions like "input.query", "input.max_results || 5", "steps.search_results.papers[0].id"
+     */
+    private evaluateMapping;
+    /**
+     * Parse tool result content to extract structured data
+     */
+    private parseToolResult;
+    /**
+     * Execute arXiv tools via the arXiv API
+     */
+    private executeArxivTool;
+    /**
+     * Parse arXiv Atom XML response
+     */
+    private parseArxivResponse;
+    private getIntegrationBaseUrl;
+    private getIntegrationHeaders;
+    private buildToolRequest;
+    private getAuthHeaders;
+    private formatToolSchema;
+    private log;
+}
+
+/**
+ * Create and configure the MCP server
+ */
+declare function createServer(options: RunnerOptions): Promise<void>;
+
+export { type AuthenticatedContext, DrumcodeRunner, type RunnerOptions, type TokenValidationResponse, createServer };