effect-assistant 0.1.0 → 0.3.0

package/dist/Decision.d.ts

@@ -1,145 +0,0 @@
-import { AnyEntry, AssistantEvent_d_exports, DecisionOutcome, DecisionRequested, ToolResult } from "./AssistantEvent.js";
-import { Block, Block_d_exports } from "./Block.js";
-import { InputId } from "./InputId.js";
-import * as Schema from "effect/Schema";
-declare namespace Decision_d_exports {
-  export { Answer, Props, State, answerAll, apply, block, fromEntries, kind };
-}
-/**
- * The kind of the decision block.
- *
- * @category utils
- * @since 0.1.0
- */
-export declare const kind = "decision";
-/**
- * Schema for the decision block's props, which list the decisions it asks for and, optionally,
- * its buttons' labels.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const Props: Schema.Struct<{
-  readonly decisionIds: Schema.$Array<Schema.String>;
-  readonly approveLabel: Schema.optional<Schema.String>;
-  readonly declineLabel: Schema.optional<Schema.String>;
-}>;
-/**
- * Represents the decision block's props.
- *
- * @category models
- * @since 0.1.0
- */
-export type Props = typeof Props.Type;
-/**
- * Schema for the decision block's answer, which holds an outcome for every decision the block
- * asks for, by id.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const Answer: Schema.Struct<{
-  readonly decisions: Schema.$Record<Schema.String, Schema.Literals<readonly ["approved", "declined"]>>;
-}>;
-/**
- * Represents the decision block's answer.
- *
- * @category models
- * @since 0.1.0
- */
-export type Answer = typeof Answer.Type;
-/**
- * Block with approve and decline buttons for the decisions waiting for the user.
- *
- * **Details**
- *
- * Put it in the assistant's `BlockKit`. An assistant with a tool that needs a decision must have
- * it. The client renders it like any other block, with the calls from {@link fromEntries} (their
- * tool and params).
- *
- * **Example** (Asking the user before placing an order)
- *
- * ```ts
- * import { Assistant, BlockKit, Decision } from "effect-assistant"
- * import * as Tool from "effect/ai/Tool"
- * import * as Toolkit from "effect/ai/Toolkit"
- * import * as Effect from "effect/Effect"
- * import * as Layer from "effect/Layer"
- * import * as Schema from "effect/Schema"
- *
- * export const Shop = Assistant.make("shop", { blocks: BlockKit.make([Decision.block]) })
- *
- * const OrderTools = Toolkit.make(
- *   Tool.make("place_order", {
- *     description: "Places an order.",
- *     parameters: Schema.Struct({ sku: Schema.String, quantity: Schema.Int }),
- *     success: Schema.Struct({ reference: Schema.String }),
- *     needsApproval: true
- *   })
- * )
- *
- * const OrderToolsLive = OrderTools.toLayer({
- *   place_order: () => Effect.succeed({ reference: "R-1042" })
- * })
- *
- * // The call waits until the user answers the decision block.
- * const ShopLive = Shop.toLayer((turn) =>
- *   turn.loop({ instructions: "You place orders for the team.", toolkit: OrderTools })
- * ).pipe(Layer.provide(OrderToolsLive))
- * ```
- *
- * @category constructors
- * @since 0.1.0
- */
-export declare const block: Block<"decision", Schema.Struct<{
-  readonly decisionIds: Schema.$Array<Schema.String>;
-  readonly approveLabel: Schema.optional<Schema.String>;
-  readonly declineLabel: Schema.optional<Schema.String>;
-}>, Schema.Struct<{
-  readonly decisions: Schema.$Record<Schema.String, Schema.Literals<readonly ["approved", "declined"]>>;
-}>>;
-/**
- * Creates an answer that gives every decision the block asks for the same outcome.
- *
- * This is what an "Approve" or "Decline" button sends.
- *
- * @category constructors
- * @since 0.1.0
- */
-export declare const answerAll: (props: Props, outcome: DecisionOutcome) => Answer;
-/**
- * Represents the state of a decision.
- *
- * @category models
- * @since 0.1.0
- */
-export interface State {
-  readonly request: DecisionRequested;
-  /** How the user decided, or `undefined` while the decision waits. */
-  readonly outcome: DecisionOutcome | undefined;
-  /** The id of the answer that decided it. */
-  readonly answer: InputId | undefined;
-  /** Whether its `DecisionResolved` is stored. A workflow's decision has been passed on by then. */
-  readonly resolved: boolean;
-  /** The approved call's result, once the call has run. */
-  readonly result: ToolResult | undefined;
-}
-/**
- * Returns the decision states after one more event.
- *
- * @category utils
- * @since 0.1.0
- */
-export declare const apply: (states: ReadonlyMap<string, State>, event: {
-  readonly _tag: string;
-}) => ReadonlyMap<string, State>;
-/**
- * Returns every decision in the log and where it stands, by id.
- *
- * @category utils
- * @since 0.1.0
- */
-export declare const fromEntries: (entries: ReadonlyArray<AnyEntry>) => ReadonlyMap<string, State>;
-//#endregion
-export { Decision_d_exports };
-//# sourceMappingURL=Decision.d.ts.map

package/dist/Decision.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Decision.d.ts","names":[],"sources":["../src/Decision.ts"],"mappings":";;;;;;;;;;;;;qBAyBa;;;;;;;;qBASA,OAAK,OAAA;;;;;;;;;;;YAqBN,eAAe,MAAM;;;;;;;;qBASpB,QAAM,OAAA;;;;;;;;;YAUP,gBAAgB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6CtB,OAAK,kBAAA,OAAA;;;;;;;;;;;;;;;qBAeL,YAAS,OAAW,OAAK,SAAW,oBAAiC;;;;;;;iBAUjE;WACN,SAAS;;WAET,SAAS;;WAET,QAAQ;;WAER;;WAEA,QAAQ;;;;;;;;qBAWN,QAAK,QACR,oBAAoB,QAAM;WAChB;MACjB,oBAAoB;;;;;;;qBAmEV,cAAW,SAAa,cAAc,cAA2B,oBAAoB"}

