@forestadmin/workflow-executor 1.0.0

package/README.md

@@ -0,0 +1,141 @@
+# @forestadmin/workflow-executor
+
+Run Forest Admin workflow steps on your own infrastructure.
+
+The executor polls the Forest orchestrator for pending steps, runs them locally
+(with access to your data via the Forest agent), and reports results back. No
+client data ever leaves your infrastructure.
+
+## Running in production
+
+### Install
+
+```bash
+npm install -g @forestadmin/workflow-executor
+```
+
+### Configure via environment
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `FOREST_ENV_SECRET` | ✓ | — | Forest Admin project environment secret |
+| `FOREST_AUTH_SECRET` | ✓ | — | JWT signing secret (shared with your agent) |
+| `AGENT_URL` | ✓ | — | URL of your running Forest Admin agent |
+| `DATABASE_URL` | ✓* | — | Postgres connection string (*not needed with `--in-memory`) |
+| `HTTP_PORT` | — | `3400` | Port for the executor HTTP server |
+| `FOREST_SERVER_URL` | — | `https://api.forestadmin.com` | Orchestrator URL |
+| `POLLING_INTERVAL_MS` | — | `5000` | Poll cadence for pending steps |
+| `STOP_TIMEOUT_MS` | — | `30000` | Graceful shutdown deadline |
+
+Optional AI configuration (all-or-nothing — falls back to server AI if any is missing):
+
+| Variable | Description |
+|----------|-------------|
+| `AI_PROVIDER` | `anthropic` or `openai` |
+| `AI_MODEL` | Model name (e.g. `claude-sonnet-4-6`) |
+| `AI_API_KEY` | Provider API key |
+
+### Run
+
+```bash
+forest-workflow-executor
+```
+
+You should see (pretty format when stdout is a TTY):
+
+```
+13:33:42 info  Workflow executor starting mode="database" forestServerUrl="https://api.forestadmin.com" agentUrl="http://localhost:3351" httpPort=3400 pollingIntervalMs=5000 aiConfig="server fallback"
+13:33:42 info  Workflow executor ready url="http://localhost:3400"
+13:33:47 info  Poll cycle completed fetched=0 dispatching=0
+```
+
+When stdout is piped, redirected or inside a container, logs are emitted as
+structured JSON instead — ready to be ingested by Datadog, CloudWatch, Loki, etc.:
+
+```json
+{"message":"Workflow executor ready","timestamp":"2026-04-20T13:33:42.000Z","url":"http://localhost:3400"}
+{"message":"Poll cycle completed","timestamp":"2026-04-20T13:33:47.000Z","fetched":0,"dispatching":0}
+```
+
+### Log format overrides
+
+| Flag | Behavior |
+|------|----------|
+| `--pretty` | Force colorized human-readable logs |
+| `--json` | Force structured JSON logs |
+| (none) | Auto-detect: pretty when stdout is a TTY, JSON otherwise |
+
+Setting `NO_COLOR=1` disables ANSI codes while keeping the pretty format.
+
+### Health check
+
+```bash
+curl http://localhost:3400/health
+# → {"state":"running"}
+```
+
+### Graceful shutdown
+
+Send `SIGTERM` or `SIGINT`. The executor drains in-flight steps, closes the HTTP
+server, and exits with code `0`. Steps that don't drain within `STOP_TIMEOUT_MS`
+are force-killed and the process exits with code `1`.
+
+### Exit codes
+
+| Code | Meaning |
+|------|---------|
+| `0` | Graceful shutdown |
+| `1` | Startup error (missing env, invalid config) or forced shutdown |
+
+### In-memory mode (dev only)
+
+```bash
+forest-workflow-executor --in-memory
+```
+
+No Postgres needed. State is lost on restart — **not for production**.
+
+### All flags
+
+```bash
+forest-workflow-executor --help
+```
+
+## Programmatic use
+
+If you prefer embedding the executor in your own Node entry point:
+
+```ts
+import { buildDatabaseExecutor } from '@forestadmin/workflow-executor';
+
+const executor = buildDatabaseExecutor({
+  envSecret: process.env.FOREST_ENV_SECRET!,
+  authSecret: process.env.FOREST_AUTH_SECRET!,
+  agentUrl: process.env.AGENT_URL!,
+  httpPort: 3400,
+  database: { uri: process.env.DATABASE_URL! },
+});
+
+await executor.start();
+// SIGTERM / SIGINT handling is built in
+```
+
+See `src/build-workflow-executor.ts` for the full options surface.
+
+## Dev with the example scaffold
+
+The `example/` folder contains a docker-compose setup with Postgres + a ready
+`index.ts` entrypoint that loads `.env` via `dotenv`. Use it for local development
+only — not for production deployments.
+
+```bash
+cd example
+docker compose up -d
+cp .env.example .env  # fill in your secrets
+npx tsx index.ts
+```
+
+## Architecture
+
+See [CLAUDE.md](./CLAUDE.md) for the full package layout, architectural
+principles, privacy boundaries, and extension points.

