liminal 0.17.0 → 0.17.2

package/L/branch.ts

@@ -1,20 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as PubSub from "effect/PubSub"
-import type { LEvent } from "../LEvent.ts"
-import { Thread, ThreadState } from "../Thread.ts"
-import { self } from "./self.ts"
-
-export const branch: Effect.Effect<Thread, never, Thread> = Effect.gen(function*() {
-  const parent = yield* self
-  return Thread({
-    id: parent.id,
-    parent: Option.some(parent),
-    events: yield* PubSub.unbounded<LEvent>(),
-    state: ThreadState.make({
-      system: parent.state.system,
-      messages: [...parent.state.messages ?? []],
-    }),
-    tools: parent.tools.pipe(Option.map((v) => new Set(v))),
-  })
-})

package/L/clear.ts

@@ -1,14 +0,0 @@
-import type { Message } from "@effect/ai/AiInput"
-import * as Effect from "effect/Effect"
-import { ThreadClearedEvent } from "../LEvent.ts"
-import type { Thread } from "../Thread.ts"
-import { self } from "./self.ts"
-
-/** Clear the thread of messages. */
-export const clear: Effect.Effect<Array<Message>, never, Thread> = Effect.gen(function*() {
-  const { state, events } = yield* self
-  const cleared = state.messages
-  state.messages = []
-  yield* events.publish(ThreadClearedEvent.make({ cleared }))
-  return cleared
-})

package/L/disable.ts

@@ -1,13 +0,0 @@
-import * as AiTool from "@effect/ai/AiTool"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import type { Thread } from "../Thread.ts"
-import type { NeverTool } from "../util/NeverTool.ts"
-import { self } from "./self.ts"
-
-export const disable = (tool: AiTool.Any): Effect.Effect<void, never, Thread> =>
-  Effect.map(self, ({ tools }) => {
-    if (Option.isSome(tools)) {
-      tools.value.delete(tool as NeverTool)
-    }
-  })

package/L/enable.ts

@@ -1,24 +0,0 @@
-import type { AiTool, AnyStructSchema, Handler } from "@effect/ai/AiTool"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import type { Schema } from "effect/Schema"
-import type { Thread } from "../Thread.ts"
-import type { NeverTool } from "../util/NeverTool.ts"
-import { self } from "./self.ts"
-
-export const enable = <
-  K extends string,
-  E extends Schema.All,
-  R,
->(
-  tool: AiTool<K, AnyStructSchema, Schema.Any, E, R>,
-): Effect.Effect<void, E, Handler<K> | Thread | R> =>
-  Effect.map(self, (thread) => {
-    const tool_: NeverTool = tool as never
-    Option.match(thread.tools, {
-      onSome: (value) => value.add(tool_),
-      onNone: () => {
-        thread.tools = Option.some(new Set([tool_]))
-      },
-    })
-  })

package/L/events.ts

@@ -1,11 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Stream from "effect/Stream"
-import type { LEvent } from "../LEvent.ts"
-import type { Thread } from "../Thread.ts"
-import { self } from "./self.ts"
-
-/** A stream of thread events. */
-export const events: Stream.Stream<LEvent, never, Thread> = self.pipe(
-  Effect.map(({ events }) => Stream.fromPubSub(events)),
-  Stream.unwrap,
-)

package/L/json.ts

@@ -1,12 +0,0 @@
-import * as Effect from "effect/Effect"
-import type * as Schema from "effect/Schema"
-import { encodeJsonc, type JsonValue } from "../util/JsonValue.ts"
-
-/** Stringify and append some JSON as a user message to the conversation. */
-export const json: <A, I extends JsonValue>(
-  value: A,
-  schema?: Schema.Schema<A, I>,
-) => Effect.Effect<string> = Effect.fnUntraced(function*(value, schema) {
-  const encoded = schema ? encodeJsonc(schema)(value) : JSON.stringify(value, null, 2)
-  return `\`\`\`json${schema ? "c" : ""}\n${encoded}\n\`\`\``
-})

package/L/line.ts

