liminal 0.4.0 → 0.5.1

package/actions/actions_derived/declareModel.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "bun:test"
+import type { LEvent } from "../../events/LEvent.ts"
+import { Exec } from "../../Exec.ts"
+import * as L from "../../L.ts"
+import { TestEmbeddingModel } from "../../testing/TestEmbeddingModel.ts"
+import { TestLanguageModel } from "../../testing/TestLanguageModel.ts"
+
+describe("Model", () => {
+  it("generates the expected event sequence", async () => {
+    const events: Array<LEvent> = []
+    await Exec(function*() {
+      const a = yield* L.declareModel("secondary")
+      yield* L.branch("fork-key", function*() {
+        const b = yield* L.declareModel("child_a")
+        const c = yield* L.declareModel("child_b")
+        yield* b
+        yield* c
+      })
+      const c = yield* L.declareModel("tertiary")
+      yield* a
+      yield* c
+    }, {
+      default: TestLanguageModel(),
+      args: {
+        secondary: TestLanguageModel(),
+        child_a: TestLanguageModel(),
+        child_b: TestEmbeddingModel(),
+        tertiary: TestEmbeddingModel(),
+      },
+    })((event) => events.push(event))
+    expect(JSON.stringify(events, null, 2)).toMatchSnapshot()
+  })
+})

package/actions/actions_derived/declareModel.ts

@@ -0,0 +1,9 @@
+import type { Model } from "../../Model.ts"
+import type { JSONKey } from "../../util/JSONKey.ts"
+import { declareArg } from "../declareArg.ts"
+import { pushModel } from "../pushModel.ts"
+
+export function* declareModel<K extends JSONKey>(key: K) {
+  const model = yield* declareArg(key)<Model>()
+  return yield* pushModel(key, model)
+}

package/actions/actions_derived/declareModel.type-test.ts

@@ -0,0 +1,70 @@
+// import type { RunEmbed, RunInfer } from "../../adapters.ts"
+// import type { ChildEvent } from "../../events/ChildEvent.ts"
+// import type { EmbeddingModelSetEvent } from "../../events/EmbeddingModelSetEvent.ts"
+// import type { LanguageModelSetEvent } from "../../events/LanguageModelSetEvent.ts"
+// import * as L from "../../L.ts"
+// import { ActorAssertions } from "../../testing/ActorAssertions.ts"
+// import { declareEmbeddingModel } from "./declareEmbeddingModel.ts"
+// import { declareLanguageModel } from "./declareLanguageModel.ts"
+
+// const languageModel = declareLanguageModel("A")
+// ActorAssertions(languageModel).assertSpec<{
+//   Entry: ["A", RunInfer]
+//   Event: LanguageModelSetEvent<"A">
+//   Throw: never
+//   Child: never
+// }>()
+
+// const embeddingModel = declareEmbeddingModel("B")
+// ActorAssertions(embeddingModel).assertSpec<{
+//   Entry: ["B", RunEmbed]
+//   Event: EmbeddingModelSetEvent<"B">
+//   Throw: never
+//   Child: never
+// }>()
+
+// function* both() {
+//   yield* languageModel
+//   yield* embeddingModel
+// }
+
+// ActorAssertions(both).assertSpec<{
+//   Entry: ["A", RunInfer] | ["B", RunEmbed]
+//   Event: LanguageModelSetEvent<"A"> | EmbeddingModelSetEvent<"B">
+//   Throw: never
+//   Child: never
+// }>()
+
+// function* parent() {
+//   yield* L.branch("fork-key", {
+//     *key() {
+//       yield* both()
+//     },
+//   })
+//   yield* declareLanguageModel("C")
+//   yield* declareEmbeddingModel("D")
+// }
+
+// ActorAssertions(parent).assertSpec<{
+//   Entry:
+//     | ["A", RunInfer]
+//     | ["B", RunEmbed]
+//     | ["C", RunInfer]
+//     | ["D", RunEmbed]
+//   Event:
+//     | ChildEvent<
+//       "branch",
+//       "fork-key",
+//       ChildEvent<
+//         "branch_arm",
+//         "key",
+//         LanguageModelSetEvent<"A"> | EmbeddingModelSetEvent<"B">,
+//         void
+//       >,
+//       { key: void }
+//     >
+//     | LanguageModelSetEvent<"C">
+//     | EmbeddingModelSetEvent<"D">
+//   Throw: never
+//   Child: never
+// }>()