package/dist/adapters/activity-log-drainer.d.ts

@@ -0,0 +1,6 @@
+export default class ActivityLogDrainer {
+    private readonly inFlight;
+    track<T>(fn: () => Promise<T>): Promise<T>;
+    drain(): Promise<void>;
+}
+//# sourceMappingURL=activity-log-drainer.d.ts.map

package/dist/adapters/activity-log-drainer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ActivityLogDrainer {
+    constructor() {
+        this.inFlight = new Set();
+    }
+    track(fn) {
+        const promise = fn();
+        this.inFlight.add(promise);
+        // Swallow rejections on the cleanup chain so tracking a rejecting promise
+        // doesn't cause UnhandledPromiseRejection. The original promise returned
+        // to the caller still rejects normally.
+        promise.finally(() => this.inFlight.delete(promise)).catch(() => { });
+        return promise;
+    }
+    async drain() {
+        await Promise.allSettled([...this.inFlight]);
+    }
+}
+exports.default = ActivityLogDrainer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aXZpdHktbG9nLWRyYWluZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYWRhcHRlcnMvYWN0aXZpdHktbG9nLWRyYWluZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxNQUFxQixrQkFBa0I7SUFBdkM7UUFDbUIsYUFBUSxHQUFHLElBQUksR0FBRyxFQUFvQixDQUFDO0lBZ0IxRCxDQUFDO0lBZEMsS0FBSyxDQUFJLEVBQW9CO1FBQzNCLE1BQU0sT0FBTyxHQUFHLEVBQUUsRUFBRSxDQUFDO1FBQ3JCLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQzNCLDBFQUEwRTtRQUMxRSx5RUFBeUU7UUFDekUsd0NBQXdDO1FBQ3hDLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsR0FBRyxFQUFFLEdBQUUsQ0FBQyxDQUFDLENBQUM7UUFFckUsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQztJQUVELEtBQUssQ0FBQyxLQUFLO1FBQ1QsTUFBTSxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQztJQUMvQyxDQUFDO0NBQ0Y7QUFqQkQscUNBaUJDIn0=

package/dist/adapters/agent-client-agent-port.d.ts

@@ -0,0 +1,27 @@
+import type { AgentPort, ExecuteActionQuery, GetActionFormInfoQuery, GetRecordQuery, GetRelatedDataQuery, GetSingleRelatedDataQuery, UpdateRecordQuery } from '../ports/agent-port';
+import type SchemaCache from '../schema-cache';
+import type { StepUser } from '../types/execution-context';
+import type { RecordData } from '../types/validated/collection';
+export default class AgentClientAgentPort implements AgentPort {
+    private readonly agentUrl;
+    private readonly authSecret;
+    private readonly schemaCache;
+    constructor(params: {
+        agentUrl: string;
+        authSecret: string;
+        schemaCache: SchemaCache;
+    });
+    getRecord({ collection, id, fields }: GetRecordQuery, user: StepUser): Promise<RecordData>;
+    updateRecord({ collection, id, values }: UpdateRecordQuery, user: StepUser): Promise<RecordData>;
+    getRelatedData({ collection, id, relation, relatedSchema, limit, fields }: GetRelatedDataQuery, user: StepUser): Promise<RecordData[]>;
+    getSingleRelatedData({ collection, id, relation, relatedSchema, fields }: GetSingleRelatedDataQuery, user: StepUser): Promise<RecordData | null>;
+    executeAction({ collection, action, id }: ExecuteActionQuery, user: StepUser): Promise<unknown>;
+    getActionFormInfo({ collection, action, id }: GetActionFormInfoQuery, user: StepUser): Promise<{
+        hasForm: boolean;
+    }>;
+    private callAgent;
+    private createClient;
+    probe(): Promise<void>;
+    private buildActionEndpoints;
+}
+//# sourceMappingURL=agent-client-agent-port.d.ts.map

