effect-assistant 0.0.0-stage → 0.1.0

package/dist/Decision.js

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

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

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

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

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

@@ -0,0 +1 @@
+{"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/InputId.d.ts

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+declare namespace InputId_d_exports {
+  export { InputId, fromKey, make };
+}
+/**
+ * Schema for input ids. Any string is a valid input id, and the schema brands it.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const InputId: Schema.brand<Schema.String, "~effect-assistant/InputId">;
+/**
+ * Represents an input id.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type InputId = typeof InputId.Type;
+/**
+ * Creates a new random input id using Effect's `Random`. Seed `Random` in tests to get the same ids
+ * on every run.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: () => Effect.Effect<InputId>;
+/**
+ * Creates the input id for a key, such as `${runId}:order_placed`. The same key always gives the
+ * same id, so an input that is sent again is stored only once.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const fromKey: (key: string) => InputId;
+//#endregion
+export { InputId_d_exports };
+//# sourceMappingURL=InputId.d.ts.map

package/dist/InputId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputId.d.ts","names":[],"sources":["../src/InputId.ts"],"mappings":";;;;;;;;;;;qBAgBa,SAAO,OAAA,MAAA,OAAA;;;;;;;YAQR,iBAAiB,QAAQ;;;;;;;;qBASxB,YAAW,OAAO,OAAO;;;;;;;;qBASzB,UAAO,gBAAkB"}

package/dist/InputId.js

@@ -0,0 +1,43 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { make as make$1 } from "./internal/uuid.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+//#region src/InputId.ts
+/**
+* This module provides the id of an input to an assistant. An input is a user message, a block
+* answer, or one of the app's events, and the id is stored in its `id` field.
+*
+* @since 0.1.0
+*/
+var InputId_exports = /* @__PURE__ */ __exportAll({
+	InputId: () => InputId,
+	fromKey: () => fromKey,
+	make: () => make
+});
+/**
+* Schema for input ids. Any string is a valid input id, and the schema brands it.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const InputId = Schema.String.pipe(Schema.brand("~effect-assistant/InputId"));
+/**
+* Creates a new random input id using Effect's `Random`. Seed `Random` in tests to get the same ids
+* on every run.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const make = () => Effect.map(make$1, (uuid) => InputId.make(uuid));
+/**
+* Creates the input id for a key, such as `${runId}:order_placed`. The same key always gives the
+* same id, so an input that is sent again is stored only once.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const fromKey = (key) => InputId.make(key);
+//#endregion
+export { InputId, InputId_exports, fromKey, make };
+
+//# sourceMappingURL=InputId.js.map

package/dist/InputId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputId.js","names":["Uuid.make"],"sources":["../src/InputId.ts"],"sourcesContent":["/**\n * This module provides the id of an input to an assistant. An input is a user message, a block\n * answer, or one of the app's events, and the id is stored in its `id` field.\n *\n * @since 0.1.0\n */\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport * as Uuid from \"./internal/uuid.ts\"\n\n/**\n * Schema for input ids. Any string is a valid input id, and the schema brands it.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const InputId = Schema.String.pipe(Schema.brand(\"~effect-assistant/InputId\"))\n\n/**\n * Represents an input id.\n *\n * @category models\n * @since 0.1.0\n */\nexport type InputId = typeof InputId.Type\n\n/**\n * Creates a new random input id using Effect's `Random`. Seed `Random` in tests to get the same ids\n * on every run.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = (): Effect.Effect<InputId> => Effect.map(Uuid.make, (uuid) => InputId.make(uuid))\n\n/**\n * Creates the input id for a key, such as `${runId}:order_placed`. The same key always gives the\n * same id, so an input that is sent again is stored only once.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const fromKey = (key: string): InputId => InputId.make(key)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAgBA,MAAa,UAAU,OAAO,OAAO,KAAK,OAAO,MAAM,2BAA2B,CAAC;;;;;;;;AAiBnF,MAAa,aAAqC,OAAO,IAAIA,SAAY,SAAS,QAAQ,KAAK,IAAI,CAAC;;;;;;;;AASpG,MAAa,WAAW,QAAyB,QAAQ,KAAK,GAAG"}