package/dist/Decision.js

@@ -1,178 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { fromCallId } from "./DecisionId.js";
-import { DecisionOutcome, isLibraryEvent } from "./AssistantEvent.js";
-import { make } from "./Block.js";
-import * as Predicate from "effect/Predicate";
-import * as Schema from "effect/Schema";
-import * as Option from "effect/Option";
-//#region src/Decision.ts
-/**
-* Lets the user approve or decline a tool call the assistant can't make on its own, such as
-* placing an order or publishing a post.
-*
-* When the model calls a tool marked with Effect's `needsApproval`, the call is parked instead of
-* run. The model asks the user with the decision {@link block}, and the user's answer to that
-* block runs the call or declines it. {@link fromEntries} computes where every decision in a
-* chat's log stands.
-*
-* @since 0.1.0
-*/
-var Decision_exports = /* @__PURE__ */ __exportAll({
-	Answer: () => Answer,
-	Props: () => Props,
-	answerAll: () => answerAll,
-	apply: () => apply,
-	block: () => block,
-	fromEntries: () => fromEntries,
-	kind: () => kind
-});
-/**
-* The kind of the decision block.
-*
-* @category utils
-* @since 0.1.0
-*/
-const kind = "decision";
-/**
-* Schema for the decision block's props, which list the decisions it asks for and, optionally,
-* its buttons' labels.
-*
-* @category schemas
-* @since 0.1.0
-*/
-const Props = Schema.Struct({
-	decisionIds: Schema.Array(Schema.String).check(Schema.isMinLength(1)).annotate({ description: "The decisions to ask for: each waiting call's decisionId. Several go in one block when the user decides them together." }),
-	approveLabel: Schema.optional(Schema.String).annotate({ description: "The approve button, like \"Place order\"." }),
-	declineLabel: Schema.optional(Schema.String).annotate({ description: "The decline button, like \"Cancel\"." })
-});
-/**
-* Schema for the decision block's answer, which holds an outcome for every decision the block
-* asks for, by id.
-*
-* @category schemas
-* @since 0.1.0
-*/
-const Answer = Schema.Struct({ decisions: Schema.Record(Schema.String, DecisionOutcome) });
-/**
-* Block with approve and decline buttons for the decisions waiting for the user.
-*
-* **Details**
-*
-* Put it in the assistant's `BlockKit`. An assistant with a tool that needs a decision must have
-* it. The client renders it like any other block, with the calls from {@link fromEntries} (their
-* tool and params).
-*
-* **Example** (Asking the user before placing an order)
-*
-* ```ts
-* import { Assistant, BlockKit, Decision } from "effect-assistant"
-* import * as Tool from "effect/ai/Tool"
-* import * as Toolkit from "effect/ai/Toolkit"
-* import * as Effect from "effect/Effect"
-* import * as Layer from "effect/Layer"
-* import * as Schema from "effect/Schema"
-*
-* export const Shop = Assistant.make("shop", { blocks: BlockKit.make([Decision.block]) })
-*
-* const OrderTools = Toolkit.make(
-*   Tool.make("place_order", {
-*     description: "Places an order.",
-*     parameters: Schema.Struct({ sku: Schema.String, quantity: Schema.Int }),
-*     success: Schema.Struct({ reference: Schema.String }),
-*     needsApproval: true
-*   })
-* )
-*
-* const OrderToolsLive = OrderTools.toLayer({
-*   place_order: () => Effect.succeed({ reference: "R-1042" })
-* })
-*
-* // The call waits until the user answers the decision block.
-* const ShopLive = Shop.toLayer((turn) =>
-*   turn.loop({ instructions: "You place orders for the team.", toolkit: OrderTools })
-* ).pipe(Layer.provide(OrderToolsLive))
-* ```
-*
-* @category constructors
-* @since 0.1.0
-*/
-const block = make(kind, {
-	description: "Approve / decline buttons for decisions waiting for the user: a call of yours that waits for their decision. The only way such a decision is made: write what they decide on (the call's key facts), and put the decision ids in decisionIds.",
-	props: Props,
-	answer: Answer
-});
-/**
-* Creates an answer that gives every decision the block asks for the same outcome.
-*
-* This is what an "Approve" or "Decline" button sends.
-*
-* @category constructors
-* @since 0.1.0
-*/
-const answerAll = (props, outcome) => ({ decisions: Object.fromEntries(props.decisionIds.map((id) => [id, outcome])) });
-const decodeAnswer = Schema.decodeUnknownOption(Answer);
-/**
-* Returns the decision states after one more event.
-*
-* @category utils
-* @since 0.1.0
-*/
-const apply = (states, event) => {
-	if (!isLibraryEvent(event)) return states;
-	const update = (id, f) => {
-		const state = states.get(id);
-		return state === void 0 ? states : new Map(states).set(id, f(state));
-	};
-	if (Predicate.isTagged(event, "DecisionRequested")) return states.has(event.id) ? states : new Map(states).set(event.id, {
-		request: event,
-		outcome: void 0,
-		answer: void 0,
-		resolved: false,
-		result: void 0
-	});
-	if (Predicate.isTagged(event, "DecisionResolved")) return update(event.id, (state) => ({
-		...state,
-		outcome: event.outcome,
-		answer: event.answer,
-		resolved: true
-	}));
-	if (Predicate.isTagged(event, "BlockAnswer") && event.kind === "decision") return Option.match(decodeAnswer(event.value), {
-		onNone: () => states,
-		onSome: ({ decisions }) => {
-			const next = new Map(states);
-			for (const [id, outcome] of Object.entries(decisions)) {
-				const state = states.get(id);
-				if (state !== void 0 && state.outcome === void 0) next.set(id, {
-					...state,
-					outcome,
-					answer: event.id
-				});
-			}
-			return next;
-		}
-	});
-	if (Predicate.isTagged(event, "ToolResult")) {
-		const id = fromCallId(event.callId);
-		const state = states.get(id);
-		return state !== void 0 && Predicate.isTagged(state.request.origin, "Call") && state.outcome === "approved" ? update(id, (current) => ({
-			...current,
-			result: event
-		})) : states;
-	}
-	return states;
-};
-/**
-* Returns every decision in the log and where it stands, by id.
-*
-* @category utils
-* @since 0.1.0
-*/
-const fromEntries = (entries) => {
-	let all = /* @__PURE__ */ new Map();
-	for (const entry of entries) all = apply(all, entry.event);
-	return all;
-};
-//#endregion
-export { Answer, Decision_exports, Props, answerAll, apply, block, fromEntries, kind };
-
-//# sourceMappingURL=Decision.js.map