@@ -1,22 +0,0 @@
-import * as Effect from "effect/Effect"
-import { prev } from "./prev.ts"
-
-export interface line<RIn = never, E = never, ROut = never> {
-  <Arg extends Array<Effect.All.EffectAny>>(
-    ...steps: Arg
-  ): 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]> | E,
-    Exclude<Effect.Effect.Context<Arg[number]>, RIn> | ROut
-  >
-}
-export const line: line = Effect.fnUntraced(function*(...steps) {
-  let acc: unknown
-  while (steps.length) {
-    const current = steps.shift()!
-    acc = yield* (current.pipe(Effect.provideService(prev, acc)) as Effect.Effect<any>)
-  }
-  return acc as never
-})

package/L/listen.ts

@@ -1,26 +0,0 @@
-import * as Effect from "effect/Effect"
-import type { RuntimeFiber } from "effect/Fiber"
-import * as Scope from "effect/Scope"
-import * as Stream from "effect/Stream"
-import type { LEvent } from "../LEvent.ts"
-import type { Thread } from "../Thread.ts"
-import { self } from "./self.ts"
-
-/** Attach an event handler to process thread events. */
-export const listen: <A, E, R>(
-  f: (event: LEvent) => Effect.Effect<A, E, R>,
-) => Effect.Effect<RuntimeFiber<void, E>, never, Thread | R | Scope.Scope> = Effect.fnUntraced(function*(f) {
-  const latch = yield* Effect.makeLatch(false)
-  const { events } = yield* self
-  const dequeue = yield* events.subscribe
-  const fiber = yield* latch.open.pipe(
-    Effect.zipRight(
-      Stream.fromQueue(dequeue).pipe(
-        Stream.runForEach(f),
-        Effect.fork,
-      ),
-    ),
-  )
-  yield* latch.await
-  return fiber
-})

package/L/messages.ts

@@ -1,10 +0,0 @@
-import type { Message } from "@effect/ai/AiInput"
-import * as Effect from "effect/Effect"
-import type { Thread } from "../Thread.ts"
-import { self } from "./self.ts"
-
-/** Get a copy of the current list of messages. */
-export const messages: Effect.Effect<Array<Message>, never, Thread> = Effect.map(
-  self,
-  ({ state: { messages: [...messages] } }) => messages,
-)

package/L/prev.ts

@@ -1,4 +0,0 @@
-import * as Context from "effect/Context"
-import { prefix } from "../util/prefix.ts"
-
-export class prev extends Context.Tag(prefix("prev"))<prev, unknown>() {}

package/L/provide.ts

@@ -1,10 +0,0 @@
-import * as Effect from "effect/Effect"
-import type { Thread } from "../Thread.ts"
-import { self } from "./self.ts"
-
-export const provide = <E, R>(
-  thread: Effect.Effect<Thread, E, R>,
-) =>
-<A1, E1, R1>(
-  a: Effect.Effect<A1, E1, R1>,
-): Effect.Effect<A1, E | E1, R | Exclude<R1, Thread>> => Effect.provideServiceEffect(self, thread)(a)

package/L/self.ts

@@ -1,5 +0,0 @@
-import * as Context from "effect/Context"
-import type { Thread } from "../Thread.ts"
-import { prefix } from "../util/prefix.ts"
-
-export const self: Context.Tag<Thread, Thread> = Context.GenericTag<Thread>(prefix("Self"))

package/L/send.ts

