@decaf-ts/integrations 0.3.3 → 0.3.5

package/lib/cjs/graph/nodes/agent.cjs

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAPH_AGENT_NODES = exports.AgentNode = void 0;
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(decorators, target, key, desc);
+    else
+        for (var i = decorators.length - 1; i >= 0; i--)
+            if (d = decorators[i])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+        return Reflect.metadata(k, v);
+};
+/**
+ * @module integrations/graph/nodes/agent
+ * @summary Production Agent node declaration.
+ * @description The Agent node is the primary AI agent entrypoint. It is a
+ * rectangular node with `@connection()` ports for its structural dependencies:
+ * `model` (the LLM), `memory` (the memory store), and `workspace` (the
+ * workspace/context). Connections are rendered on the bottom side of the node
+ * (DECAF-32 §21.3). Each connection category has a distinct color defined in
+ * the category style registry.
+ *
+ * The single `prompt` input accepts placeholder expressions (§22.4) such as
+ * `{{ $input.brief }}` or `{{ $node["Research"].output.summary }}` that are
+ * resolved at execution time by the placeholder compiler.
+ */
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const ui_decorators_1 = require("@decaf-ts/ui-decorators");
+const graph_1 = require("@decaf-ts/ui-decorators/graph");
+// Ensure category styles are registered (idempotent).
+require("./category-styles.cjs");
+/**
+ * Agent node — an AI agent that orchestrates a model, memory, and workspace.
+ *
+ * The agent has:
+ * - `@input` port on the **left**: `prompt` (the task prompt; supports
+ *   placeholder expressions like `{{ $input.something }}` per §22.4).
+ * - `@output` ports on the **right**: `response` (the agent's output), `actions`
+ *   (any actions the agent decided to take).
+ * - `@connection` ports on the **bottom**: `model` (LLM), `memory` (memory
+ *   store), `workspace` (workspace/context). Each connection has a distinct
+ *   category color.
+ *
+ * The node is rectangular (not rounded) to visually distinguish it from
+ * regular processing nodes. The `color` and `icon` are omitted from `@node()`
+ * so they are resolved from the `"Agent"` category style.
+ */
+let AgentNode = class AgentNode extends decorator_validation_1.Model {
+};
+exports.AgentNode = AgentNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", {
+        label: "Prompt",
+        placeholder: "Enter task prompt. Supports placeholders like {{ $input.brief }} or {{ $node[\"Research\"].output.summary }}",
+    }),
+    (0, graph_1.input)({ handle: "prompt" }),
+    __metadata("design:type", String)
+], AgentNode.prototype, "prompt", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Response", placeholder: "Agent response" }),
+    (0, graph_1.output)({ handle: "response" }),
+    __metadata("design:type", String)
+], AgentNode.prototype, "response", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Actions", placeholder: "Actions taken by the agent" }),
+    (0, graph_1.output)({ handle: "actions" }),
+    __metadata("design:type", Array)
+], AgentNode.prototype, "actions", void 0);
+__decorate([
+    (0, graph_1.connection)({ category: "model", handle: "model" }),
+    __metadata("design:type", Object)
+], AgentNode.prototype, "model", void 0);
+__decorate([
+    (0, graph_1.connection)({ category: "memory", handle: "memory" }),
+    __metadata("design:type", Object)
+], AgentNode.prototype, "memory", void 0);
+__decorate([
+    (0, graph_1.connection)({ category: "workspace", handle: "workspace" }),
+    __metadata("design:type", Object)
+], AgentNode.prototype, "workspace", void 0);
+exports.AgentNode = AgentNode = __decorate([
+    (0, graph_1.node)("core.agent", {
+        kind: "core.agent",
+        category: "Agent",
+        // color and icon omitted — resolved from the "Agent" category style
+        width: 120,
+        height: 140,
+        labels: ["agent", "ai", "orchestrator"],
+        metadata: {
+            title: "Agent",
+            description: "AI agent that orchestrates a model, memory, and workspace to complete a task.",
+            shape: "rectangle",
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], AgentNode);
+/**
+ * All built-in agent node constructors.
+ */
+exports.GRAPH_AGENT_NODES = [AgentNode];
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agent.js","sourceRoot":"","sources":["agent.js"],"names":[],"mappings":"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","sourcesContent":["var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\n/**\n * @module integrations/graph/nodes/agent\n * @summary Production Agent node declaration.\n * @description The Agent node is the primary AI agent entrypoint. It is a\n * rectangular node with `@connection()` ports for its structural dependencies:\n * `model` (the LLM), `memory` (the memory store), and `workspace` (the\n * workspace/context). Connections are rendered on the bottom side of the node\n * (DECAF-32 §21.3). Each connection category has a distinct color defined in\n * the category style registry.\n *\n * The single `prompt` input accepts placeholder expressions (§22.4) such as\n * `{{ $input.brief }}` or `{{ $node[\"Research\"].output.summary }}` that are\n * resolved at execution time by the placeholder compiler.\n */\nimport { Model, model, required } from \"@decaf-ts/decorator-validation\";\nimport { uielement } from \"@decaf-ts/ui-decorators\";\nimport { connection, input, node, output } from \"@decaf-ts/ui-decorators/graph\";\n// Ensure category styles are registered (idempotent).\nimport \"./category-styles.js\";\n/**\n * Agent node — an AI agent that orchestrates a model, memory, and workspace.\n *\n * The agent has:\n * - `@input` port on the **left**: `prompt` (the task prompt; supports\n *   placeholder expressions like `{{ $input.something }}` per §22.4).\n * - `@output` ports on the **right**: `response` (the agent's output), `actions`\n *   (any actions the agent decided to take).\n * - `@connection` ports on the **bottom**: `model` (LLM), `memory` (memory\n *   store), `workspace` (workspace/context). Each connection has a distinct\n *   category color.\n *\n * The node is rectangular (not rounded) to visually distinguish it from\n * regular processing nodes. The `color` and `icon` are omitted from `@node()`\n * so they are resolved from the `\"Agent\"` category style.\n */\nlet AgentNode = class AgentNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", {\n        label: \"Prompt\",\n        placeholder: \"Enter task prompt. Supports placeholders like {{ $input.brief }} or {{ $node[\\\"Research\\\"].output.summary }}\",\n    }),\n    input({ handle: \"prompt\" }),\n    __metadata(\"design:type\", String)\n], AgentNode.prototype, \"prompt\", void 0);\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Response\", placeholder: \"Agent response\" }),\n    output({ handle: \"response\" }),\n    __metadata(\"design:type\", String)\n], AgentNode.prototype, \"response\", void 0);\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Actions\", placeholder: \"Actions taken by the agent\" }),\n    output({ handle: \"actions\" }),\n    __metadata(\"design:type\", Array)\n], AgentNode.prototype, \"actions\", void 0);\n__decorate([\n    connection({ category: \"model\", handle: \"model\" }),\n    __metadata(\"design:type\", Object)\n], AgentNode.prototype, \"model\", void 0);\n__decorate([\n    connection({ category: \"memory\", handle: \"memory\" }),\n    __metadata(\"design:type\", Object)\n], AgentNode.prototype, \"memory\", void 0);\n__decorate([\n    connection({ category: \"workspace\", handle: \"workspace\" }),\n    __metadata(\"design:type\", Object)\n], AgentNode.prototype, \"workspace\", void 0);\nAgentNode = __decorate([\n    node(\"core.agent\", {\n        kind: \"core.agent\",\n        category: \"Agent\",\n        // color and icon omitted — resolved from the \"Agent\" category style\n        width: 120,\n        height: 140,\n        labels: [\"agent\", \"ai\", \"orchestrator\"],\n        metadata: {\n            title: \"Agent\",\n            description: \"AI agent that orchestrates a model, memory, and workspace to complete a task.\",\n            shape: \"rectangle\",\n        },\n    }),\n    model()\n], AgentNode);\nexport { AgentNode };\n/**\n * All built-in agent node constructors.\n */\nexport const GRAPH_AGENT_NODES = [AgentNode];\n//# sourceMappingURL=data:application/json;base64,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"]}

package/lib/cjs/graph/nodes/category-styles.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBuiltinCategoryStyles = registerBuiltinCategoryStyles;
+/**
+ * @module integrations/graph/nodes/category-styles
+ * @summary Built-in node/connection category style registrations.
+ * @description Registers default colors and icons for the built-in node and
+ * connection categories (DECAF-32 §21.2). The `color` / `icon` on a node's
+ * `@node()` metadata are optional overrides — when omitted, the effective
+ * style is resolved from the category registry.
+ */
+const graph_1 = require("@decaf-ts/ui-decorators/graph");
+/**
+ * Registers all built-in category styles. Called once at module init.
+ *
+ * Categories define the default visual style for nodes and connection ports.
+ * A node's explicit `color` / `icon` (on `@node()`) overrides the category
+ * style; when omitted, the category style is used.
+ */
+function registerBuiltinCategoryStyles() {
+    // Node categories
+    (0, graph_1.registerGraphCategoryStyle)("Trigger", { color: "#3b82f6", icon: "ti-bolt" });
+    (0, graph_1.registerGraphCategoryStyle)("Flow Control", { color: "#f59e0b", icon: "ti-arrows-split-2" });
+    (0, graph_1.registerGraphCategoryStyle)("Utility", { color: "#0d9488", icon: "ti-tool" });
+    (0, graph_1.registerGraphCategoryStyle)("Loop", { color: "#eab308", icon: "ti-repeat" });
+    (0, graph_1.registerGraphCategoryStyle)("Workflow", { color: "#f97316", icon: "ti-sitemap" });
+    (0, graph_1.registerGraphCategoryStyle)("Pipeline", { color: "#0ea5e9", icon: "ti-git-merge" });
+    (0, graph_1.registerGraphCategoryStyle)("Node", { color: "#8b5cf6", icon: "ti-point-filled" });
+    (0, graph_1.registerGraphCategoryStyle)("Agent", { color: "#7c3aed", icon: "ti-robot" });
+    // Connection categories (for @connection() ports)
+    (0, graph_1.registerGraphCategoryStyle)("model", { color: "#3b82f6", icon: "ti-cpu" });
+    (0, graph_1.registerGraphCategoryStyle)("memory", { color: "#10b981", icon: "ti-database" });
+    (0, graph_1.registerGraphCategoryStyle)("workspace", { color: "#f59e0b", icon: "ti-folder" });
+}
+// Register at module load so the styles are available immediately.
+registerBuiltinCategoryStyles();
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category-styles.js","sourceRoot":"","sources":["category-styles.js"],"names":[],"mappings":";;AAgBA,sEAcC;AA9BD;;;;;;;GAOG;AACH,yDAA4E;AAC5E;;;;;;GAMG;AACH,SAAgB,6BAA6B;IACzC,kBAAkB;IAClB,IAAA,kCAA0B,EAAC,SAAS,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IAC7E,IAAA,kCAA0B,EAAC,cAAc,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC,CAAC;IAC5F,IAAA,kCAA0B,EAAC,SAAS,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IAC7E,IAAA,kCAA0B,EAAC,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;IAC5E,IAAA,kCAA0B,EAAC,UAAU,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;IACjF,IAAA,kCAA0B,EAAC,UAAU,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC;IACnF,IAAA,kCAA0B,EAAC,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC;IAClF,IAAA,kCAA0B,EAAC,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;IAC5E,kDAAkD;IAClD,IAAA,kCAA0B,EAAC,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC1E,IAAA,kCAA0B,EAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAC;IAChF,IAAA,kCAA0B,EAAC,WAAW,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;AACrF,CAAC;AACD,mEAAmE;AACnE,6BAA6B,EAAE,CAAC;AAChC,00IAA00I","sourcesContent":["/**\n * @module integrations/graph/nodes/category-styles\n * @summary Built-in node/connection category style registrations.\n * @description Registers default colors and icons for the built-in node and\n * connection categories (DECAF-32 §21.2). The `color` / `icon` on a node's\n * `@node()` metadata are optional overrides — when omitted, the effective\n * style is resolved from the category registry.\n */\nimport { registerGraphCategoryStyle, } from \"@decaf-ts/ui-decorators/graph\";\n/**\n * Registers all built-in category styles. Called once at module init.\n *\n * Categories define the default visual style for nodes and connection ports.\n * A node's explicit `color` / `icon` (on `@node()`) overrides the category\n * style; when omitted, the category style is used.\n */\nexport function registerBuiltinCategoryStyles() {\n    // Node categories\n    registerGraphCategoryStyle(\"Trigger\", { color: \"#3b82f6\", icon: \"ti-bolt\" });\n    registerGraphCategoryStyle(\"Flow Control\", { color: \"#f59e0b\", icon: \"ti-arrows-split-2\" });\n    registerGraphCategoryStyle(\"Utility\", { color: \"#0d9488\", icon: \"ti-tool\" });\n    registerGraphCategoryStyle(\"Loop\", { color: \"#eab308\", icon: \"ti-repeat\" });\n    registerGraphCategoryStyle(\"Workflow\", { color: \"#f97316\", icon: \"ti-sitemap\" });\n    registerGraphCategoryStyle(\"Pipeline\", { color: \"#0ea5e9\", icon: \"ti-git-merge\" });\n    registerGraphCategoryStyle(\"Node\", { color: \"#8b5cf6\", icon: \"ti-point-filled\" });\n    registerGraphCategoryStyle(\"Agent\", { color: \"#7c3aed\", icon: \"ti-robot\" });\n    // Connection categories (for @connection() ports)\n    registerGraphCategoryStyle(\"model\", { color: \"#3b82f6\", icon: \"ti-cpu\" });\n    registerGraphCategoryStyle(\"memory\", { color: \"#10b981\", icon: \"ti-database\" });\n    registerGraphCategoryStyle(\"workspace\", { color: \"#f59e0b\", icon: \"ti-folder\" });\n}\n// Register at module load so the styles are available immediately.\nregisterBuiltinCategoryStyles();\n//# sourceMappingURL=data:application/json;base64,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"]}