package/dist/Decision.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Decision.js","names":["AssistantEvent.DecisionOutcome","Block.make","AssistantEvent.isLibraryEvent","DecisionId.fromCallId"],"sources":["../src/Decision.ts"],"sourcesContent":["/**\n * Lets the user approve or decline a tool call the assistant can't make on its own, such as\n * placing an order or publishing a post.\n *\n * When the model calls a tool marked with Effect's `needsApproval`, the call is parked instead of\n * run. The model asks the user with the decision {@link block}, and the user's answer to that\n * block runs the call or declines it. {@link fromEntries} computes where every decision in a\n * chat's log stands.\n *\n * @since 0.1.0\n */\nimport * as Option from \"effect/Option\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as Schema from \"effect/Schema\"\nimport * as AssistantEvent from \"./AssistantEvent.ts\"\nimport * as Block from \"./Block.ts\"\nimport * as DecisionId from \"./DecisionId.ts\"\nimport type { InputId } from \"./InputId.ts\"\n\n/**\n * The kind of the decision block.\n *\n * @category utils\n * @since 0.1.0\n */\nexport const kind = \"decision\"\n\n/**\n * Schema for the decision block's props, which list the decisions it asks for and, optionally,\n * its buttons' labels.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Props = Schema.Struct({\n  // Plain strings: a strict tool schema with the id's pattern is too much for some providers; the\n  // ids are checked against the decisions waiting when the message is sent.\n  decisionIds: Schema.Array(Schema.String).check(Schema.isMinLength(1)).annotate({\n    description:\n      \"The decisions to ask for: each waiting call's decisionId. Several go in one block when the user decides them together.\"\n  }),\n  approveLabel: Schema.optional(Schema.String).annotate({\n    description: 'The approve button, like \"Place order\".'\n  }),\n  declineLabel: Schema.optional(Schema.String).annotate({\n    description: 'The decline button, like \"Cancel\".'\n  })\n})\n\n/**\n * Represents the decision block's props.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Props = typeof Props.Type\n\n/**\n * Schema for the decision block's answer, which holds an outcome for every decision the block\n * asks for, by id.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Answer = Schema.Struct({\n  decisions: Schema.Record(Schema.String, AssistantEvent.DecisionOutcome)\n})\n\n/**\n * Represents the decision block's answer.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Answer = typeof Answer.Type\n\n/**\n * Block with approve and decline buttons for the decisions waiting for the user.\n *\n * **Details**\n *\n * Put it in the assistant's `BlockKit`. An assistant with a tool that needs a decision must have\n * it. The client renders it like any other block, with the calls from {@link fromEntries} (their\n * tool and params).\n *\n * **Example** (Asking the user before placing an order)\n *\n * ```ts\n * import { Assistant, BlockKit, Decision } from \"effect-assistant\"\n * import * as Tool from \"effect/ai/Tool\"\n * import * as Toolkit from \"effect/ai/Toolkit\"\n * import * as Effect from \"effect/Effect\"\n * import * as Layer from \"effect/Layer\"\n * import * as Schema from \"effect/Schema\"\n *\n * export const Shop = Assistant.make(\"shop\", { blocks: BlockKit.make([Decision.block]) })\n *\n * const OrderTools = Toolkit.make(\n *   Tool.make(\"place_order\", {\n *     description: \"Places an order.\",\n *     parameters: Schema.Struct({ sku: Schema.String, quantity: Schema.Int }),\n *     success: Schema.Struct({ reference: Schema.String }),\n *     needsApproval: true\n *   })\n * )\n *\n * const OrderToolsLive = OrderTools.toLayer({\n *   place_order: () => Effect.succeed({ reference: \"R-1042\" })\n * })\n *\n * // The call waits until the user answers the decision block.\n * const ShopLive = Shop.toLayer((turn) =>\n *   turn.loop({ instructions: \"You place orders for the team.\", toolkit: OrderTools })\n * ).pipe(Layer.provide(OrderToolsLive))\n * ```\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const block = Block.make(kind, {\n  description:\n    \"Approve / decline buttons for decisions waiting for the user: a call of yours that waits for their decision. The only way such a decision is made: write what they decide on (the call's key facts), and put the decision ids in decisionIds.\",\n  props: Props,\n  answer: Answer\n})\n\n/**\n * Creates an answer that gives every decision the block asks for the same outcome.\n *\n * This is what an \"Approve\" or \"Decline\" button sends.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const answerAll = (props: Props, outcome: AssistantEvent.DecisionOutcome): Answer => ({\n  decisions: Object.fromEntries(props.decisionIds.map((id) => [id, outcome]))\n})\n\n/**\n * Represents the state of a decision.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface State {\n  readonly request: AssistantEvent.DecisionRequested\n  /** How the user decided, or `undefined` while the decision waits. */\n  readonly outcome: AssistantEvent.DecisionOutcome | undefined\n  /** The id of the answer that decided it. */\n  readonly answer: InputId | undefined\n  /** Whether its `DecisionResolved` is stored. A workflow's decision has been passed on by then. */\n  readonly resolved: boolean\n  /** The approved call's result, once the call has run. */\n  readonly result: AssistantEvent.ToolResult | undefined\n}\n\nconst decodeAnswer = Schema.decodeUnknownOption(Answer)\n\n/**\n * Returns the decision states after one more event.\n *\n * @category utils\n * @since 0.1.0\n */\nexport const apply = (\n  states: ReadonlyMap<string, State>,\n  event: { readonly _tag: string }\n): ReadonlyMap<string, State> => {\n  if (!AssistantEvent.isLibraryEvent(event)) return states\n\n  const update = (id: string, f: (state: State) => State) => {\n    const state = states.get(id)\n\n    return state === undefined ? states : new Map(states).set(id, f(state))\n  }\n\n  if (Predicate.isTagged(event, \"DecisionRequested\")) {\n    return states.has(event.id)\n      ? states\n      : new Map(states).set(event.id, {\n          request: event,\n          outcome: undefined,\n          answer: undefined,\n          resolved: false,\n          result: undefined\n        })\n  }\n\n  if (Predicate.isTagged(event, \"DecisionResolved\")) {\n    return update(event.id, (state) => ({\n      ...state,\n      outcome: event.outcome,\n      answer: event.answer,\n      resolved: true\n    }))\n  }\n\n  // A stored decision answer was checked against its block when it was submitted: the first one\n  // for a decision decides it.\n  if (Predicate.isTagged(event, \"BlockAnswer\") && event.kind === kind) {\n    return Option.match(decodeAnswer(event.value), {\n      onNone: () => states,\n      onSome: ({ decisions }) => {\n        const next = new Map(states)\n\n        for (const [id, outcome] of Object.entries(decisions)) {\n          const state = states.get(id)\n\n          if (state !== undefined && state.outcome === undefined) next.set(id, { ...state, outcome, answer: event.id })\n        }\n\n        return next\n      }\n    })\n  }\n\n  if (Predicate.isTagged(event, \"ToolResult\")) {\n    const id = DecisionId.fromCallId(event.callId)\n    const state = states.get(id)\n\n    return state !== undefined && Predicate.isTagged(state.request.origin, \"Call\") && state.outcome === \"approved\"\n      ? update(id, (current) => ({ ...current, result: event }))\n      : states\n  }\n\n  return states\n}\n\n/**\n * Returns every decision in the log and where it stands, by id.\n *\n * @category utils\n * @since 0.1.0\n */\nexport const fromEntries = (entries: ReadonlyArray<AssistantEvent.AnyEntry>): ReadonlyMap<string, State> => {\n  let all: ReadonlyMap<string, State> = new Map()\n\n  for (const entry of entries) all = apply(all, entry.event)\n\n  return all\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,OAAO;;;;;;;;AASpB,MAAa,QAAQ,OAAO,OAAO;CAGjC,aAAa,OAAO,MAAM,OAAO,MAAM,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS,EAC7E,aACE,yHACJ,CAAC;CACD,cAAc,OAAO,SAAS,OAAO,MAAM,CAAC,CAAC,SAAS,EACpD,aAAa,4CACf,CAAC;CACD,cAAc,OAAO,SAAS,OAAO,MAAM,CAAC,CAAC,SAAS,EACpD,aAAa,uCACf,CAAC;AACH,CAAC;;;;;;;;AAiBD,MAAa,SAAS,OAAO,OAAO,EAClC,WAAW,OAAO,OAAO,OAAO,QAAQA,eAA8B,EACxE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDD,MAAa,QAAQC,KAAW,MAAM;CACpC,aACE;CACF,OAAO;CACP,QAAQ;AACV,CAAC;;;;;;;;;AAUD,MAAa,aAAa,OAAc,aAAqD,EAC3F,WAAW,OAAO,YAAY,MAAM,YAAY,KAAK,OAAO,CAAC,IAAI,OAAO,CAAC,CAAC,EAC5E;AAoBA,MAAM,eAAe,OAAO,oBAAoB,MAAM;;;;;;;AAQtD,MAAa,SACX,QACA,UAC+B;CAC/B,IAAI,CAACC,eAA8B,KAAK,GAAG,OAAO;CAElD,MAAM,UAAU,IAAY,MAA+B;EACzD,MAAM,QAAQ,OAAO,IAAI,EAAE;EAE3B,OAAO,UAAU,KAAA,IAAY,SAAS,IAAI,IAAI,MAAM,CAAC,CAAC,IAAI,IAAI,EAAE,KAAK,CAAC;CACxE;CAEA,IAAI,UAAU,SAAS,OAAO,mBAAmB,GAC/C,OAAO,OAAO,IAAI,MAAM,EAAE,IACtB,SACA,IAAI,IAAI,MAAM,CAAC,CAAC,IAAI,MAAM,IAAI;EAC5B,SAAS;EACT,SAAS,KAAA;EACT,QAAQ,KAAA;EACR,UAAU;EACV,QAAQ,KAAA;CACV,CAAC;CAGP,IAAI,UAAU,SAAS,OAAO,kBAAkB,GAC9C,OAAO,OAAO,MAAM,KAAK,WAAW;EAClC,GAAG;EACH,SAAS,MAAM;EACf,QAAQ,MAAM;EACd,UAAU;CACZ,EAAE;CAKJ,IAAI,UAAU,SAAS,OAAO,aAAa,KAAK,MAAM,SAAA,YACpD,OAAO,OAAO,MAAM,aAAa,MAAM,KAAK,GAAG;EAC7C,cAAc;EACd,SAAS,EAAE,gBAAgB;GACzB,MAAM,OAAO,IAAI,IAAI,MAAM;GAE3B,KAAK,MAAM,CAAC,IAAI,YAAY,OAAO,QAAQ,SAAS,GAAG;IACrD,MAAM,QAAQ,OAAO,IAAI,EAAE;IAE3B,IAAI,UAAU,KAAA,KAAa,MAAM,YAAY,KAAA,GAAW,KAAK,IAAI,IAAI;KAAE,GAAG;KAAO;KAAS,QAAQ,MAAM;IAAG,CAAC;GAC9G;GAEA,OAAO;EACT;CACF,CAAC;CAGH,IAAI,UAAU,SAAS,OAAO,YAAY,GAAG;EAC3C,MAAM,KAAKC,WAAsB,MAAM,MAAM;EAC7C,MAAM,QAAQ,OAAO,IAAI,EAAE;EAE3B,OAAO,UAAU,KAAA,KAAa,UAAU,SAAS,MAAM,QAAQ,QAAQ,MAAM,KAAK,MAAM,YAAY,aAChG,OAAO,KAAK,aAAa;GAAE,GAAG;GAAS,QAAQ;EAAM,EAAE,IACvD;CACN;CAEA,OAAO;AACT;;;;;;;AAQA,MAAa,eAAe,YAAgF;CAC1G,IAAI,sBAAkC,IAAI,IAAI;CAE9C,KAAK,MAAM,SAAS,SAAS,MAAM,MAAM,KAAK,MAAM,KAAK;CAEzD,OAAO;AACT"}