@@ -1,56 +0,0 @@
-import * as AiInput from "@effect/ai/AiInput"
-import * as Array from "effect/Array"
-import * as Effect from "effect/Effect"
-import type { YieldWrap } from "effect/Utils"
-import type { Envelope } from "../Envelope.ts"
-import type { Thread } from "../Thread.ts"
-import type { ExtractE, ExtractR } from "../util/extract.ts"
-import { raw } from "../util/raw.ts"
-import { normalize, type TaggableArg0, type TaggableArgRest } from "../util/Taggable.ts"
-import { append } from "./append.ts"
-import { self } from "./self.ts"
-
-export const send = (envelope: Envelope) =>
-  Effect.fnUntraced(function*<
-    A0 extends TaggableArg0,
-    ARest extends TaggableArgRest<A0>,
-  >(
-    a0: A0,
-    ...aRest: ARest
-  ): Generator<
-    YieldWrap<
-      Effect.Effect<
-        void,
-        ExtractE<A0 | ARest[number]>,
-        ExtractR<A0 | ARest[number]> | Thread
-      >
-    >,
-    void,
-    never
-  > {
-    const text = yield* normalize(a0, ...aRest)
-    if (!text) return
-    const { to, cc, bcc } = envelope
-    const ccHeader = cc?.length
-      ? yield* raw`; ${Effect.all(cc).pipe(Effect.map(Array.join(", ")))}`
-      : ""
-    const headers = raw`[FROM: ${self}${ccHeader}]`
-    const knownRecipients = [...to ?? [], ...cc ?? []]
-    const program = append(
-      AiInput.UserMessage.make({
-        parts: [
-          AiInput.TextPart.make({
-            text: `${headers}\n${text}`,
-          }),
-        ],
-      }),
-    )
-    for (const recipient of knownRecipients) {
-      yield* program.pipe(Effect.provideService(self, recipient))
-    }
-    if (bcc?.length) {
-      for (const hiddenRecipient of bcc) {
-        yield* program.pipe(Effect.provideService(self, hiddenRecipient))
-      }
-    }
-  })

package/L/system.ts

@@ -1,25 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import type { YieldWrap } from "effect/Utils"
-import { SystemSetEvent } from "../LEvent.ts"
-import { normalize, type TaggableArg0, type TaggableArgRest } from "../util/Taggable.ts"
-import { self } from "./self.ts"
-
-/** Set the thread's system instruction. */
-export const system = Effect.fnUntraced(function*<
-  A0 extends TaggableArg0,
-  ARest extends TaggableArgRest<A0>,
->(
-  a0: A0,
-  ...aRest: ARest
-): Generator<
-  YieldWrap<typeof self | ReturnType<typeof normalize<A0, ARest>> | Effect.Effect<boolean>>,
-  Option.Option<string>,
-  never
-> {
-  const { state, events } = yield* self
-  const { system } = state
-  state.system = a0 ? Option.some(yield* normalize(a0, ...aRest)) : Option.none()
-  yield* events.publish(new SystemSetEvent({ system: state.system }))
-  return system
-})

package/L/thread.ts

@@ -1,16 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as PubSub from "effect/PubSub"
-import type { LEvent } from "../LEvent.ts"
-import { Thread, ThreadId, ThreadState } from "../Thread.ts"
-import { self } from "./self.ts"
-
-export const thread: Effect.Effect<Thread> = Effect.gen(function*() {
-  return Thread({
-    id: ThreadId.make(crypto.randomUUID()),
-    parent: yield* Effect.serviceOption(self),
-    events: yield* PubSub.unbounded<LEvent>(),
-    state: ThreadState.default(),
-    tools: Option.none(),
-  })
-})

package/L/toolkit.ts

@@ -1,14 +0,0 @@
-import * as AiToolkit from "@effect/ai/AiToolkit"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import type { NeverTool } from "../util/NeverTool.ts"
-import { self } from "./self.ts"
-
-export const toolkit = self.pipe(
-  Effect.flatMap(({ tools }) =>
-    Option.match(tools, {
-      onSome: (tools) => AiToolkit.make(...tools),
-      onNone: () => AiToolkit.make<ReadonlyArray<NeverTool>>(),
-    })
-  ),
-)

package/L/user.test.ts

@@ -1,33 +0,0 @@
-import { TextPart, UserMessage } from "@effect/ai/AiInput"
-import { expect, it } from "@effect/vitest"
-import * as Effect from "effect/Effect"
-import { messages } from "./messages.ts"
-import { provide } from "./provide.ts"
-import { thread } from "./thread.ts"
-import { user } from "./user.ts"
-
-it.effect("test success", () =>
-  Effect.gen(function*() {
-    yield* user`A`
-    yield* user("B")
-    expect(yield* messages).toStrictEqual([
-      UserMessage.make({
-        parts: [
-          TextPart.make({
-            text: "A",
-          }),
-        ],
-      }),
-      UserMessage.make({
-        parts: [
-          TextPart.make({
-            text: "B",
-          }),
-        ],
-      }),
-    ])
-  }).pipe(
-    provide(
-      thread,
-    ),
-  ))

package/L/user.ts

