@swirls/looms 0.0.2 → 0.1.0

package/dist/evaluator/definitions.d.ts

@@ -0,0 +1,18 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { Schema } from 'effect';
+import { type JsonValue } from '@swirls/looms/core';
+import type { EvaluatorQuestions, EvaluatorRouteArgs, EvaluatorRouteDecision, EvaluatorSkipResult } from './types';
+export interface EvaluatorDefinition<TName extends string = string, TInput = JsonValue> {
+    readonly kind: 'evaluator';
+    readonly name: TName;
+    readonly description?: string;
+    /** Provider model id. Omit it to use the adapter default. */
+    readonly model?: string;
+    readonly input?: StandardSchemaV1<any, TInput> | Schema.ConstraintDecoder<TInput>;
+    readonly questions: EvaluatorQuestions;
+    state?(this: void, input: TInput): string;
+    skipModel?(this: void, input: TInput): EvaluatorSkipResult | undefined;
+    route?(this: void, args: EvaluatorRouteArgs): EvaluatorRouteDecision;
+}
+export type AnyEvaluatorDefinition = EvaluatorDefinition;
+export declare function defineEvaluator<TName extends string, TInput = JsonValue>(def: Omit<EvaluatorDefinition<TName, TInput>, 'kind'>): EvaluatorDefinition<TName, TInput>;

package/dist/evaluator/definitions.js

@@ -0,0 +1,4 @@
+import { defineKind } from '@swirls/looms/core';
+export function defineEvaluator(def) {
+    return defineKind('evaluator', def);
+}

package/dist/evaluator/effects.d.ts

