liminal 0.5.2 → 0.5.4

package/actions/catch.ts

@@ -1,42 +0,0 @@
-import { Action } from "../Action.ts"
-import type { AgentLike } from "../Agent.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,
-  agentLike: AgentLike<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(agentLike))
-      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,29 +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"
-import { peekLast } from "../util/peekLast.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 = peekLast(scope.embeddingModels)
-    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
-}

package/actions/enableTool.ts

@@ -1,75 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import { Action } from "../Action.ts"
-import type { Agent } from "../Agent.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) => Agent<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),
-    }
-  })
-}

package/actions/enableTool.type-test.ts

@@ -1,118 +0,0 @@
-import type { AssertTrue, IsExact } from "conditional-type-checks"
-import type { AgentLike } from "../Agent.ts"
-import type { Emitted } from "../events/Emitted.ts"
-import type { ToolCalled } from "../events/ToolCalled.ts"
-import type { ToolDisabled } from "../events/ToolDisabled.ts"
-import type { ToolEnabled } from "../events/ToolEnabled.ts"
-import * as L from "../L.ts"
-import { AgentAssertions } from "../testing/AgentAssertions.ts"
-import { emit } from "./emit.ts"
-import { enableTool } from "./enableTool.ts"
-
-type P = typeof P["T"]
-const P = L.object({
-  a: L.string,
-  b: L.string,
-})
-
-const arrowTool = L.enableTool("Tool", "", P, (params) => {
-  type _ = [AssertTrue<IsExact<typeof params, P>>]
-})
-
-AgentAssertions(arrowTool).assertSpec<{
-  Event:
-    | ToolEnabled<"Tool">
-    | ToolCalled<"Tool", {
-      a: string
-      b: string
-    }>
-  Child: never
-  Throw: never
-  Entry: never
-  Value: never
-}>()
-
-function* _0() {
-  const detach = yield* arrowTool
-  AgentAssertions(detach).assertSpec<{
-    Event: ToolDisabled<"Tool">
-    Child: never
-    Throw: never
-    Entry: never
-    Value: never
-  }>()
-}
-
-const genTool = enableTool("tool-key", "", P, function*(params) {
-  type _ = [AssertTrue<IsExact<typeof params, P>>]
-  yield* emit("Test")
-  return ""
-})
-
-AgentAssertions(genTool).assertSpec<{
-  Event:
-    | ToolEnabled<"tool-key">
-    | ToolCalled<"tool-key", {
-      a: string
-      b: string
-    }>
-  Child: ["tool-key", {
-    Event: Emitted<"Test">
-    Child: never
-    Throw: never
-    Entry: never
-    Value: never
-  }]
-  Throw: never
-  Entry: never
-  Value: string
-}>()
-
-function* parent() {
-  yield* L.enableTool("parent-tool", "", P, () => {})
-  yield* L.branch("fork-key", {
-    *"arm-key"() {
-      yield* arrowTool
-    },
-  })
-}
-
-type g = typeof parent extends AgentLike<infer Y> ? Y[""] : never
-
-AgentAssertions(parent).assertSpec<
-  {
-    Event:
-      | ToolEnabled<"parent-tool">
-      | ToolCalled<"parent-tool", {
-        a: string
-        b: string
-      }>
-    Child: never
-    Throw: never
-    Entry: never
-    Value: never
-  } | {
-    Event: never
-    Child: ["fork-key", {
-      Event: never
-      Child: ["arm-key", {
-        Event:
-          | ToolEnabled<"Tool">
-          | ToolCalled<"Tool", {
-            a: string
-            b: string
-          }>
-        Child: never
-        Throw: never
-        Entry: never
-        Value: never
-      }]
-      Throw: never
-      Entry: never
-      Value: void
-    }]
-    Throw: never
-    Entry: never
-    Value: never
-  }
->()

package/actions/infer.ts