@@ -1,32 +0,0 @@
-import { TextPart, UserMessage } from "@effect/ai/AiInput"
-import * as Effect from "effect/Effect"
-import type { Thread } from "../Thread.ts"
-import type { ExtractE, ExtractR } from "../util/extract.ts"
-import { normalize, type TaggableArg0, type TaggableArgRest } from "../util/Taggable.ts"
-import { append } from "./append.ts"
-
-/** Append a user message to the thread. */
-export const user = <
-  A0 extends TaggableArg0,
-  ARest extends TaggableArgRest<A0>,
->(
-  a0: A0,
-  ...aRest: ARest
-): Effect.Effect<
-  void,
-  ExtractE<A0 | ARest[number]>,
-  ExtractR<A0 | ARest[number]> | Thread
-> =>
-  normalize(a0, ...aRest).pipe(
-    Effect.flatMap((text) =>
-      text
-        ? append(
-          UserMessage.make({
-            parts: [
-              TextPart.make({ text }),
-            ],
-          }),
-        )
-        : Effect.succeed(undefined)
-    ),
-  )

package/LEvent.ts

@@ -1,33 +0,0 @@
-import { Message } from "@effect/ai/AiInput"
-import * as Schema from "effect/Schema"
-
-/** Event in which the thread's system is set to a new string. */
-export class SystemSetEvent extends Schema.TaggedClass<SystemSetEvent>("SystemSetEvent")("system_set", {
-  system: Schema.Option(Schema.String),
-}) {}
-
-/** Event in which one or more messages were added to the thread. */
-export class MessagesAppendedEvent
-  extends Schema.TaggedClass<MessagesAppendedEvent>("MessagesAppendedEvent")("messages_appended", {
-    messages: Schema.Array(Message),
-  })
-{}
-
-/** Event in which the thread is cleared of messages. */
-export class ThreadClearedEvent
-  extends Schema.TaggedClass<ThreadClearedEvent>("MessagesClearedEvent")("messages_cleared", {})
-{}
-
-export type LEvent = typeof LEvent["Type"]
-export const LEvent: Schema.Union<[
-  typeof SystemSetEvent,
-  typeof MessagesAppendedEvent,
-  typeof ThreadClearedEvent,
-]> = Schema.Union(
-  SystemSetEvent,
-  MessagesAppendedEvent,
-  ThreadClearedEvent,
-)
-
-export const encodeLEvent = Schema.encode(LEvent)
-export const decodeLEvent = Schema.decode(LEvent)

package/Thread.ts

@@ -1,67 +0,0 @@
-import { Message } from "@effect/ai/AiInput"
-import * as Brand from "effect/Brand"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as PubSub from "effect/PubSub"
-import * as Schema from "effect/Schema"
-import type { Mutable } from "effect/Types"
-import { line } from "./L/line.ts"
-import { self } from "./L/self.ts"
-import type { LEvent } from "./LEvent.ts"
-import type { NeverTool } from "./util/NeverTool.ts"
-import { prefix } from "./util/prefix.ts"
-
-export const ThreadIdTypeId: unique symbol = Symbol.for(prefix("ThreadNameTypeId"))
-export type ThreadId = string & Brand.Brand<typeof ThreadIdTypeId>
-export const ThreadId: Schema.brand<typeof Schema.String, typeof ThreadIdTypeId> = Schema.String.pipe(
-  Schema.brand(ThreadIdTypeId),
-)
-
-export class ThreadState extends Schema.Class<ThreadState>(prefix("ThreadState"))({
-  /** The system prompt to be passed along to the model. */
-  system: Schema.Option(Schema.String),
-  /** The messages based off of which the model infers the next message. */
-  messages: Schema.Array(Message).pipe(Schema.mutable),
-}) {
-  static default = (): ThreadState =>
-    ThreadState.make({
-      system: Option.none(),
-      messages: [],
-    })
-}
-
-export interface ThreadInit {
-  /** The unique id of the thread. */
-  readonly id: ThreadId
-  /** The parent thread. */
-  readonly parent: Option.Option<Thread>
-  /** The pubsub with which thread-specific events are emitted. */
-  readonly events: PubSub.PubSub<LEvent>
-  /** The state of the current thread. */
-  readonly state: Mutable<ThreadState>
-  /** The tools to be made accessible to the model. */
-  tools: Option.Option<Set<NeverTool>>
-}
-
-export const ThreadTypeId: unique symbol = Symbol.for(prefix("Thread"))
-export type ThreadTypeId = typeof ThreadTypeId
-
-interface ThreadMembers extends ThreadInit {
-  readonly [ThreadTypeId]: ThreadTypeId
-}
-
-/** A conversation isolate. */
-export interface Thread extends line<Thread>, ThreadMembers, Effect.Effect<ThreadId> {}
-
-export const Thread = (init: ThreadInit): Thread => {
-  const members = {
-    [ThreadTypeId]: ThreadTypeId,
-    ...init,
-  } satisfies ThreadMembers
-  const self_ = Object.assign(
-    ((...args) => line(...args).pipe(Effect.provideService(self, self_))) satisfies line<Thread>,
-    Effect.succeed(init.id),
-    members,
-  ) as Thread
-  return self_
-}