package/dist/DecisionId.d.ts

@@ -1,37 +0,0 @@
-import * as Schema from "effect/Schema";
-declare namespace DecisionId_d_exports {
-  export { DecisionId, fromCallId, fromKey };
-}
-/**
- * Schema for decision ids of the form `` `decision:${uuid}` ``, branded.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const DecisionId: Schema.brand<Schema.TemplateLiteral<readonly ["decision:", Schema.String]>, "~effect-assistant/DecisionId">;
-/**
- * Represents a decision id.
- *
- * @category models
- * @since 0.1.0
- */
-export type DecisionId = typeof DecisionId.Type;
-/**
- * Creates the decision id for a key. The same key always gives the same id, so a decision that is
- * requested again is stored only once.
- *
- * @category constructors
- * @since 0.1.0
- */
-export declare const fromKey: (key: string) => DecisionId;
-/**
- * Returns the decision id for a tool call that waits for the user's decision, derived from the
- * call's id.
- *
- * @category constructors
- * @since 0.1.0
- */
-export declare const fromCallId: (callId: string) => DecisionId;
-//#endregion
-export { DecisionId_d_exports };
-//# sourceMappingURL=DecisionId.d.ts.map

package/dist/DecisionId.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DecisionId.d.ts","names":[],"sources":["../src/DecisionId.ts"],"mappings":";;;;;;;;;;qBAiBa,YAAU,OAAA,MAAA,OAAA,uCAAA,OAAA;;;;;;;YAUX,oBAAoB,WAAW;;;;;;;;qBAS9B,UAAO,gBAAkB;;;;;;;;qBASzB,aAAU,mBAAqB"}

