@swirls/looms 0.4.0 → 0.5.0

package/dist/evaluator/module.d.ts

@@ -39,8 +39,55 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
     evaluate: import("@swirls/looms/core").EffectDefinition<{
         readonly evaluationId: string;
         readonly definitionName?: string | undefined;
+        readonly definitionVersion?: string | undefined;
         readonly input?: import("effect/Schema").Json | undefined;
     }, import("./definitions-store").EvaluatorDefinitionsTag | EvaluatorTag, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "evaluator.evaluated";
+        readonly payload: {
+            readonly evaluationId: string;
+            readonly definitionName?: string | undefined;
+            readonly answers: {
+                readonly [x: string]: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                    readonly probability: number;
+                } | {
+                    readonly type: "choice";
+                    readonly value: string;
+                } | {
+                    readonly type: "score";
+                    readonly value: number;
+                };
+            };
+            readonly route: string;
+            readonly reason: "model" | "skipped" | "unavailable" | "uncertain";
+            readonly usage?: {
+                readonly input: number;
+                readonly output: number;
+            } | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "evaluator.requested";
+        readonly payload: {
+            readonly evaluationId: string;
+            readonly definitionName?: string | undefined;
+            readonly state: string;
+            readonly model?: string | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.child.close.requested";
+        readonly payload: {
+            readonly policy: "terminate" | "wait";
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.child.settled";
+        readonly payload: {
+            readonly runId: string;
+            readonly status: "cancelled" | "completed" | "failed";
+            readonly output: import("effect/Schema").Json;
+            readonly error: string | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.effect.ambiguous";
         readonly payload: {
             readonly effectId: string;
@@ -84,6 +131,8 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
         readonly payload: {
             readonly effectId: string;
             readonly error: string;
+            readonly nonRetryable?: boolean | undefined;
+            readonly retryAfterMs?: number | undefined;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.effect.heartbeat";
@@ -92,6 +141,7 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
             readonly attempt: number;
             readonly heartbeatAt: number;
             readonly deadlineAt: number | null;
+            readonly details?: import("effect/Schema").Json | undefined;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.effect.queued";
@@ -144,6 +194,16 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
             readonly sourceRunId: string;
             readonly sourceSeq: number;
         };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.run.launched";
+        readonly payload: {
+            readonly runId: string;
+            readonly kind: string;
+            readonly definitionName: string;
+            readonly definitionVersion: string;
+            readonly effectId: string;
+            readonly close: "terminate" | "wait";
+        };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.run.started";
         readonly payload: {
@@ -153,6 +213,20 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
             readonly definitionVersion: string;
             readonly input: import("effect/Schema").Json;
             readonly requestedThreadId?: string | null | undefined;
+            readonly launchedBy?: {
+                readonly runId: string;
+                readonly threadId: string;
+                readonly effectId: string;
+                readonly causationId: string;
+                readonly causationSeq: number;
+            } | undefined;
+            readonly attributes?: {
+                readonly [x: string]: string;
+            } | undefined;
+            readonly trace?: {
+                readonly traceparent: string;
+                readonly tracestate?: string | undefined;
+            } | undefined;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.signal.received";
@@ -237,43 +311,11 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
                 readonly payload: import("effect/Schema").Json;
             };
         };
-    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
-        readonly type: "evaluator.evaluated";
-        readonly payload: {
-            readonly evaluationId: string;
-            readonly definitionName?: string | undefined;
-            readonly answers: {
-                readonly [x: string]: {
-                    readonly type: "boolean";
-                    readonly value: boolean;
-                    readonly probability: number;
-                } | {
-                    readonly type: "choice";
-                    readonly value: string;
-                } | {
-                    readonly type: "score";
-                    readonly value: number;
-                };
-            };
-            readonly route: string;
-            readonly reason: "model" | "skipped" | "unavailable" | "uncertain";
-            readonly usage?: {
-                readonly input: number;
-                readonly output: number;
-            } | undefined;
-        };
-    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
-        readonly type: "evaluator.requested";
-        readonly payload: {
-            readonly evaluationId: string;
-            readonly definitionName?: string | undefined;
-            readonly state: string;
-            readonly model?: string | undefined;
-        };
     })>;
 }, {
     evaluator: import("@swirls/looms/core").ThreadDefinition<{
         readonly definitionName?: string | undefined;
+        readonly definitionVersion?: string | undefined;
         readonly input: import("effect/Schema").Json;
         readonly evaluationId: string;
         readonly dispatched: boolean;
@@ -334,8 +376,55 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
         evaluate: import("@swirls/looms/core").EffectDefinition<{
             readonly evaluationId: string;
             readonly definitionName?: string | undefined;
+            readonly definitionVersion?: string | undefined;
             readonly input?: import("effect/Schema").Json | undefined;
         }, import("./definitions-store").EvaluatorDefinitionsTag | EvaluatorTag, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "evaluator.evaluated";
+            readonly payload: {
+                readonly evaluationId: string;
+                readonly definitionName?: string | undefined;
+                readonly answers: {
+                    readonly [x: string]: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                        readonly probability: number;
+                    } | {
+                        readonly type: "choice";
+                        readonly value: string;
+                    } | {
+                        readonly type: "score";
+                        readonly value: number;
+                    };
+                };
+                readonly route: string;
+                readonly reason: "model" | "skipped" | "unavailable" | "uncertain";
+                readonly usage?: {
+                    readonly input: number;
+                    readonly output: number;
+                } | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "evaluator.requested";
+            readonly payload: {
+                readonly evaluationId: string;
+                readonly definitionName?: string | undefined;
+                readonly state: string;
+                readonly model?: string | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.child.close.requested";
+            readonly payload: {
+                readonly policy: "terminate" | "wait";
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.child.settled";
+            readonly payload: {
+                readonly runId: string;
+                readonly status: "cancelled" | "completed" | "failed";
+                readonly output: import("effect/Schema").Json;
+                readonly error: string | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.effect.ambiguous";
             readonly payload: {
                 readonly effectId: string;
@@ -379,6 +468,8 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
             readonly payload: {
                 readonly effectId: string;
                 readonly error: string;
+                readonly nonRetryable?: boolean | undefined;
+                readonly retryAfterMs?: number | undefined;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.effect.heartbeat";
@@ -387,6 +478,7 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
                 readonly attempt: number;
                 readonly heartbeatAt: number;
                 readonly deadlineAt: number | null;
+                readonly details?: import("effect/Schema").Json | undefined;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.effect.queued";
@@ -439,6 +531,16 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
                 readonly sourceRunId: string;
                 readonly sourceSeq: number;
             };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.run.launched";
+            readonly payload: {
+                readonly runId: string;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly definitionVersion: string;
+                readonly effectId: string;
+                readonly close: "terminate" | "wait";
+            };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.run.started";
             readonly payload: {
@@ -448,6 +550,20 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
                 readonly definitionVersion: string;
                 readonly input: import("effect/Schema").Json;
                 readonly requestedThreadId?: string | null | undefined;
+                readonly launchedBy?: {
+                    readonly runId: string;
+                    readonly threadId: string;
+                    readonly effectId: string;
+                    readonly causationId: string;
+                    readonly causationSeq: number;
+                } | undefined;
+                readonly attributes?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly trace?: {
+                    readonly traceparent: string;
+                    readonly tracestate?: string | undefined;
+                } | undefined;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.signal.received";
@@ -532,44 +648,12 @@ export declare function evaluator(options?: EvaluatorModuleOptions): import("@sw
                     readonly payload: import("effect/Schema").Json;
                 };
             };
-        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
-            readonly type: "evaluator.evaluated";
-            readonly payload: {
-                readonly evaluationId: string;
-                readonly definitionName?: string | undefined;
-                readonly answers: {
-                    readonly [x: string]: {
-                        readonly type: "boolean";
-                        readonly value: boolean;
-                        readonly probability: number;
-                    } | {
-                        readonly type: "choice";
-                        readonly value: string;
-                    } | {
-                        readonly type: "score";
-                        readonly value: number;
-                    };
-                };
-                readonly route: string;
-                readonly reason: "model" | "skipped" | "unavailable" | "uncertain";
-                readonly usage?: {
-                    readonly input: number;
-                    readonly output: number;
-                } | undefined;
-            };
-        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
-            readonly type: "evaluator.requested";
-            readonly payload: {
-                readonly evaluationId: string;
-                readonly definitionName?: string | undefined;
-                readonly state: string;
-                readonly model?: string | undefined;
-            };
         })>;
     };
     readonly threads: {
         evaluator: import("@swirls/looms/core").ThreadDefinition<{
             readonly definitionName?: string | undefined;
+            readonly definitionVersion?: string | undefined;
             readonly input: import("effect/Schema").Json;
             readonly evaluationId: string;
             readonly dispatched: boolean;

package/dist/evaluator/module.js

@@ -1,5 +1,5 @@
 import { Layer } from 'effect';
-import { defineModule } from '@swirls/looms/core';
+import { defineModule, makeDefinitionStore } from '@swirls/looms/core';
 import { EvaluatorDefinitionsLive } from './definitions-store.js';
 import { evaluateEffect } from './effects.js';
 import { evaluatorFromAdapter, EvaluatorTag, StubEvaluatorLive, } from './evaluator.js';
@@ -7,12 +7,13 @@ import { evaluations } from './projections.js';
 import { evaluatorModule } from './scope.js';
 import { evaluatorThread } from './threads.js';
 export function evaluator(options = {}) {
-    const definitions = options.definitions ?? [];
+    const listed = options.definitions ?? [];
+    const definitions = makeDefinitionStore('evaluator', listed);
     const evaluatorLayer = options.evaluator
         ? Layer.succeed(EvaluatorTag, evaluatorFromAdapter(options.evaluator))
         : StubEvaluatorLive(options.evaluatorPolicy);
     return defineModule(evaluatorModule, () => ({
-        definitions,
+        definitions: listed,
         threads: { evaluator: evaluatorThread },
         effects: {
             evaluate: evaluateEffect,
@@ -21,5 +22,8 @@ export function evaluator(options = {}) {
             evaluations,
         },
         services: () => Layer.merge(evaluatorLayer, EvaluatorDefinitionsLive(definitions)),
+        bindHost(host) {
+            definitions.useResolver(host.definitionResolver);
+        },
     }));
 }

package/dist/evaluator/threads.d.ts

@@ -1,6 +1,7 @@
 import { Schema } from 'effect';
 export declare const EvaluatorThreadStateSchema: Schema.Struct<{
     readonly definitionName: Schema.optional<Schema.String>;
+    readonly definitionVersion: Schema.optional<Schema.String>;
     readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
     readonly evaluationId: Schema.String;
     readonly dispatched: Schema.Boolean;
@@ -31,6 +32,7 @@ export declare const EvaluatorThreadStateSchema: Schema.Struct<{
 export type EvaluatorThreadState = Schema.Schema.Type<typeof EvaluatorThreadStateSchema>;
 export declare const evaluatorThread: import("@swirls/looms/core").ThreadDefinition<{
     readonly definitionName?: string | undefined;
+    readonly definitionVersion?: string | undefined;
     readonly input: Schema.Json;
     readonly evaluationId: string;
     readonly dispatched: boolean;

package/dist/evaluator/threads.js

@@ -5,6 +5,7 @@ import { EvaluatorEvaluatedPayloadSchema } from './events.js';
 import { evaluatorModule } from './scope.js';
 export const EvaluatorThreadStateSchema = Schema.Struct({
     definitionName: Schema.optional(Schema.String),
+    definitionVersion: Schema.optional(Schema.String),
     input: Schema.Json,
     evaluationId: Schema.String,
     dispatched: Schema.Boolean,
@@ -26,6 +27,7 @@ export const evaluatorThread = evaluatorModule.thread({
     shape: EvaluatorThreadStateSchema,
     initialState: (ctx) => ({
         definitionName: ctx.definitionName,
+        definitionVersion: ctx.definitionVersion,
         input: ctx.input,
         evaluationId: `eval_${ctx.threadId}`,
         dispatched: false,
@@ -42,6 +44,7 @@ export const evaluatorThread = evaluatorModule.thread({
                 return {
                     ...state,
                     definitionName: event.payload.definitionName || state.definitionName,
+                    definitionVersion: event.payload.definitionVersion || state.definitionVersion,
                     input: event.payload.input ?? state.input,
                     evaluationId: `eval_${ctx.threadId}`,
                 };
@@ -105,6 +108,7 @@ export const evaluatorThread = evaluatorModule.thread({
             effects.push(invoke(evaluateEffect, {
                 evaluationId: state.evaluationId,
                 definitionName: state.definitionName,
+                definitionVersion: state.definitionVersion,
                 input: state.input,
             }, `evaluate_${state.evaluationId}`));
         }

package/dist/projectors/event-log.d.ts

@@ -0,0 +1,87 @@
+import { type Sql } from 'postgres';
+import { type EventEnvelope, type EventOrigin, type EventStore, type JsonValue, type RunStatus } from '@swirls/looms/core';
+import type { Projector } from './projector';
+export declare const POSTGRES_EVENT_LOG_SCHEMA_SQL: string;
+export interface EventLogEntry {
+    readonly runId: string;
+    readonly seq: number;
+    readonly eventId: string;
+    readonly ts: number;
+    readonly type: string;
+    readonly payload: JsonValue;
+    readonly threadId: string | null;
+    readonly parentThreadId: string | null;
+    readonly causationId: string | null;
+    readonly correlationId: string | null;
+    readonly effectId: string | null;
+    readonly origin: EventOrigin;
+    readonly idempotencyKey: string | null;
+}
+export interface RunLogRow {
+    readonly runId: string;
+    readonly status: RunStatus;
+    readonly kind: string | null;
+    readonly definitionName: string | null;
+    readonly definitionVersion: string | null;
+    readonly rootThreadId: string | null;
+    readonly parentRunId: string | null;
+    readonly launchedByEffectId: string | null;
+    readonly correlationId: string | null;
+    readonly attributes: {
+        readonly [key: string]: string;
+    };
+    readonly tenant: string | null;
+    readonly project: string | null;
+    readonly org: string | null;
+    readonly startedAt: number | null;
+    readonly updatedAt: number;
+    readonly completedAt: number | null;
+}
+export type EventLogOp = {
+    readonly type: 'insert';
+    readonly entry: EventLogEntry;
+} | {
+    readonly type: 'start';
+    readonly runId: string;
+    readonly kind: string | null;
+    readonly definitionName: string | null;
+    readonly definitionVersion: string | null;
+    readonly rootThreadId: string | null;
+    readonly parentRunId: string | null;
+    readonly launchedByEffectId: string | null;
+    readonly correlationId: string | null;
+    readonly attributes: {
+        readonly [key: string]: string;
+    };
+    readonly tenant: string | null;
+    readonly project: string | null;
+    readonly org: string | null;
+    readonly at: number;
+} | {
+    readonly type: 'finish';
+    readonly runId: string;
+    readonly status: 'completed' | 'failed' | 'cancelled';
+    readonly at: number;
+} | {
+    readonly type: 'touch';
+    readonly runId: string;
+    readonly at: number;
+};
+export interface EventLogProjector extends Projector {
+    /** Replays the source log into this sink. Safe to repeat; do not run it beside live delivery. */
+    rebuild(source: EventStore, options?: {
+        readonly runId?: string;
+        readonly batchSize?: number;
+    }): Promise<number>;
+}
+export interface MemoryEventLog extends EventLogProjector {
+    events(runId: string): readonly EventLogEntry[];
+    run(runId: string): RunLogRow | null;
+}
+export declare function eventLogOps(event: EventEnvelope): readonly EventLogOp[];
+export declare function memoryEventLog(): MemoryEventLog;
+export declare function postgresEventLog(options: {
+    url: string;
+} | {
+    sql: Sql;
+}): EventLogProjector;