@@ -1,49 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import { Action } from "../Action.ts"
-import type { InferenceRequested } from "../events/InferenceRequested.ts"
-import type { Inferred } from "../events/Inferred.ts"
-import type { Spec } from "../Spec.ts"
-import type { JSONObject } from "../util/JSONObject.ts"
-import type { JSONValue } from "../util/JSONValue.ts"
-import { peekLast } from "../util/peekLast.ts"
-
-export { infer_ as infer }
-
-interface infer_<_T> extends
-  Action<
-    "infer",
-    Spec.Make<{
-      Event: InferenceRequested | Inferred
-    }>
-  >
-{}
-
-const infer_ = Object.assign(
-  function* infer_<T extends JSONValue>(type: StandardSchemaV1<JSONObject, T>): Generator<infer_<T>, T> {
-    return yield* impl(type)
-  },
-  {
-    *[Symbol.iterator](): Iterator<infer_<string>, string> {
-      return yield* impl()
-    },
-  },
-)
-Object.defineProperty(infer_, "name", { value: "infer" })
-
-function* impl(type?: StandardSchemaV1<JSONObject, any>): Generator<infer_<any>, any> {
-  return yield Action("infer", async (scope) => {
-    scope.event({
-      type: "inference_requested",
-    })
-    const model = peekLast(scope.languageModels)!
-    scope = await scope.reduce(model.infer(type))
-    scope.event({
-      type: "inferred",
-      value: scope.value,
-    })
-    return {
-      ...scope,
-      nextArg: scope.value,
-    }
-  })
-}

package/actions/messages.ts

@@ -1,62 +0,0 @@
-import { Action } from "../Action.ts"
-import type { Agent } from "../Agent.ts"
-import type { MessagesSet } from "../events/MessagesSet.ts"
-import type { Message } from "../Message.ts"
-import type { Spec } from "../Spec.ts"
-import { isPropertyKey } from "../util/isPropertyKey.ts"
-import type { JSONKey } from "../util/JSONKey.ts"
-import type { PromiseOr } from "../util/PromiseOr.ts"
-import { type getScope, scope } from "./scope.ts"
-
-interface messages extends Iterable<getScope, Set<Message>> {
-  (messages: Array<Message>): Generator<Action<"set_messages", Spec.Make<{ Event: MessagesSet }>>, Array<Message>>
-  (
-    setter: (messages: Array<Message>) => PromiseOr<Array<Message>>,
-  ): Generator<Action<"set_messages", Spec.Make<{ Event: MessagesSet }>>, Array<Message>>
-  <K extends JSONKey, Y extends Action>(
-    key: K,
-    setter: (messages: Array<Message>) => Agent<Y, void>,
-  ): Generator<
-    Action<
-      "set_messages",
-      Spec.Make<{ Event: MessagesSet; Child: [K, Y[""]]; Entry: Y[""]["Entry"]; Value: Array<Message> }>
-    >,
-    Array<Message>
-  >
-}
-
-export const messages: messages = Object.assign(messages_, {
-  *[Symbol.iterator]() {
-    const scope_ = yield* scope
-    return scope_.messages
-  },
-}) as never
-
-function* messages_(
-  setterOrKey: JSONKey | ((messages: Array<Message>) => PromiseOr<Array<Message>>),
-  maybeSetter?: (messages: Array<Message>) => Agent<Action, void>,
-): Generator<Action<"set_messages">, Array<Message>> {
-  return yield Action("set_messages", async (scope) => {
-    if (isPropertyKey(setterOrKey)) {
-      const setterScope = scope.fork("set_messages", [setterOrKey])
-      const reduced = await setterScope.reduce(maybeSetter!([...scope.messages]))
-      const { messages } = reduced
-      setterScope.event({
-        type: "messages_set",
-        messages: [...messages],
-      })
-      return {
-        ...scope,
-        messages,
-        nextArg: scope.messages,
-      }
-    }
-    const messages = new Set(Array.isArray(setterOrKey) ? setterOrKey : await setterOrKey([...scope.messages]))
-    return {
-      ...scope,
-      messages,
-      nextArg: scope.messages,
-    }
-  })
-}
-Object.defineProperty(messages_, "name", { value: "messages" })