package/actions/actions_derived/getMessages.ts

@@ -0,0 +1,9 @@
+import { Action } from "../../Action.ts"
+import type { Message } from "../../Message.ts"
+
+export function* getMessages(): Generator<Action<"get_messages">, Array<Message>> {
+  return yield Action("get_messages", (scope) => ({
+    ...scope,
+    nextArg: [...scope.messages],
+  }))
+}

package/actions/actions_derived/messages.test.ts

@@ -0,0 +1,88 @@
+// import { describe, expect, test } from "bun:test"
+// import * as L from "../L.ts"
+// import { takeFirstAction } from "../testing/takeFirstAction.ts"
+
+// describe("message templates", () => {
+//   test("system messages with indentation", async () => {
+//     // Create a system message with indented multiline content
+//     const messageGenerator = L.system`
+//       Hello, I am an AI assistant.
+//       I can help with the following:
+//         - Code generation
+//         - Answering questions
+//         - General assistance
+//     `
+
+//     const action = await takeFirstAction(messageGenerator)
+
+//     expect(action?.message.content).toBe(
+//       "Hello, I am an AI assistant.\nI can help with the following:\n  - Code generation\n  - Answering questions\n  - General assistance",
+//     )
+//   })
+
+//   test("user messages with substitution", async () => {
+//     const name = "John"
+//     const messageGenerator = L.user`Hello, my name is ${name}.`
+
+//     const action = await takeFirstAction(messageGenerator)
+
+//     expect(action?.message.content).toBe("Hello, my name is John.")
+//   })
+
+//   test("user messages with multiline substitution and indentation", async () => {
+//     const codeBlock = "function example() {\n  console.log('Hello');\n}"
+
+//     const messageGenerator = L.user`
+//       Here's my code:
+//         ${codeBlock}
+//       Can you help me understand it?
+//     `
+
+//     const action = await takeFirstAction(messageGenerator)
+
+//     // The code block should get indentation applied to lines after the first
+//     expect(action?.message.content).toBe(
+//       "Here's my code:\n  function example() {\n    console.log('Hello');\n  }\nCan you help me understand it?",
+//     )
+//   })
+
+//   test("assistant messages with multiline substitution", async () => {
+//     const explanation =
+//       "1. First, we declare a function\n2. Then we log a message\n3. The function doesn't return anything"
+
+//     const messageGenerator = L.assistant`
+//       Let me explain:
+//         ${explanation}
+//       Does that help?
+//     `
+
+//     const action = await takeFirstAction(messageGenerator)
+
+//     // The explanation lines should get indentation
+//     expect(action?.message.content).toBe(
+//       "Let me explain:\n  1. First, we declare a function\n  2. Then we log a message\n  3. The function doesn't return anything\nDoes that help?",
+//     )
+//   })
+
+//   test("preserves code indentation", async () => {
+//     const code = `if (condition) {
+//   // This is indented once
+//   if (nestedCondition) {
+//     // This is indented twice
+//   }
+// }`
+
+//     const messageGenerator = L.user`
+//       My code:
+//         ${code}
+//     `
+
+//     const action = await takeFirstAction(messageGenerator)
+
+//     // The code's internal indentation structure should be preserved
+//     // while getting additional indentation from the template
+//     expect(action?.message.content).toBe(
+//       "My code:\n  if (condition) {\n    // This is indented once\n    if (nestedCondition) {\n      // This is indented twice\n    }\n  }",
+//     )
+//   })
+// })

package/actions/actions_derived/messages.ts

@@ -0,0 +1,19 @@
+import type { MessageRemoved } from "../../events/MessageRemoved.ts"
+import type { AssistantContent, UserContent } from "../../Message.ts"
+import { normalizeTaggableArgs, type TaggableArgs } from "../../util/Taggable.ts"
+import { appendMessage } from "../appendMessage.ts"
+
+export function user(...args: TaggableArgs<[content: UserContent]>) {
+  const [content] = normalizeTaggableArgs(...args)
+  return appendMessage("user", content)
+}
+
+export function system(...args: TaggableArgs<[content: string]>) {
+  const [content] = normalizeTaggableArgs(...args)
+  return appendMessage("system", content)
+}
+
+export function assistant(...args: TaggableArgs<[content: AssistantContent]>) {
+  const [content] = normalizeTaggableArgs(...args)
+  return appendMessage("assistant", content)
+}

