effect-assistant 0.0.0-stage → 0.1.0

package/dist/AssistantEvent.d.ts

@@ -0,0 +1,614 @@
+import { ChatId } from "./ChatId.js";
+import * as Schema from "effect/Schema";
+import * as Response from "effect/ai/Response";
+declare namespace AssistantEvent_d_exports {
+  export { AnyEntry, AppTag, AssistantEvent, AssistantMessage, Attachment, BlockAnswer, BlocksClosed, CallOrigin, ChatDeleted, DecisionOutcome, DecisionRequested, DecisionResolved, Entry, Input, MessageBlock, ModelOutput, ModelPart, SpecialistFinished, SpecialistStarted, StoredAppEvent, ToolCallPart, ToolOutcome, ToolResult, ToolStarted, TurnCompleted, TurnFailed, TurnStarted, UserInput, UserMessage, assistantTexts, attachmentLine, formatSize, isInput, isLibraryEvent, isTurnEnd, isUserInput, isWaking, maxAttachments, textWithAttachments };
+}
+/**
+ * Schema for a file the user attached to a message, kept by reference.
+ *
+ * The file itself is stored elsewhere, so the log never holds its bytes.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Attachment: Schema.Struct<{
+  readonly fileId: Schema.String;
+  readonly name: Schema.String;
+  readonly mediaType: Schema.String;
+  /** In bytes. */
+  readonly size: Schema.Finite;
+}>;
+/**
+ * The maximum number of files one message can carry.
+ *
+ * Each attached file is a line in every prompt after the message.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const maxAttachments = 10;
+/**
+ * Represents a file the user attached to a message.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Attachment = typeof Attachment.Type;
+/**
+ * Formats a byte count for people and the model, such as `2.1 MB`.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const formatSize: (bytes: number) => string;
+/**
+ * Returns the line the model reads for an attachment.
+ *
+ * The line names the file and never holds its content.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const attachmentLine: (attachment: Attachment) => string;
+/**
+ * Returns a message's text followed by a line for each attached file.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const textWithAttachments: (text: string, attachments: ReadonlyArray<Attachment> | undefined) => string;
+declare const UserMessage_base: Schema.Class<UserMessage, Schema.TaggedStruct<"UserMessage", {
+  readonly id: Schema.withConstructorDefault<Schema.brand<Schema.String, "~effect-assistant/InputId">>;
+  readonly text: Schema.String;
+  readonly attachments: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly fileId: Schema.String;
+    readonly name: Schema.String;
+    readonly mediaType: Schema.String;
+    /** In bytes. */
+    readonly size: Schema.Finite;
+  }>>>;
+}>, {}>;
+/**
+ * Represents text the user typed, and the files they attached.
+ *
+ * `id` defaults to a new one. Pass the client's own id so that a retried send stores the message
+ * once.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class UserMessage extends UserMessage_base {}
+declare const BlockAnswer_base: Schema.Class<BlockAnswer, Schema.TaggedStruct<"BlockAnswer", {
+  readonly id: Schema.brand<Schema.String, "~effect-assistant/InputId">;
+  readonly messageId: Schema.String;
+  readonly kind: Schema.String;
+  readonly value: Schema.Unknown;
+}>, {}>;
+/**
+ * Represents the user's answer to a block.
+ *
+ * It holds the id of the message the block was on, and the value in the block's answer schema
+ * (in its JSON form). A chat UI shows it inside the block rather than as a message.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class BlockAnswer extends BlockAnswer_base {}
+declare const SpecialistFinished_base: Schema.Class<SpecialistFinished, Schema.TaggedStruct<"SpecialistFinished", {
+  readonly id: Schema.brand<Schema.String, "~effect-assistant/InputId">;
+  readonly runId: Schema.brand<Schema.TemplateLiteral<readonly ["run:", Schema.String]>, "~effect-assistant/RunId">;
+  readonly specialist: Schema.String;
+  /** Which brief this answers: 1 for the first, then one more per follow-up. */
+  readonly brief: Schema.Int;
+  readonly goal: Schema.String;
+  readonly status: Schema.Literals<readonly ["answered", "failed", "stopped", "cut_off"]>;
+  readonly report: Schema.optional<Schema.String>;
+  readonly error: Schema.optional<Schema.String>;
+}>, {}>;
+/**
+ * Represents a specialist run that finished working on a brief.
+ *
+ * Unless the assistant stopped the run, it is an input, and a turn reads its report and decides
+ * what to tell the user. Its id is fixed per run and brief, so it is stored once.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class SpecialistFinished extends SpecialistFinished_base {}
+/**
+ * Schema for how the user decided, either `"approved"` or `"declined"`.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const DecisionOutcome: Schema.Literals<readonly ["approved", "declined"]>;
+/**
+ * Represents how the user decided.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type DecisionOutcome = typeof DecisionOutcome.Type;
+/**
+ * Schema for the origin of a decision that a tool call waits for.
+ *
+ * It holds the call as the model wrote it. Approving the decision runs exactly this call.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const CallOrigin: Schema.TaggedStruct<"Call", {
+  readonly callId: Schema.String;
+  readonly tool: Schema.String;
+  readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+/**
+ * Represents the origin of a decision that a tool call waits for.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type CallOrigin = typeof CallOrigin.Type;
+declare const DecisionRequested_base: Schema.Class<DecisionRequested, Schema.TaggedStruct<"DecisionRequested", {
+  readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["decision:", Schema.String]>, "~effect-assistant/DecisionId">;
+  readonly origin: Schema.TaggedStruct<"Call", {
+    readonly callId: Schema.String;
+    readonly tool: Schema.String;
+    readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  }>;
+}>, {}>;
+/**
+ * Represents a request for the user to decide something, by approving or declining it.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class DecisionRequested extends DecisionRequested_base {}
+declare const DecisionResolved_base: Schema.Class<DecisionResolved, Schema.TaggedStruct<"DecisionResolved", {
+  readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["decision:", Schema.String]>, "~effect-assistant/DecisionId">;
+  readonly outcome: Schema.Literals<readonly ["approved", "declined"]>;
+  readonly answer: Schema.brand<Schema.String, "~effect-assistant/InputId">;
+}>, {}>;
+/**
+ * Represents a decision the user made by answering a decision block for it.
+ *
+ * `answer` is the id of that `BlockAnswer`. An approved call runs at the turn's next step.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class DecisionResolved extends DecisionResolved_base {}
+/**
+ * Schema for every input `Assistant.submit` accepts.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Input: Schema.Union<readonly [typeof UserMessage, typeof BlockAnswer, typeof SpecialistFinished]>;
+/**
+ * Represents an input to an assistant.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Input = typeof Input.Type;
+/**
+ * Schema for the inputs from the chat's user, which are messages and block answers.
+ *
+ * A turn owes each one a reply. It is also what a chat client usually may submit, since the app's
+ * events come from the server.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const UserInput: Schema.Union<readonly [typeof UserMessage, typeof BlockAnswer]>;
+/**
+ * Represents an input from the chat's user.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type UserInput = typeof UserInput.Type;
+declare const MessageBlock_base: Schema.Class<MessageBlock, Schema.Struct<{
+  readonly kind: Schema.String;
+  readonly props: Schema.Unknown;
+}>, {}>;
+/**
+ * Represents the UI shown with a message, as a block kind from the assistant's `BlockKit` and its
+ * props.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class MessageBlock extends MessageBlock_base {}
+declare const AssistantMessage_base: Schema.Class<AssistantMessage, Schema.TaggedStruct<"AssistantMessage", {
+  readonly id: Schema.String;
+  readonly text: Schema.String;
+  readonly block: Schema.optional<typeof MessageBlock>;
+  /** Earlier messages whose block the user answered by typing instead. Their blocks close. */
+  readonly closes: Schema.optional<Schema.$Array<Schema.String>>;
+}>, {}>;
+/**
+ * Represents a message the assistant sent the user with `send_user_message`, optionally with a
+ * block.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class AssistantMessage extends AssistantMessage_base {}
+/**
+ * Schema for a tool call the model made.
+ *
+ * It is `effect/ai`'s tool call part (`Response.ToolCallPart`) for any tool, with its params in
+ * JSON, as the model wrote them.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ToolCallPart: Schema.Struct<{
+  readonly type: Schema.Literal<"tool-call">;
+  readonly id: Schema.String;
+  readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly providerExecuted: Schema.withDecodingDefaultKey<Schema.Boolean>;
+  readonly "~effect/ai/Response/Part": Schema.withDecodingDefaultKey<Schema.tag<"~effect/ai/Response/Part">>;
+  readonly metadata: Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Codec<Schema.Json>>>;
+  readonly name: Schema.String;
+}>;
+/**
+ * Represents a tool call the model made.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type ToolCallPart = typeof ToolCallPart.Type;
+/**
+ * Schema for what the log keeps of a model call.
+ *
+ * It uses `effect/ai`'s response parts for text, reasoning (with the provider's metadata, such as
+ * a thinking block's signature), and tool calls.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ModelPart: Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.tag<"text">;
+  readonly text: Schema.String;
+  readonly "~effect/ai/Response/Part": Schema.withDecodingDefaultKey<Schema.tag<"~effect/ai/Response/Part">>;
+  readonly metadata: Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Codec<Schema.Json>>>;
+}>, Schema.Struct<{
+  readonly type: Schema.tag<"reasoning">;
+  readonly text: Schema.String;
+  readonly "~effect/ai/Response/Part": Schema.withDecodingDefaultKey<Schema.tag<"~effect/ai/Response/Part">>;
+  readonly metadata: Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Codec<Schema.Json>>>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"tool-call">;
+  readonly id: Schema.String;
+  readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly providerExecuted: Schema.withDecodingDefaultKey<Schema.Boolean>;
+  readonly "~effect/ai/Response/Part": Schema.withDecodingDefaultKey<Schema.tag<"~effect/ai/Response/Part">>;
+  readonly metadata: Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Codec<Schema.Json>>>;
+  readonly name: Schema.String;
+}>]>;
+/**
+ * Represents a part of a model call's output.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type ModelPart = typeof ModelPart.Type;
+declare const ModelOutput_base: Schema.Class<ModelOutput, Schema.TaggedStruct<"ModelOutput", {
+  readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.tag<"text">;
+    readonly text: Schema.String;
+    readonly "~effect/ai/Response/Part": Schema.withDecodingDefaultKey<Schema.tag<"~effect/ai/Response/Part">>;
+    readonly metadata: Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Codec<Schema.Json>>>;
+  }>, Schema.Struct<{
+    readonly type: Schema.tag<"reasoning">;
+    readonly text: Schema.String;
+    readonly "~effect/ai/Response/Part": Schema.withDecodingDefaultKey<Schema.tag<"~effect/ai/Response/Part">>;
+    readonly metadata: Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Codec<Schema.Json>>>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"tool-call">;
+    readonly id: Schema.String;
+    readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly providerExecuted: Schema.withDecodingDefaultKey<Schema.Boolean>;
+    readonly "~effect/ai/Response/Part": Schema.withDecodingDefaultKey<Schema.tag<"~effect/ai/Response/Part">>;
+    readonly metadata: Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Codec<Schema.Json>>>;
+    readonly name: Schema.String;
+  }>]>>;
+  /**
+   * The last entry the model had read when it wrote this. Inputs after it
+   * arrived while the model was working. A turn has handled what its
+   * outputs had read.
+   */
+  readonly seenThroughSeq: Schema.optional<Schema.Int>;
+  /** The model that wrote it, as the provider's id for it or the name the context gave it. */
+  readonly model: Schema.optional<Schema.String>;
+  /** The provider's id for the response, when it gives one. */
+  readonly responseId: Schema.optional<Schema.String>;
+  /** The call's token usage, with input (including the cache's reads and writes) and output. */
+  readonly usage: Schema.optional<typeof Response.Usage>;
+  /** How long the call took, in milliseconds. */
+  readonly durationMillis: Schema.optional<Schema.Finite>;
+}>, {}>;
+/**
+ * Represents what one model call wrote, as response parts for text, reasoning, and tool calls.
+ *
+ * `Prompt.fromResponseParts` turns the parts into history.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class ModelOutput extends ModelOutput_base {}
+declare const ToolStarted_base: Schema.Class<ToolStarted, Schema.TaggedStruct<"ToolStarted", {
+  readonly callId: Schema.String;
+  readonly tool: Schema.String;
+}>, {}>;
+/**
+ * Represents a tool call that is about to run.
+ *
+ * It is stored before the tool runs, so after a crash the log says which calls may have done
+ * something. Those calls run again with the same call id (see `AssistantToolCall`).
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class ToolStarted extends ToolStarted_base {}
+/**
+ * Schema for how a tool call went, either `"success"` or `"failure"`, which the model reads as an
+ * error.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ToolOutcome: Schema.Literals<readonly ["success", "failure"]>;
+/**
+ * Represents how a tool call went.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type ToolOutcome = typeof ToolOutcome.Type;
+declare const ToolResult_base: Schema.Class<ToolResult, Schema.TaggedStruct<"ToolResult", {
+  readonly callId: Schema.String;
+  readonly tool: Schema.String;
+  readonly outcome: Schema.Literals<readonly ["success", "failure"]>;
+  readonly result: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly reason: Schema.optional<Schema.String>;
+}>, {}>;
+/**
+ * Represents the result of one tool call, as the model reads it.
+ *
+ * It holds the tool's success or failure in its encoded (JSON) form, and which of the two it is. A
+ * failure includes its reason when it has one, which is a `ToolFailure`'s `reason` or the
+ * failure's tag.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class ToolResult extends ToolResult_base {}
+declare const TurnStarted_base: Schema.Class<TurnStarted, Schema.TaggedStruct<"TurnStarted", {
+  /** The assistant that runs it. */
+  readonly assistant: Schema.String;
+  /**
+   * The id of the turn's trace, when a tracer records it (not Effect's own, which exports nothing).
+   */
+  readonly traceId: Schema.optional<Schema.String>;
+}>, {}>;
+/**
+ * Represents the start of a turn.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class TurnStarted extends TurnStarted_base {}
+declare const TurnCompleted_base: Schema.Class<TurnCompleted, Schema.TaggedStruct<"TurnCompleted", {
+  readonly throughSeq: Schema.Int;
+}>, {}>;
+/**
+ * Represents a turn that finished.
+ *
+ * `throughSeq` is the last entry the turn read. Inputs after it still need a turn.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class TurnCompleted extends TurnCompleted_base {}
+declare const TurnFailed_base: Schema.Class<TurnFailed, Schema.TaggedStruct<"TurnFailed", {
+  readonly throughSeq: Schema.Int;
+  readonly message: Schema.String;
+}>, {}>;
+/**
+ * Represents a turn that failed.
+ *
+ * `throughSeq` covers everything stored when the turn failed, so a failing input isn't retried
+ * forever.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class TurnFailed extends TurnFailed_base {}
+declare const SpecialistStarted_base: Schema.Class<SpecialistStarted, Schema.TaggedStruct<"SpecialistStarted", {
+  readonly runId: Schema.brand<Schema.TemplateLiteral<readonly ["run:", Schema.String]>, "~effect-assistant/RunId">;
+  readonly specialist: Schema.String;
+  /** The goal it's working on. */
+  readonly goal: Schema.String;
+}>, {}>;
+/**
+ * Represents a specialist run that started working, either spawned or continued by a follow-up
+ * message.
+ *
+ * The model doesn't see it, since the call that started the run says so, and the run's report
+ * arrives as a {@link SpecialistFinished}.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class SpecialistStarted extends SpecialistStarted_base {}
+declare const ChatDeleted_base: Schema.Class<ChatDeleted, Schema.TaggedStruct<"ChatDeleted", {}>, {}>;
+/**
+ * Represents the deletion of a chat.
+ *
+ * The chat stores nothing after it, the work running in the chat stopped, and its subscribers'
+ * streams end here. Its log stays.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class ChatDeleted extends ChatDeleted_base {}
+declare const BlocksClosed_base: Schema.Class<BlocksClosed, Schema.TaggedStruct<"BlocksClosed", {
+  readonly messageIds: Schema.$Array<Schema.String>;
+}>, {}>;
+/**
+ * Represents blocks that closed without an answer, like the ones `BlockKit.closeStale` closes
+ * from a turn once the user moved on.
+ *
+ * The model doesn't see it.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class BlocksClosed extends BlocksClosed_base {}
+/**
+ * Schema for every event the library defines.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const AssistantEvent: Schema.Union<readonly [typeof UserMessage, typeof BlockAnswer, typeof AssistantMessage, typeof ModelOutput, typeof ToolStarted, typeof ToolResult, typeof TurnStarted, typeof TurnCompleted, typeof TurnFailed, typeof SpecialistStarted, typeof SpecialistFinished, typeof BlocksClosed, typeof DecisionRequested, typeof DecisionResolved, typeof ChatDeleted]>;
+/**
+ * Represents an event the library defines.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type AssistantEvent = typeof AssistantEvent.Type;
+/**
+ * Schema for the tag of one of the application's own events.
+ *
+ * It accepts any tag but the library's, and it is branded, so narrowing an entry's event to one
+ * of the library's events (`Predicate.isTagged(event, "UserMessage")`) never leaves an app event
+ * in.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const AppTag: Schema.brand<Schema.String, "~effect-assistant/AppTag">;
+/**
+ * Schema for one of the application's own events as it is stored, with its `_tag` and its fields
+ * in JSON.
+ *
+ * An assistant made with `events: [AppEvent.make(Summary)]` decodes it to a `Summary` in
+ * `CurrentChat`'s `entries` and in its `subscribe`.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const StoredAppEvent: Schema.StructWithRest<Schema.Struct<{
+  readonly _tag: Schema.brand<Schema.String, "~effect-assistant/AppTag">;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+/**
+ * Represents one of the application's own events, as it is stored.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type StoredAppEvent = typeof StoredAppEvent.Type;
+/**
+ * Returns whether an event is one of the library's, not one of the app's own.
+ *
+ * @category guards
+ * @since 0.1.0
+ */
+export declare const isLibraryEvent: (event: {
+  readonly _tag: string;
+}) => event is AssistantEvent;
+/**
+ * Represents a chat's entry with any event in it, either the library's or the application's own
+ * (decoded or not).
+ *
+ * The folds over a chat take this type, so a client's typed entries fit too.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface AnyEntry {
+  readonly chatId: ChatId;
+  readonly seq: number;
+  readonly at: number;
+  readonly event: {
+    readonly _tag: string;
+  };
+}
+/**
+ * Schema for a stored event with its position in the chat.
+ *
+ * `seq` starts at 1 and has no gaps. `at` is the time the event was stored, in epoch
+ * milliseconds.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Entry: Schema.Struct<{
+  readonly chatId: Schema.brand<Schema.TemplateLiteral<readonly ["chat:", Schema.String]>, "~effect-assistant/ChatId">;
+  readonly seq: Schema.Int;
+  readonly at: Schema.Finite;
+  readonly event: Schema.Union<readonly [Schema.Union<readonly [typeof UserMessage, typeof BlockAnswer, typeof AssistantMessage, typeof ModelOutput, typeof ToolStarted, typeof ToolResult, typeof TurnStarted, typeof TurnCompleted, typeof TurnFailed, typeof SpecialistStarted, typeof SpecialistFinished, typeof BlocksClosed, typeof DecisionRequested, typeof DecisionResolved, typeof ChatDeleted]>, Schema.StructWithRest<Schema.Struct<{
+    readonly _tag: Schema.brand<Schema.String, "~effect-assistant/AppTag">;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>;
+}>;
+/**
+ * Represents a stored event with its position in the chat.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Entry = typeof Entry.Type;
+/**
+ * Returns whether an event is one of the library's inputs, which are a user message, a block
+ * answer, or a finished specialist run.
+ *
+ * The application's events that wake a turn are inputs too, but only their assistant knows which
+ * (see `AppEvent`).
+ *
+ * @category guards
+ * @since 0.1.0
+ */
+export declare const isInput: (event: {
+  readonly _tag: string;
+}) => event is Input;
+/**
+ * Returns whether an input starts a turn, which every input does except a run the assistant
+ * stopped itself.
+ *
+ * @category guards
+ * @since 0.1.0
+ */
+export declare const isWaking: (input: Input) => boolean;
+/**
+ * Returns whether an input came from the chat's user, and so is owed a reply.
+ *
+ * @category guards
+ * @since 0.1.0
+ */
+export declare const isUserInput: (input: Input) => input is UserInput;
+/**
+ * Returns whether an event ends a turn, and so says how far the assistant has read.
+ *
+ * @category guards
+ * @since 0.1.0
+ */
+export declare const isTurnEnd: (event: {
+  readonly _tag: string;
+}) => event is TurnCompleted | TurnFailed;
+/**
+ * Returns the text of every message the user was shown, in order.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const assistantTexts: (entries: ReadonlyArray<AnyEntry>) => ReadonlyArray<string>;
+//#endregion
+export { AssistantEvent_d_exports };
+//# sourceMappingURL=AssistantEvent.d.ts.map

package/dist/AssistantEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssistantEvent.d.ts","names":[],"sources":["../src/AssistantEvent.ts"],"mappings":";;;;;;;;;;;;;;qBA0Ba,YAAU,OAAA;;;;;;;;;;;;;;;qBAgBV;;;;;;;YAQD,oBAAoB,WAAW;;;;;;;qBAQ9B,aAAU;;;;;;;;;qBAiBV,iBAAc,YAAgB;;;;;;;qBAS9B,sBAAmB,cAAgB,aAAe,cAAc;;;;;;;;;;;;;;;;;;;;;qBAchE,oBAAoB;;;;;;;;;;;;;;;;qBAepB,oBAAoB;;;;;;;;;;;;;;;;;;;;;qBAgBpB,2BAA2B;;;;;;;qBAkB3B,iBAAe,OAAA;;;;;;;YAQhB,yBAAyB,gBAAgB;;;;;;;;;qBAUxC,YAAU,OAAA;;;;;;;;;;;YAYX,oBAAoB,WAAW;;;;;;;;;;;;;;;qBAQ9B,0BAA0B;;;;;;;;;;;;;;qBAa1B,yBAAyB;;;;;;;qBAYzB,OAAK,OAAA,uBAAA,oBAAA,oBAAA;;;;;;;YAQN,eAAe,MAAM;;;;;;;;;;qBAWpB,WAAS,OAAA,uBAAA,oBAAA;;;;;;;YAQV,mBAAmB,UAAU;;;;;;;;;;;;qBAS5B,qBAAqB;;;;;;;;;;;;;;;qBAYrB,yBAAyB;;;;;;;;;;qBAiBzB,cAAY,OAAA;;;;;;;;;;;;;;;YAWb,sBAAsB,aAAa;;;;;;;;;;qBAWlC,WAAS,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;YAQV,mBAAmB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAU5B,oBAAoB;;;;;;;;;;;;;;qBA2BpB,oBAAoB;;;;;;;;qBAYpB,aAAW,OAAA;;;;;;;YAQZ,qBAAqB,YAAY;;;;;;;;;;;;;;;;;;qBAYhC,mBAAmB;;;;;;;;;;;;;;;qBAcnB,oBAAoB;;;;;;;;;;;;qBAiBpB,sBAAsB;;;;;;;;;;;;;;qBAatB,mBAAmB;;;;;;;;;;;;;;;;;qBAenB,0BAA0B;;;;;;;;;;;qBAgB1B,oBAAoB;;;;;;;;;;;;;qBAWpB,qBAAqB;;;;;;;qBAUrB,gBAAc,OAAA,uBAAA,oBAAA,oBAAA,yBAAA,oBAAA,oBAAA,mBAAA,oBAAA,sBAAA,mBAAA,0BAAA,2BAAA,qBAAA,0BAAA,yBAAA;;;;;;;YAwBf,wBAAwB,eAAe;;;;;;;;;;;qBAgBtC,QAAM,OAAA,MAAA,OAAA;;;;;;;;;;;qBAYN,gBAAc,OAAA,eAAA,OAAA;;cAE2F,OAAA,QAAA,OAAA,QAAA,OAAA,MAAA,OAAA,MAAA,OAAA;;;;;;;YAQ1G,wBAAwB,eAAe;;;;;;;qBAQtC,iBAAc;WAAsB;MAAiB,SAAS;;;;;;;;;;iBAW1D;WACN,QAAQ;WACR;WACA;WACA;aAAkB;;;;;;;;;;;;qBAYhB,OAAK,OAAA;;;;;;;;;;;;;;YAaN,eAAe,MAAM;;;;;;;;;;;qBAYpB,UAAO;WAAsB;MAAiB,SAAS;;;;;;;;qBAYvD,WAAQ,OAAW;;;;;;;qBASnB,cAAW,OAAW,UAAQ,SAAS;;;;;;;qBASvC,YAAS;WAAsB;MAAiB,SAAS,gBAAgB;;;;;;;qBASzE,iBAAc,SAAa,cAAc,cAAY"}