liminal 0.12.2 → 0.14.0

package/util/JsonValue.ts

@@ -1,3 +1,6 @@
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as Option from "effect/Option"
 import * as Schema from "effect/Schema"
 import * as SchemaAST from "effect/SchemaAST"
 
@@ -7,10 +10,10 @@ export type JsonValueArray = Array<JsonValue> | ReadonlyArray<JsonValue>
 
 export type JsonValueObject = { [key: string]: JsonValue }
 
-export const encodeJsonc: <A, I extends JsonValue>(schema: Schema.Schema<A, I>) => (value: A) => string = (
-  schema,
-) => {
-  const encoder = encodeAstJsonc(SchemaAST.encodedAST(schema.ast))
+export const encodeJsonc: <A, I extends JsonValue>(
+  schema: Schema.Schema<A, I>,
+) => (value: A) => Effect.Effect<string> = (schema) => {
+  const encoder = encodeAst(SchemaAST.encodedBoundAST(schema.ast))
   return (value) => encoder(value, new EncodeJsoncContext(0))
 }
 
@@ -26,72 +29,116 @@ class EncodeJsoncContext {
 
   next = () => new EncodeJsoncContext(this.depth + 1)
 
-  comment = (type: SchemaAST.AST): string => {
-    const description = extractAnnotation(type)?.trim()
-    if (description) {
-      return `// ${description}\n${this.childIndentation}`
-    }
-    return ""
-  }
+  comment = (type: SchemaAST.AST): string =>
+    Option.match(SchemaAST.getDescriptionAnnotation(type), {
+      onSome: (v) => {
+        v = v.trim()
+        if (v) {
+          return `// ${v}\n${this.childIndentation}`
+        }
+        return ""
+      },
+      onNone: () => "",
+    })
 }
 
-const encodeAstJsonc: (ast: SchemaAST.AST) => (value: unknown, ctx: EncodeJsoncContext) => string = (ast) => {
+const encodeAst: (
+  ast: SchemaAST.AST,
+  refinement?: SchemaAST.Refinement,
+) => (value: unknown, ctx: EncodeJsoncContext) => Effect.Effect<string> = (ast, refinement) => {
   switch (ast._tag) {
     case "TypeLiteral": {
-      return (value, ctx) => {
-        const props = ast.propertySignatures
-          .map(({ name, type }) => {
-            if (typeof name === "symbol") throw 0
-
-            const child = encodeAstJsonc(type)((value as never)[name], ctx.next())
-            return `${ctx.comment(type)}${name}: ${child}`
-          })
-          .join(`,\n${ctx.childIndentation}`)
+      return Effect.fnUntraced(function*(value, ctx) {
+        const props = yield* Effect.all(
+          ast.propertySignatures.map(
+            Effect.fnUntraced(function*({ name, type }) {
+              if (typeof name === "symbol") throw 0
+              const child = yield* encodeAst(type)((value as never)[name], ctx.next())
+              return `${ctx.comment(refinement ?? type)}${name}: ${child}`
+            }),
+          ),
+        ).pipe(
+          Effect.map((v) => v.join(`,\n${ctx.childIndentation}`)),
+        )
         return `{\n${ctx.childIndentation}${props}\n${ctx.indentation}}`
-      }
+      })
     }
     case "StringKeyword": {
-      return (value) => `"${value}"`
+      return (value) => Effect.succeed(`"${value}"`)
     }
+    case "BooleanKeyword":
     case "NumberKeyword": {
-      return (value) => `${value}`
+      return (value) => Effect.succeed(String(value))
+    }
+    case "Refinement": {
+      return encodeAst(ast.from, refinement ?? ast)
+    }
+    case "UnknownKeyword":
+    case "AnyKeyword": {
+      return (value, ctx) =>
+        Effect.succeed(
+          JSON
+            .stringify(value, null, 2)
+            .split("\n")
+            .map((line, i) => i ? ctx.indentation.concat(line) : line)
+            .join("\n"),
+        )
+    }
+    case "Union": {
+      const { types } = ast
+      const guards = types.map((ast) =>
+        pipe(
+          ast,
+          Schema.make,
+          Schema.is,
+        )
+      )
+      return (value, ctx) => {
+        for (let i = 0; i < types.length; i++) {
+          const guard = guards[i]!
+          if (guard(value)) {
+            return encodeAst(types[i]!)(value, ctx)
+          }
+        }
+        throw 0
+      }
     }
     case "Literal": {
       const { literal } = ast
-      if (typeof literal === "string") {
-        return () => `"${literal}"`
-      }
-      if (typeof literal === "number" || typeof literal === "boolean") {
-        return () => String(literal)
-      }
-      if (literal === null) {
-        return () => "null"
-      }
-      throw 0
+      const v = (() => {
+        switch (typeof literal) {
+          case "boolean":
+          case "number": {
+            return String(literal)
+          }
+          case "string": {
+            return `"${literal}"`
+          }
+        }
+        if (literal === null) {
+          return "null"
+        }
+        console.log({ literal })
+        throw 0
+      })()
+      return () => Effect.succeed(v)
     }
     case "TupleType": {
       const { elements, rest } = ast
-      return (value, ctx) => {
-        const e = (elements.length ? elements : rest).map((element, i) => {
-          const child = encodeAstJsonc(element.type)((value as never)[i]!, ctx.next())
-          return `${ctx.comment(element.type)}${child}`
-        }).join(`,\n${ctx.childIndentation}`)
-        return `[\n${ctx.childIndentation}${e}\n${ctx.indentation}]`
-      }
+      return (value, ctx) =>
+        Effect.all((elements.length ? elements : rest).map(
+          Effect.fnUntraced(function*(element, i) {
+            const child = yield* encodeAst(element.type)((value as never)[i]!, ctx.next())
+            return `${ctx.comment(refinement ?? element.type)}${child}`
+          }),
+        )).pipe(
+          Effect.map((v) => `[\n${ctx.childIndentation}${v.join(`,\n${ctx.childIndentation}`)}\n${ctx.indentation}]`),
+        )
     }
-  }
-  console.log(ast._tag)
-  throw 0
-}
-
-const extractAnnotation = ({ annotations }: SchemaAST.AST): string | undefined => {
-  if (SchemaAST.JSONSchemaAnnotationId in annotations) {
-    const jsonSchemaAnnotations = annotations[SchemaAST.JSONSchemaAnnotationId] as
-      | SchemaAST.Annotations
-      | undefined
-    if (jsonSchemaAnnotations) {
-      return jsonSchemaAnnotations.description as string
+    case "Suspend": {
+      return encodeAst(ast.f())
     }
   }
-  return
+  console.log({ ast })
+  throw 0
 }

package/util/Sequence.ts

@@ -1,9 +1,11 @@
-import type { Effect } from "effect/Effect"
+import type * as Effect from "effect/Effect"
 
-export type Sequence<I = never, O = never> = <Arg extends Array<Effect<any, any, any>>>(
+export type Sequence<I = never, O = never> = <Arg extends Array<Effect.All.EffectAny>>(
   ...steps: Arg
-) => Effect<
-  Arg extends [] ? void : Arg extends [...infer _0, infer L extends Effect<any, any, any>] ? Effect.Success<L> : never,
-  Effect.Error<Arg[number]>,
-  Exclude<Effect.Context<Arg[number]>, I> | O
+) => Effect.Effect<
+  Arg extends [] ? void
+    : Arg extends [...infer _0, infer L extends Effect.All.EffectAny] ? Effect.Effect.Success<L>
+    : never,
+  Effect.Effect.Error<Arg[number]>,
+  Exclude<Effect.Effect.Context<Arg[number]>, I> | O
 >

package/util/Taggable.ts

@@ -1,12 +1,8 @@
 import * as Effect from "effect/Effect"
+import { normalizeRaw } from "./fixRaw.ts"
 
-/** Append a user message to the conversation. */
 export type Taggable<A, E, R> = <L extends Array<unknown>, E1 = never, R1 = never>(
-  template?:
-    | TemplateStringsArray
-    | string
-    | Effect.Effect<string | undefined, E1, R1>
-    | undefined,
+  template?: TaggableArg0 | Effect.Effect<string | undefined, E1, R1>,
   ...substitutions: L
 ) => Effect.Effect<
   A,
@@ -14,34 +10,31 @@ export type Taggable<A, E, R> = <L extends Array<unknown>, E1 = never, R1 = neve
   ([ExtractEffect<L>] extends [never] ? never : Effect.Effect.Context<ExtractEffect<L>>) | R | R1
 >
 
+export type TaggableArg0 = TemplateStringsArray | string | undefined
+
 type ExtractEffect<T extends Array<unknown>> = Extract<T[number], Effect.All.EffectAny>
 
 export const normalize: <
-  A0 extends
-    | TemplateStringsArray
-    | string
-    | Effect.Effect<string | undefined, any, any>
-    | undefined,
+  A0 extends TaggableArg0 | Effect.Effect<string | undefined, any, any>,
   L extends Array<unknown>,
 >(
   a0: A0,
-  ...aRest: L
-) => Effect.Effect<string | (undefined extends A0 ? undefined : never)> = Effect.fnUntraced(function*(a0, ...aRest) {
-  let a0_: TemplateStringsArray | string | undefined
-  if (Effect.isEffect(a0)) {
-    a0_ = yield* a0 as Effect.Effect<TemplateStringsArray | string | undefined>
-  } else {
-    a0_ = a0
-  }
+  aRest: L,
+) => Effect.Effect<string | (undefined extends A0 ? undefined : never)> = Effect.fnUntraced(function*(a0, aRest) {
+  const a0_: TaggableArg0 = Effect.isEffect(a0)
+    ? yield* a0 as Effect.Effect<TaggableArg0>
+    : a0
   if (!a0_) return undefined as never
   const aRest_ = yield* Effect.all(
-    aRest.map((v) => Effect.isEffect(v) ? v : Effect.succeed(v)),
-  ) as never as Effect.Effect<Array<unknown>>
-  if (typeof a0_ === "string") {
-    if (aRest_.length === 0) {
-      return a0_
-    }
-    return [a0_, ...aRest_].join("")
-  }
-  return String.raw(a0_, ...aRest)
+    aRest.map((v) =>
+      Effect.isEffect(v)
+        ? v
+        : Effect.succeed(v)
+    ),
+  ) as Effect.Effect<Array<unknown>>
+  return typeof a0_ === "string"
+    ? aRest_.length === 0
+      ? a0_
+      : [a0_, ...aRest_].join("")
+    : normalizeRaw(a0_, aRest_)
 })

package/util/fixRaw.ts

@@ -0,0 +1,93 @@
+const LEADING_SPACE_RE = /^([ \t]*)/
+const INDENTATION_RE = /^\n([ \t]+)/
+const ESCAPE_SEQ_RE = /\\([`${\\]|\n)/g
+const LAST_INDENTATION_RE = /\n[ \t]+$/
+
+export const normalizeRaw = (strings: TemplateStringsArray, values: Array<unknown>): string => {
+  const fixedStrings = normalizeTemplateStrings(strings)
+  const rawArr = fixedStrings.raw
+  const valuesLength = values.length
+
+  const resultParts = new Array(Math.max(1, rawArr.length * 2 - 1))
+  let resultIndex = 0
+
+  for (let i = 0; i < rawArr.length; i++) {
+    const str = rawArr[i] || ""
+    resultParts[resultIndex++] = str
+
+    // Only process values for non-final segments.
+    if (i < valuesLength) {
+      const value = String(values[i])
+
+      // If value has line breaks, we should indent it.
+      if (value.includes("\n")) {
+        const lastNewlineIndex = str.lastIndexOf("\n")
+
+        if (lastNewlineIndex !== -1) {
+          // Extract the indentation after the last newline.
+          const textAfterLastNewline = str.substring(lastNewlineIndex + 1)
+          const leadingSpaceMatch = LEADING_SPACE_RE.exec(textAfterLastNewline)
+          const indentationToApply = leadingSpaceMatch && leadingSpaceMatch[1] ? leadingSpaceMatch[1] : ""
+
+          if (indentationToApply) {
+            // Split the value into lines once.
+            const lines = value.split("\n")
+            const linesLength = lines.length
+
+            // First line doesn't need indentation.
+            resultParts[resultIndex++] = lines[0]
+
+            // Apply indentation to subsequent lines.
+            for (let j = 1; j < linesLength; j++) {
+              resultParts[resultIndex++] = "\n" + indentationToApply + lines[j]
+            }
+            continue
+          }
+        }
+      }
+      // For simple values or when no indentation is needed.
+      resultParts[resultIndex++] = value
+    }
+  }
+
+  // Combine all parts at once
+  return resultParts.slice(0, resultIndex).join("")
+}
+
+export const normalizeTemplateStrings = (template: TemplateStringsArray): {
+  readonly raw: ReadonlyArray<string>
+} => {
+  const leadingIndentMatch = INDENTATION_RE.exec(template.raw[0]!)
+  const indentation = leadingIndentMatch?.[1]
+
+  const rawLength = template.raw.length
+  const raw = new Array(rawLength)
+
+  for (let i = 0; i < rawLength; i++) {
+    let str = template.raw[i]!
+    // Only perform common indentation replacements if needed.
+    if (indentation) {
+      // Remove leading newline and indentation in the first segment.
+      if (i === 0) {
+        str = str.slice(indentation.length + 1)
+      }
+      // Use a simple string replacement with a regular expression for better performance.
+      str = str.replaceAll(`\n${indentation}`, "\n")
+    }
+
+    // Replace common escape sequences in a single pass.
+    str = str.replace(ESCAPE_SEQ_RE, (_match, char) => {
+      // Keep the escaped newline replacement separate for clarity.
+      return char === "\n" ? "" : char
+    })
+
+    // Handle trailing spaces only for the last segment.
+    if (indentation && i === rawLength - 1) {
+      str = str.replace(LAST_INDENTATION_RE, "")
+    }
+
+    raw[i] = str
+  }
+
+  return { raw }
+}

package/assistantStruct.ts

@@ -1,34 +0,0 @@
-import type { AiError } from "@effect/ai/AiError"
-import { AssistantMessage, TextPart } from "@effect/ai/AiInput"
-import { AiLanguageModel } from "@effect/ai/AiLanguageModel"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as Schema from "effect/Schema"
-import { append } from "./append.ts"
-import { Strand } from "./Strand.ts"
-
-/** Infer a structured assistant message and append its JSON representation to the conversation. */
-export const assistantStruct: {
-  <F extends Record<string, Schema.Schema.AnyNoContext>>(
-    fields: F,
-  ): Effect.Effect<{ [K in keyof F]: Schema.Schema.Type<F[K]> }, AiError, AiLanguageModel | Strand>
-  <O, I extends Record<string, unknown>>(
-    schema: Schema.Schema<O, I, never>,
-  ): Effect.Effect<O, AiError, AiLanguageModel | Strand>
-} = Effect.fnUntraced(
-  function*(schema) {
-    const model = yield* AiLanguageModel
-    const { system, messages } = yield* Strand
-    const { value, text } = yield* model.generateObject({
-      system: Option.getOrUndefined(system),
-      schema: Schema.isSchema(schema) ? schema as Schema.Schema.AnyNoContext : Schema.Struct(schema),
-      prompt: messages,
-    })
-    yield* append(
-      new AssistantMessage({
-        parts: [new TextPart({ text })],
-      }),
-    )
-    return value
-  },
-)

package/dist/assistantStruct.js

@@ -1,22 +0,0 @@
-import { AssistantMessage, TextPart } from "@effect/ai/AiInput";
-import { AiLanguageModel } from "@effect/ai/AiLanguageModel";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
-import { append } from "./append.js";
-import { Strand } from "./Strand.js";
-/** Infer a structured assistant message and append its JSON representation to the conversation. */
-export const assistantStruct = Effect.fnUntraced(function* (schema) {
-    const model = yield* AiLanguageModel;
-    const { system, messages } = yield* Strand;
-    const { value, text } = yield* model.generateObject({
-        system: Option.getOrUndefined(system),
-        schema: Schema.isSchema(schema) ? schema : Schema.Struct(schema),
-        prompt: messages,
-    });
-    yield* append(new AssistantMessage({
-        parts: [new TextPart({ text })],
-    }));
-    return value;
-});
-//# sourceMappingURL=assistantStruct.js.map

package/dist/assistantStruct.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"assistantStruct.js","sourceRoot":"","sources":["../assistantStruct.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAC5D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEpC,mGAAmG;AACnG,MAAM,CAAC,MAAM,eAAe,GAOxB,MAAM,CAAC,UAAU,CACnB,QAAQ,CAAC,EAAC,MAAM;IACd,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,eAAe,CAAA;IACpC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC,CAAC,MAAM,CAAA;IAC1C,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC;QAClD,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC;QACrC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAoC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;QAC9F,MAAM,EAAE,QAAQ;KACjB,CAAC,CAAA;IACF,KAAK,CAAC,CAAC,MAAM,CACX,IAAI,gBAAgB,CAAC;QACnB,KAAK,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;KAChC,CAAC,CACH,CAAA;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CACF,CAAA"}