package/dist/adapters/agent-client-agent-port.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const agent_client_1 = require("@forestadmin/agent-client");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const errors_1 = require("../errors");
+function toCamelCase(name) {
+    return name.replace(/_([a-zA-Z0-9])/g, (_, c) => c.toUpperCase());
+}
+// The agent-client HTTP layer deserializes JSON:API responses with camelCase keys.
+// Field names in the schema and in GetRecordQuery.fields use the original format (e.g. snake_case).
+// This function restores the original field names so callers can look up values by schema fieldName.
+function restoreFieldNames(values, originalFieldNames) {
+    if (!originalFieldNames?.length)
+        return values;
+    const camelToOriginal = {};
+    for (const name of originalFieldNames) {
+        camelToOriginal[toCamelCase(name)] = name;
+    }
+    return Object.fromEntries(Object.entries(values).map(([k, v]) => [camelToOriginal[k] ?? k, v]));
+}
+class AgentClientAgentPort {
+    constructor(params) {
+        this.agentUrl = params.agentUrl;
+        this.authSecret = params.authSecret;
+        this.schemaCache = params.schemaCache;
+    }
+    async getRecord({ collection, id, fields }, user) {
+        return this.callAgent('getRecord', async () => {
+            const client = this.createClient(user);
+            // Fetch by id through the agent's by-id route (like update/delete): the recordId is an
+            // opaque ordered token and the agent — the only party that knows the primary key column
+            // order — does the matching. No primaryKeyFields ordering assumption here.
+            let record;
+            try {
+                record = await client
+                    .collection(collection)
+                    .getOne(id, { ...(fields?.length && { fields }) });
+            }
+            catch (error) {
+                if (agent_client_1.HttpRequester.is404Error(error)) {
+                    throw new errors_1.RecordNotFoundError(collection, id);
+                }
+                throw error;
+            }
+            // Some agents answer a missing composite-key record with a 200 + empty body instead of 404.
+            if (!record || Object.keys(record).length === 0) {
+                throw new errors_1.RecordNotFoundError(collection, id);
+            }
+            return {
+                collectionName: collection,
+                recordId: id,
+                values: restoreFieldNames(record, fields),
+            };
+        });
+    }
+    async updateRecord({ collection, id, values }, user) {
+        return this.callAgent('updateRecord', async () => {
+            const client = this.createClient(user);
+            const updatedRecord = await client
+                .collection(collection)
+                .update(id, values);
+            return {
+                collectionName: collection,
+                recordId: id,
+                values: restoreFieldNames(updatedRecord, Object.keys(values)),
+            };
+        });
+    }
+    async getRelatedData({ collection, id, relation, relatedSchema, limit, fields }, user) {
+        return this.callAgent('getRelatedData', async () => {
+            const client = this.createClient(user);
+            const rows = await client
+                .collection(collection)
+                .relation(relation, id)
+                .list({
+                ...(limit !== null && { pagination: { size: limit, number: 1 } }),
+                ...(fields?.length && { fields }),
+            });
+            return rows.map(row => {
+                const restored = restoreFieldNames(row, relatedSchema.fields.map(f => f.fieldName));
+                // For composite PKs, rebuilding the id from primaryKeyFields assumes the schema's
+                // (alphabetical) order matches the agent's column order — it may not, which would
+                // mis-pair the key. Use the agent's opaque record id (pipe-joined when composite),
+                // like getSingleRelatedData, so it round-trips through the by-id route.
+                const recordId = relatedSchema.primaryKeyFields.length > 1
+                    ? String(row.id).split('|')
+                    : relatedSchema.primaryKeyFields.map(f => restored[f]);
+                return {
+                    collectionName: relatedSchema.collectionName,
+                    recordId,
+                    values: restored,
+                };
+            });
+        });
+    }
+    // xToOne relations have no /relationships/<relation> route on the agent. We read the
+    // parent record with a `<relation>@@@<field>` projection and unpack the relation linkage
+    // jsonapi-serializer emits as a nested object on the parent (with the related PK packed
+    // under "id" when composite).
+    async getSingleRelatedData({ collection, id, relation, relatedSchema, fields }, user) {
+        return this.callAgent('getSingleRelatedData', async () => {
+            // The agent can't parse multiple sub-fields on one relation in a single projection
+            // (`fields[store]=id,name` is read as a single field name → ValidationError). The linkage
+            // `id` carries the (packed) related PK regardless of projection, so project at most ONE
+            // field: the requested reference field for display, else a single PK field just to pull the
+            // relation into the response.
+            const projectedField = fields?.[0] ?? relatedSchema.primaryKeyFields[0];
+            const parent = await this.getRecord({
+                collection,
+                id,
+                fields: [`${relation}@@@${projectedField}`],
+            }, user);
+            // agent-client camelCases relation keys; look the linkage up under the camelCased name.
+            const linkage = parent.values[toCamelCase(relation)];
+            const packedId = linkage?.id;
+            if (!linkage || !packedId)
+                return null;
+            const restored = restoreFieldNames(linkage, [projectedField]);
+            return {
+                collectionName: relatedSchema.collectionName,
+                recordId: packedId.split('|'),
+                values: restored,
+            };
+        });
+    }
+    async executeAction({ collection, action, id }, user) {
+        return this.callAgent('executeAction', async () => {
+            const client = this.createClient(user);
+            const recordIds = id?.length ? [id] : [];
+            const act = await client.collection(collection).action(action, { recordIds });
+            return act.execute();
+        });
+    }
+    async getActionFormInfo({ collection, action, id }, user) {
+        return this.callAgent('getActionFormInfo', async () => {
+            const client = this.createClient(user);
+            const act = await client.collection(collection).action(action, { recordIds: [id] });
+            return { hasForm: act.getFields().length > 0 };
+        });
+    }
+    async callAgent(operation, fn) {
+        try {
+            return await fn();
+        }
+        catch (cause) {
+            if (cause instanceof errors_1.WorkflowExecutorError)
+                throw cause;
+            throw new errors_1.AgentPortError(operation, cause);
+        }
+    }
+    createClient(user) {
+        // snake_case aliases: Ruby/Python agents splat JWT claims into Caller.new (snake_case kwargs).
+        const token = jsonwebtoken_1.default.sign({
+            ...user,
+            first_name: user.firstName,
+            last_name: user.lastName,
+            rendering_id: user.renderingId,
+            permission_level: user.permissionLevel,
+            scope: 'step-execution',
+        }, this.authSecret, { expiresIn: '5m' });
+        return (0, agent_client_1.createRemoteAgentClient)({
+            url: this.agentUrl,
+            token,
+            actionEndpoints: this.buildActionEndpoints(),
+        });
+    }
+    // Hits GET /forest/ (public, no auth required across all agent versions). A 4xx here means
+    // the URL points to something that isn't a Forest agent. JWT is validated naturally on first step.
+    async probe() {
+        const url = `${this.agentUrl.replace(/\/+$/, '')}/forest/`;
+        let response;
+        try {
+            response = await fetch(url, { method: 'GET', signal: AbortSignal.timeout(5000) });
+        }
+        catch (error) {
+            const isTimeout = error instanceof Error && error.name === 'TimeoutError';
+            const reason = isTimeout ? 'timeout after 5000ms' : (0, errors_1.extractErrorMessage)(error);
+            throw new errors_1.AgentProbeError(`cannot reach ${this.agentUrl} (${reason})`, { cause: error });
+        }
+        if (!response.ok) {
+            throw new errors_1.AgentProbeError(`${this.agentUrl} responded with ${response.status} ${response.statusText}`);
+        }
+    }
+    buildActionEndpoints() {
+        const endpoints = {};
+        for (const [collectionName, schema] of this.schemaCache) {
+            endpoints[collectionName] = {};
+            for (const action of schema.actions) {
+                // agent-client POSTs /hooks/load unconditionally; `hooks.load` tells it whether a 404
+                // there is expected (Ruby agent, swallowed → fallback to the static `fields` below) or
+                // a real error. Both `hooks` and `fields` must mirror the agent's real schema for form
+                // detection to work on Ruby agents.
+                endpoints[collectionName][action.name] = {
+                    id: action.name,
+                    name: action.name,
+                    endpoint: action.endpoint,
+                    hooks: action.hooks ?? { load: false, change: [] },
+                    // Zod envelope-validates `fields` as an array of opaque objects. Inner widget/parameters
+                    // shape is owned by @forestadmin/forestadmin-client and consumed by agent-client below.
+                    fields: (action.fields ?? []),
+                };
+            }
+        }
+        return endpoints;
+    }
+}
+exports.default = AgentClientAgentPort;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agent-client-agent-port.js","sourceRoot":"","sources":["../../src/adapters/agent-client-agent-port.ts"],"names":[],"mappings":"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"}

