liminal 0.5.1 → 0.5.3

package/actions/abort.ts

@@ -1,23 +0,0 @@
-import { Action } from "../Action.ts"
-import type { Aborted } from "../events/Aborted.ts"
-import type { Spec } from "../Spec.ts"
-import type { EnsureNarrow } from "../util/EnsureNarrow.ts"
-
-export interface abort<V> extends Action<"abort", Spec.Make<{ Event: Aborted<V> }>> {}
-
-export function* abort<V>(reason: V, ...[_error]: EnsureNarrow<V>): Generator<
-  abort<V>,
-  never
-> {
-  return (yield (Action("abort", (scope) => {
-    scope.event({
-      type: "aborted",
-      reason,
-    })
-    scope.controller.abort(reason)
-    return {
-      ...scope,
-      nextArg: undefined,
-    }
-  }))) as never
-}

package/actions/actions_common/updateModels.ts

@@ -1,23 +0,0 @@
-import type { EmbeddingModel, LanguageModel, Model } from "../../Model.ts"
-import type { Scope } from "../../Scope.ts"
-import { unreachable } from "../../util/unreachable.ts"
-
-export function applyToModels<M extends Model>(
-  scope: Scope,
-  model: M,
-  f: (initial: Set<M>) => Set<M>,
-): Pick<Scope, "languageModels" | "embeddingModels"> {
-  const initial: Set<M> = (model.type === "language" ? scope.languageModels : scope.embeddingModels) as never
-  const models = f(new Set(initial))
-  return model.type === "language"
-    ? {
-      languageModels: models as Set<LanguageModel>,
-      embeddingModels: scope.embeddingModels,
-    }
-    : model.type === "embedding"
-    ? {
-      languageModels: scope.languageModels,
-      embeddingModels: models as Set<EmbeddingModel>,
-    }
-    : unreachable()
-}

package/actions/actions_derived/__snapshots__/declareModel.test.ts.snap

@@ -1,89 +0,0 @@
-// Bun Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Model generates the expected event sequence 1`] = `
-"[
-  {
-    "scope": [],
-    "index": 0,
-    "type": "model_pushed",
-    "modelKey": "secondary",
-    "modelType": "language"
-  },
-  {
-    "scope": [
-      "fork-key"
-    ],
-    "index": 0,
-    "type": "forked"
-  },
-  {
-    "scope": [
-      "fork-key"
-    ],
-    "index": 0,
-    "type": "model_pushed",
-    "modelKey": "child_a",
-    "modelType": "language"
-  },
-  {
-    "scope": [
-      "fork-key"
-    ],
-    "index": 0,
-    "type": "model_pushed",
-    "modelKey": "child_b",
-    "modelType": "embedding"
-  },
-  {
-    "scope": [
-      "fork-key"
-    ],
-    "index": 0,
-    "type": "model_removed",
-    "modelKey": "child_a",
-    "modelType": "language"
-  },
-  {
-    "scope": [
-      "fork-key"
-    ],
-    "index": 0,
-    "type": "model_removed",
-    "modelKey": "child_b",
-    "modelType": "embedding"
-  },
-  {
-    "scope": [
-      "fork-key"
-    ],
-    "index": 0,
-    "type": "returned"
-  },
-  {
-    "scope": [],
-    "index": 0,
-    "type": "model_pushed",
-    "modelKey": "tertiary",
-    "modelType": "embedding"
-  },
-  {
-    "scope": [],
-    "index": 0,
-    "type": "model_removed",
-    "modelKey": "secondary",
-    "modelType": "language"
-  },
-  {
-    "scope": [],
-    "index": 0,
-    "type": "model_removed",
-    "modelKey": "tertiary",
-    "modelType": "embedding"
-  },
-  {
-    "scope": [],
-    "index": 0,
-    "type": "returned"
-  }
-]"
-`;

package/actions/actions_derived/clear.ts

@@ -1,6 +0,0 @@
-import { setMessages } from "../../actions/setMessages.ts"
-import type { MessagesSet } from "../../events/MessagesSet.ts"
-
-export function clear() {
-  return setMessages(() => [])
-}

package/actions/actions_derived/declareModel.test.ts

@@ -1,33 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,70 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

@@ -1,88 +0,0 @@
-// 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

@@ -1,19 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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
-}