@bpmnkit/proxy 0.0.32 → 0.1.0

package/README.md

@@ -9,7 +9,7 @@
   [![ai-assisted](https://img.shields.io/badge/AI--assisted-claude-8b5cf6?style=flat-square)](https://github.com/bpmnkit/monorepo)
   [![experimental](https://img.shields.io/badge/status-experimental-f59e0b?style=flat-square)](https://github.com/bpmnkit/monorepo)
 
-  [Website](https://bpmnkit.com) · [Documentation](https://docs.bpmnkit.com) · [GitHub](https://github.com/bpmnkit/monorepo) · [Changelog](https://github.com/bpmnkit/monorepo/blob/main/apps/proxy/CHANGELOG.md)
+  [Website](https://bpmnkit.com) · [Documentation](https://bpmnkit.com/docs) · [GitHub](https://github.com/bpmnkit/monorepo) · [Changelog](https://github.com/bpmnkit/monorepo/blob/main/apps/proxy/CHANGELOG.md)
 </div>
 
 ---
@@ -80,10 +80,12 @@ curl -H "X-Profile: production" http://localhost:3033/api/v2/process-definitions
 | [`@bpmnkit/plugins`](https://www.npmjs.com/package/@bpmnkit/plugins) | 22 composable canvas plugins |
 | [`@bpmnkit/api`](https://www.npmjs.com/package/@bpmnkit/api) | Camunda 8 REST API TypeScript client |
 | [`@bpmnkit/ascii`](https://www.npmjs.com/package/@bpmnkit/ascii) | Render BPMN diagrams as Unicode ASCII art |
+| [`@bpmnkit/docspack`](https://www.npmjs.com/package/@bpmnkit/docspack) | BPMN Kit docs as an offline docspack package for AI agents |
 | [`@bpmnkit/ui`](https://www.npmjs.com/package/@bpmnkit/ui) | Shared design tokens and UI components |
 | [`@bpmnkit/profiles`](https://www.npmjs.com/package/@bpmnkit/profiles) | Shared auth, profile storage, and client factories for CLI & proxy |
 | [`@bpmnkit/operate`](https://www.npmjs.com/package/@bpmnkit/operate) | Monitoring & operations frontend for Camunda clusters |
 | [`@bpmnkit/connector-gen`](https://www.npmjs.com/package/@bpmnkit/connector-gen) | Generate connector templates from OpenAPI specs |
+| [`@bpmnkit/connectors`](https://www.npmjs.com/package/@bpmnkit/connectors) | Camunda 8 OOTB connector catalog and deterministic template application |
 | [`@bpmnkit/cli`](https://www.npmjs.com/package/@bpmnkit/cli) | Camunda 8 command-line interface (casen) |
 | [`@bpmnkit/patterns`](https://www.npmjs.com/package/@bpmnkit/patterns) | Domain process patterns for BPMNKit AIKit |
 | [`@bpmnkit/reebe-wasm`](https://www.npmjs.com/package/@bpmnkit/reebe-wasm) | WebAssembly BPMN engine for browser simulation |

package/dist/adapters/claude.d.ts

@@ -0,0 +1,9 @@
+export declare const supportsMcp = true;
+interface Message {
+    role: string;
+    content: string;
+}
+export declare function available(): Promise<boolean>;
+export declare function stream(messages: Message[], systemPrompt: string, mcpConfigFile: string | null, onToken: (text: string) => void): Promise<void>;
+export {};
+//# sourceMappingURL=claude.d.ts.map

package/dist/adapters/copilot.d.ts

@@ -0,0 +1,9 @@
+export declare const supportsMcp = true;
+interface Message {
+    role: string;
+    content: string;
+}
+export declare function available(): Promise<boolean>;
+export declare function stream(messages: Message[], systemPrompt: string, mcpConfigFile: string | null, onToken: (text: string) => void): Promise<void>;
+export {};
+//# sourceMappingURL=copilot.d.ts.map

package/dist/adapters/gemini.d.ts

@@ -0,0 +1,9 @@
+export declare const supportsMcp = false;
+interface Message {
+    role: string;
+    content: string;
+}
+export declare function available(): Promise<boolean>;
+export declare function stream(messages: Message[], systemPrompt: string, _mcpConfigFile: string | null, onToken: (text: string) => void): Promise<void>;
+export {};
+//# sourceMappingURL=gemini.d.ts.map

package/dist/aikit-mcp.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * AIKit MCP server — exposes BPMNKit capabilities as MCP tools for Claude Code skills.
+ *
+ * Tools:
+ *   bpmn_create, bpmn_read, bpmn_update, bpmn_validate, bpmn_deploy,
+ *   bpmn_simulate, bpmn_run_history,
+ *   worker_list, worker_scaffold,
+ *   form_create, dmn_create,
+ *   pattern_list, pattern_get
+ *
+ * Usage:
+ *   node dist/aikit-mcp.js
+ *
+ * Environment:
+ *   BPMNKIT_PROXY_URL   — proxy base URL (default: http://localhost:3033)
+ *   ZEEBE_ADDRESS       — Zeebe/reebe REST URL (default: http://localhost:26500)
+ *   ZEEBE_CLIENT_ID     — OAuth client ID (Camunda SaaS)
+ *   ZEEBE_CLIENT_SECRET — OAuth client secret (Camunda SaaS)
+ */
+export declare function handleCamundaSearch(code: string): Promise<string>;
+export declare function handleCamundaExecute(code: string): Promise<string>;
+//# sourceMappingURL=aikit-mcp.d.ts.map

package/dist/aikit-mcp.js

@@ -483,6 +483,18 @@ async function toolBpmnSimulate(path, scenarios) {
         throw new Error(`File not found: ${path}`);
     const xml = readFileSync(absPath, "utf8");
     const defs = Bpmn.parse(xml);
+    if (scenarios.length > 0) {
+        const { Engine, runScenario } = await import("@bpmnkit/engine");
+        const results = [];
+        for (const scenario of scenarios) {
+            results.push(await runScenario(new Engine(), defs, scenario));
+        }
+        return JSON.stringify({
+            mode: "execution",
+            note: "Ran each scenario against the in-process TS engine (@bpmnkit/engine): mocked job workers, path/variable assertions. Sub-process tools inside an AI Agent sub-process are not individually executed — the sub-process is dispatched and mocked as a single job.",
+            results,
+        }, null, 2);
+    }
     // Collect all service task job types referenced in the diagram
     const referencedJobTypes = new Set();
     for (const proc of defs.processes) {
@@ -510,7 +522,8 @@ async function toolBpmnSimulate(path, scenarios) {
     const validationReport = optimize(defs);
     const errors = validationReport.findings.filter((f) => f.severity === "error");
     return JSON.stringify({
-        note: "Phase 1: structural analysis. Full simulation (with process execution) coming in a future phase.",
+        mode: "structural",
+        note: "No scenarios provided — ran structural analysis only (validation findings + worker coverage). Pass `scenarios` to actually execute the process.",
         validation: {
             errors: errors.length,
             findings: errors.map((f) => ({ message: f.message, elementIds: f.elementIds })),
@@ -520,7 +533,6 @@ async function toolBpmnSimulate(path, scenarios) {
             covered: coveredWorkers.length,
             missing: missingWorkers,
         },
-        scenariosRequested: scenarios.length,
     }, null, 2);
 }
 async function toolBpmnRunHistory(processId) {
@@ -741,15 +753,18 @@ const TOOLS = [
     },
     {
         name: "bpmn_simulate",
-        description: "Analyse a BPMN process structurally: checks validation findings and worker coverage. " +
-            "Full process execution simulation is planned for a future phase.",
+        description: "Run or analyse a BPMN process. With `scenarios`, actually executes each one against the " +
+            'in-process TS engine (mocked job workers, path/variable assertions) — mode: "execution". ' +
+            "Without scenarios, runs structural analysis only (validation findings + worker coverage) — " +
+            'mode: "structural". The response always reports which mode ran.',
         inputSchema: {
             type: "object",
             properties: {
                 path: { type: "string", description: "Path to the .bpmn file" },
                 scenarios: {
                     type: "array",
-                    description: "Test scenarios (reserved for future use)",
+                    description: "Test scenarios to execute: { id, name, processId?, inputs?, mocks?: " +
+                        "{ [taskType]: { outputs?, error? } }, expect?: { path?, variables? } }",
                     items: { type: "object" },
                 },
             },

package/dist/bridge.d.ts

@@ -0,0 +1,7 @@
+/**
+ * QuickJS bridge — exposes all @bpmnkit/core operations as globalThis.Bridge.* functions.
+ * Bundled as an IIFE (platform=neutral) and embedded in the Rust binaries via rquickjs.
+ * All inputs/outputs are JSON strings or primitives.
+ */
+export {};
+//# sourceMappingURL=bridge.d.ts.map

package/dist/camunda-spec.d.ts

@@ -0,0 +1,8 @@
+export interface MethodSpec {
+    description: string;
+    endpoint: string;
+    params: string;
+    returns: string;
+}
+export declare const CAMUNDA_SPEC: Record<string, Record<string, MethodSpec>>;
+//# sourceMappingURL=camunda-spec.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function startServer(port?: number): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4,7 +4,7 @@ import http from "node:http";
 import { homedir, tmpdir } from "node:os";
 import { basename, dirname, extname, join, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Bpmn, applyOperations, compactify, expand, optimize } from "@bpmnkit/core";
+import { Bpmn, applyBpmnOperations, compactify, expand, optimize } from "@bpmnkit/core";
 import { createClientFromProfile } from "@bpmnkit/profiles";
 import { getActiveName, getActiveProfile, getAuthHeader, getProfile, listProfiles, } from "@bpmnkit/profiles";
 import * as claude from "./adapters/claude.js";
@@ -979,12 +979,27 @@ const server = http.createServer(async (req, res) => {
     // Emits SSE: tokens (explanation) + ops event + xml event + done.
     if (url.pathname === "/improve" && req.method === "POST") {
         const body = await readBody(req);
-        let context;
+        let definitions;
         let instruction;
         let backend;
         try {
             const parsed = JSON.parse(body);
-            context = parsed.context;
+            // `xml` carries the whole model, so operations apply to it directly and
+            // nothing outside the compact projection is lost. `context` is the older
+            // contract, kept working for clients that have not been updated — it can
+            // only ever describe what compact models.
+            if (typeof parsed.xml === "string") {
+                definitions = Bpmn.parse(parsed.xml);
+            }
+            else if (parsed.context) {
+                console.warn("[server] /improve received compact context; send { xml } to keep pools, lanes and ioMapping detail");
+                definitions = expand(parsed.context);
+            }
+            else {
+                res.writeHead(400);
+                res.end("Bad Request: send { xml } or { context }");
+                return;
+            }
             instruction = parsed.instruction ?? null;
             backend = parsed.backend ?? null;
         }
@@ -1003,10 +1018,9 @@ const server = http.createServer(async (req, res) => {
             return;
         }
         // ── Phase 1: auto-fix ─────────────────────────────────────────────────
-        let fixedCompact = context;
         let autoFixCount = 0;
         try {
-            const defs = expand(context);
+            const defs = definitions;
             const report = optimize(defs);
             const fixable = report.findings
                 .filter((f) => f.applyFix)
@@ -1018,7 +1032,6 @@ const server = http.createServer(async (req, res) => {
                 f.applyFix?.(defs);
             autoFixCount = fixable.length;
             if (autoFixCount > 0) {
-                fixedCompact = compactify(defs);
                 console.log(`[server] /improve → auto-fixed ${autoFixCount} issue(s)`);
             }
         }
@@ -1028,7 +1041,7 @@ const server = http.createServer(async (req, res) => {
         // ── Phase 2: collect remaining findings ───────────────────────────────
         const findings = [];
         try {
-            const remaining = optimize(expand(fixedCompact));
+            const remaining = optimize(definitions);
             for (const f of remaining.findings) {
                 findings.push({
                     category: f.category,
@@ -1051,7 +1064,9 @@ const server = http.createServer(async (req, res) => {
         // ── Phase 3: AI call — outputs explanation + ```json operations block ─
         const systemPrompt = buildImproveSystemPrompt();
         const improveCtx = {
-            compact: fixedCompact,
+            // The prompt gets the compact view — that is what it is for. The
+            // operations it produces are applied to the full model below.
+            compact: compactify(definitions),
             findings,
             autoFixCount,
             instruction,
@@ -1078,13 +1093,24 @@ const server = http.createServer(async (req, res) => {
         res.write(`data: ${JSON.stringify({ type: "ops", ops, autoFixCount })}\n\n`);
         if (ops.length > 0 || autoFixCount > 0) {
             try {
-                const finalCompact = ops.length > 0 ? applyOperations(fixedCompact, ops) : fixedCompact;
-                const xml = Bpmn.export(expand(finalCompact));
+                // Operations land on the full model, so anything the compact view in
+                // the prompt could not describe survives the edit untouched.
+                const edited = ops.length > 0
+                    ? applyBpmnOperations(definitions, ops, { strict: false })
+                    : { definitions, problems: [], applied: 0 };
+                if (edited.problems.length > 0) {
+                    // An operation naming an element that does not exist used to be
+                    // skipped in silence; report it so the model can be corrected.
+                    const detail = edited.problems.map((p) => `[${p.index}] ${p.reason}`).join("; ");
+                    console.warn(`[server] /improve → ${edited.problems.length} operation(s) skipped: ${detail}`);
+                    res.write(`data: ${JSON.stringify({ type: "problems", problems: edited.problems })}\n\n`);
+                }
+                const xml = Bpmn.export(edited.definitions);
                 res.write(`data: ${JSON.stringify({ type: "xml", xml })}\n\n`);
-                console.log(`[server] /improve → ${ops.length} ops applied, XML emitted`);
+                console.log(`[server] /improve → ${edited.applied} ops applied, XML emitted`);
             }
             catch (err) {
-                console.error("[server] /improve expand failed:", String(err));
+                console.error("[server] /improve apply failed:", String(err));
                 res.write(`data: ${JSON.stringify({ type: "error", message: `Failed to apply operations: ${String(err)}` })}\n\n`);
             }
         }

package/dist/mcp-server.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * Minimal stdio MCP server for BPMN/DMN/Form editing.
+ * Zero external dependencies — pure Node.js built-ins + @bpmnkit/core (workspace package).
+ *
+ * State is stored as the native model (BpmnDefinitions, DmnDefinitions, or FormDefinition)
+ * so core builder APIs produce the correct structure.
+ *
+ * Usage:
+ *   node dist/mcp-server.js [--input <file>] [--output <file>]
+ *
+ * File type is detected from input file content:
+ *   - DMN XML  → DmnDefinitions
+ *   - Form JSON → FormDefinition
+ *   - BPMN XML  → BpmnDefinitions (default)
+ */
+export {};
+//# sourceMappingURL=mcp-server.d.ts.map

package/dist/mcp-server.js

@@ -17,7 +17,7 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { createInterface } from "node:readline";
 import vm from "node:vm";
-import { Bpmn, Dmn, Form, compactify, compactifyDmn, compactifyForm, expand, expandDmn, expandForm, layoutDmn, layoutProcess, } from "@bpmnkit/core";
+import { Bpmn, Dmn, Form, compactify, compactifyDmn, compactifyForm, expand, expandDmn, expandForm, layoutDmn, layoutProcess, reconcileCompact, semanticHash, } from "@bpmnkit/core";
 import { handleSdkExecute, handleSdkSearch } from "./sdk-code-mode.js";
 // ── CLI args ──────────────────────────────────────────────────────────────────
 function getArg(flag) {
@@ -84,12 +84,27 @@ function buildBpmnDiagram(proc) {
         },
     };
 }
+/**
+ * Writes the current model out.
+ *
+ * BPMN goes through the same check `writeBpmn` makes — serialise, parse back,
+ * compare the semantic hash — so a serialisation that lost something fails the
+ * tool call instead of quietly replacing the user's file. It cannot call
+ * `writeBpmn` itself: the code-mode bridge invokes tools synchronously inside a
+ * `vm` context, and that function is async. Adopting it here means giving the
+ * bridge an async path first.
+ */
 function saveState() {
     if (!outputFile)
         return;
     if (state.kind === "bpmn") {
         state.data.diagrams = state.data.processes.map((proc) => buildBpmnDiagram(proc));
-        writeFileSync(outputFile, Bpmn.export(state.data));
+        const xml = Bpmn.export(state.data);
+        const expected = semanticHash(state.data);
+        if (semanticHash(Bpmn.parse(xml)) !== expected) {
+            throw new Error("Serialising the model did not reproduce it; nothing was written. This is a bug in @bpmnkit/core — please report the model that triggered it.");
+        }
+        writeFileSync(outputFile, xml);
     }
     else if (state.kind === "dmn") {
         const laid = layoutDmn(state.data);
@@ -537,7 +552,18 @@ function callTool(name, args) {
                 state = { kind: "form", data: expandForm(raw) };
             }
             else {
-                state = { kind: "bpmn", data: expand(raw) };
+                // Reconcile rather than expand. `expand` would rebuild the whole
+                // document from the compact view, discarding the pools, lanes, data
+                // wiring and Zeebe detail that view cannot describe; this applies the
+                // same input as changes to the model already loaded.
+                const result = reconcileCompact(state.data, raw, { strict: false });
+                state = { kind: "bpmn", data: result.definitions };
+                saveState();
+                return result.problems.length === 0
+                    ? "Diagram updated."
+                    : `Diagram updated, ${result.problems.length} change(s) skipped: ${result.problems
+                        .map((problem) => problem.reason)
+                        .join("; ")}`;
             }
             saveState();
             return "Diagram replaced.";

package/dist/prompt.d.ts

@@ -0,0 +1,55 @@
+import type { CompactDiagram } from "@bpmnkit/core";
+/** Short system prompt for MCP-capable adapters. The LLM uses tools instead of returning JSON blobs. */
+export declare function buildMcpSystemPrompt(): string;
+export interface FindingInfo {
+    category: string;
+    severity: string;
+    message: string;
+    suggestion: string;
+    elementIds: string[];
+}
+/** System prompt for the improve action with MCP tools. Passes pre-computed findings from core optimize(). */
+export declare function buildMcpImprovePrompt(findings: FindingInfo[]): string;
+/** System prompt for the explain action with MCP tools. */
+export declare function buildMcpExplainPrompt(): string;
+export declare function buildIncidentSystemPrompt(): string;
+export interface IncidentContext {
+    errorType: string;
+    errorMessage: string;
+    elementId: string;
+    processDefinitionId: string;
+    processInstanceKey: string;
+    state: string;
+    creationTime?: string;
+    jobKey?: string;
+}
+export declare function buildIncidentUserMessage(incident: IncidentContext, variables: Array<{
+    name: string;
+    value?: string;
+}>, processXml: string | null): string;
+/**
+ * Minimal system prompt for the AI search endpoint.
+ * Instructs the model to output ONLY a JSON object (no prose) to keep token usage low.
+ */
+export declare function buildSearchSystemPrompt(): string;
+export interface OperateStats {
+    runningInstances: number;
+    activeIncidents: number;
+    pendingTasks: number;
+    deployedDefinitions: number;
+    activeJobs: number;
+}
+export declare function buildOperateChatSystemPrompt(stats: OperateStats | null): string;
+export declare function buildImproveSystemPrompt(): string;
+export interface ImproveContext {
+    compact: CompactDiagram;
+    findings: FindingInfo[];
+    autoFixCount: number;
+    instruction?: string | null;
+}
+export declare function buildImproveUserMessage(ctx: ImproveContext): string;
+export declare function buildFormCreateSystemPrompt(taskName: string, taskContext: string): string;
+export declare function buildDmnCreateSystemPrompt(decisionId: string, taskContext: string): string;
+/** Full system prompt for non-MCP adapters that must return a CompactDiagram JSON block. */
+export declare function buildSystemPrompt(context: unknown): string;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/routes/run-history.d.ts

@@ -0,0 +1,25 @@
+import type http from "node:http";
+import type { WorkerJob } from "../worker.js";
+/** Called before a job handler is invoked. */
+export declare function onJobStart(job: WorkerJob): void;
+/** Called after a job handler succeeds. */
+export declare function onJobComplete(job: WorkerJob, outputs: Record<string, unknown>, durationMs: number): void;
+/** Called after a job handler throws. */
+export declare function onJobFail(job: WorkerJob, errorMessage: string, durationMs: number): void;
+/** GET /run-history — list of runs, most recent first. */
+export declare function handleGetRunHistory(req: http.IncomingMessage, res: http.ServerResponse): void;
+/** GET /run-history/:id — single run with steps. */
+export declare function handleGetRunHistoryDetail(req: http.IncomingMessage, res: http.ServerResponse, runId: string): void;
+/** DELETE /run-history — clear all history. */
+export declare function handleDeleteRunHistory(_req: http.IncomingMessage, res: http.ServerResponse): void;
+/** Route matcher — returns the run ID if the URL matches /run-history/:id */
+export declare function matchRunHistoryRoute(req: http.IncomingMessage): {
+    id: string;
+} | null;
+/** POST /run-history/:id/rerun — start a new process instance from a historical run. */
+export declare function handleRerunHistory(req: http.IncomingMessage, res: http.ServerResponse, runId: string): Promise<void>;
+/** Route matcher — returns run ID if URL matches /run-history/:id/rerun */
+export declare function matchRerunHistoryRoute(req: http.IncomingMessage): {
+    id: string;
+} | null;
+//# sourceMappingURL=run-history.d.ts.map

package/dist/sandbox.d.ts

@@ -0,0 +1,15 @@
+export type HostFunction = (...args: unknown[]) => Promise<unknown>;
+export interface SandboxContext {
+    /** JSON-serializable values injected as named globals */
+    data?: Record<string, unknown>;
+    /**
+     * Async host functions exposed as ivm.References.
+     * Inside the sandbox, call them with:
+     *   await __name.apply(undefined, [...args], { result: { promise: true, copy: true } })
+     */
+    functions?: Record<string, HostFunction>;
+    /** JS injected before user code (e.g. proxy builders) */
+    bootstrap?: string;
+}
+export declare function runSandboxed(code: string, ctx: SandboxContext, timeoutMs?: number): Promise<unknown>;
+//# sourceMappingURL=sandbox.d.ts.map

package/dist/sdk-code-mode.d.ts

@@ -0,0 +1,3 @@
+export declare function handleSdkSearch(code: string): string;
+export declare function handleSdkExecute(code: string, xml?: string): string;
+//# sourceMappingURL=sdk-code-mode.d.ts.map

package/dist/sdk-spec.d.ts

@@ -0,0 +1,59 @@
+export declare const SDK_SPEC: {
+    readonly functions: {
+        readonly "sdk.parse": {
+            readonly description: "Parse BPMN XML into a CompactDiagram JSON string.";
+            readonly params: "xml: string";
+            readonly returns: "string (CompactDiagram JSON)";
+            readonly example: "const compact = sdk.parse(xml)";
+        };
+        readonly "sdk.exportXml": {
+            readonly description: "Convert a CompactDiagram JSON string to BPMN XML with auto-layout applied.";
+            readonly params: "compactJson: string";
+            readonly returns: "string (BPMN XML)";
+            readonly example: "const xml = sdk.exportXml(compact)";
+        };
+        readonly "sdk.optimize": {
+            readonly description: "Run the pattern advisor on a CompactDiagram. Returns findings and an optimized diagram.";
+            readonly params: "compactJson: string";
+            readonly returns: "string (JSON: { diagram: CompactDiagram, findings: Finding[] })";
+            readonly example: "const { diagram, findings } = JSON.parse(sdk.optimize(compact))";
+        };
+        readonly "sdk.layout": {
+            readonly description: "Apply automatic ELK layout to a CompactDiagram. Returns updated CompactDiagram JSON.";
+            readonly params: "compactJson: string";
+            readonly returns: "string (CompactDiagram JSON)";
+            readonly example: "const laidOut = JSON.parse(sdk.layout(compact))";
+        };
+        readonly "sdk.analyzeVariables": {
+            readonly description: "Analyze FEEL variable flow across a process. Identifies undeclared inputs and output variable paths.";
+            readonly params: "compactJson: string";
+            readonly returns: "string (JSON: VariableFlowAnalysis)";
+            readonly example: "const analysis = JSON.parse(sdk.analyzeVariables(compact))";
+        };
+    };
+    readonly compactDiagram: {
+        readonly description: "Lightweight JSON representation of a BPMN diagram. Input/output format for all sdk functions.";
+        readonly shape: {
+            readonly processes: readonly [{
+                readonly id: "string — process id, e.g. 'order-flow'";
+                readonly name: "string? — display name";
+                readonly elements: readonly [{
+                    readonly id: "string";
+                    readonly type: "startEvent | endEvent | serviceTask | userTask | businessRuleTask | scriptTask | callActivity | exclusiveGateway | parallelGateway | inclusiveGateway | eventBasedGateway | subProcess | adHocSubProcess | intermediateThrowEvent | intermediateCatchEvent | boundaryEvent";
+                    readonly name: "string?";
+                    readonly jobType: "string? — Zeebe job worker type (serviceTask only)";
+                    readonly decisionId: "string? — DMN decision id (businessRuleTask only)";
+                    readonly formId: "string? — Camunda form id (userTask only)";
+                    readonly calledElement: "string? — process id of called process (callActivity only)";
+                }];
+                readonly flows: readonly [{
+                    readonly id: "string";
+                    readonly sourceRef: "string — source element id";
+                    readonly targetRef: "string — target element id";
+                    readonly condition: "string? — FEEL expression (exclusive gateway outgoing flows only)";
+                }];
+            }];
+        };
+    };
+};
+//# sourceMappingURL=sdk-spec.d.ts.map

package/dist/triggers/file-watcher.d.ts

@@ -0,0 +1,2 @@
+export declare function startFileWatchTrigger(): void;
+//# sourceMappingURL=file-watcher.d.ts.map

package/dist/triggers/index.d.ts

@@ -0,0 +1,3 @@
+export { matchWebhookRoute, handleWebhook } from "./webhook.js";
+export declare function startTriggers(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/triggers/timer.d.ts

@@ -0,0 +1,2 @@
+export declare function startTimerTrigger(): void;
+//# sourceMappingURL=timer.d.ts.map

package/dist/triggers/webhook.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Webhook trigger — starts a process instance when `POST /webhooks/:processId`
+ * is called. The request body becomes the process variables.
+ *
+ * Optional security: set a `WEBHOOK_TOKEN` env var; the trigger then requires
+ * `Authorization: Bearer <token>` on incoming requests.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+/** Returns the processId if the request matches `POST /webhooks/:processId`. */
+export declare function matchWebhookRoute(req: IncomingMessage): {
+    processId: string;
+} | null;
+export declare function handleWebhook(req: IncomingMessage, res: ServerResponse, processId: string): Promise<void>;
+//# sourceMappingURL=webhook.d.ts.map

package/dist/worker-templates.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Element template definitions for bpmnkit built-in workers.
+ * Served via GET /worker-templates — consumed by the Studio connector catalog.
+ *
+ * Follows the Camunda element template schema so they are compatible with
+ * the config-panel-bpmn template renderer.
+ */
+export interface TemplateProperty {
+    id?: string;
+    label?: string;
+    description?: string;
+    type?: string;
+    value?: string | number | boolean;
+    optional?: boolean;
+    feel?: "optional" | "required" | "static";
+    group?: string;
+    choices?: Array<{
+        name: string;
+        value: string;
+    }>;
+    constraints?: {
+        notEmpty?: boolean;
+    };
+    binding: {
+        type: "zeebe:taskDefinition" | "zeebe:taskDefinition:type" | "zeebe:taskHeader" | "zeebe:input" | "zeebe:output" | "property";
+        property?: "type" | "retries";
+        key?: string;
+        name?: string;
+        source?: string;
+    };
+    condition?: {
+        property: string;
+        equals: string;
+    };
+}
+export interface ElementTemplate {
+    $schema?: string;
+    id: string;
+    name: string;
+    version: number;
+    description: string;
+    documentationRef?: string;
+    category: {
+        id: string;
+        name: string;
+    };
+    appliesTo: string[];
+    icon?: {
+        contents: string;
+    };
+    groups?: Array<{
+        id: string;
+        label: string;
+    }>;
+    properties: TemplateProperty[];
+}
+export declare const WORKER_TEMPLATES: ElementTemplate[];
+//# sourceMappingURL=worker-templates.d.ts.map

package/dist/worker.d.ts

@@ -0,0 +1,21 @@
+export interface WorkerJob {
+    jobKey: string;
+    type: string;
+    processInstanceKey: string;
+    elementInstanceKey: string;
+    variables: Record<string, unknown>;
+    customHeaders: Record<string, string>;
+}
+/**
+ * Replace `{{varName}}` and `{{secrets.NAME}}` placeholders in a string.
+ * Secrets are read from `process.env` (proxy runs in Node.js).
+ */
+export declare function interpolate(template: string, vars: Record<string, unknown>): string;
+export declare const workerState: {
+    active: boolean;
+    pollCount: number;
+    jobTypes: string[];
+    lastError: string | null;
+};
+export declare function startWorkerDaemon(): void;
+//# sourceMappingURL=worker.d.ts.map

package/dist/workers/cli.d.ts

@@ -0,0 +1,14 @@
+import type { WorkerJob } from "../worker.js";
+export declare const JOB_TYPE = "io.bpmnkit:cli:1";
+/**
+ * CLI worker — runs a shell command and returns stdout/stderr/exitCode.
+ *
+ * Task headers:
+ *   command       (required) — shell command, supports {{varName}} and {{secrets.NAME}} interpolation
+ *   cwd           (optional) — working directory; default ~
+ *   timeout       (optional) — timeout in seconds; default 60
+ *   ignoreExitCode (optional) — "true" to complete even on non-zero exit; default false
+ *   resultVariable (optional) — if set, wraps result under this key; default outputs at root
+ */
+export declare function handle(job: WorkerJob): Promise<Record<string, unknown>>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/workers/email.d.ts

@@ -0,0 +1,24 @@
+import type { WorkerJob } from "../worker.js";
+export declare const JOB_TYPE_FETCH = "io.bpmnkit:email:fetch:1";
+export declare const JOB_TYPE_SEND = "io.bpmnkit:email:send:1";
+/**
+ * Email fetch worker — connects via IMAP and retrieves messages.
+ *
+ * Task headers (all support {{secrets.X}} interpolation):
+ *   imapHost, imapPort (default 993), imapUser, imapPassword, imapSecure (default "true")
+ *   folder (default "INBOX"), limit (default 10), unreadOnly (default "true")
+ *   resultVariable (default "emails")
+ */
+export declare function handleFetch(job: WorkerJob): Promise<Record<string, unknown>>;
+/**
+ * Email send worker — sends a message via SMTP using nodemailer.
+ *
+ * Task headers (support interpolation):
+ *   smtpHost, smtpPort (default 587), smtpUser, smtpPassword, smtpSecure (default "false")
+ *   from (optional, defaults to smtpUser)
+ *
+ * Input variables (job.variables, headers as fallback):
+ *   to, subject, body
+ */
+export declare function handleSend(job: WorkerJob): Promise<Record<string, unknown>>;
+//# sourceMappingURL=email.d.ts.map

package/dist/workers/fs.d.ts

@@ -0,0 +1,30 @@
+import type { WorkerJob } from "../worker.js";
+export declare const JOB_TYPE_READ = "io.bpmnkit:fs:read:1";
+export declare const JOB_TYPE_WRITE = "io.bpmnkit:fs:write:1";
+export declare const JOB_TYPE_APPEND = "io.bpmnkit:fs:append:1";
+export declare const JOB_TYPE_LIST = "io.bpmnkit:fs:list:1";
+/**
+ * io.bpmnkit:fs:read:1
+ * Variables: path (string)
+ * Outputs:   content (string)
+ */
+export declare function handleRead(job: WorkerJob): Promise<Record<string, unknown>>;
+/**
+ * io.bpmnkit:fs:write:1
+ * Variables: path (string), content (string)
+ * Outputs:   bytesWritten (number)
+ */
+export declare function handleWrite(job: WorkerJob): Promise<Record<string, unknown>>;
+/**
+ * io.bpmnkit:fs:append:1
+ * Variables: path (string), content (string)
+ * Outputs:   bytesWritten (number)
+ */
+export declare function handleAppend(job: WorkerJob): Promise<Record<string, unknown>>;
+/**
+ * io.bpmnkit:fs:list:1
+ * Variables: path (string)
+ * Outputs:   files (string[])
+ */
+export declare function handleList(job: WorkerJob): Promise<Record<string, unknown>>;
+//# sourceMappingURL=fs.d.ts.map

package/dist/workers/http.d.ts

@@ -0,0 +1,12 @@
+import type { WorkerJob } from "../worker.js";
+export declare const JOB_TYPE = "io.bpmnkit:http:scrape:1";
+/**
+ * HTTP scraper worker — fetches a URL and extracts text content.
+ *
+ * Task headers:
+ *   url            (required) — URL to fetch, supports {{varName}} interpolation
+ *   timeout        (optional) — timeout in seconds; default 30
+ *   resultVariable (optional) — if set, wraps result under this key; default outputs at root
+ */
+export declare function handle(job: WorkerJob): Promise<Record<string, unknown>>;
+//# sourceMappingURL=http.d.ts.map

package/dist/workers/js.d.ts

@@ -0,0 +1,13 @@
+import type { WorkerJob } from "../worker.js";
+export declare const JOB_TYPE = "io.bpmnkit:js:1";
+/**
+ * JavaScript eval worker — evaluates an expression with process variables in scope.
+ *
+ * Task headers:
+ *   expression     (required) — JS expression; receives `variables` object in scope
+ *   resultVariable (optional) — variable name to store result; default "result"
+ *
+ * Example expression:  variables.items.filter(x => x.score > 0.5).length
+ */
+export declare function handle(job: WorkerJob): Promise<Record<string, unknown>>;
+//# sourceMappingURL=js.d.ts.map

package/dist/workers/llm.d.ts

@@ -0,0 +1,15 @@
+import type { WorkerJob } from "../worker.js";
+export declare const JOB_TYPE = "io.bpmnkit:llm:1";
+/**
+ * LLM worker — calls the first available LLM adapter with a prompt.
+ *
+ * Variables:
+ *   prompt         (required) — prompt text; supports {{varName}} interpolation
+ *
+ * Task headers:
+ *   system         (optional) — system prompt
+ *   model          (optional) — "claude" | "copilot" | "gemini"; auto-detects if omitted
+ *   resultVariable (optional) — variable to store response; default "response"
+ */
+export declare function handle(job: WorkerJob): Promise<Record<string, unknown>>;
+//# sourceMappingURL=llm.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/proxy",
-  "version": "0.0.32",
+  "version": "0.1.0",
   "description": "Local proxy server for BPMN Kit — AI bridge (SSE/MCP) and Camunda API proxy using stored CLI profiles",
   "type": "module",
   "bin": {
@@ -18,7 +18,8 @@
   "files": [
     "LICENSE",
     "README.md",
-    "dist/**/*.js"
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
   ],
   "engines": {
     "node": ">=20"
@@ -28,10 +29,11 @@
     "imapflow": "^1.2.18",
     "isolated-vm": "^7.0.0",
     "nodemailer": "^6.10.1",
-    "@bpmnkit/api": "0.0.19",
-    "@bpmnkit/core": "0.1.1",
-    "@bpmnkit/patterns": "0.0.4",
-    "@bpmnkit/profiles": "0.0.17"
+    "@bpmnkit/api": "0.0.20",
+    "@bpmnkit/core": "0.2.0",
+    "@bpmnkit/engine": "0.1.31",
+    "@bpmnkit/patterns": "0.0.5",
+    "@bpmnkit/profiles": "0.0.18"
   },
   "publishConfig": {
     "access": "public"