package/dist/adapters/ai-client-adapter.d.ts

@@ -0,0 +1,11 @@
+import type { AiModelPort } from '../ports/ai-model-port';
+import type { AiConfiguration, BaseChatModel, RemoteTool, ToolConfig } from '@forestadmin/ai-proxy';
+export default class AiClientAdapter implements AiModelPort {
+    private readonly aiClient;
+    constructor(aiConfigurations: AiConfiguration[]);
+    getModel(aiConfigName?: string): BaseChatModel;
+    loadRemoteTools(configs: Record<string, ToolConfig>): Promise<RemoteTool[]>;
+    closeConnections(): Promise<void>;
+    private callPort;
+}
+//# sourceMappingURL=ai-client-adapter.d.ts.map

package/dist/adapters/ai-client-adapter.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ai_proxy_1 = require("@forestadmin/ai-proxy");
+const errors_1 = require("../errors");
+class AiClientAdapter {
+    constructor(aiConfigurations) {
+        const withRetries = aiConfigurations.map(c => ({ maxRetries: 2, ...c }));
+        this.aiClient = new ai_proxy_1.AiClient({ aiConfigurations: withRetries });
+    }
+    getModel(aiConfigName) {
+        try {
+            return this.aiClient.getModel(aiConfigName);
+        }
+        catch (cause) {
+            if (cause instanceof errors_1.WorkflowExecutorError)
+                throw cause;
+            throw new errors_1.AiModelPortError('getModel', cause);
+        }
+    }
+    loadRemoteTools(configs) {
+        return this.callPort('loadRemoteTools', () => this.aiClient.loadRemoteTools(configs));
+    }
+    closeConnections() {
+        return this.callPort('closeConnections', () => this.aiClient.closeConnections());
+    }
+    async callPort(operation, fn) {
+        try {
+            return await fn();
+        }
+        catch (cause) {
+            if (cause instanceof errors_1.WorkflowExecutorError)
+                throw cause;
+            throw new errors_1.AiModelPortError(operation, cause);
+        }
+    }
+}
+exports.default = AiClientAdapter;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWktY2xpZW50LWFkYXB0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYWRhcHRlcnMvYWktY2xpZW50LWFkYXB0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSxvREFBaUQ7QUFFakQsc0NBQW9FO0FBRXBFLE1BQXFCLGVBQWU7SUFHbEMsWUFBWSxnQkFBbUM7UUFDN0MsTUFBTSxXQUFXLEdBQUcsZ0JBQWdCLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLFVBQVUsRUFBRSxDQUFDLEVBQUUsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDekUsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLG1CQUFRLENBQUMsRUFBRSxnQkFBZ0IsRUFBRSxXQUFnQyxFQUFFLENBQUMsQ0FBQztJQUN2RixDQUFDO0lBRUQsUUFBUSxDQUFDLFlBQXFCO1FBQzVCLElBQUksQ0FBQztZQUNILE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDOUMsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixJQUFJLEtBQUssWUFBWSw4QkFBcUI7Z0JBQUUsTUFBTSxLQUFLLENBQUM7WUFDeEQsTUFBTSxJQUFJLHlCQUFnQixDQUFDLFVBQVUsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUNoRCxDQUFDO0lBQ0gsQ0FBQztJQUVELGVBQWUsQ0FBQyxPQUFtQztRQUNqRCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsaUJBQWlCLEVBQUUsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUN4RixDQUFDO0lBRUQsZ0JBQWdCO1FBQ2QsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixFQUFFLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDO0lBQ25GLENBQUM7SUFFTyxLQUFLLENBQUMsUUFBUSxDQUFJLFNBQWlCLEVBQUUsRUFBb0I7UUFDL0QsSUFBSSxDQUFDO1lBQ0gsT0FBTyxNQUFNLEVBQUUsRUFBRSxDQUFDO1FBQ3BCLENBQUM7UUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1lBQ2YsSUFBSSxLQUFLLFlBQVksOEJBQXFCO2dCQUFFLE1BQU0sS0FBSyxDQUFDO1lBQ3hELE1BQU0sSUFBSSx5QkFBZ0IsQ0FBQyxTQUFTLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDL0MsQ0FBQztJQUNILENBQUM7Q0FDRjtBQWpDRCxrQ0FpQ0MifQ==