package/dist/DecisionId.js

@@ -1,44 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Uuid, fromKey as fromKey$1 } from "./internal/uuid.js";
-import * as Schema from "effect/Schema";
-//#region src/DecisionId.ts
-/**
-* This module provides the id of a decision the user is asked to make, which is `decision:`
-* followed by a UUID.
-*
-* The model passes the id to a decision block, and the user's answer refers to it.
-*
-* @since 0.1.0
-*/
-var DecisionId_exports = /* @__PURE__ */ __exportAll({
-	DecisionId: () => DecisionId,
-	fromCallId: () => fromCallId,
-	fromKey: () => fromKey
-});
-/**
-* Schema for decision ids of the form `` `decision:${uuid}` ``, branded.
-*
-* @category schemas
-* @since 0.1.0
-*/
-const DecisionId = Schema.TemplateLiteral(["decision:", Uuid]).pipe(Schema.brand("~effect-assistant/DecisionId"));
-/**
-* Creates the decision id for a key. The same key always gives the same id, so a decision that is
-* requested again is stored only once.
-*
-* @category constructors
-* @since 0.1.0
-*/
-const fromKey = (key) => DecisionId.make(`decision:${fromKey$1(key)}`);
-/**
-* Returns the decision id for a tool call that waits for the user's decision, derived from the
-* call's id.
-*
-* @category constructors
-* @since 0.1.0
-*/
-const fromCallId = (callId) => fromKey(`tool-call:${callId}`);
-//#endregion
-export { DecisionId, DecisionId_exports, fromCallId, fromKey };
-
-//# sourceMappingURL=DecisionId.js.map

package/dist/DecisionId.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DecisionId.js","names":["Uuid.Uuid","Uuid.fromKey"],"sources":["../src/DecisionId.ts"],"sourcesContent":["/**\n * This module provides the id of a decision the user is asked to make, which is `decision:`\n * followed by a UUID.\n *\n * The model passes the id to a decision block, and the user's answer refers to it.\n *\n * @since 0.1.0\n */\nimport * as Schema from \"effect/Schema\"\nimport * as Uuid from \"./internal/uuid.ts\"\n\n/**\n * Schema for decision ids of the form `` `decision:${uuid}` ``, branded.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const DecisionId = Schema.TemplateLiteral([\"decision:\", Uuid.Uuid]).pipe(\n  Schema.brand(\"~effect-assistant/DecisionId\")\n)\n\n/**\n * Represents a decision id.\n *\n * @category models\n * @since 0.1.0\n */\nexport type DecisionId = typeof DecisionId.Type\n\n/**\n * Creates the decision id for a key. The same key always gives the same id, so a decision that is\n * requested again is stored only once.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const fromKey = (key: string): DecisionId => DecisionId.make(`decision:${Uuid.fromKey(key)}`)\n\n/**\n * Returns the decision id for a tool call that waits for the user's decision, derived from the\n * call's id.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const fromCallId = (callId: string): DecisionId => fromKey(`tool-call:${callId}`)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAiBA,MAAa,aAAa,OAAO,gBAAgB,CAAC,aAAaA,IAAS,CAAC,CAAC,CAAC,KACzE,OAAO,MAAM,8BAA8B,CAC7C;;;;;;;;AAiBA,MAAa,WAAW,QAA4B,WAAW,KAAK,YAAYC,UAAa,GAAG,GAAG;;;;;;;;AASnG,MAAa,cAAc,WAA+B,QAAQ,aAAa,QAAQ"}

package/dist/internal/decisions.js