@@ -0,0 +1,226 @@
+import { Schema } from 'effect';
+import { EvaluatorDefinitionsTag } from './definitions-store';
+import { EvaluatorTag } from './evaluator';
+export declare const evaluateEffect: NoInfer<import("@swirls/looms/core").EffectDefinition<{
+    readonly evaluationId: string;
+    readonly definitionName?: string | undefined;
+    readonly input?: Schema.Json | undefined;
+}, 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.effect.ambiguous";
+    readonly payload: {
+        readonly effectId: string;
+        readonly attempt: number;
+        readonly error: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.attempt.started";
+    readonly payload: {
+        readonly effectId: string;
+        readonly attempt: number;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.cancel.requested";
+    readonly payload: {
+        readonly effectId: string;
+        readonly attempt: number;
+        readonly deadlineAt: number | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.cancelled";
+    readonly payload: {
+        readonly effectId: string;
+        readonly attempt: number;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.completed";
+    readonly payload: {
+        readonly effectId: string;
+        readonly attempt: number;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.dispatched";
+    readonly payload: {
+        readonly effectId: string;
+        readonly attempt: number;
+        readonly deadlineAt: number | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.failed";
+    readonly payload: {
+        readonly effectId: string;
+        readonly error: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.heartbeat";
+    readonly payload: {
+        readonly effectId: string;
+        readonly attempt: number;
+        readonly heartbeatAt: number;
+        readonly deadlineAt: number | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.queued";
+    readonly payload: {
+        readonly effectId: string;
+        readonly attempt: number;
+        readonly deadlineAt: number | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.retry.scheduled";
+    readonly payload: {
+        readonly effectId: string;
+        readonly attempt: number;
+        readonly nextAttemptAt: number;
+        readonly error: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.timed_out";
+    readonly payload: {
+        readonly effectId: string;
+        readonly attempt: number;
+        readonly timeout: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.worker.started";
+    readonly payload: {
+        readonly effectId: string;
+        readonly attempt: number;
+        readonly deadlineAt: number | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.run.cancelled";
+    readonly payload: {
+        readonly reason?: string | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.run.completed";
+    readonly payload: {
+        readonly output: Schema.Json;
+        readonly error: string | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.run.started";
+    readonly payload: {
+        readonly rootThreadId?: string | undefined;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly definitionVersion: string;
+        readonly input: Schema.Json;
+        readonly requestedThreadId?: string | null | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.signal.received";
+    readonly payload: {
+        readonly signalType: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.snapshot.taken";
+    readonly payload: {
+        readonly seq: number;
+        readonly stateHash: string;
+        readonly state?: Schema.Json | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.cancel.requested";
+    readonly payload: {
+        readonly threadId: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.cancelled";
+    readonly payload: {
+        readonly threadId: string;
+        readonly reason?: string | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.completed";
+    readonly payload: {
+        readonly threadId: string;
+        readonly output: Schema.Json;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.failed";
+    readonly payload: {
+        readonly threadId: string;
+        readonly error: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.started";
+    readonly payload: {
+        readonly threadId: string;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly definitionVersion: string;
+        readonly input: Schema.Json;
+        readonly parentThreadId: string | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.timer.fired";
+    readonly payload: {
+        readonly timerId: string;
+        readonly waitId: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.timer.set";
+    readonly payload: {
+        readonly timerId: string;
+        readonly waitId: string;
+        readonly wakeAt: number;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.wait.registered";
+    readonly payload: {
+        readonly waitId: string;
+        readonly threadId?: string | undefined;
+        readonly on: {
+            readonly type: string | readonly string[];
+            readonly match?: Schema.Json | undefined;
+        } | {
+            readonly timerAt: number;
+        };
+        readonly tag?: Schema.Json | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.wait.satisfied";
+    readonly payload: {
+        readonly waitId: string;
+        readonly tag?: Schema.Json | undefined;
+        readonly event: {
+            readonly id: string;
+            readonly type: string;
+            readonly payload: Schema.Json;
+        };
+    };
+})>>;

package/dist/evaluator/effects.js

@@ -0,0 +1,132 @@
+import { Effect, Schema } from 'effect';
+import { stringifyJson, validateInputEffect } from '@swirls/looms/core';
+import { EvaluatorDefinitionsTag } from './definitions-store.js';
+import { EvaluatorTag } from './evaluator.js';
+import { evaluatorModule } from './scope.js';
+const EvaluateInput = Schema.Struct({
+    evaluationId: Schema.String,
+    definitionName: Schema.optional(Schema.String),
+    input: Schema.optional(Schema.Json),
+});
+function errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+function capture(run) {
+    return Effect.try({
+        try: run,
+        catch: errorMessage,
+    }).pipe(Effect.match({
+        onFailure: (error) => ({ ok: false, error }),
+        onSuccess: (value) => ({ ok: true, value }),
+    }));
+}
+function failed(threadId, error) {
+    return [
+        {
+            type: 'runtime.thread.failed',
+            payload: { threadId, error },
+            threadId,
+        },
+    ];
+}
+export const evaluateEffect = evaluatorModule.effect({
+    type: 'evaluator.evaluate',
+    input: EvaluateInput,
+    execute: (input, ctx) => Effect.gen(function* () {
+        const threadId = ctx.threadId;
+        const definitions = yield* EvaluatorDefinitionsTag;
+        const evaluator = yield* EvaluatorTag;
+        const definition = input.definitionName ? definitions.get(input.definitionName) : undefined;
+        if (!definition) {
+            const name = input.definitionName ?? 'unknown';
+            return failed(threadId, `Unknown evaluator definition for ${name}`);
+        }
+        const rawInput = input.input ?? null;
+        const validated = definition.input
+            ? yield* validateInputEffect(definition.input, rawInput).pipe(Effect.match({
+                onFailure: (error) => ({ ok: false, error: error.message }),
+                onSuccess: (value) => ({ ok: true, value }),
+            }))
+            : { ok: true, value: rawInput };
+        if (!validated.ok) {
+            return failed(threadId, validated.error);
+        }
+        const subject = validated.value;
+        if (Object.keys(definition.questions).length === 0) {
+            return failed(threadId, 'Evaluator is missing questions');
+        }
+        const renderState = definition.state;
+        const stateText = renderState
+            ? yield* capture(() => renderState(subject))
+            : { ok: true, value: stringifyJson(subject) };
+        if (!stateText.ok) {
+            return failed(threadId, stateText.error);
+        }
+        const events = [
+            {
+                type: 'evaluator.requested',
+                payload: {
+                    evaluationId: input.evaluationId,
+                    definitionName: input.definitionName,
+                    state: stateText.value,
+                    model: definition.model,
+                },
+                threadId,
+            },
+        ];
+        const skipModel = definition.skipModel;
+        const skipped = skipModel
+            ? yield* capture(() => skipModel(subject))
+            : { ok: true, value: undefined };
+        if (!skipped.ok) {
+            return failed(threadId, skipped.error);
+        }
+        let answers = {};
+        let usage;
+        let decision = { route: 'continue', reason: 'unavailable' };
+        if (skipped.value) {
+            answers = skipped.value.answers ?? {};
+            decision = { route: skipped.value.route, reason: skipped.value.reason };
+        }
+        else {
+            const evaluated = yield* evaluator
+                .evaluate({
+                model: definition.model,
+                state: stateText.value,
+                questions: definition.questions,
+            })
+                .pipe(Effect.match({
+                onFailure: () => ({ ok: false }),
+                onSuccess: (value) => ({ ok: true, value }),
+            }));
+            if (evaluated.ok) {
+                answers = evaluated.value.answers;
+                usage = evaluated.value.usage;
+                const route = definition.route;
+                if (route) {
+                    const routed = yield* capture(() => route({ answers, input: subject }));
+                    if (!routed.ok) {
+                        return failed(threadId, routed.error);
+                    }
+                    decision = { route: routed.value.route, reason: routed.value.reason ?? 'model' };
+                }
+                else {
+                    decision = { route: 'continue', reason: 'model' };
+                }
+            }
+        }
+        events.push({
+            type: 'evaluator.evaluated',
+            payload: {
+                evaluationId: input.evaluationId,
+                definitionName: input.definitionName,
+                answers,
+                route: decision.route,
+                reason: decision.reason,
+                usage,
+            },
+            threadId,
+        });
+        return events;
+    }),
+});

package/dist/evaluator/evaluator.d.ts

@@ -0,0 +1,24 @@
+import { Context, Effect, Layer } from 'effect';
+import type { EvaluatorAdapter } from './types';
+declare const EvaluatorError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "EvaluatorError";
+} & Readonly<A>;
+export declare class EvaluatorError extends EvaluatorError_base<{
+    readonly cause: unknown;
+    readonly message: string;
+}> {
+    constructor(cause: unknown);
+}
+export interface EvaluatorService {
+    readonly evaluate: (args: Parameters<EvaluatorAdapter['evaluate']>[0]) => Effect.Effect<Awaited<ReturnType<EvaluatorAdapter['evaluate']>>, EvaluatorError>;
+}
+export declare function evaluatorFromAdapter(adapter: EvaluatorAdapter): EvaluatorService;
+declare const EvaluatorTag_base: Context.ServiceClass<EvaluatorTag, "looms/Evaluator", EvaluatorService>;
+export declare class EvaluatorTag extends EvaluatorTag_base {
+}
+export interface StubEvaluatorPolicy {
+    evaluate?: EvaluatorAdapter['evaluate'];
+}
+export declare const makeStubEvaluator: (policy?: StubEvaluatorPolicy) => EvaluatorService;
+export declare const StubEvaluatorLive: (policy?: StubEvaluatorPolicy) => Layer.Layer<EvaluatorTag, never, never>;
+export {};

package/dist/evaluator/evaluator.js

@@ -0,0 +1,67 @@
+import { Context, Data, Effect, Layer } from 'effect';
+export class EvaluatorError extends Data.TaggedError('EvaluatorError') {
+    constructor(cause) {
+        super({
+            cause,
+            message: cause instanceof Error ? cause.message : String(cause),
+        });
+        this.name = 'EvaluatorError';
+    }
+}
+export function evaluatorFromAdapter(adapter) {
+    return {
+        evaluate: (args) => Effect.tryPromise({
+            try: () => adapter.evaluate(args),
+            catch: (cause) => new EvaluatorError(cause),
+        }),
+    };
+}
+export class EvaluatorTag extends Context.Service()('looms/Evaluator') {
+}
+function defaultStubEvaluate(args) {
+    const text = args.state.toLowerCase();
+    const high = /\b(error|fail|fatal|dispute|urgent)\b/.test(text);
+    const low = /\b(routine|resolved|duplicate)\b/.test(text);
+    const answers = Object.fromEntries(Object.entries(args.questions).map(([name, question]) => {
+        if (question.type === 'boolean') {
+            return [
+                name,
+                {
+                    type: 'boolean',
+                    value: high,
+                    probability: high ? 0.95 : low ? 0.02 : 0.4,
+                },
+            ];
+        }
+        if (question.type === 'choice') {
+            const allowed = Object.keys(question.criteria);
+            const preferred = high ? ['critical', 'high'] : low ? ['low'] : ['normal'];
+            const value = preferred.find((item) => allowed.includes(item)) ?? allowed[0] ?? 'low';
+            return [
+                name,
+                {
+                    type: 'choice',
+                    value,
+                },
+            ];
+        }
+        return [
+            name,
+            {
+                type: 'score',
+                value: high ? 4 : low ? 0 : 2,
+            },
+        ];
+    }));
+    return {
+        answers,
+        usage: { input: 0, output: 0 },
+    };
+}
+export const makeStubEvaluator = (policy = {}) => ({
+    evaluate: (args) => Effect.tryPromise({
+        try: () => Promise.resolve((policy.evaluate ?? defaultStubEvaluate)(args)),
+        catch: (cause) => new EvaluatorError(cause),
+    }),
+});
+export const StubEvaluatorLive = (policy) => Layer.succeed(EvaluatorTag, makeStubEvaluator(policy));

package/dist/evaluator/events.d.ts

@@ -0,0 +1,59 @@
+import { Schema } from 'effect';
+export declare const EvaluatorRequestedPayloadSchema: Schema.Struct<{
+    readonly evaluationId: Schema.String;
+    readonly definitionName: Schema.optional<Schema.String>;
+    readonly state: Schema.String;
+    readonly model: Schema.optional<Schema.String>;
+}>;
+export type EvaluatorRequested = Schema.Schema.Type<typeof EvaluatorRequestedPayloadSchema>;
+export declare const EvaluatorEvaluatedPayloadSchema: Schema.Struct<{
+    readonly evaluationId: Schema.String;
+    readonly definitionName: Schema.optional<Schema.String>;
+    readonly answers: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"boolean">;
+        readonly value: Schema.Boolean;
+        readonly probability: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"choice">;
+        readonly value: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"score">;
+        readonly value: Schema.Finite;
+    }>]>>;
+    readonly route: Schema.String;
+    readonly reason: Schema.Union<readonly [Schema.Literal<"model">, Schema.Literal<"uncertain">, Schema.Literal<"skipped">, Schema.Literal<"unavailable">]>;
+    readonly usage: Schema.optional<Schema.Struct<{
+        readonly input: Schema.Finite;
+        readonly output: Schema.Finite;
+    }>>;
+}>;
+export type EvaluatorEvaluated = Schema.Schema.Type<typeof EvaluatorEvaluatedPayloadSchema>;
+export declare const evaluatorCatalog: import("@swirls/looms/core").EventCatalog<"evaluator", {
+    requested: Schema.Struct<{
+        readonly evaluationId: Schema.String;
+        readonly definitionName: Schema.optional<Schema.String>;
+        readonly state: Schema.String;
+        readonly model: Schema.optional<Schema.String>;
+    }>;
+    evaluated: Schema.Struct<{
+        readonly evaluationId: Schema.String;
+        readonly definitionName: Schema.optional<Schema.String>;
+        readonly answers: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"boolean">;
+            readonly value: Schema.Boolean;
+            readonly probability: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"choice">;
+            readonly value: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"score">;
+            readonly value: Schema.Finite;
+        }>]>>;
+        readonly route: Schema.String;
+        readonly reason: Schema.Union<readonly [Schema.Literal<"model">, Schema.Literal<"uncertain">, Schema.Literal<"skipped">, Schema.Literal<"unavailable">]>;
+        readonly usage: Schema.optional<Schema.Struct<{
+            readonly input: Schema.Finite;
+            readonly output: Schema.Finite;
+        }>>;
+    }>;
+}>;

package/dist/evaluator/events.js

@@ -0,0 +1,21 @@
+import { Schema } from 'effect';
+import { defineEventCatalog } from '@swirls/looms/core';
+import { EvaluatorAnswersSchema, EvaluatorReasonSchema, EvaluatorRouteSchema, EvaluatorUsageSchema, } from './types.js';
+export const EvaluatorRequestedPayloadSchema = Schema.Struct({
+    evaluationId: Schema.String,
+    definitionName: Schema.optional(Schema.String),
+    state: Schema.String,
+    model: Schema.optional(Schema.String),
+});
+export const EvaluatorEvaluatedPayloadSchema = Schema.Struct({
+    evaluationId: Schema.String,
+    definitionName: Schema.optional(Schema.String),
+    answers: EvaluatorAnswersSchema,
+    route: EvaluatorRouteSchema,
+    reason: EvaluatorReasonSchema,
+    usage: Schema.optional(EvaluatorUsageSchema),
+});
+export const evaluatorCatalog = defineEventCatalog('evaluator', {
+    requested: EvaluatorRequestedPayloadSchema,
+    evaluated: EvaluatorEvaluatedPayloadSchema,
+});

package/dist/evaluator/index.d.ts

@@ -0,0 +1,11 @@
+export * from './types';
+export * from './definitions';
+export * from './definitions-store';
+export * from './events';
+export * from './scope';
+export * from './evaluator';
+export * from './effects';
+export * from './threads';
+export * from './projections';
+export * from './signals';
+export * from './module';

package/dist/evaluator/index.js

@@ -0,0 +1,11 @@
+export * from './types.js';
+export * from './definitions.js';
+export * from './definitions-store.js';
+export * from './events.js';
+export * from './scope.js';
+export * from './evaluator.js';
+export * from './effects.js';
+export * from './threads.js';
+export * from './projections.js';
+export * from './signals.js';
+export * from './module.js';