package/dist/Digest.d.ts

@@ -1,17 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
-import type { Thread } from "./Thread.ts";
-export declare const DigestTypeId: unique symbol;
-export type DigestTypeId = typeof DigestTypeId;
-export declare const Digest: <const K extends string, A = string, I = string>(key: K, schema?: Schema.Schema<A, I>) => <Self>() => DigestClass<K, A, I, Self>;
-export interface DigestClass<K extends string, A, I, Self> extends Effect.Effect<A, never, Self> {
-    new (_: never): this;
-    readonly Type: A;
-    readonly Encoded: I;
-    readonly [DigestTypeId]: DigestTypeId;
-    readonly key: K;
-    readonly digest: Effect.Effect<void, never, Self>;
-    readonly layer: <E, R>(f: (state: Option.Option<A>, inbox: Thread) => Effect.Effect<A, E, R>) => Layer.Layer<Self, E, Exclude<R, Self | Thread>>;
-}

package/dist/Digest.js

@@ -1,7 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
-import { prefix } from "./util/prefix.js";
-export const DigestTypeId = Symbol.for(prefix("Digest"));
-//# sourceMappingURL=Digest.js.map

package/dist/Digest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Digest.js","sourceRoot":"","sources":["../Digest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAEzC,MAAM,CAAC,MAAM,YAAY,GAAkB,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAA"}

package/dist/Envelope.d.ts

@@ -1,13 +0,0 @@
-import { Thread } from "./Thread.ts";
-export type Envelope = ({
-    to: Array<Thread>;
-    cc?: never;
-} | {
-    to?: never;
-    cc: Array<Thread>;
-} | {
-    to: Array<Thread>;
-    cc: Array<Thread>;
-}) & {
-    bcc?: Array<Thread>;
-};

package/dist/Envelope.js

@@ -1,2 +0,0 @@
-import { Thread } from "./Thread.js";
-//# sourceMappingURL=Envelope.js.map

package/dist/Envelope.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Envelope.js","sourceRoot":"","sources":["../Envelope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA"}

package/dist/F/F.d.ts

@@ -1 +0,0 @@
-export * from "../L/json.ts";

package/dist/F/F.js

@@ -1,2 +0,0 @@
-export * from "../L/json.js";
-//# sourceMappingURL=F.js.map

package/dist/F/F.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"F.js","sourceRoot":"","sources":["../../F/F.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA"}

package/dist/L/L.d.ts

@@ -1,20 +0,0 @@
-export * from "./append.ts";
-export * from "./assistant.ts";
-export * from "./assistantSchema.ts";
-export * from "./assistantStream.ts";
-export * from "./branch.ts";
-export * from "./clear.ts";
-export * from "./disable.ts";
-export * from "./enable.ts";
-export * from "./events.ts";
-export * from "./line.ts";
-export * from "./listen.ts";
-export * from "./messages.ts";
-export * from "./prev.ts";
-export * from "./provide.ts";
-export * from "./self.ts";
-export * from "./send.ts";
-export * from "./system.ts";
-export * from "./thread.ts";
-export * from "./toolkit.ts";
-export * from "./user.ts";

package/dist/L/L.js

