@positronic/core 0.0.52 → 0.0.53

package/dist/src/dsl/builder/step.js

@@ -0,0 +1,75 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { v4 as uuidv4 } from 'uuid';
+import { STATUS } from '../constants.js';
+export var Step = /*#__PURE__*/ function() {
+    "use strict";
+    function Step(block, id) {
+        _class_call_check(this, Step);
+        _define_property(this, "block", void 0);
+        _define_property(this, "id", void 0);
+        _define_property(this, "patch", void 0);
+        _define_property(this, "status", void 0);
+        this.block = block;
+        this.status = STATUS.PENDING;
+        this.id = id || uuidv4();
+    }
+    _create_class(Step, [
+        {
+            key: "withPatch",
+            value: function withPatch(patch) {
+                this.patch = patch;
+                return this;
+            }
+        },
+        {
+            key: "withStatus",
+            value: function withStatus(status) {
+                this.status = status;
+                return this;
+            }
+        },
+        {
+            key: "serialized",
+            get: function get() {
+                return {
+                    id: this.id,
+                    title: this.block.title,
+                    status: this.status,
+                    patch: typeof this.patch === 'string' ? JSON.parse(this.patch) : this.patch
+                };
+            }
+        }
+    ]);
+    return Step;
+}();

package/dist/src/dsl/constants.js

@@ -10,16 +10,15 @@ export var BRAIN_EVENTS = {
     CANCELLED: 'brain:cancelled',
     WEBHOOK: 'brain:webhook',
     WEBHOOK_RESPONSE: 'brain:webhook_response',
-    HEARTBEAT: 'brain:heartbeat',
-    // Loop step events
-    LOOP_START: 'loop:start',
-    LOOP_ITERATION: 'loop:iteration',
-    LOOP_TOOL_CALL: 'loop:tool_call',
-    LOOP_TOOL_RESULT: 'loop:tool_result',
-    LOOP_ASSISTANT_MESSAGE: 'loop:assistant_message',
-    LOOP_COMPLETE: 'loop:complete',
-    LOOP_TOKEN_LIMIT: 'loop:token_limit',
-    LOOP_WEBHOOK: 'loop:webhook'
+    // Agent step events
+    AGENT_START: 'agent:start',
+    AGENT_ITERATION: 'agent:iteration',
+    AGENT_TOOL_CALL: 'agent:tool_call',
+    AGENT_TOOL_RESULT: 'agent:tool_result',
+    AGENT_ASSISTANT_MESSAGE: 'agent:assistant_message',
+    AGENT_COMPLETE: 'agent:complete',
+    AGENT_TOKEN_LIMIT: 'agent:token_limit',
+    AGENT_WEBHOOK: 'agent:webhook'
 };
 export var STATUS = {
     PENDING: 'pending',

package/dist/src/dsl/create-brain.js

@@ -0,0 +1,63 @@
+import { brain as coreBrain } from './builder/brain.js';
+/**
+ * Creates a project-level brain function with pre-configured services, components, and tools.
+ *
+ * This is the recommended way to set up brains in a Positronic project. It provides:
+ * - Type-safe access to services in all brain steps
+ * - Automatic injection of components and default tools
+ * - Support for both builder pattern and direct agent creation
+ *
+ * @example
+ * ```typescript
+ * // brain.ts - your project's brain configuration
+ * import { createBrain } from '@positronic/core';
+ * import { components } from './components/index.js';
+ * import slack from './services/slack.js';
+ * import gmail from './services/gmail.js';
+ *
+ * export const brain = createBrain({
+ *   services: { slack, gmail },
+ *   components,
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // brains/my-brain.ts - using the configured brain
+ * import { brain } from '../brain.js';
+ *
+ * // Builder pattern
+ * export default brain('my-workflow')
+ *   .step('Init', ({ slack }) => {
+ *     slack.postMessage('#general', 'Starting workflow');
+ *     return { started: true };
+ *   });
+ *
+ * // Or direct agent creation
+ * export default brain('my-agent', ({ slack, env }) => ({
+ *   system: 'You are helpful',
+ *   prompt: 'Help the user',
+ *   tools: { ... }
+ * }));
+ * ```
+ */ export function createBrain(config) {
+    var services = config.services, components = config.components, defaultTools = config.defaultTools;
+    // Implementation
+    function brain(titleOrConfig, agentConfig) {
+        var base = coreBrain(titleOrConfig);
+        if (components) {
+            base = base.withComponents(components);
+        }
+        if (defaultTools) {
+            base = base.withTools(defaultTools);
+        }
+        if (services) {
+            base = base.withServices(services);
+        }
+        if (agentConfig) {
+            return base.brain('main', agentConfig);
+        }
+        return base;
+    }
+    return brain;
+}

package/dist/src/dsl/definitions/blocks.js

@@ -0,0 +1 @@
+export { };

package/dist/src/dsl/definitions/brain-types.js

@@ -0,0 +1,4 @@
+/**
+ * Configuration for creating a brain - either a simple string title
+ * or an object with title and optional description.
+ */ export { };

package/dist/src/dsl/definitions/events.js

@@ -0,0 +1,2 @@
+// Union type of all possible events
+export { };

package/dist/src/dsl/definitions/run-params.js

@@ -0,0 +1 @@
+export { };

package/dist/src/dsl/definitions/steps.js

@@ -0,0 +1,2 @@
+// Type for brain structure
+export { };

package/dist/src/dsl/execution/constants.js

@@ -0,0 +1,14 @@
+/**
+ * Default runtime environment used when env is not provided.
+ * This ensures backward compatibility with existing code.
+ */ export var DEFAULT_ENV = {
+    origin: 'http://localhost:3000',
+    secrets: {}
+};
+/**
+ * Default system prompt prepended to all agent steps.
+ * Explains tool execution quirks to the LLM.
+ */ export var DEFAULT_AGENT_SYSTEM_PROMPT = "## Tool Execution Behavior\n- Tools are executed sequentially in the order you call them\n- If a tool triggers a webhook (e.g., human approval), remaining tools in your response will NOT execute - you'll need to call them again after resuming\n- When waiting on multiple webhooks (e.g., Slack + email), the first webhook response received will resume execution\n- Terminal tools end the agent immediately - no further tools or iterations will run\n\n## Resumption Context\nWhen resuming after a webhook response, that response appears as the tool result in your conversation history.";
+/**
+ * Maximum number of retries for step execution.
+ */ export var MAX_RETRIES = 1;