package/dist/adapters/always-error-ai-model-port.d.ts

@@ -0,0 +1,8 @@
+import type { AiModelPort } from '../ports/ai-model-port';
+import type { BaseChatModel, RemoteTool, ToolConfig } from '@forestadmin/ai-proxy';
+export default class AlwaysErrorAiModelPort implements AiModelPort {
+    getModel(): BaseChatModel;
+    loadRemoteTools(_configs: Record<string, ToolConfig>): Promise<RemoteTool[]>;
+    closeConnections(): Promise<void>;
+}
+//# sourceMappingURL=always-error-ai-model-port.d.ts.map

package/dist/adapters/always-error-ai-model-port.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+// Dev-only adapter: every AI call throws immediately so devs can reproduce AI error paths
+// without a real AI service. Activated via FORCE_AI_ERROR=true.
+class AlwaysErrorAiModelPort {
+    getModel() {
+        return {
+            bindTools: () => ({
+                invoke: () => Promise.reject(new errors_1.AiModelPortError('invoke', new Error('[dev] AI forced to always error'))),
+            }),
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    loadRemoteTools(_configs) {
+        return Promise.resolve([]);
+    }
+    closeConnections() {
+        return Promise.resolve();
+    }
+}
+exports.default = AlwaysErrorAiModelPort;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWx3YXlzLWVycm9yLWFpLW1vZGVsLXBvcnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYWRhcHRlcnMvYWx3YXlzLWVycm9yLWFpLW1vZGVsLXBvcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSxzQ0FBNkM7QUFFN0MsMEZBQTBGO0FBQzFGLGdFQUFnRTtBQUNoRSxNQUFxQixzQkFBc0I7SUFDekMsUUFBUTtRQUNOLE9BQU87WUFDTCxTQUFTLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQztnQkFDaEIsTUFBTSxFQUFFLEdBQUcsRUFBRSxDQUNYLE9BQU8sQ0FBQyxNQUFNLENBQ1osSUFBSSx5QkFBZ0IsQ0FBQyxRQUFRLEVBQUUsSUFBSSxLQUFLLENBQUMsaUNBQWlDLENBQUMsQ0FBQyxDQUM3RTthQUNKLENBQUM7U0FDeUIsQ0FBQztJQUNoQyxDQUFDO0lBRUQsNkRBQTZEO0lBQzdELGVBQWUsQ0FBQyxRQUFvQztRQUNsRCxPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDN0IsQ0FBQztJQUVELGdCQUFnQjtRQUNkLE9BQU8sT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzNCLENBQUM7Q0FDRjtBQXBCRCx5Q0FvQkMifQ==

package/dist/adapters/console-logger.d.ts

@@ -0,0 +1,7 @@
+import type { Logger } from '../ports/logger-port';
+export default class ConsoleLogger implements Logger {
+    error(message: string, context: Record<string, unknown>): void;
+    warn(message: string, context: Record<string, unknown>): void;
+    info(message: string, context: Record<string, unknown>): void;
+}
+//# sourceMappingURL=console-logger.d.ts.map

package/dist/adapters/console-logger.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ConsoleLogger {
+    error(message, context) {
+        console.error(JSON.stringify({ message, timestamp: new Date().toISOString(), ...context }));
+    }
+    warn(message, context) {
+        console.warn(JSON.stringify({ message, timestamp: new Date().toISOString(), ...context }));
+    }
+    info(message, context) {
+        console.info(JSON.stringify({ message, timestamp: new Date().toISOString(), ...context }));
+    }
+}
+exports.default = ConsoleLogger;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc29sZS1sb2dnZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYWRhcHRlcnMvY29uc29sZS1sb2dnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSxNQUFxQixhQUFhO0lBQ2hDLEtBQUssQ0FBQyxPQUFlLEVBQUUsT0FBZ0M7UUFDckQsT0FBTyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEVBQUUsT0FBTyxFQUFFLFNBQVMsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFLEdBQUcsT0FBTyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQzlGLENBQUM7SUFFRCxJQUFJLENBQUMsT0FBZSxFQUFFLE9BQWdDO1FBQ3BELE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBQyxXQUFXLEVBQUUsRUFBRSxHQUFHLE9BQU8sRUFBRSxDQUFDLENBQUMsQ0FBQztJQUM3RixDQUFDO0lBRUQsSUFBSSxDQUFDLE9BQWUsRUFBRSxPQUFnQztRQUNwRCxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUFFLElBQUksSUFBSSxFQUFFLENBQUMsV0FBVyxFQUFFLEVBQUUsR0FBRyxPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDN0YsQ0FBQztDQUNGO0FBWkQsZ0NBWUMifQ==

package/dist/adapters/forest-server-workflow-port.d.ts

@@ -0,0 +1,25 @@
+import type { Logger } from '../ports/logger-port';
+import type { AvailableRunDispatch, AvailableRunsBatch, WorkflowPort } from '../ports/workflow-port';
+import type { StepUser } from '../types/execution-context';
+import type { CollectionSchema } from '../types/validated/collection';
+import type { StepOutcome } from '../types/validated/step-outcome';
+import type { ToolConfig } from '@forestadmin/ai-proxy';
+export default class ForestServerWorkflowPort implements WorkflowPort {
+    private readonly options;
+    private readonly logger;
+    constructor(params: {
+        envSecret: string;
+        forestServerUrl: string;
+        logger?: Logger;
+    });
+    getAvailableRuns(): Promise<AvailableRunsBatch>;
+    getAvailableRun(runId: string): Promise<AvailableRunDispatch | null>;
+    private toDispatch;
+    private toMalformedInfo;
+    updateStepExecution(runId: string, stepOutcome: StepOutcome): Promise<AvailableRunDispatch | null>;
+    getCollectionSchema(collectionName: string, runId: string): Promise<CollectionSchema>;
+    getMcpServerConfigs(): Promise<Record<string, ToolConfig>>;
+    hasRunAccess(runId: string, user: StepUser): Promise<boolean>;
+    private callPort;
+}
+//# sourceMappingURL=forest-server-workflow-port.d.ts.map