package/actions/pushModel.ts

@@ -1,52 +0,0 @@
-import { Action } from "../Action.ts"
-import type { ModelPushed } from "../events/ModelPushed.ts"
-import type { ModelRemoved } from "../events/ModelRemoved.ts"
-import type { Model, ModelType } from "../Model.ts"
-import type { Spec } from "../Spec.ts"
-import type { JSONKey } from "../util/JSONKey.ts"
-import { applyToModels } from "./actions_common/updateModels.ts"
-
-export interface pushModel<K extends JSONKey, M extends ModelType>
-  extends Action<"remove_model", Spec.Make<{ Event: ModelPushed<K, M> }>>
-{}
-
-export interface removeModel<K extends JSONKey, M extends ModelType>
-  extends Action<"remove_model", Spec.Make<{ Event: ModelRemoved<K, M> }>>
-{}
-
-export function* pushModel<K extends JSONKey, M extends Model>(
-  modelKey: K,
-  model: M,
-): Generator<pushModel<K, M["type"]>, Generator<removeModel<K, M["type"]>, void>> {
-  return yield Action("remove_model", (scope) => {
-    scope.event({
-      type: "model_pushed",
-      modelKey,
-      modelType: model.type,
-    })
-    return {
-      ...scope,
-      ...applyToModels(scope, model, (models) => {
-        models.add(model)
-        return models
-      }),
-      nextArg: (function*(): Generator<removeModel<K, M["type"]>, void> {
-        yield Action("remove_model", (scope) => {
-          scope.event({
-            type: "model_removed",
-            modelKey,
-            modelType: model.type,
-          })
-          return {
-            ...scope,
-            ...applyToModels(scope, model, (models) => {
-              models.delete(model)
-              return models
-            }),
-            nextArg: undefined,
-          }
-        })
-      })(),
-    }
-  })
-}

package/actions/scope.ts

@@ -1,13 +0,0 @@
-import { Action } from "../Action.ts"
-import type { Scope } from "../Scope.ts"
-
-export interface getScope extends Action<"get_scope", never> {}
-
-export const scope = {
-  *[Symbol.iterator](): Iterator<getScope, Scope> {
-    return yield Action("get_scope", (scope) => ({
-      ...scope,
-      nextArg: scope,
-    }))
-  },
-}

package/actions/section.ts