@@ -1,66 +0,0 @@
-import { isLibraryEvent } from "../AssistantEvent.js";
-import { Answer, Props, fromEntries, kind } from "../Decision.js";
-import { fromEntries as fromEntries$1 } from "../BlockKit.js";
-import * as Predicate from "effect/Predicate";
-import * as Context from "effect/Context";
-import * as Schema from "effect/Schema";
-import * as Data from "effect/Data";
-import * as Option from "effect/Option";
-import * as Response from "effect/ai/Response";
-//#region src/internal/decisions.ts
-/** @internal */
-const TurnDecisions = Context.Reference("effect-assistant/TurnDecisions", { defaultValue: Option.none });
-const Verdicts = Data.taggedEnum();
-const store = Verdicts.Store();
-const refuse = (reason) => Verdicts.Refuse({ reason });
-const decodeProps = Schema.decodeUnknownOption(Props);
-const decodeAnswer = Schema.decodeUnknownOption(Answer);
-const messageOf = (entries, id) => entries.map(({ event }) => event).find((event) => isLibraryEvent(event) && Predicate.isTagged(event, "AssistantMessage") && event.id === id);
-const answerVerdict = (entries, answer) => {
-	const message = messageOf(entries, answer.messageId);
-	const onDecisionBlock = message?.block?.kind === kind;
-	if (!onDecisionBlock && answer.kind !== "decision") return store;
-	if (message?.block === void 0 || !onDecisionBlock || answer.kind !== "decision") return refuse(`${answer.messageId} has no decision block.`);
-	if (fromEntries$1(entries).get(message.id)?.open !== true) return refuse(`The block on ${message.id} is closed.`);
-	const props = decodeProps(message.block.props);
-	const value = decodeAnswer(answer.value);
-	if (Option.isNone(props) || Option.isNone(value)) return refuse(`That isn't an answer to the block on ${message.id}.`);
-	const asked = props.value.decisionIds;
-	const given = Object.keys(value.value.decisions);
-	if (given.length !== asked.length || !given.every((id) => asked.some((askedId) => askedId === id))) return refuse(`An answer decides exactly the decisions its block asks for: ${asked.join(", ")}.`);
-	const states = fromEntries(entries);
-	const decided = [];
-	for (const id of asked) {
-		const state = states.get(id);
-		const outcome = value.value.decisions[id];
-		if (state === void 0 || outcome === void 0) return refuse(`No decision ${id}.`);
-		if (state.outcome !== void 0) return refuse(`${id} is already decided.`);
-		decided.push({
-			request: state.request,
-			outcome
-		});
-	}
-	return Verdicts.Decide({
-		decided,
-		answer: answer.id
-	});
-};
-/** @internal */
-const verdict = (entries, input) => isLibraryEvent(input) && Predicate.isTagged(input, "BlockAnswer") ? answerVerdict(entries, input) : store;
-/** @internal */
-const unresolved = (entries) => [...fromEntries(entries).values()].flatMap((state) => state.outcome !== void 0 && state.answer !== void 0 && !state.resolved ? [{
-	request: state.request,
-	outcome: state.outcome,
-	answer: state.answer
-}] : []);
-/** @internal */
-const approvedCalls = (entries) => [...fromEntries(entries).values()].flatMap(({ request, outcome, resolved, result }) => resolved && outcome === "approved" && result === void 0 ? [Response.makePart("tool-call", {
-	id: request.origin.callId,
-	name: request.origin.tool,
-	params: request.origin.params,
-	providerExecuted: false
-})] : []);
-//#endregion
-export { TurnDecisions, approvedCalls, unresolved, verdict };
-
-//# sourceMappingURL=decisions.js.map