package/actions/actions_derived/metatype.ts

@@ -0,0 +1,9 @@
+import { fromMetatypeRootDescriptor } from "../../types/Metatype/fromMetatypeDescriptor.ts"
+import { MetatypeRootDescriptor } from "../../types/Metatype/MetatypeDescriptor.ts"
+import type { Falsy } from "../../util/Falsy.ts"
+import type { TaggableArgs } from "../../util/Taggable.ts"
+
+export function* metatype(...args: TaggableArgs<[...description: Array<string | Falsy>]>) {
+  const descriptor = yield* MetatypeRootDescriptor(args.map((e) => typeof e === "string").join("\n"))
+  return fromMetatypeRootDescriptor(descriptor)
+}

package/actions/appendMessage.ts

@@ -0,0 +1,30 @@
+import { Action } from "../Action.ts"
+import type { MessageAppended } from "../events/MessageAppended.ts"
+import type { Message, MessageContents, MessageRole, Messages } from "../Message.ts"
+import type { Spec } from "../Spec.ts"
+import { removeMessage } from "./removeMessage.ts"
+
+export interface appendMessage<M extends Message>
+  extends Action<"append_message", Spec.Make<{ Event: MessageAppended<M> }>>
+{}
+
+export function* appendMessage<R extends MessageRole>(
+  role: R,
+  content: MessageContents[R],
+): Generator<appendMessage<Messages[R]>, Generator<removeMessage, void>> {
+  return yield Action("append_message", (scope) => {
+    const message = {
+      role,
+      content,
+    } as Messages[R] // <-- why isn't this inferred?
+    scope.event({
+      type: "message_appended",
+      message,
+    })
+    return {
+      ...scope,
+      nextArg: removeMessage(message),
+      messages: new Set([...scope.messages, message]),
+    }
+  })
+}

package/actions/await.ts

@@ -0,0 +1,13 @@
+import { Action } from "../Action.ts"
+
+export interface await_<_T> extends Action<"await", never> {}
+
+function* await_<T>(value: T): Generator<await_<Awaited<T>>, Awaited<T>> {
+  return yield Action("await", async (scope) => ({
+    ...scope,
+    nextArg: await value,
+  }))
+}
+Object.defineProperty(await_, "name", { value: "await" })
+
+export { await_ as await }

package/actions/branch.ts

@@ -0,0 +1,108 @@
+import { Action } from "../Action.ts"
+import type {
+  Actor,
+  ActorLike,
+  ActorLikeArray,
+  ActorLikeRecord,
+  ActorLikesT,
+  ActorLikeT,
+  ActorLikeY,
+} from "../Actor.ts"
+import type { ActorLikes } from "../Actor.ts"
+import type { Spec } from "../Spec.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import { unwrapDeferred } from "../util/unwrapDeferred.ts"
+
+export function branch<
+  K extends JSONKey,
+  Y extends Action,
+  T,
+>(
+  key: K,
+  actorLike: ActorLike<Y, T>,
+): Generator<
+  Action<
+    "branch",
+    Spec.Make<{
+      Child: [Y[""]] extends [never] ? never : [K, Y[""]]
+      Entry: Y[""]["Entry"]
+      Value: T
+    }>
+  >,
+  T
+>
+export function branch<K extends JSONKey, const A extends ActorLikeArray>(name: K, actorLikeArray: A): Generator<
+  Action<
+    "branch",
+    Spec.Make<{
+      Child: [
+        K,
+        {
+          [L in keyof A]: Spec.Make<{
+            Child: [L, ActorLikeY<A[L]>[""]]
+            Entry: ActorLikeY<A[L]>[""]["Entry"]
+            Value: ActorLikeT<A[L]>
+          }>
+        }[keyof A],
+      ]
+      Entry: ActorLikeY<A[number]>[""]["Entry"]
+    }>
+  >,
+  ActorLikesT<A>
+>
+export function branch<K extends JSONKey, A extends ActorLikeRecord>(name: K, actorLikeRecord: A): Generator<
+  Action<
+    "branch",
+    Spec.Make<{
+      Child: [
+        K,
+        {
+          [L in Exclude<keyof A, symbol>]: Spec.Make<{
+            Child: [L, ActorLikeY<A[L]>[""]]
+            Entry: ActorLikeY<A[L]>[""]["Entry"]
+            Value: ActorLikeT<A[L]>
+          }>
+        }[Exclude<keyof A, symbol>],
+      ]
+      Entry: ActorLikeY<A[keyof A]>[""]["Entry"]
+    }>
+  >,
+  ActorLikesT<A>
+>
+export function* branch(key: JSONKey, implementation: ActorLike | ActorLikes): Generator<Action<"branch">, any> {
+  return yield Action("branch", async (scope) => {
+    if (typeof implementation === "function") {
+      const branchScope = scope.fork("branch", [key])
+      const actor = unwrapDeferred(implementation as ActorLike)
+      const { value } = await branchScope.reduce(actor)
+      branchScope.event({
+        type: "returned",
+        value,
+      })
+      return {
+        ...scope,
+        nextArg: value,
+      }
+    }
+    const armKeys = Array.isArray(implementation)
+      ? Array.from({ length: implementation.length }, (_0, i) => i)
+      : Reflect.ownKeys(implementation) as Array<string>
+    const values = await Promise.all(armKeys.map(async (armKey) => {
+      const branchArmScope = scope.fork("branch_arm", [key, armKey])
+      const actor = unwrapDeferred(implementation[armKey as never]) as Actor
+      const { value } = await branchArmScope.reduce(actor)
+      branchArmScope.event({
+        type: "returned",
+        value,
+      })
+      return value
+    }))
+    const value = Array.isArray(implementation)
+      ? values
+      : Object.fromEntries(armKeys.map((key, i) => [key, values[i]]))
+    return {
+      ...scope,
+      nextArg: value,
+    }
+  })
+}