@@ -1,105 +0,0 @@
-import { Action } from "../Action.ts"
-import type { Agent, AgentLike } from "../Agent.ts"
-import type { SectionCleared } from "../events/SectionCleared.ts"
-import type { Sectioned } from "../events/Sectioned.ts"
-import type { Message } from "../Message.ts"
-import type { Section } from "../Scope.ts"
-import type { Spec } from "../Spec.ts"
-import type { JSONKey } from "../util/JSONKey.ts"
-import { unwrapDeferred } from "../util/unwrapDeferred.ts"
-
-export interface section<K extends JSONKey> extends Action<"section", Spec.Make<{ Event: Sectioned<K> }>> {}
-
-export interface SectionHandle<K extends JSONKey> {
-  clear: Generator<Action<"clear_section", Spec.Make<{ Event: SectionCleared<K> }>>, void>
-  getMessages: () => Generator<Action<"get_section_messages", never>, Set<Message>>
-
-  <L extends JSONKey, Y extends Action, T>(key: L, agentLike: AgentLike<Y, T>): Generator<
-    Action<
-      "run_section",
-      Spec.Make<{
-        Child: [L, Y[""]]
-        Entry: Y[""]["Entry"]
-        Value: T
-      }>
-    >,
-    T
-  >
-}
-
-export function* section<K extends JSONKey>(sectionKey: K): Generator<section<K>, SectionHandle<K>> {
-  return yield Action("section", (scope) => {
-    scope.event({
-      type: "sectioned",
-      sectionKey,
-    })
-    const section: Section = {
-      sectionKey,
-      messages: new Set(),
-    }
-    scope.sections.add(section)
-    return {
-      ...scope,
-      nextArg: Object.assign(
-        function*<L extends JSONKey, Y extends Action, T>(key: L, agentLike: AgentLike<Y, T>): Generator<
-          Action<
-            "run_section",
-            Spec.Make<{
-              Child: [L, Y[""]]
-              Entry: Y[""]["Entry"]
-              Value: T
-            }>
-          >,
-          T
-        > {
-          return yield Action("run_section", async (scope) => {
-            const sectionScope = scope.fork("run_section", [key], {
-              messages: new Set(section.messages),
-            })
-            const reduced = await sectionScope.reduce(unwrapDeferred(agentLike))
-            const { value } = reduced
-            sectionScope.event({
-              type: "returned",
-              value,
-            })
-            return {
-              ...scope,
-              nextArg: value,
-            }
-          })
-        },
-        {
-          getMessages: (function*(): Generator<Action<"get_section_messages", never>, Set<Message>> {
-            return yield Action("get_section_messages", (scope) => ({
-              ...scope,
-              nextArg: new Set(section.messages),
-            }))
-          })(),
-        },
-        {
-          clear:
-            (function*(): Generator<Action<"clear_section", Spec.Make<{ Event: SectionCleared<K> }>>, Set<Message>> {
-              return yield Action("clear_section", (scope) => {
-                const sections = new Set(scope.sections)
-                sections.delete(section)
-                const messages = new Set(scope.messages)
-                section.messages.forEach((message) => {
-                  messages.delete(message)
-                })
-                scope.event({
-                  type: "section_cleared",
-                  sectionKey,
-                })
-                return {
-                  ...scope,
-                  nextArg: messages,
-                  sections,
-                  messages,
-                }
-              })
-            })(),
-        },
-      ),
-    }
-  })
-}

package/actions/throw.ts

@@ -1,18 +0,0 @@
-import { Action } from "../Action.ts"
-import type { Spec } from "../Spec.ts"
-import type { EnsureNarrow } from "../util/EnsureNarrow.ts"
-
-export { throw_ as throw }
-
-interface throw_<V> extends Action<"throw", Spec.Make<{ Throw: V }>> {}
-
-function* throw_<V>(value: V, ...[_error]: EnsureNarrow<V>): Generator<throw_<V>, never> {
-  return (yield Action("throw", (scope) => {
-    return {
-      ...scope,
-      thrown: value,
-      nextArg: undefined,
-    }
-  })) as never
-}
-Object.defineProperty(throw_, "name", { value: "throw" })

package/cli/WriteHandler.ts

@@ -1,35 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises"
-import { type ParsedPath, relative, resolve } from "node:path"
-import type { EventResolved } from "../events/EventResolved.ts"
-
-export async function WriteHandler({
-  stateDir,
-  parsedPath,
-  configDir,
-  startTime,
-}: {
-  stateDir: string
-  execId: string | undefined
-  parsedPath: ParsedPath
-  startTime: number
-  configDir: string
-}): Promise<(event: EventResolved) => Promise<void>> {
-  const destDir = resolve(stateDir, relative(configDir, parsedPath.dir), parsedPath.name, startTime.toString())
-  let ensureDir: undefined | PromiseWithResolvers<void>
-  let i = 0
-  return async (event) => {
-    if (!ensureDir) {
-      ensureDir = Promise.withResolvers()
-      ;(async () => {
-        try {
-          await mkdir(destDir, { recursive: true })
-        } catch (_e: unknown) {}
-        ensureDir.resolve()
-      })()
-    }
-    await ensureDir.promise
-    const key = `${i++}__${event.scope.join("__")}__${event.type}.json`
-    const destPath = resolve(destDir, key)
-    await writeFile(destPath, JSON.stringify(event, null, 2), "utf-8")
-  }
-}

package/cli/cli_common.ts

@@ -1,4 +0,0 @@
-export interface CliCtx {
-  ctl: AbortController
-  error(message: string): never
-}