package/dist/internal/decisions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"decisions.js","names":["Decision.Props","Decision.Answer","AssistantEvent.isLibraryEvent","Decision.kind","BlockKit.fromEntries","Decision.fromEntries"],"sources":["../../src/internal/decisions.ts"],"sourcesContent":["import * as Response from \"effect/ai/Response\"\nimport * as Context from \"effect/Context\"\nimport * as Data from \"effect/Data\"\nimport type * as Effect from \"effect/Effect\"\nimport * as Option from \"effect/Option\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as Schema from \"effect/Schema\"\nimport * as AssistantEvent from \"../AssistantEvent.ts\"\nimport * as BlockKit from \"../BlockKit.ts\"\nimport * as Decision from \"../Decision.ts\"\nimport type { InputId } from \"../InputId.ts\"\n\n// Only a turn's loop parks calls and runs approved ones. A turn's specialists inherit its context, so their runs set\n// it back to none.\n/** @internal */\nexport const TurnDecisions = Context.Reference<\n  Option.Option<{\n    readonly approved: Effect.Effect<ReadonlyArray<AssistantEvent.ToolCallPart>>\n  }>\n>(\"effect-assistant/TurnDecisions\", { defaultValue: Option.none })\n\n/** @internal */\nexport interface Decided {\n  readonly request: AssistantEvent.DecisionRequested\n  readonly outcome: AssistantEvent.DecisionOutcome\n}\n\n/** @internal */\nexport type Verdict = Data.TaggedEnum<{\n  Store: Record<never, never>\n  Refuse: { readonly reason: string }\n  Decide: { readonly decided: ReadonlyArray<Decided>; readonly answer: InputId }\n}>\n\nconst Verdicts = Data.taggedEnum<Verdict>()\n\nconst store = Verdicts.Store()\n\nconst refuse = (reason: string) => Verdicts.Refuse({ reason })\n\nconst decodeProps = Schema.decodeUnknownOption(Decision.Props)\n\nconst decodeAnswer = Schema.decodeUnknownOption(Decision.Answer)\n\nconst messageOf = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, id: string) =>\n  entries\n    .map(({ event }) => event)\n    .find(\n      (event): event is AssistantEvent.AssistantMessage =>\n        AssistantEvent.isLibraryEvent(event) && Predicate.isTagged(event, \"AssistantMessage\") && event.id === id\n    )\n\nconst answerVerdict = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, answer: AssistantEvent.BlockAnswer) => {\n  const message = messageOf(entries, answer.messageId)\n  const onDecisionBlock = message?.block?.kind === Decision.kind\n\n  if (!onDecisionBlock && answer.kind !== Decision.kind) return store\n\n  if (message?.block === undefined || !onDecisionBlock || answer.kind !== Decision.kind) {\n    return refuse(`${answer.messageId} has no decision block.`)\n  }\n\n  if (BlockKit.fromEntries(entries).get(message.id)?.open !== true)\n    return refuse(`The block on ${message.id} is closed.`)\n\n  const props = decodeProps(message.block.props)\n  const value = decodeAnswer(answer.value)\n\n  if (Option.isNone(props) || Option.isNone(value)) return refuse(`That isn't an answer to the block on ${message.id}.`)\n\n  const asked = props.value.decisionIds\n  const given = Object.keys(value.value.decisions)\n\n  if (given.length !== asked.length || !given.every((id) => asked.some((askedId) => askedId === id))) {\n    return refuse(`An answer decides exactly the decisions its block asks for: ${asked.join(\", \")}.`)\n  }\n\n  const states = Decision.fromEntries(entries)\n  const decided: Array<Decided> = []\n\n  for (const id of asked) {\n    const state = states.get(id)\n    const outcome = value.value.decisions[id]\n\n    if (state === undefined || outcome === undefined) return refuse(`No decision ${id}.`)\n\n    if (state.outcome !== undefined) return refuse(`${id} is already decided.`)\n\n    decided.push({ request: state.request, outcome })\n  }\n\n  return Verdicts.Decide({ decided, answer: answer.id })\n}\n\n/** @internal */\nexport const verdict = (\n  entries: ReadonlyArray<AssistantEvent.AnyEntry>,\n  input: AssistantEvent.Input | AssistantEvent.StoredAppEvent\n): Verdict =>\n  AssistantEvent.isLibraryEvent(input) && Predicate.isTagged(input, \"BlockAnswer\")\n    ? answerVerdict(entries, input)\n    : store\n\n// A restart can cut the chat off between storing an answer and resolving what it decided.\n/** @internal */\nexport const unresolved = (\n  entries: ReadonlyArray<AssistantEvent.AnyEntry>\n): ReadonlyArray<Decided & { readonly answer: InputId }> =>\n  [...Decision.fromEntries(entries).values()].flatMap((state) =>\n    state.outcome !== undefined && state.answer !== undefined && !state.resolved\n      ? [{ request: state.request, outcome: state.outcome, answer: state.answer }]\n      : []\n  )\n\n// They run with the ids and params the model gave them, before the model's next step.\n/** @internal */\nexport const approvedCalls = (\n  entries: ReadonlyArray<AssistantEvent.AnyEntry>\n): ReadonlyArray<AssistantEvent.ToolCallPart> =>\n  [...Decision.fromEntries(entries).values()].flatMap(({ request, outcome, resolved, result }) =>\n    resolved && outcome === \"approved\" && result === undefined\n      ? [\n          Response.makePart(\"tool-call\", {\n            id: request.origin.callId,\n            name: request.origin.tool,\n            params: request.origin.params,\n            providerExecuted: false\n          })\n        ]\n      : []\n  )\n"],"mappings":";;;;;;;;;;;AAeA,MAAa,gBAAgB,QAAQ,UAInC,kCAAkC,EAAE,cAAc,OAAO,KAAK,CAAC;AAejE,MAAM,WAAW,KAAK,WAAoB;AAE1C,MAAM,QAAQ,SAAS,MAAM;AAE7B,MAAM,UAAU,WAAmB,SAAS,OAAO,EAAE,OAAO,CAAC;AAE7D,MAAM,cAAc,OAAO,oBAAoBA,KAAc;AAE7D,MAAM,eAAe,OAAO,oBAAoBC,MAAe;AAE/D,MAAM,aAAa,SAAiD,OAClE,QACG,KAAK,EAAE,YAAY,KAAK,CAAC,CACzB,MACE,UACCC,eAA8B,KAAK,KAAK,UAAU,SAAS,OAAO,kBAAkB,KAAK,MAAM,OAAO,EAC1G;AAEJ,MAAM,iBAAiB,SAAiD,WAAuC;CAC7G,MAAM,UAAU,UAAU,SAAS,OAAO,SAAS;CACnD,MAAM,kBAAkB,SAAS,OAAO,SAASC;CAEjD,IAAI,CAAC,mBAAmB,OAAO,SAAS,YAAe,OAAO;CAE9D,IAAI,SAAS,UAAU,KAAA,KAAa,CAAC,mBAAmB,OAAO,SAAS,YACtE,OAAO,OAAO,GAAG,OAAO,UAAU,wBAAwB;CAG5D,IAAIC,cAAqB,OAAO,CAAC,CAAC,IAAI,QAAQ,EAAE,CAAC,EAAE,SAAS,MAC1D,OAAO,OAAO,gBAAgB,QAAQ,GAAG,YAAY;CAEvD,MAAM,QAAQ,YAAY,QAAQ,MAAM,KAAK;CAC7C,MAAM,QAAQ,aAAa,OAAO,KAAK;CAEvC,IAAI,OAAO,OAAO,KAAK,KAAK,OAAO,OAAO,KAAK,GAAG,OAAO,OAAO,wCAAwC,QAAQ,GAAG,EAAE;CAErH,MAAM,QAAQ,MAAM,MAAM;CAC1B,MAAM,QAAQ,OAAO,KAAK,MAAM,MAAM,SAAS;CAE/C,IAAI,MAAM,WAAW,MAAM,UAAU,CAAC,MAAM,OAAO,OAAO,MAAM,MAAM,YAAY,YAAY,EAAE,CAAC,GAC/F,OAAO,OAAO,+DAA+D,MAAM,KAAK,IAAI,EAAE,EAAE;CAGlG,MAAM,SAASC,YAAqB,OAAO;CAC3C,MAAM,UAA0B,CAAC;CAEjC,KAAK,MAAM,MAAM,OAAO;EACtB,MAAM,QAAQ,OAAO,IAAI,EAAE;EAC3B,MAAM,UAAU,MAAM,MAAM,UAAU;EAEtC,IAAI,UAAU,KAAA,KAAa,YAAY,KAAA,GAAW,OAAO,OAAO,eAAe,GAAG,EAAE;EAEpF,IAAI,MAAM,YAAY,KAAA,GAAW,OAAO,OAAO,GAAG,GAAG,qBAAqB;EAE1E,QAAQ,KAAK;GAAE,SAAS,MAAM;GAAS;EAAQ,CAAC;CAClD;CAEA,OAAO,SAAS,OAAO;EAAE;EAAS,QAAQ,OAAO;CAAG,CAAC;AACvD;;AAGA,MAAa,WACX,SACA,UAEAH,eAA8B,KAAK,KAAK,UAAU,SAAS,OAAO,aAAa,IAC3E,cAAc,SAAS,KAAK,IAC5B;;AAIN,MAAa,cACX,YAEA,CAAC,GAAGG,YAAqB,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,UACnD,MAAM,YAAY,KAAA,KAAa,MAAM,WAAW,KAAA,KAAa,CAAC,MAAM,WAChE,CAAC;CAAE,SAAS,MAAM;CAAS,SAAS,MAAM;CAAS,QAAQ,MAAM;AAAO,CAAC,IACzE,CAAC,CACP;;AAIF,MAAa,iBACX,YAEA,CAAC,GAAGA,YAAqB,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,EAAE,SAAS,SAAS,UAAU,aACjF,YAAY,YAAY,cAAc,WAAW,KAAA,IAC7C,CACE,SAAS,SAAS,aAAa;CAC7B,IAAI,QAAQ,OAAO;CACnB,MAAM,QAAQ,OAAO;CACrB,QAAQ,QAAQ,OAAO;CACvB,kBAAkB;AACpB,CAAC,CACH,IACA,CAAC,CACP"}