@@ -1,21 +0,0 @@
-export * from "./append.js";
-export * from "./assistant.js";
-export * from "./assistantSchema.js";
-export * from "./assistantStream.js";
-export * from "./branch.js";
-export * from "./clear.js";
-export * from "./disable.js";
-export * from "./enable.js";
-export * from "./events.js";
-export * from "./line.js";
-export * from "./listen.js";
-export * from "./messages.js";
-export * from "./prev.js";
-export * from "./provide.js";
-export * from "./self.js";
-export * from "./send.js";
-export * from "./system.js";
-export * from "./thread.js";
-export * from "./toolkit.js";
-export * from "./user.js";
-//# sourceMappingURL=L.js.map

package/dist/L/L.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"L.js","sourceRoot":"","sources":["../../L/L.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,sBAAsB,CAAA;AACpC,cAAc,sBAAsB,CAAA;AACpC,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA;AACzB,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,WAAW,CAAA"}

package/dist/L/append.d.ts

@@ -1,5 +0,0 @@
-import type { Message } from "@effect/ai/AiInput";
-import * as Effect from "effect/Effect";
-import type { Thread } from "../Thread.ts";
-/** Append messages to the thread. */
-export declare const append: (...messages: Array<Message>) => Effect.Effect<void, never, Thread>;

package/dist/L/append.js

@@ -1,10 +0,0 @@
-import * as Effect from "effect/Effect";
-import { MessagesAppendedEvent } from "../LEvent.js";
-import { self } from "./self.js";
-/** Append messages to the thread. */
-export const append = Effect.fnUntraced(function* (...messages) {
-    const { state, events } = yield* self;
-    state.messages.push(...messages);
-    yield* events.publish(MessagesAppendedEvent.make({ messages }));
-});
-//# sourceMappingURL=append.js.map

package/dist/L/append.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"append.js","sourceRoot":"","sources":["../../L/append.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAEpD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAEhC,qCAAqC;AACrC,MAAM,CAAC,MAAM,MAAM,GAEuB,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAC,GAAG,QAAQ;IAC/E,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,IAAI,CAAA;IACrC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAA;IAChC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAA;AACjE,CAAC,CAAC,CAAA"}

package/dist/L/assistant.d.ts

@@ -1,6 +0,0 @@
-import type { AiError } from "@effect/ai/AiError";
-import { AiLanguageModel } from "@effect/ai/AiLanguageModel";
-import * as Effect from "effect/Effect";
-import type { Thread } from "../Thread.ts";
-/** Infer an assistant message and append it to the thread. */
-export declare const assistant: Effect.Effect<string, AiError, AiLanguageModel | Thread>;

package/dist/L/assistant.js

@@ -1,26 +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 { append } from "./append.js";
-import { self } from "./self.js";
-import { toolkit } from "./toolkit.js";
-/** Infer an assistant message and append it to the thread. */
-export const assistant = Effect.gen(function* () {
-    const model = yield* AiLanguageModel;
-    const { state: { system, messages: prompt } } = yield* self;
-    let { text, results } = yield* model.generateText({
-        system: Option.getOrUndefined(system),
-        prompt,
-        toolkit,
-    });
-    // TODO: this shouldn't be necessary. Bug in Effect AI?
-    if (!text.trim()) {
-        text = results.values().next().value?.result;
-    }
-    yield* append(AssistantMessage.make({
-        parts: [TextPart.make({ text })],
-    }));
-    return text;
-});
-//# sourceMappingURL=assistant.js.map

package/dist/L/assistant.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"assistant.js","sourceRoot":"","sources":["../../L/assistant.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;AAEvC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,8DAA8D;AAC9D,MAAM,CAAC,MAAM,SAAS,GAA6D,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IACrG,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,eAAe,CAAA;IACpC,MAAM,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,GAAG,KAAK,CAAC,CAAC,IAAI,CAAA;IAC3D,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC;QAChD,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC;QACrC,MAAM;QACN,OAAO;KACR,CAAC,CAAA;IACF,uDAAuD;IACvD,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;QACjB,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAyB,CAAA;IACjE,CAAC;IACD,KAAK,CAAC,CAAC,MAAM,CACX,gBAAgB,CAAC,IAAI,CAAC;QACpB,KAAK,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;KACjC,CAAC,CACH,CAAA;IACD,OAAO,IAAI,CAAA;AACb,CAAC,CAAC,CAAA"}