package/actions/catch.ts

@@ -0,0 +1,42 @@
+import { Action } from "../Action.ts"
+import type { ActorLike } from "../Actor.ts"
+import type { Spec } from "../Spec.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { Result } from "../util/Result.ts"
+import { unwrapDeferred } from "../util/unwrapDeferred.ts"
+
+export { catch_ as catch }
+function* catch_<K extends JSONKey, Y extends Action, T>(
+  key: K,
+  actorLike: ActorLike<Y, T>,
+): Generator<
+  Action<
+    "catch",
+    Spec.Make<{
+      Child: [K, Y[""]]
+      Value: T
+    }>
+  >,
+  Result<T, Y[""]["Throw"]>
+> {
+  return yield Action("catch", async (scope) => {
+    const catchScope = scope.fork("catch", [key])
+    try {
+      const { value } = await catchScope.reduce(unwrapDeferred(actorLike))
+      catchScope.event({
+        type: "returned",
+        value,
+      })
+      return {
+        ...scope,
+        nextArg: { value },
+      }
+    } catch (thrown: unknown) {
+      return {
+        ...scope,
+        nextArg: { thrown },
+      }
+    }
+  })
+}
+Object.defineProperty(catch_, "name", { value: "catch" })

package/actions/declareArg.ts

@@ -0,0 +1,14 @@
+import { Action } from "../Action.ts"
+import type { Spec } from "../Spec.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+
+export interface declareArg<K extends JSONKey, T> extends Action<"declare_arg", Spec.Make<{ Entry: [K, T] }>> {}
+
+export function declareArg<K extends JSONKey>(key: K): <T>() => Generator<declareArg<K, T>, T> {
+  return function*() {
+    return yield Action("declare_arg", (scope) => ({
+      ...scope,
+      nextArg: scope.args?.[key],
+    }))
+  }
+}

package/actions/disableTool.ts

@@ -0,0 +1,26 @@
+import { Action } from "../Action.ts"
+import type { ToolDisabled } from "../events/ToolDisabled.ts"
+import type { Spec } from "../Spec.ts"
+import type { Tool } from "../Tool.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+
+export interface disableTool<K extends JSONKey> extends Action<"disable_tool", Spec.Make<{ Event: ToolDisabled<K> }>> {}
+
+export function* disableTool<K extends JSONKey>(tool: Tool<K>): Generator<
+  disableTool<K>,
+  void
+> {
+  yield Action("disable_tool", (scope) => {
+    scope.event({
+      type: "tool_disabled",
+      tool: tool.toolKey,
+    })
+    const tools = new Set(scope.tools)
+    tools.delete(tool)
+    return {
+      ...scope,
+      tools,
+      nextArg: undefined,
+    }
+  })
+}