package/src/AppEvent.ts

@@ -1,134 +0,0 @@
-/**
- * Registers an application's own events with an assistant.
- *
- * An app event is a tagged schema for something the application reports into a chat, such as a
- * workflow's progress, a webhook, a summary for compaction, or the draft the user opened.
- * {@link make} registers one with two choices: whether storing it wakes a turn (`wakes`), and
- * how the model reads it (`render`).
- *
- * @since 0.1.0
- */
-import * as Predicate from "effect/Predicate"
-import type * as Schema from "effect/Schema"
-import * as SchemaAST from "effect/SchemaAST"
-
-/**
- * Schema for one of the application's own events.
- *
- * It is a tagged struct or class (`Schema.TaggedStruct`, `Schema.TaggedClass`) that needs no
- * services.
- *
- * @category models
- * @since 0.1.0
- */
-export type EventSchema = Schema.Codec<{ readonly _tag: string }, { readonly _tag: string }> & {
-  readonly fields: { readonly _tag: { readonly ast: SchemaAST.AST } }
-}
-
-/**
- * Describes how the model reads an event.
- *
- * `"json"` shows the event's tag and fields as JSON. A function shows the text it returns for the
- * event.
- *
- * @category models
- * @since 0.1.0
- */
-export type Render<A> = "json" | ((event: A) => string)
-
-/**
- * Represents one of the application's events, registered with an assistant.
- *
- * It holds the event's schema and tag, whether storing it wakes a turn, and how the model reads
- * it. A `render` of `undefined` means the model doesn't read it.
- *
- * @category models
- * @since 0.1.0
- */
-export interface AppEvent<S extends EventSchema = EventSchema> {
-  readonly schema: S
-  readonly tag: string
-  readonly wakes: boolean
-  readonly render: Render<S["Type"]> | undefined
-}
-
-/**
- * Represents any registered event, for generic constraints.
- *
- * @category utility types
- * @since 0.1.0
- */
-export type Any = AppEvent<any>
-
-/**
- * Extracts the type of a registered event's values.
- *
- * @category utility types
- * @since 0.1.0
- */
-export type Type<E extends Any> = E["schema"]["Type"]
-
-const tagOf = (schema: EventSchema): string => {
-  const ast = schema.fields._tag.ast
-
-  if (SchemaAST.isLiteral(ast) && Predicate.isString(ast.literal)) return ast.literal
-
-  throw new Error("An app event is a tagged struct or class.")
-}
-
-/**
- * Registers one of the application's events with an assistant.
- *
- * **Details**
- *
- * Storing the event wakes a turn only when `wakes` is `true`; it defaults to `false`. `render`
- * defaults to `"json"` for an event that wakes a turn. An event that doesn't wake a turn and has
- * no `render` isn't read by the model.
- *
- * The schema must be a tagged struct or class whose `_tag` is a string literal; `make` throws
- * otherwise.
- *
- * **Example** (Registering an event that wakes a turn)
- *
- * ```ts
- * import { AppEvent, Assistant, InputId } from "effect-assistant"
- * import * as Schema from "effect/Schema"
- *
- * class OrderShipped extends Schema.TaggedClass<OrderShipped>()("OrderShipped", {
- *   id: InputId.InputId,
- *   orderId: Schema.String,
- *   carrier: Schema.String
- * }) {}
- *
- * export const MyAssistant = Assistant.make("my-assistant", {
- *   events: [
- *     AppEvent.make(OrderShipped, {
- *       wakes: true,
- *       render: (shipped) =>
- *         `Order ${shipped.orderId} shipped with ${shipped.carrier}. Tell the user if it matters.`
- *     })
- *   ]
- * })
- * ```
- *
- * @category constructors
- * @since 0.1.0
- */
-export const make = <S extends EventSchema>(
-  schema: S,
-  options?: {
-    /** Whether storing it starts a turn, like a user's message. Default false. */
-    readonly wakes?: boolean | undefined
-    /** How the model reads it in its history. */
-    readonly render?: Render<S["Type"]> | undefined
-  }
-): AppEvent<S> => {
-  const wakes = options?.wakes ?? false
-
-  return {
-    schema,
-    tag: tagOf(schema),
-    wakes,
-    render: options?.render ?? (wakes ? "json" : undefined)
-  }
-}