package/dist/Instructions.d.ts

@@ -0,0 +1,56 @@
+import * as Effect from "effect/Effect";
+declare namespace Instructions_d_exports {
+  export { Instructions, Resolved, SpanAttributes, protocol, resolve };
+}
+/**
+ * The text the model has to know for a turn's loop to work.
+ *
+ * **Details**
+ *
+ * It tells the model that every step is a tool call, that `wait` (or a last message with
+ * `wait: true`) ends the turn, that the user sees only what it sends with `send_user_message`, and
+ * that messages can arrive mid-turn. The rest, such as what a `<specialist>` block or an app's
+ * event is, is in the tools' descriptions and in the history itself.
+ *
+ * `turn.instructions(text)` puts it before the text, and a custom loop on `AssistantLoop.run` can
+ * use it too.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const protocol = "Every step is a tool call. When you have nothing more to do right now, end your turn: set wait to true on your last send_user_message, or call wait if you have nothing to say.\nThe user sees only the text of what you send with send_user_message: anything else you write is never shown, so put the whole answer in the message, not next to it.\nMessages and updates can arrive while you work: handle the newest one, and don't repeat what you already told the user.";
+/**
+ * Represents the span attributes added to every model call made with a prompt.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type SpanAttributes = Readonly<Record<string, string | number | boolean>>;
+/**
+ * Represents instructions resolved to text, with the span attributes to record them under.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Resolved {
+  readonly text: string;
+  readonly attributes?: SpanAttributes | undefined;
+}
+/**
+ * Represents instructions as text, or as an Effect that produces the text (optionally with span
+ * attributes).
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Instructions<R = never> = string | Effect.Effect<string | Resolved, never, R>;
+/**
+ * Resolves instructions to their text and span attributes.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const resolve: <R = never>(instructions: Instructions<R>) => Effect.Effect<Resolved, never, R>;
+//#endregion
+export { Instructions_d_exports };
+//# sourceMappingURL=Instructions.d.ts.map

package/dist/Instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Instructions.d.ts","names":[],"sources":["../src/Instructions.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBA4Ba;;;;;;;YAUD,iBAAiB,SAAS;;;;;;;iBAQrB;WACN;WACA,aAAa;;;;;;;;;YAUZ,aAAa,sBAAsB,OAAO,gBAAgB,iBAAiB;;;;;;;qBAQ1E,UAAuD,WAAC,cAAA,aAAA,OAAA,OAAA,OAAA,iBAAA"}

package/dist/Instructions.js

@@ -0,0 +1,50 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+//#region src/Instructions.ts
+/**
+* Defines the instructions that tell an assistant, specialist, or skill what to do.
+*
+* Instructions are text, or an Effect that produces text, optionally with span attributes
+* (a {@link Resolved}). {@link resolve} turns them into a `Resolved`, and {@link protocol} is the
+* text a turn's loop needs the model to know.
+*
+* @since 0.1.0
+*/
+var Instructions_exports = /* @__PURE__ */ __exportAll({
+	protocol: () => protocol,
+	resolve: () => resolve
+});
+/**
+* The text the model has to know for a turn's loop to work.
+*
+* **Details**
+*
+* It tells the model that every step is a tool call, that `wait` (or a last message with
+* `wait: true`) ends the turn, that the user sees only what it sends with `send_user_message`, and
+* that messages can arrive mid-turn. The rest, such as what a `<specialist>` block or an app's
+* event is, is in the tools' descriptions and in the history itself.
+*
+* `turn.instructions(text)` puts it before the text, and a custom loop on `AssistantLoop.run` can
+* use it too.
+*
+* @category utils
+* @since 0.1.0
+*/
+const protocol = `Every step is a tool call. When you have nothing more to do right now, end your turn: set wait to true on your last send_user_message, or call wait if you have nothing to say.
+The user sees only the text of what you send with send_user_message: anything else you write is never shown, so put the whole answer in the message, not next to it.
+Messages and updates can arrive while you work: handle the newest one, and don't repeat what you already told the user.`;
+/**
+* Resolves instructions to their text and span attributes.
+*
+* @category utils
+* @since 0.1.0
+*/
+const resolve = Effect.fn("Instructions.resolve")(function* (instructions) {
+	return Predicate.isString(instructions) ? { text: instructions } : toResolved(yield* instructions);
+});
+const toResolved = (resolved) => Predicate.isString(resolved) ? { text: resolved } : resolved;
+//#endregion
+export { Instructions_exports, protocol, resolve };
+
+//# sourceMappingURL=Instructions.js.map