package/actions/embed.ts

@@ -0,0 +1,28 @@
+import { Action } from "../Action.ts"
+import type { Embedded } from "../events/Embedded.ts"
+import type { EmbeddingRequested } from "../events/EmbeddingRequested.ts"
+import type { Spec } from "../Spec.ts"
+import { assert } from "../util/assert.ts"
+
+export interface embed extends Action<"embed", Spec.Make<{ Event: EmbeddingRequested | Embedded }>> {}
+
+export function* embed(value: string): Generator<embed, Array<number>> {
+  return yield Action("embed", async (scope) => {
+    const model = scope.embeddingModels.values().next().value
+    assert(model)
+    scope.event({
+      type: "embedding_requested",
+      value,
+    })
+    const embedding = await model.embed(value)
+    scope.event({
+      type: "embedded",
+      value,
+      embedding,
+    })
+    return {
+      ...scope,
+      nextArg: scope.value,
+    }
+  })
+}

package/actions/emit.ts

@@ -0,0 +1,21 @@
+import { Action } from "../Action.ts"
+import type { Emitted } from "../events/Emitted.ts"
+import type { Spec } from "../Spec.ts"
+import type { JSONValue } from "../util/JSONValue.ts"
+
+export interface emit<V extends JSONValue> extends Action<"emit", Spec.Make<{ Event: Emitted<V> }>> {}
+
+export function* emit<V extends JSONValue = never>(
+  value: V = undefined as never,
+): Generator<emit<V>, void> {
+  return yield Action("emit", (scope) => {
+    scope.event({
+      type: "emitted",
+      value,
+    })
+    return {
+      ...scope,
+      nextArg: undefined,
+    }
+  }) as never
+}

package/actions/enableTool.ts

@@ -0,0 +1,75 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+import { Action } from "../Action.ts"
+import type { Actor } from "../Actor.ts"
+import type { ToolCalled } from "../events/ToolCalled.ts"
+import type { ToolEnabled } from "../events/ToolEnabled.ts"
+import type { Spec } from "../Spec.ts"
+import { Tool, type ToolImplementation, type ToolResult } from "../Tool.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { JSONObject } from "../util/JSONObject.ts"
+import { JSONSchemaMemo } from "../util/JSONSchemaMemo.ts"
+import type { PromiseOr } from "../util/PromiseOr.ts"
+import { disableTool } from "./disableTool.ts"
+
+export function enableTool<K extends JSONKey, A>(
+  key: K,
+  description: string,
+  params: StandardSchemaV1<JSONObject, A>,
+  implementation: (params: A) => PromiseOr<ToolResult>,
+): Generator<
+  Action<
+    "enable_tool",
+    Spec.Make<{
+      Event: ToolEnabled<K> | ToolCalled<K, A>
+    }>
+  >,
+  Generator<disableTool<K>, void>
+>
+export function enableTool<
+  K extends JSONKey,
+  A,
+  Y extends Action,
+  T extends ToolResult,
+>(
+  key: K,
+  description: string,
+  params: StandardSchemaV1<JSONObject, A>,
+  implementation: (params: A) => Actor<Y, T>,
+): Generator<
+  Action<
+    "enable_tool",
+    Spec.Make<{
+      Event: ToolEnabled<K> | ToolCalled<K, A>
+      Child: [K, Y[""]]
+      Entry: Y[""]["Entry"]
+      Value: T
+    }>
+  >,
+  Generator<disableTool<K>, void>
+>
+export function* enableTool(
+  key: JSONKey,
+  description: string,
+  params: StandardSchemaV1<JSONObject, any>,
+  implementation: ToolImplementation,
+): Generator<Action<"enable_tool">, Generator<Action<"disable_tool">, void>> {
+  return yield Action("enable_tool", async (scope) => {
+    scope.event({
+      type: "tool_enabled",
+      description,
+      schema: await JSONSchemaMemo(params),
+      tool: key,
+    })
+    const tool = Tool({
+      toolKey: key,
+      description,
+      params,
+      implementation,
+    })
+    return {
+      ...scope,
+      tools: new Set([...scope.tools, tool]),
+      nextArg: disableTool(tool),
+    }
+  })
+}