package/dist/Instructions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Instructions.js","names":[],"sources":["../src/Instructions.ts"],"sourcesContent":["/**\n * Defines the instructions that tell an assistant, specialist, or skill what to do.\n *\n * Instructions are text, or an Effect that produces text, optionally with span attributes\n * (a {@link Resolved}). {@link resolve} turns them into a `Resolved`, and {@link protocol} is the\n * text a turn's loop needs the model to know.\n *\n * @since 0.1.0\n */\nimport * as Effect from \"effect/Effect\"\nimport * as Predicate from \"effect/Predicate\"\n\n/**\n * The text the model has to know for a turn's loop to work.\n *\n * **Details**\n *\n * It tells the model that every step is a tool call, that `wait` (or a last message with\n * `wait: true`) ends the turn, that the user sees only what it sends with `send_user_message`, and\n * that messages can arrive mid-turn. The rest, such as what a `<specialist>` block or an app's\n * event is, is in the tools' descriptions and in the history itself.\n *\n * `turn.instructions(text)` puts it before the text, and a custom loop on `AssistantLoop.run` can\n * use it too.\n *\n * @category utils\n * @since 0.1.0\n */\nexport const protocol = `Every step is a tool call. When you have nothing more to do right now, end your turn: set wait to true on your last send_user_message, or call wait if you have nothing to say.\nThe user sees only the text of what you send with send_user_message: anything else you write is never shown, so put the whole answer in the message, not next to it.\nMessages and updates can arrive while you work: handle the newest one, and don't repeat what you already told the user.`\n\n/**\n * Represents the span attributes added to every model call made with a prompt.\n *\n * @category models\n * @since 0.1.0\n */\nexport type SpanAttributes = Readonly<Record<string, string | number | boolean>>\n\n/**\n * Represents instructions resolved to text, with the span attributes to record them under.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Resolved {\n  readonly text: string\n  readonly attributes?: SpanAttributes | undefined\n}\n\n/**\n * Represents instructions as text, or as an Effect that produces the text (optionally with span\n * attributes).\n *\n * @category models\n * @since 0.1.0\n */\nexport type Instructions<R = never> = string | Effect.Effect<string | Resolved, never, R>\n\n/**\n * Resolves instructions to their text and span attributes.\n *\n * @category utils\n * @since 0.1.0\n */\nexport const resolve = Effect.fn(\"Instructions.resolve\")(function* <R = never>(instructions: Instructions<R>) {\n  return Predicate.isString(instructions) ? { text: instructions } : toResolved(yield* instructions)\n})\n\nconst toResolved = (resolved: string | Resolved): Resolved =>\n  Predicate.isString(resolved) ? { text: resolved } : resolved\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,WAAW;;;;;;;;;AAsCxB,MAAa,UAAU,OAAO,GAAG,sBAAsB,CAAC,CAAC,WAAsB,cAA+B;CAC5G,OAAO,UAAU,SAAS,YAAY,IAAI,EAAE,MAAM,aAAa,IAAI,WAAW,OAAO,YAAY;AACnG,CAAC;AAED,MAAM,cAAc,aAClB,UAAU,SAAS,QAAQ,IAAI,EAAE,MAAM,SAAS,IAAI"}