effect-assistant 0.0.0-stage → 0.1.0

package/dist/internal/telemetry.js

@@ -0,0 +1,85 @@
+import { ModelPart } from "../AssistantEvent.js";
+import { toJsonText } from "./schema.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+import * as Prompt from "effect/ai/Prompt";
+import * as Model from "effect/ai/Model";
+import * as Telemetry from "effect/ai/Telemetry";
+import * as References from "effect/References";
+import * as Tracer from "effect/Tracer";
+//#region src/internal/telemetry.ts
+/** @internal */
+const agentSpan = (name, options) => Effect.withSpan(`invoke_agent ${name}`, {
+	kind: "internal",
+	root: options.root ?? false,
+	attributes: {
+		"gen_ai.operation.name": "invoke_agent",
+		"gen_ai.agent.name": name,
+		"gen_ai.conversation.id": options.chatId,
+		"session.id": options.chatId
+	}
+});
+/** @internal */
+const currentTraceId = Effect.gen(function* () {
+	const tracer = yield* Tracer.Tracer;
+	if (!(yield* References.TracerEnabled) || tracer === Tracer.nativeTracer) return Option.none();
+	return Option.map(yield* Effect.option(Effect.currentSpan), (span) => span.traceId);
+});
+/** @internal */
+const agentInput = (input) => Effect.annotateCurrentSpan("input.value", toJsonText(input));
+/** @internal */
+const agentOutput = (output) => Effect.annotateCurrentSpan("output.value", toJsonText(output));
+const encodePrompt = Schema.encodeOption(Prompt.Prompt);
+const encodeParts = Schema.encodeOption(Schema.Array(ModelPart));
+const annotateChat = Effect.fnUntraced(function* (response, name) {
+	const span = yield* Effect.currentSpan;
+	const { usage } = response;
+	Telemetry.addGenAIAnnotations(span, {
+		operation: { name: "chat" },
+		request: { model: Option.getOrUndefined(name) },
+		response: { finishReasons: [response.finishReason] },
+		usage: {
+			inputTokens: usage.inputTokens.total,
+			outputTokens: usage.outputTokens.total
+		}
+	});
+	const completion = encodeParts(response.content.flatMap((part) => Option.toArray(Schema.decodeUnknownOption(ModelPart)(part))));
+	span.attribute("gen_ai.completion", toJsonText(Option.getOrUndefined(completion)));
+	if (usage.inputTokens.cacheRead !== void 0) span.attribute("gen_ai.usage.cache_read_input_tokens", usage.inputTokens.cacheRead);
+	if (usage.inputTokens.cacheWrite !== void 0) span.attribute("gen_ai.usage.cache_creation_input_tokens", usage.inputTokens.cacheWrite);
+});
+/** @internal */
+const chatSpan = (prompt, attributes) => (self) => Effect.gen(function* () {
+	const name = yield* Effect.serviceOption(Model.ModelName);
+	return yield* Effect.gen(function* () {
+		const response = yield* self;
+		yield* annotateChat(response, name).pipe(Effect.ignore);
+		return response;
+	}).pipe(Effect.withSpan(Option.match(name, {
+		onNone: () => "chat",
+		onSome: (model) => `chat ${model}`
+	}), {
+		kind: "client",
+		attributes: {
+			"gen_ai.prompt": toJsonText(Option.map(encodePrompt(prompt), (encoded) => encoded.content)),
+			...attributes
+		}
+	}));
+});
+/** @internal */
+const toolSpan = (call) => Effect.withSpan(`execute_tool ${call.name}`, {
+	kind: "internal",
+	attributes: {
+		"gen_ai.operation.name": "execute_tool",
+		"gen_ai.tool.name": call.name,
+		"gen_ai.tool.call.id": call.id,
+		"input.value": toJsonText({ arguments: call.params })
+	}
+});
+/** @internal */
+const toolOutput = (result) => Effect.annotateCurrentSpan("output.value", Schema.is(Schema.String)(result) ? result : toJsonText(result));
+//#endregion
+export { agentInput, agentOutput, agentSpan, chatSpan, currentTraceId, toolOutput, toolSpan };
+
+//# sourceMappingURL=telemetry.js.map

package/dist/internal/telemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.js","names":["AssistantEvent.ModelPart"],"sources":["../../src/internal/telemetry.ts"],"sourcesContent":["import type * as LanguageModel from \"effect/ai/LanguageModel\"\nimport * as Model from \"effect/ai/Model\"\nimport * as Prompt from \"effect/ai/Prompt\"\nimport * as Telemetry from \"effect/ai/Telemetry\"\nimport type * as Tool from \"effect/ai/Tool\"\nimport * as Effect from \"effect/Effect\"\nimport * as Option from \"effect/Option\"\nimport * as References from \"effect/References\"\nimport * as Schema from \"effect/Schema\"\nimport * as Tracer from \"effect/Tracer\"\nimport * as AssistantEvent from \"../AssistantEvent.ts\"\nimport type { SpanAttributes } from \"../Instructions.ts\"\nimport { toJsonText } from \"./schema.ts\"\n\ntype Traced = string | ReadonlyArray<{ readonly _tag: string }>\n\n// Spans follow the OpenTelemetry GenAI conventions, so LLM tools (Langfuse, Phoenix, Datadog LLM Observability) can\n// pick the agent work out of a trace.\n/** @internal */\nexport const agentSpan = (name: string, options: { readonly chatId: string; readonly root?: boolean }) =>\n  Effect.withSpan(`invoke_agent ${name}`, {\n    kind: \"internal\",\n    root: options.root ?? false,\n    attributes: {\n      \"gen_ai.operation.name\": \"invoke_agent\",\n      \"gen_ai.agent.name\": name,\n      \"gen_ai.conversation.id\": options.chatId,\n      \"session.id\": options.chatId\n    }\n  })\n\n// None when tracing is off, or when the tracer is Effect's own, which exports nothing.\n/** @internal */\nexport const currentTraceId: Effect.Effect<Option.Option<string>> = Effect.gen(function* () {\n  const tracer = yield* Tracer.Tracer\n\n  if (!(yield* References.TracerEnabled) || tracer === Tracer.nativeTracer) return Option.none()\n\n  return Option.map(yield* Effect.option(Effect.currentSpan), (span) => span.traceId)\n})\n\n/** @internal */\nexport const agentInput = (input: Traced) => Effect.annotateCurrentSpan(\"input.value\", toJsonText(input))\n\n/** @internal */\nexport const agentOutput = (output: Traced) => Effect.annotateCurrentSpan(\"output.value\", toJsonText(output))\n\nconst encodePrompt = Schema.encodeOption(Prompt.Prompt)\n\nconst encodeParts = Schema.encodeOption(Schema.Array(AssistantEvent.ModelPart))\n\nconst annotateChat = Effect.fnUntraced(function* <Tools extends Record<string, Tool.Any>>(\n  response: LanguageModel.GenerateTextResponse<Tools, \"opaque\">,\n  name: Option.Option<string>\n) {\n  const span = yield* Effect.currentSpan\n  const { usage } = response\n\n  Telemetry.addGenAIAnnotations(span, {\n    operation: { name: \"chat\" },\n    request: { model: Option.getOrUndefined(name) },\n    response: { finishReasons: [response.finishReason] },\n    usage: {\n      inputTokens: usage.inputTokens.total,\n      outputTokens: usage.outputTokens.total\n    }\n  })\n\n  const completion = encodeParts(\n    response.content.flatMap((part) => Option.toArray(Schema.decodeUnknownOption(AssistantEvent.ModelPart)(part)))\n  )\n\n  span.attribute(\"gen_ai.completion\", toJsonText(Option.getOrUndefined(completion)))\n\n  if (usage.inputTokens.cacheRead !== undefined) {\n    span.attribute(\"gen_ai.usage.cache_read_input_tokens\", usage.inputTokens.cacheRead)\n  }\n\n  if (usage.inputTokens.cacheWrite !== undefined) {\n    span.attribute(\"gen_ai.usage.cache_creation_input_tokens\", usage.inputTokens.cacheWrite)\n  }\n})\n\n// Named after the model when the context has its name (`AnthropicLanguageModel.model(...)` provides it).\n/** @internal */\nexport const chatSpan =\n  (prompt: Prompt.Prompt, attributes: SpanAttributes | undefined) =>\n  <Tools extends Record<string, Tool.Any>, E, R>(\n    self: Effect.Effect<LanguageModel.GenerateTextResponse<Tools, \"opaque\">, E, R>\n  ): Effect.Effect<LanguageModel.GenerateTextResponse<Tools, \"opaque\">, E, R> =>\n    Effect.gen(function* () {\n      const name = yield* Effect.serviceOption(Model.ModelName)\n\n      return yield* Effect.gen(function* () {\n        const response = yield* self\n\n        yield* annotateChat(response, name).pipe(Effect.ignore)\n\n        return response\n      }).pipe(\n        Effect.withSpan(Option.match(name, { onNone: () => \"chat\", onSome: (model) => `chat ${model}` }), {\n          kind: \"client\",\n          attributes: {\n            \"gen_ai.prompt\": toJsonText(Option.map(encodePrompt(prompt), (encoded) => encoded.content)),\n            ...attributes\n          }\n        })\n      )\n    })\n\n/** @internal */\nexport const toolSpan = (call: AssistantEvent.ToolCallPart) =>\n  Effect.withSpan(`execute_tool ${call.name}`, {\n    kind: \"internal\",\n    attributes: {\n      \"gen_ai.operation.name\": \"execute_tool\",\n      \"gen_ai.tool.name\": call.name,\n      \"gen_ai.tool.call.id\": call.id,\n      \"input.value\": toJsonText({ arguments: call.params })\n    }\n  })\n\n/** @internal */\nexport const toolOutput = (result: Schema.Json) =>\n  Effect.annotateCurrentSpan(\"output.value\", Schema.is(Schema.String)(result) ? result : toJsonText(result))\n"],"mappings":";;;;;;;;;;;;AAmBA,MAAa,aAAa,MAAc,YACtC,OAAO,SAAS,gBAAgB,QAAQ;CACtC,MAAM;CACN,MAAM,QAAQ,QAAQ;CACtB,YAAY;EACV,yBAAyB;EACzB,qBAAqB;EACrB,0BAA0B,QAAQ;EAClC,cAAc,QAAQ;CACxB;AACF,CAAC;;AAIH,MAAa,iBAAuD,OAAO,IAAI,aAAa;CAC1F,MAAM,SAAS,OAAO,OAAO;CAE7B,IAAI,EAAE,OAAO,WAAW,kBAAkB,WAAW,OAAO,cAAc,OAAO,OAAO,KAAK;CAE7F,OAAO,OAAO,IAAI,OAAO,OAAO,OAAO,OAAO,WAAW,IAAI,SAAS,KAAK,OAAO;AACpF,CAAC;;AAGD,MAAa,cAAc,UAAkB,OAAO,oBAAoB,eAAe,WAAW,KAAK,CAAC;;AAGxG,MAAa,eAAe,WAAmB,OAAO,oBAAoB,gBAAgB,WAAW,MAAM,CAAC;AAE5G,MAAM,eAAe,OAAO,aAAa,OAAO,MAAM;AAEtD,MAAM,cAAc,OAAO,aAAa,OAAO,MAAMA,SAAwB,CAAC;AAE9E,MAAM,eAAe,OAAO,WAAW,WACrC,UACA,MACA;CACA,MAAM,OAAO,OAAO,OAAO;CAC3B,MAAM,EAAE,UAAU;CAElB,UAAU,oBAAoB,MAAM;EAClC,WAAW,EAAE,MAAM,OAAO;EAC1B,SAAS,EAAE,OAAO,OAAO,eAAe,IAAI,EAAE;EAC9C,UAAU,EAAE,eAAe,CAAC,SAAS,YAAY,EAAE;EACnD,OAAO;GACL,aAAa,MAAM,YAAY;GAC/B,cAAc,MAAM,aAAa;EACnC;CACF,CAAC;CAED,MAAM,aAAa,YACjB,SAAS,QAAQ,SAAS,SAAS,OAAO,QAAQ,OAAO,oBAAoBA,SAAwB,CAAC,CAAC,IAAI,CAAC,CAAC,CAC/G;CAEA,KAAK,UAAU,qBAAqB,WAAW,OAAO,eAAe,UAAU,CAAC,CAAC;CAEjF,IAAI,MAAM,YAAY,cAAc,KAAA,GAClC,KAAK,UAAU,wCAAwC,MAAM,YAAY,SAAS;CAGpF,IAAI,MAAM,YAAY,eAAe,KAAA,GACnC,KAAK,UAAU,4CAA4C,MAAM,YAAY,UAAU;AAE3F,CAAC;;AAID,MAAa,YACV,QAAuB,gBAEtB,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,OAAO,OAAO,OAAO,cAAc,MAAM,SAAS;CAExD,OAAO,OAAO,OAAO,IAAI,aAAa;EACpC,MAAM,WAAW,OAAO;EAExB,OAAO,aAAa,UAAU,IAAI,CAAC,CAAC,KAAK,OAAO,MAAM;EAEtD,OAAO;CACT,CAAC,CAAC,CAAC,KACD,OAAO,SAAS,OAAO,MAAM,MAAM;EAAE,cAAc;EAAQ,SAAS,UAAU,QAAQ;CAAQ,CAAC,GAAG;EAChG,MAAM;EACN,YAAY;GACV,iBAAiB,WAAW,OAAO,IAAI,aAAa,MAAM,IAAI,YAAY,QAAQ,OAAO,CAAC;GAC1F,GAAG;EACL;CACF,CAAC,CACH;AACF,CAAC;;AAGL,MAAa,YAAY,SACvB,OAAO,SAAS,gBAAgB,KAAK,QAAQ;CAC3C,MAAM;CACN,YAAY;EACV,yBAAyB;EACzB,oBAAoB,KAAK;EACzB,uBAAuB,KAAK;EAC5B,eAAe,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC;CACtD;AACF,CAAC;;AAGH,MAAa,cAAc,WACzB,OAAO,oBAAoB,gBAAgB,OAAO,GAAG,OAAO,MAAM,CAAC,CAAC,MAAM,IAAI,SAAS,WAAW,MAAM,CAAC"}

package/dist/internal/toolkit.d.ts

@@ -0,0 +1,76 @@
+import { AssistantEvent_d_exports, ToolCallPart, ToolOutcome } from "../AssistantEvent.js";
+import { AssistantToolCall } from "../AssistantToolCall.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Prompt from "effect/ai/Prompt";
+import * as Tool from "effect/ai/Tool";
+import * as Toolkit from "effect/ai/Toolkit";
+declare namespace toolkit_d_exports {
+  export { CallResult, ToolServices, Tools, duplicateNames, empty, failed, fromToolkit, fromToolkitOrEmpty, fromWithHandler, merge, needsDecision, needsDecisionOf, provide, runNative, runOnly, withContext };
+}
+/** @internal */
+export interface CallResult {
+  readonly outcome: ToolOutcome;
+  readonly result: Schema.Json;
+  readonly reason?: string | undefined;
+}
+/** @internal */
+export interface Tools<out R = never> {
+  readonly definitions: ReadonlyArray<Tool.Any>;
+  readonly run: (call: ToolCallPart) => Effect.Effect<CallResult, never, R>;
+  readonly needsDecision?: ((call: ToolCallPart, history: ReadonlyArray<Prompt.Message>) => Effect.Effect<boolean, never, R>) | undefined;
+}
+/** @internal */
+export type ToolServices<T extends Record<string, Tool.Any>> = Exclude<Tool.HandlerServices<T[keyof T]>, AssistantToolCall> | T[keyof T]["parametersSchema"]["DecodingServices"];
+/** @internal */
+export declare const failed: (message: string, reason: string) => CallResult;
+/** @internal */
+export declare const needsDecision: <T extends Record<string, Tool.Any>>(toolkit: {
+  readonly tools: T;
+}, call: {
+  readonly type: "tool-call";
+  readonly id: string;
+  readonly params: Schema.Json;
+  readonly providerExecuted: boolean;
+  readonly "~effect/ai/Response/Part": "~effect/ai/Response/Part";
+  readonly metadata: {
+    readonly [x: string]: Schema.Json;
+  };
+  readonly name: string;
+}, history: readonly Prompt.Message[]) => Effect.Effect<boolean, never, ToolServices<T>>;
+/** @internal */
+export declare const runNative: <T extends Record<string, Tool.Any>>(toolkit: Toolkit.WithHandler<T>, call: {
+  readonly type: "tool-call";
+  readonly id: string;
+  readonly params: Schema.Json;
+  readonly providerExecuted: boolean;
+  readonly "~effect/ai/Response/Part": "~effect/ai/Response/Part";
+  readonly metadata: {
+    readonly [x: string]: Schema.Json;
+  };
+  readonly name: string;
+}) => Effect.Effect<CallResult, never, ToolServices<T>>;
+/** @internal */
+export declare const fromWithHandler: <T extends Record<string, Tool.Any>>(toolkit: Toolkit.WithHandler<T>) => Tools<ToolServices<T>>;
+/** @internal */
+export declare const fromToolkit: <T extends Record<string, Tool.Any>>(toolkit: Toolkit.Toolkit<T>) => Tools<ToolServices<T> | Tool.HandlersFor<T>>;
+/** @internal */
+export declare const withContext: <T extends Record<string, Tool.Any>, R>(toolkit: Toolkit.Toolkit<T>, handlers: (context: Context.Context<R>) => Toolkit.HandlersFrom<T>) => Tools<R | ToolServices<T>>;
+/** @internal */
+export declare const fromToolkitOrEmpty: <T extends Record<string, Tool.Any>>(toolkit: Toolkit.Toolkit<T> | undefined) => Tools<ToolServices<T> | Tool.HandlersFor<T>>;
+/** @internal */
+export declare const empty: Tools;
+/** @internal */
+export declare const merge: <A, B>(self: Tools<A>, that: Tools<B>) => Tools<A | B>;
+/** @internal */
+export declare const needsDecisionOf: <R>(tools: Tools<R>, call: ToolCallPart, history: ReadonlyArray<Prompt.Message>) => Effect.Effect<boolean, never, R>;
+/** @internal */
+export declare const provide: <R>(tools: Tools<R>, context: Context.Context<R>) => Tools;
+/** @internal */
+export declare const duplicateNames: (tools: Tools<unknown>) => ReadonlyArray<string>;
+/** @internal */
+export declare const runOnly: <R>(tools: Tools<R>, names: ReadonlyArray<string>, message: string) => Tools<R>;
+//#endregion
+export { toolkit_d_exports };
+//# sourceMappingURL=toolkit.d.ts.map

package/dist/internal/toolkit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolkit.d.ts","names":[],"sources":["../../src/internal/toolkit.ts"],"mappings":";;;;;;;;;;;;iBAgBiB;WACN,SAAS;WACT,QAAQ,OAAO;WACf;;;iBAKM,UAAU;WAChB,aAAa,cAAc,KAAK;WAChC,MAAM,MAAM,iBAAgC,OAAO,OAAO,mBAAmB;WAE7E,kBACH,MAAM,cAA6B,SAAS,cAAc,OAAO,aAAa,OAAO,uBAAuB;;;YAKxG,aAAa,UAAU,eAAe,KAAK,QACnD,QAAQ,KAAK,gBAAgB,QAAQ,KAAK,qBAE1C,QAAQ;;qBAKC,SAAM,iBAAmB,mBAAmB;;qBAkC5C,gBAA6C,UAAU,eAAe,KAAK,MAAI;WAC/D,OAAA;;;;;;;;;;;GAoB3B,kBAAA,OAAA,cAAA,OAAA,uBAAA,aAAA;;qBASW,YAAyC,UAAU,eAAe,KAAK,MAAI,SAAA,QAAA,YAAA,IAAA;;;;;;;;;;MAiCtF,OAAA,OAAA,mBAAA,aAAA;;qBAGW,kBAAmB,UAAU,eAAe,KAAK,MAAI,SACvD,QAAQ,YAAY,OAC5B,MAAM,aAAa;;qBAOT,cAAe,UAAU,eAAe,KAAK,MAAI,SACnD,QAAQ,QAAQ,OACxB,MAAM,aAAa,KAAK,KAAK,YAAY;;qBAU/B,cAAe,UAAU,eAAe,KAAK,MAAM,GAAC,SACtD,QAAQ,QAAQ,IAAE,WAChB,SAAS,QAAQ,QAAQ,OAAO,QAAQ,aAAa,OAC/D,MAAM,IAAI,aAAa;;qBAYb,qBAAsB,UAAU,eAAe,KAAK,MAAI,SAC1D,QAAQ,QAAQ,mBACxB,MAAM,aAAa,KAAK,KAAK,YAAY;;qBAG/B,OAAO;;qBAMP,QAAS,GAAG,GAAC,MAAQ,MAAM,IAAE,MAAQ,MAAM,OAAK,MAAM,IAAI;;qBAY1D,kBAAmB,GAAC,OACxB,MAAM,IAAE,MACT,cAA2B,SACxB,cAAc,OAAO,aAC7B,OAAO,uBAAuB;;qBAKpB,UAAW,GAAC,OAAS,MAAM,IAAE,SAAW,QAAQ,QAAQ,OAAK;;qBAO7D,iBAAc,OAAW,mBAAiB;;qBAQ1C,UAAW,GAAC,OAAS,MAAM,IAAE,OAAS,uBAAqB,oBAAoB,MAAM"}

package/dist/internal/toolkit.js

@@ -0,0 +1,129 @@
+import { toJson } from "./schema.js";
+import { AssistantToolCall } from "../AssistantToolCall.js";
+import { ToolFailure } from "../ToolFailure.js";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as Option from "effect/Option";
+import * as AiError from "effect/ai/AiError";
+//#region src/internal/toolkit.ts
+const encodeFailure = Schema.encodeSync(ToolFailure);
+/** @internal */
+const failed = (message, reason) => ({
+	outcome: "failure",
+	result: toJson(encodeFailure(new ToolFailure({
+		message,
+		reason
+	}))),
+	reason
+});
+const decodeReason = Schema.decodeUnknownOption(Schema.Struct({ reason: Schema.String }));
+const decodeTag = Schema.decodeUnknownOption(Schema.Struct({ _tag: Schema.String }));
+const failure = (result) => ({
+	outcome: "failure",
+	result,
+	reason: Option.getOrUndefined(Option.orElse(Option.map(decodeReason(result), ({ reason }) => reason), () => Option.map(decodeTag(result), ({ _tag }) => _tag)))
+});
+const hasTool = (toolkit, name) => Object.hasOwn(toolkit.tools, name);
+const toolNamed = (toolkit, name) => Object.hasOwn(toolkit.tools, name) ? toolkit.tools[name] : void 0;
+const decodeParams = (tool, params) => Schema.decodeUnknownEffect(tool.parametersSchema)(params);
+/** @internal */
+const needsDecision = Effect.fnUntraced(function* (toolkit, call, history) {
+	const tool = toolNamed(toolkit, call.name);
+	if (tool === void 0) return false;
+	const needs = tool.needsApproval;
+	if (needs === void 0 || Predicate.isBoolean(needs)) return needs === true;
+	return yield* Effect.gen(function* () {
+		const decided = needs(yield* decodeParams(tool, call.params), {
+			toolCallId: call.id,
+			messages: history
+		});
+		return Effect.isEffect(decided) ? yield* decided : decided;
+	}).pipe(Effect.orElseSucceed(() => false));
+});
+const isParams = (params) => params !== void 0;
+/** @internal */
+const runNative = Effect.fnUntraced(function* (toolkit, call) {
+	const name = call.name;
+	if (!hasTool(toolkit, name)) return failed(`No tool named ${call.name}.`, "ToolNotFoundError");
+	const params = call.params;
+	if (!isParams(params)) return failed(`Invalid parameters for ${call.name}.`, "ToolParameterValidationError");
+	return yield* Effect.gen(function* () {
+		const results = yield* toolkit.handle(name, params, call.id);
+		const last = yield* Stream.runLast(Stream.filter(results, (result) => !result.preliminary));
+		return Option.match(last, {
+			onNone: () => failed(`${call.name} returned no result.`, "NoResult"),
+			onSome: (result) => result.isFailure ? failure(toJson(result.encodedResult)) : {
+				outcome: "success",
+				result: toJson(result.encodedResult)
+			}
+		});
+	}).pipe(Effect.catch((error) => Effect.succeed(AiError.isAiError(error) ? failed(error.reason.message, error.reason._tag) : failure(toJson(error)))), Effect.provideService(AssistantToolCall, {
+		callId: call.id,
+		tool: call.name
+	}));
+});
+/** @internal */
+const fromWithHandler = (toolkit) => ({
+	definitions: Object.values(toolkit.tools),
+	run: (call) => runNative(toolkit, call),
+	needsDecision: (call, history) => needsDecision(toolkit, call, history)
+});
+/** @internal */
+const fromToolkit = (toolkit) => ({
+	definitions: Object.values(toolkit.tools),
+	run: Effect.fnUntraced(function* (call) {
+		return yield* runNative(yield* toolkit, call);
+	}),
+	needsDecision: (call, history) => needsDecision(toolkit, call, history)
+});
+/** @internal */
+const withContext = (toolkit, handlers) => ({
+	definitions: Object.values(toolkit.tools),
+	run: Effect.fnUntraced(function* (call) {
+		const context = yield* Effect.context();
+		const resolved = yield* Effect.provideContext(toolkit, yield* toolkit.toHandlers(handlers(context)));
+		return yield* runNative(resolved, call);
+	}),
+	needsDecision: (call, history) => needsDecision(toolkit, call, history)
+});
+/** @internal */
+const fromToolkitOrEmpty = (toolkit) => toolkit === void 0 ? empty : fromToolkit(toolkit);
+/** @internal */
+const empty = {
+	definitions: [],
+	run: (call) => Effect.succeed(failed(`No tool named ${call.name}.`, "ToolNotFoundError"))
+};
+/** @internal */
+const merge = (self, that) => {
+	const inSelf = (call) => self.definitions.some((tool) => tool.name === call.name);
+	return {
+		definitions: [...self.definitions, ...that.definitions],
+		run: (call) => inSelf(call) ? self.run(call) : that.run(call),
+		needsDecision: (call, history) => inSelf(call) ? needsDecisionOf(self, call, history) : needsDecisionOf(that, call, history)
+	};
+};
+/** @internal */
+const needsDecisionOf = (tools, call, history) => tools.needsDecision === void 0 ? Effect.succeed(false) : tools.needsDecision(call, history);
+/** @internal */
+const provide = (tools, context) => ({
+	definitions: tools.definitions,
+	run: (call) => Effect.provideContext(tools.run(call), context),
+	needsDecision: (call, history) => Effect.provideContext(needsDecisionOf(tools, call, history), context)
+});
+/** @internal */
+const duplicateNames = (tools) => {
+	const names = tools.definitions.map((tool) => tool.name);
+	return names.filter((name, i) => names.indexOf(name) !== i);
+};
+/** @internal */
+const runOnly = (tools, names, message) => ({
+	definitions: tools.definitions,
+	run: (call) => names.includes(call.name) ? tools.run(call) : Effect.succeed(failed(message, "NotNow")),
+	needsDecision: (call, history) => names.includes(call.name) ? needsDecisionOf(tools, call, history) : Effect.succeed(false)
+});
+//#endregion
+export { duplicateNames, empty, failed, fromToolkit, fromToolkitOrEmpty, fromWithHandler, merge, needsDecision, needsDecisionOf, provide, runNative, runOnly, withContext };
+
+//# sourceMappingURL=toolkit.js.map

package/dist/internal/toolkit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolkit.js","names":["ToolFailure.ToolFailure"],"sources":["../../src/internal/toolkit.ts"],"sourcesContent":["import * as AiError from \"effect/ai/AiError\"\nimport type * as Prompt from \"effect/ai/Prompt\"\nimport type * as Tool from \"effect/ai/Tool\"\nimport type * as Toolkit from \"effect/ai/Toolkit\"\nimport type * as Context from \"effect/Context\"\nimport * 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 Stream from \"effect/Stream\"\nimport type * as AssistantEvent from \"../AssistantEvent.ts\"\nimport { AssistantToolCall } from \"../AssistantToolCall.ts\"\nimport * as ToolFailure from \"../ToolFailure.ts\"\nimport { toJson } from \"./schema.ts\"\n\n/** @internal */\nexport interface CallResult {\n  readonly outcome: AssistantEvent.ToolOutcome\n  readonly result: Schema.Json\n  readonly reason?: string | undefined\n}\n\n// Apps give the loop native toolkits; these are what the loop makes of them, merged with its own.\n/** @internal */\nexport interface Tools<out R = never> {\n  readonly definitions: ReadonlyArray<Tool.Any>\n  readonly run: (call: AssistantEvent.ToolCallPart) => Effect.Effect<CallResult, never, R>\n  // Unset: no call waits for the user's decision.\n  readonly needsDecision?:\n    | ((call: AssistantEvent.ToolCallPart, history: ReadonlyArray<Prompt.Message>) => Effect.Effect<boolean, never, R>)\n    | undefined\n}\n\n/** @internal */\nexport type ToolServices<T extends Record<string, Tool.Any>> =\n  | Exclude<Tool.HandlerServices<T[keyof T]>, AssistantToolCall>\n  // Already in the handlers' services; stated for the loop, which decodes params to decide on a call.\n  | T[keyof T][\"parametersSchema\"][\"DecodingServices\"]\n\nconst encodeFailure = Schema.encodeSync(ToolFailure.ToolFailure)\n\n/** @internal */\nexport const failed = (message: string, reason: string): CallResult => ({\n  outcome: \"failure\",\n  result: toJson(encodeFailure(new ToolFailure.ToolFailure({ message, reason }))),\n  reason\n})\n\nconst decodeReason = Schema.decodeUnknownOption(Schema.Struct({ reason: Schema.String }))\n\nconst decodeTag = Schema.decodeUnknownOption(Schema.Struct({ _tag: Schema.String }))\n\nconst failure = (result: Schema.Json): CallResult => ({\n  outcome: \"failure\",\n  result,\n  reason: Option.getOrUndefined(\n    Option.orElse(\n      Option.map(decodeReason(result), ({ reason }) => reason),\n      () => Option.map(decodeTag(result), ({ _tag }) => _tag)\n    )\n  )\n})\n\nconst hasTool = <T extends Record<string, Tool.Any>>(\n  toolkit: { readonly tools: T },\n  name: PropertyKey\n): name is keyof T => Object.hasOwn(toolkit.tools, name)\n\n// With noUncheckedIndexedAccess, an index doesn't narrow on `hasTool`.\nconst toolNamed = (toolkit: { readonly tools: Record<string, Tool.Any> }, name: string): Tool.Any | undefined =>\n  Object.hasOwn(toolkit.tools, name) ? toolkit.tools[name] : undefined\n\nconst decodeParams = (tool: Tool.Any, params: Schema.Json) => Schema.decodeUnknownEffect(tool.parametersSchema)(params)\n\n// Params that don't fit the tool don't park: the call runs, and fails with why.\n/** @internal */\nexport const needsDecision = Effect.fnUntraced(function* <T extends Record<string, Tool.Any>>(\n  toolkit: { readonly tools: T },\n  call: AssistantEvent.ToolCallPart,\n  history: ReadonlyArray<Prompt.Message>\n): Effect.fn.Return<boolean, never, ToolServices<T>> {\n  const tool = toolNamed(toolkit, call.name)\n\n  if (tool === undefined) return false\n\n  const needs = tool.needsApproval\n\n  if (needs === undefined || Predicate.isBoolean(needs)) return needs === true\n\n  return yield* Effect.gen(function* () {\n    const decided = needs(yield* decodeParams(tool, call.params), {\n      toolCallId: call.id,\n      messages: history\n    })\n\n    return Effect.isEffect(decided) ? yield* decided : decided\n  }).pipe(Effect.orElseSucceed(() => false))\n})\n\n// The toolkit decodes the params with the tool's schema before its handler sees them, and a call whose params don't\n// fit fails with a validation error the model reads: the model's JSON is what `handle` takes.\nconst isParams = <T>(params: unknown): params is Tool.ParametersEncoded<T> => params !== undefined\n\n// Every failure is the call's result, for the model to read. With `failureMode: \"return\"` the toolkit encodes the\n// tool's own failure with its schema first.\n/** @internal */\nexport const runNative = Effect.fnUntraced(function* <T extends Record<string, Tool.Any>>(\n  toolkit: Toolkit.WithHandler<T>,\n  call: AssistantEvent.ToolCallPart\n): Effect.fn.Return<CallResult, never, ToolServices<T>> {\n  const name: PropertyKey = call.name\n\n  if (!hasTool(toolkit, name)) return failed(`No tool named ${call.name}.`, \"ToolNotFoundError\")\n\n  const params: unknown = call.params\n\n  if (!isParams<T[keyof T]>(params)) {\n    return failed(`Invalid parameters for ${call.name}.`, \"ToolParameterValidationError\")\n  }\n\n  return yield* Effect.gen(function* () {\n    const results = yield* toolkit.handle<keyof T>(name, params, call.id)\n    const last = yield* Stream.runLast(Stream.filter(results, (result) => !result.preliminary))\n\n    return Option.match(last, {\n      onNone: () => failed(`${call.name} returned no result.`, \"NoResult\"),\n      onSome: (result): CallResult =>\n        result.isFailure\n          ? failure(toJson(result.encodedResult))\n          : { outcome: \"success\", result: toJson(result.encodedResult) }\n    })\n  }).pipe(\n    Effect.catch((error) =>\n      Effect.succeed(\n        AiError.isAiError(error) ? failed(error.reason.message, error.reason._tag) : failure(toJson(error))\n      )\n    ),\n    Effect.provideService(AssistantToolCall, { callId: call.id, tool: call.name })\n  )\n})\n\n/** @internal */\nexport const fromWithHandler = <T extends Record<string, Tool.Any>>(\n  toolkit: Toolkit.WithHandler<T>\n): Tools<ToolServices<T>> => ({\n  definitions: Object.values(toolkit.tools),\n  run: (call) => runNative(toolkit, call),\n  needsDecision: (call, history) => needsDecision(toolkit, call, history)\n})\n\n/** @internal */\nexport const fromToolkit = <T extends Record<string, Tool.Any>>(\n  toolkit: Toolkit.Toolkit<T>\n): Tools<ToolServices<T> | Tool.HandlersFor<T>> => ({\n  definitions: Object.values(toolkit.tools),\n  run: Effect.fnUntraced(function* (call) {\n    return yield* runNative(yield* toolkit, call)\n  }),\n  needsDecision: (call, history) => needsDecision(toolkit, call, history)\n})\n\n// The handlers use services of the loop they run in, so they're made for each call, with its context.\n/** @internal */\nexport const withContext = <T extends Record<string, Tool.Any>, R>(\n  toolkit: Toolkit.Toolkit<T>,\n  handlers: (context: Context.Context<R>) => Toolkit.HandlersFrom<T>\n): Tools<R | ToolServices<T>> => ({\n  definitions: Object.values(toolkit.tools),\n  run: Effect.fnUntraced(function* (call) {\n    const context = yield* Effect.context<R>()\n    const resolved = yield* Effect.provideContext(toolkit, yield* toolkit.toHandlers(handlers(context)))\n\n    return yield* runNative(resolved, call)\n  }),\n  needsDecision: (call, history) => needsDecision(toolkit, call, history)\n})\n\n/** @internal */\nexport const fromToolkitOrEmpty = <T extends Record<string, Tool.Any>>(\n  toolkit: Toolkit.Toolkit<T> | undefined\n): Tools<ToolServices<T> | Tool.HandlersFor<T>> => (toolkit === undefined ? empty : fromToolkit(toolkit))\n\n/** @internal */\nexport const empty: Tools = {\n  definitions: [],\n  run: (call) => Effect.succeed(failed(`No tool named ${call.name}.`, \"ToolNotFoundError\"))\n}\n\n/** @internal */\nexport const merge = <A, B>(self: Tools<A>, that: Tools<B>): Tools<A | B> => {\n  const inSelf = (call: AssistantEvent.ToolCallPart) => self.definitions.some((tool) => tool.name === call.name)\n\n  return {\n    definitions: [...self.definitions, ...that.definitions],\n    run: (call) => (inSelf(call) ? self.run(call) : that.run(call)),\n    needsDecision: (call, history) =>\n      inSelf(call) ? needsDecisionOf(self, call, history) : needsDecisionOf(that, call, history)\n  }\n}\n\n/** @internal */\nexport const needsDecisionOf = <R>(\n  tools: Tools<R>,\n  call: AssistantEvent.ToolCallPart,\n  history: ReadonlyArray<Prompt.Message>\n): Effect.Effect<boolean, never, R> =>\n  tools.needsDecision === undefined ? Effect.succeed(false) : tools.needsDecision(call, history)\n\n// A turn's own services, for a loop the app writes.\n/** @internal */\nexport const provide = <R>(tools: Tools<R>, context: Context.Context<R>): Tools => ({\n  definitions: tools.definitions,\n  run: (call) => Effect.provideContext(tools.run(call), context),\n  needsDecision: (call, history) => Effect.provideContext(needsDecisionOf(tools, call, history), context)\n})\n\n/** @internal */\nexport const duplicateNames = (tools: Tools<unknown>): ReadonlyArray<string> => {\n  const names = tools.definitions.map((tool) => tool.name)\n\n  return names.filter((name, i) => names.indexOf(name) !== i)\n}\n\n// The same tools are offered, so the prompt doesn't change.\n/** @internal */\nexport const runOnly = <R>(tools: Tools<R>, names: ReadonlyArray<string>, message: string): Tools<R> => ({\n  definitions: tools.definitions,\n  run: (call) => (names.includes(call.name) ? tools.run(call) : Effect.succeed(failed(message, \"NotNow\"))),\n  needsDecision: (call, history) =>\n    names.includes(call.name) ? needsDecisionOf(tools, call, history) : Effect.succeed(false)\n})\n"],"mappings":"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"}

package/dist/internal/tools.js

@@ -0,0 +1,132 @@
+import { fromKey } from "./uuid.js";
+import { AssistantMessage, MessageBlock, isLibraryEvent } from "../AssistantEvent.js";
+import { CurrentChat } from "../CurrentChat.js";
+import { Props, fromEntries } from "../Decision.js";
+import { fromEntries as fromEntries$1 } from "../BlockKit.js";
+import { AssistantToolCall } from "../AssistantToolCall.js";
+import { ToolFailure, fail } from "../ToolFailure.js";
+import { fromWithHandler } from "./toolkit.js";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+import * as Tool from "effect/ai/Tool";
+import * as Toolkit from "effect/ai/Toolkit";
+//#region src/internal/tools.ts
+/** @internal */
+const waitToolName = "wait";
+/** @internal */
+const sendUserMessageName = "send_user_message";
+const Wait = Tool.make(waitToolName, {
+	description: "End your turn and wait for the next message or update, when you have nothing more to do right now and no message to send (otherwise set wait on send_user_message).",
+	success: Schema.String
+});
+const description = "Send the user a chat message. It's the only way they see anything you write: text outside it is private to you.";
+const WaitFlag = Schema.Boolean.annotate({ description: "true when this is your last message for now: your turn ends with it, as with the wait tool. false when you keep working after it." });
+const endsWithMessage = Schema.decodeUnknownOption(Schema.Struct({ wait: Schema.Literal(true) }));
+/** @internal */
+const isTurnEnding = (call) => call.name === "wait" || call.name === "send_user_message" && Option.isSome(endsWithMessage(call.params));
+const messageId = AssistantToolCall.useSync((call) => fromKey(`message:${call.callId}`));
+const append = Effect.fnUntraced(function* (message) {
+	const chat = yield* CurrentChat;
+	if (!(yield* chat.entries).some(({ event }) => isLibraryEvent(event) && Predicate.isTagged(event, "AssistantMessage") && event.id === message.id)) yield* chat.append(message);
+});
+const PlainMessage = Tool.make(sendUserMessageName, {
+	description,
+	parameters: Schema.Struct({
+		text: Schema.String,
+		wait: WaitFlag
+	}),
+	success: Schema.String,
+	failure: ToolFailure,
+	dependencies: [CurrentChat, AssistantToolCall]
+});
+const PlainTools = Toolkit.make(PlainMessage, Wait);
+const plainHandlers = PlainTools.toHandlers({
+	wait: () => Effect.succeed("waiting"),
+	send_user_message: Effect.fnUntraced(function* ({ text }) {
+		yield* append(AssistantMessage.make({
+			id: yield* messageId,
+			text
+		}));
+		return "sent";
+	})
+});
+const plainTools = Effect.gen(function* () {
+	return yield* Effect.provideContext(PlainTools, yield* plainHandlers);
+});
+const decodeDecisionProps = Schema.decodeUnknownOption(Props);
+const checkDecisions = Effect.fnUntraced(function* (ids) {
+	const states = fromEntries(yield* CurrentChat.use((chat) => chat.entries));
+	const notWaiting = ids.filter((id) => states.get(id)?.outcome !== void 0 || !states.has(id));
+	if (notWaiting.length > 0) return yield* fail(`Not waiting for the user's decision: ${notWaiting.join(", ")}. Use the ids of decisions that wait for one.`, { reason: "NotWaitingForDecision" });
+});
+const checkCloses = Effect.fnUntraced(function* (ids) {
+	const entries = yield* CurrentChat.use((chat) => chat.entries);
+	const states = fromEntries$1(entries);
+	const waiting = ids.filter((id) => entries.some(({ event }) => isLibraryEvent(event) && Predicate.isTagged(event, "AssistantMessage") && event.id === id && event.block?.kind === "decision" && states.get(id)?.open === true));
+	if (waiting.length > 0) return yield* fail(`${waiting.join(", ")} asks for a decision that still waits for the user: only their answer in the block closes it. Send the message again without ${waiting.length === 1 ? "that id" : "those ids"} in closes.`, { reason: "DecisionWaiting" });
+});
+const blockTools = Effect.fnUntraced(function* (kit) {
+	const catalog = kit.blocks.map((block) => `- ${block.kind}: ${block.description}`).join("\n");
+	const kinds = kit.blocks.map((block) => block.kind);
+	const BlockMessage = Tool.make(sendUserMessageName, {
+		description: `${description}
+You can add a block to show UI with the message, e.g. a few options to pick from or a yes/no, when that makes answering easier than typing. Plain text is fine too. Using it sends you an <answer>; the user may also just type their answer instead, and then you pass that message's id in closes.
+Blocks:
+${catalog}`,
+		parameters: Schema.Struct({
+			text: Schema.String,
+			wait: WaitFlag,
+			block: Schema.optional(Schema.Struct({
+				kind: Schema.Literals(kinds),
+				props: Schema.Union(kit.blocks.map((block) => block.props))
+			})),
+			closes: Schema.optional(Schema.Array(Schema.String)).annotate({ description: "Ids of your earlier messages whose block the user just answered by typing instead of using it. Those blocks close. Leave it out otherwise: a block stays open when the user talks about something else. A decision block never closes this way: only the user's answer in it decides." })
+		}),
+		success: Schema.String,
+		failure: ToolFailure,
+		dependencies: [CurrentChat, AssistantToolCall]
+	});
+	const BlockTools = Toolkit.make(BlockMessage, Wait);
+	const handlers = yield* BlockTools.toHandlers({
+		wait: () => Effect.succeed("waiting"),
+		send_user_message: Effect.fnUntraced(function* ({ text, block, closes }) {
+			if (text.trim() === "") return yield* fail("The message has no text: the user sees only what you send here, and a block alone is an empty bubble. Send it again with the words they should read (a short lead-in for the block).", { reason: "EmptyMessage" });
+			const id = yield* messageId;
+			const closed = closes === void 0 || closes.length === 0 ? {} : { closes };
+			if (closes !== void 0 && closes.length > 0) yield* checkCloses(closes);
+			if (block === void 0) {
+				yield* append(AssistantMessage.make({
+					id,
+					text,
+					...closed
+				}));
+				return "sent";
+			}
+			const props = kit.byKind.get(block.kind)?.props;
+			if (props === void 0 || Option.isNone(Schema.decodeUnknownOption(props)(block.props))) return yield* fail(`Those props don't fit a ${block.kind} block.`);
+			if (block.kind === "decision") yield* checkDecisions(Option.match(decodeDecisionProps(block.props), {
+				onNone: () => [],
+				onSome: (decoded) => decoded.decisionIds
+			}));
+			yield* append(AssistantMessage.make({
+				id,
+				text,
+				block: MessageBlock.make(block),
+				...closed
+			}));
+			return `sent as message ${id}`;
+		})
+	});
+	return yield* Effect.provideContext(BlockTools, handlers);
+});
+/** @internal */
+const makeMessaging = Effect.fnUntraced(function* (kit) {
+	if (kit === void 0 || kit.blocks.length === 0) return fromWithHandler(yield* plainTools);
+	return fromWithHandler(yield* blockTools(kit));
+});
+//#endregion
+export { isTurnEnding, makeMessaging, sendUserMessageName, waitToolName };
+
+//# sourceMappingURL=tools.js.map

package/dist/internal/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","names":["Uuid.fromKey","AssistantEvent.isLibraryEvent","ToolFailure.ToolFailure","Decision.Props","Decision.fromEntries","ToolFailure.fail","BlockKit.fromEntries","Toolkits.fromWithHandler"],"sources":["../../src/internal/tools.ts"],"sourcesContent":["import * as Tool from \"effect/ai/Tool\"\nimport * as Toolkit from \"effect/ai/Toolkit\"\nimport * 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 { AssistantToolCall } from \"../AssistantToolCall.ts\"\nimport * as BlockKit from \"../BlockKit.ts\"\nimport { CurrentChat } from \"../CurrentChat.ts\"\nimport * as Decision from \"../Decision.ts\"\nimport * as ToolFailure from \"../ToolFailure.ts\"\nimport * as Toolkits from \"./toolkit.ts\"\nimport * as Uuid from \"./uuid.ts\"\n\n/** @internal */\nexport const waitToolName = \"wait\"\n\n/** @internal */\nexport const sendUserMessageName = \"send_user_message\"\n\nconst Wait = Tool.make(waitToolName, {\n  description:\n    \"End your turn and wait for the next message or update, when you have nothing more to do right now and no message to send (otherwise set wait on send_user_message).\",\n  success: Schema.String\n})\n\nconst description =\n  \"Send the user a chat message. It's the only way they see anything you write: text outside it is private to you.\"\n\nconst WaitFlag = Schema.Boolean.annotate({\n  description:\n    \"true when this is your last message for now: your turn ends with it, as with the wait tool. false when you keep working after it.\"\n})\n\nconst endsWithMessage = Schema.decodeUnknownOption(Schema.Struct({ wait: Schema.Literal(true) }))\n\n/** @internal */\nexport const isTurnEnding = (call: AssistantEvent.ToolCallPart): boolean =>\n  call.name === waitToolName || (call.name === sendUserMessageName && Option.isSome(endsWithMessage(call.params)))\n\n// From the call: a call cut off by a crash runs again with the same id, and finds its message already sent.\nconst messageId = AssistantToolCall.useSync((call) => Uuid.fromKey(`message:${call.callId}`))\n\nconst append = Effect.fnUntraced(function* (message: AssistantEvent.AssistantMessage) {\n  const chat = yield* CurrentChat\n  const entries = yield* chat.entries\n\n  const sent = entries.some(\n    ({ event }) =>\n      AssistantEvent.isLibraryEvent(event) && Predicate.isTagged(event, \"AssistantMessage\") && event.id === message.id\n  )\n\n  if (!sent) yield* chat.append(message)\n})\n\nconst PlainMessage = Tool.make(sendUserMessageName, {\n  description,\n  parameters: Schema.Struct({ text: Schema.String, wait: WaitFlag }),\n  success: Schema.String,\n  failure: ToolFailure.ToolFailure,\n  dependencies: [CurrentChat, AssistantToolCall]\n})\n\nconst PlainTools = Toolkit.make(PlainMessage, Wait)\n\nconst plainHandlers = PlainTools.toHandlers({\n  wait: () => Effect.succeed(\"waiting\"),\n  send_user_message: Effect.fnUntraced(function* ({ text }) {\n    yield* append(AssistantEvent.AssistantMessage.make({ id: yield* messageId, text }))\n\n    return \"sent\"\n  })\n})\n\nconst plainTools = Effect.gen(function* () {\n  return yield* Effect.provideContext(PlainTools, yield* plainHandlers)\n})\n\nconst decodeDecisionProps = Schema.decodeUnknownOption(Decision.Props)\n\nconst checkDecisions = Effect.fnUntraced(function* (ids: ReadonlyArray<string>) {\n  const states = Decision.fromEntries(yield* CurrentChat.use((chat) => chat.entries))\n  const notWaiting = ids.filter((id) => states.get(id)?.outcome !== undefined || !states.has(id))\n\n  if (notWaiting.length > 0) {\n    return yield* ToolFailure.fail(\n      `Not waiting for the user's decision: ${notWaiting.join(\", \")}. Use the ids of decisions that wait for one.`,\n      { reason: \"NotWaitingForDecision\" }\n    )\n  }\n})\n\n// A decision block closes when the user decides on it, not because the model says so: the order it asks about would\n// otherwise never be approved.\nconst checkCloses = Effect.fnUntraced(function* (ids: ReadonlyArray<string>) {\n  const entries = yield* CurrentChat.use((chat) => chat.entries)\n  const states = BlockKit.fromEntries(entries)\n\n  const waiting = ids.filter((id) =>\n    entries.some(\n      ({ event }) =>\n        AssistantEvent.isLibraryEvent(event) &&\n        Predicate.isTagged(event, \"AssistantMessage\") &&\n        event.id === id &&\n        event.block?.kind === Decision.kind &&\n        states.get(id)?.open === true\n    )\n  )\n\n  if (waiting.length > 0) {\n    return yield* ToolFailure.fail(\n      `${waiting.join(\", \")} asks for a decision that still waits for the user: only their answer in the block closes it. Send the message again without ${waiting.length === 1 ? \"that id\" : \"those ids\"} in closes.`,\n      { reason: \"DecisionWaiting\" }\n    )\n  }\n})\n\nconst blockTools = Effect.fnUntraced(function* (kit: BlockKit.BlockKit) {\n  const catalog = kit.blocks.map((block) => `- ${block.kind}: ${block.description}`).join(\"\\n\")\n  const kinds = kit.blocks.map((block) => block.kind)\n\n  const BlockMessage = Tool.make(sendUserMessageName, {\n    description: `${description}\nYou can add a block to show UI with the message, e.g. a few options to pick from or a yes/no, when that makes answering easier than typing. Plain text is fine too. Using it sends you an <answer>; the user may also just type their answer instead, and then you pass that message's id in closes.\nBlocks:\n${catalog}`,\n    // Props are checked against their kind's schema by the handler; the model sees every kind's in the parameters.\n    parameters: Schema.Struct({\n      text: Schema.String,\n      wait: WaitFlag,\n      block: Schema.optional(\n        Schema.Struct({\n          kind: Schema.Literals(kinds),\n          props: Schema.Union(kit.blocks.map((block) => block.props))\n        })\n      ),\n      closes: Schema.optional(Schema.Array(Schema.String)).annotate({\n        description:\n          \"Ids of your earlier messages whose block the user just answered by typing instead of using it. Those blocks close. Leave it out otherwise: a block stays open when the user talks about something else. A decision block never closes this way: only the user's answer in it decides.\"\n      })\n    }),\n    success: Schema.String,\n    failure: ToolFailure.ToolFailure,\n    dependencies: [CurrentChat, AssistantToolCall]\n  })\n\n  const BlockTools = Toolkit.make(BlockMessage, Wait)\n\n  const handlers = yield* BlockTools.toHandlers({\n    wait: () => Effect.succeed(\"waiting\"),\n    send_user_message: Effect.fnUntraced(function* ({ text, block, closes }) {\n      if (text.trim() === \"\") {\n        return yield* ToolFailure.fail(\n          \"The message has no text: the user sees only what you send here, and a block alone is an empty bubble. Send it again with the words they should read (a short lead-in for the block).\",\n          { reason: \"EmptyMessage\" }\n        )\n      }\n\n      const id = yield* messageId\n      const closed = closes === undefined || closes.length === 0 ? {} : { closes }\n\n      if (closes !== undefined && closes.length > 0) yield* checkCloses(closes)\n\n      if (block === undefined) {\n        yield* append(AssistantEvent.AssistantMessage.make({ id, text, ...closed }))\n\n        return \"sent\"\n      }\n\n      const props = kit.byKind.get(block.kind)?.props\n\n      if (props === undefined || Option.isNone(Schema.decodeUnknownOption(props)(block.props))) {\n        return yield* ToolFailure.fail(`Those props don't fit a ${block.kind} block.`)\n      }\n\n      if (block.kind === Decision.kind) {\n        yield* checkDecisions(\n          Option.match(decodeDecisionProps(block.props), {\n            onNone: () => [],\n            onSome: (decoded) => decoded.decisionIds\n          })\n        )\n      }\n\n      yield* append(\n        AssistantEvent.AssistantMessage.make({\n          id,\n          text,\n          block: AssistantEvent.MessageBlock.make(block),\n          ...closed\n        })\n      )\n\n      return `sent as message ${id}`\n    })\n  })\n\n  return yield* Effect.provideContext(BlockTools, handlers)\n})\n\n/** @internal */\nexport const makeMessaging: (kit: BlockKit.BlockKit | undefined) => Effect.Effect<Toolkits.Tools<CurrentChat>> =\n  Effect.fnUntraced(function* (kit) {\n    if (kit === undefined || kit.blocks.length === 0) {\n      return Toolkits.fromWithHandler(yield* plainTools)\n    }\n\n    return Toolkits.fromWithHandler(yield* blockTools(kit))\n  })\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAa,eAAe;;AAG5B,MAAa,sBAAsB;AAEnC,MAAM,OAAO,KAAK,KAAK,cAAc;CACnC,aACE;CACF,SAAS,OAAO;AAClB,CAAC;AAED,MAAM,cACJ;AAEF,MAAM,WAAW,OAAO,QAAQ,SAAS,EACvC,aACE,oIACJ,CAAC;AAED,MAAM,kBAAkB,OAAO,oBAAoB,OAAO,OAAO,EAAE,MAAM,OAAO,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAGhG,MAAa,gBAAgB,SAC3B,KAAK,SAAA,UAA0B,KAAK,SAAA,uBAAgC,OAAO,OAAO,gBAAgB,KAAK,MAAM,CAAC;AAGhH,MAAM,YAAY,kBAAkB,SAAS,SAASA,QAAa,WAAW,KAAK,QAAQ,CAAC;AAE5F,MAAM,SAAS,OAAO,WAAW,WAAW,SAA0C;CACpF,MAAM,OAAO,OAAO;CAQpB,IAAI,EALS,OAFU,KAAK,QAAA,CAEP,MAClB,EAAE,YACDC,eAA8B,KAAK,KAAK,UAAU,SAAS,OAAO,kBAAkB,KAAK,MAAM,OAAO,QAAQ,EAG1G,GAAG,OAAO,KAAK,OAAO,OAAO;AACvC,CAAC;AAED,MAAM,eAAe,KAAK,KAAK,qBAAqB;CAClD;CACA,YAAY,OAAO,OAAO;EAAE,MAAM,OAAO;EAAQ,MAAM;CAAS,CAAC;CACjE,SAAS,OAAO;CAChB,SAASC;CACT,cAAc,CAAC,aAAa,iBAAiB;AAC/C,CAAC;AAED,MAAM,aAAa,QAAQ,KAAK,cAAc,IAAI;AAElD,MAAM,gBAAgB,WAAW,WAAW;CAC1C,YAAY,OAAO,QAAQ,SAAS;CACpC,mBAAmB,OAAO,WAAW,WAAW,EAAE,QAAQ;EACxD,OAAO,OAAA,iBAAuC,KAAK;GAAE,IAAI,OAAO;GAAW;EAAK,CAAC,CAAC;EAElF,OAAO;CACT,CAAC;AACH,CAAC;AAED,MAAM,aAAa,OAAO,IAAI,aAAa;CACzC,OAAO,OAAO,OAAO,eAAe,YAAY,OAAO,aAAa;AACtE,CAAC;AAED,MAAM,sBAAsB,OAAO,oBAAoBC,KAAc;AAErE,MAAM,iBAAiB,OAAO,WAAW,WAAW,KAA4B;CAC9E,MAAM,SAASC,YAAqB,OAAO,YAAY,KAAK,SAAS,KAAK,OAAO,CAAC;CAClF,MAAM,aAAa,IAAI,QAAQ,OAAO,OAAO,IAAI,EAAE,CAAC,EAAE,YAAY,KAAA,KAAa,CAAC,OAAO,IAAI,EAAE,CAAC;CAE9F,IAAI,WAAW,SAAS,GACtB,OAAO,OAAOC,KACZ,wCAAwC,WAAW,KAAK,IAAI,EAAE,gDAC9D,EAAE,QAAQ,wBAAwB,CACpC;AAEJ,CAAC;AAID,MAAM,cAAc,OAAO,WAAW,WAAW,KAA4B;CAC3E,MAAM,UAAU,OAAO,YAAY,KAAK,SAAS,KAAK,OAAO;CAC7D,MAAM,SAASC,cAAqB,OAAO;CAE3C,MAAM,UAAU,IAAI,QAAQ,OAC1B,QAAQ,MACL,EAAE,YACDL,eAA8B,KAAK,KACnC,UAAU,SAAS,OAAO,kBAAkB,KAC5C,MAAM,OAAO,MACb,MAAM,OAAO,SAAS,cACtB,OAAO,IAAI,EAAE,CAAC,EAAE,SAAS,IAC7B,CACF;CAEA,IAAI,QAAQ,SAAS,GACnB,OAAO,OAAOI,KACZ,GAAG,QAAQ,KAAK,IAAI,EAAE,+HAA+H,QAAQ,WAAW,IAAI,YAAY,YAAY,cACpM,EAAE,QAAQ,kBAAkB,CAC9B;AAEJ,CAAC;AAED,MAAM,aAAa,OAAO,WAAW,WAAW,KAAwB;CACtE,MAAM,UAAU,IAAI,OAAO,KAAK,UAAU,KAAK,MAAM,KAAK,IAAI,MAAM,aAAa,CAAC,CAAC,KAAK,IAAI;CAC5F,MAAM,QAAQ,IAAI,OAAO,KAAK,UAAU,MAAM,IAAI;CAElD,MAAM,eAAe,KAAK,KAAK,qBAAqB;EAClD,aAAa,GAAG,YAAY;;;EAG9B;EAEE,YAAY,OAAO,OAAO;GACxB,MAAM,OAAO;GACb,MAAM;GACN,OAAO,OAAO,SACZ,OAAO,OAAO;IACZ,MAAM,OAAO,SAAS,KAAK;IAC3B,OAAO,OAAO,MAAM,IAAI,OAAO,KAAK,UAAU,MAAM,KAAK,CAAC;GAC5D,CAAC,CACH;GACA,QAAQ,OAAO,SAAS,OAAO,MAAM,OAAO,MAAM,CAAC,CAAC,CAAC,SAAS,EAC5D,aACE,wRACJ,CAAC;EACH,CAAC;EACD,SAAS,OAAO;EAChB,SAASH;EACT,cAAc,CAAC,aAAa,iBAAiB;CAC/C,CAAC;CAED,MAAM,aAAa,QAAQ,KAAK,cAAc,IAAI;CAElD,MAAM,WAAW,OAAO,WAAW,WAAW;EAC5C,YAAY,OAAO,QAAQ,SAAS;EACpC,mBAAmB,OAAO,WAAW,WAAW,EAAE,MAAM,OAAO,UAAU;GACvE,IAAI,KAAK,KAAK,MAAM,IAClB,OAAO,OAAOG,KACZ,wLACA,EAAE,QAAQ,eAAe,CAC3B;GAGF,MAAM,KAAK,OAAO;GAClB,MAAM,SAAS,WAAW,KAAA,KAAa,OAAO,WAAW,IAAI,CAAC,IAAI,EAAE,OAAO;GAE3E,IAAI,WAAW,KAAA,KAAa,OAAO,SAAS,GAAG,OAAO,YAAY,MAAM;GAExE,IAAI,UAAU,KAAA,GAAW;IACvB,OAAO,OAAA,iBAAuC,KAAK;KAAE;KAAI;KAAM,GAAG;IAAO,CAAC,CAAC;IAE3E,OAAO;GACT;GAEA,MAAM,QAAQ,IAAI,OAAO,IAAI,MAAM,IAAI,CAAC,EAAE;GAE1C,IAAI,UAAU,KAAA,KAAa,OAAO,OAAO,OAAO,oBAAoB,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,GACrF,OAAO,OAAOA,KAAiB,2BAA2B,MAAM,KAAK,QAAQ;GAG/E,IAAI,MAAM,SAAS,YACjB,OAAO,eACL,OAAO,MAAM,oBAAoB,MAAM,KAAK,GAAG;IAC7C,cAAc,CAAC;IACf,SAAS,YAAY,QAAQ;GAC/B,CAAC,CACH;GAGF,OAAO,OAAA,iBAC2B,KAAK;IACnC;IACA;IACA,OAAA,aAAmC,KAAK,KAAK;IAC7C,GAAG;GACL,CAAC,CACH;GAEA,OAAO,mBAAmB;EAC5B,CAAC;CACH,CAAC;CAED,OAAO,OAAO,OAAO,eAAe,YAAY,QAAQ;AAC1D,CAAC;;AAGD,MAAa,gBACX,OAAO,WAAW,WAAW,KAAK;CAChC,IAAI,QAAQ,KAAA,KAAa,IAAI,OAAO,WAAW,GAC7C,OAAOE,gBAAyB,OAAO,UAAU;CAGnD,OAAOA,gBAAyB,OAAO,WAAW,GAAG,CAAC;AACxD,CAAC"}

package/dist/internal/turns.d.ts

@@ -0,0 +1,64 @@
+import { ChatId } from "../ChatId.js";
+import { Tools, toolkit_d_exports } from "./toolkit.js";
+import { AssistantLoop_d_exports, Event } from "../AssistantLoop.js";
+import { CurrentChat } from "../CurrentChat.js";
+import { BlockKit, BlockKit_d_exports } from "../BlockKit.js";
+import { Any, Built, Specialist_d_exports } from "../Specialist.js";
+import { AppEvents, DecodedEntries, events_d_exports } from "./events.js";
+import { Writer } from "./writer.js";
+import { Assistant_d_exports, Turn, TurnServices } from "../Assistant.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Scope from "effect/Scope";
+import * as LanguageModel from "effect/ai/LanguageModel";
+declare namespace turns_d_exports {
+  export { Definition, Registration, TurnHandler, TypedChat, defaultReplyNudge, deliveryNudge, register, run, silentTurnMessage };
+}
+/** @internal */
+export declare const silentTurnMessage = "I finished without sending a reply.";
+/** @internal */
+export declare const defaultReplyNudge = "You haven't replied to the user's latest message yet. Reply now with send_user_message.";
+/** @internal */
+export declare const deliveryNudge = "You told the user you're on it, but stopped without giving them the result. Send it now with send_user_message; if part of it is still running, say what and that you'll report back. If they already have everything, call wait.";
+/** @internal */
+export interface Definition {
+  readonly name: string;
+  readonly blocks: BlockKit | undefined;
+  readonly specialists: ReadonlyArray<Any>;
+  readonly app: AppEvents;
+}
+/** @internal */
+export type TurnHandler = (turn: Turn<any>) => Stream.Stream<Event, unknown, TurnServices | LanguageModel.LanguageModel>;
+/** @internal */
+export interface TypedChat {
+  readonly chatId: ChatId;
+  readonly entries: Effect.Effect<DecodedEntries>;
+  readonly append: CurrentChat["Service"]["append"];
+}
+/** @internal */
+export interface Registration {
+  readonly definition: Definition;
+  readonly model: Context.Context<LanguageModel.LanguageModel>;
+  readonly open: (chat: TypedChat) => Effect.Effect<TurnHandler, never, Scope.Scope | CurrentChat>;
+  readonly specialists: ReadonlyArray<{
+    readonly specialist: Any;
+    readonly built: Built;
+  }>;
+  readonly builtins: Tools<TurnServices>;
+}
+/** @internal */
+export declare const register: (definition: Definition, options: {
+  readonly open: Registration["open"];
+}) => Effect.Effect<Registration, never, LanguageModel.LanguageModel>;
+/** @internal */
+export declare const run: (options: {
+  readonly registration: Registration;
+  readonly handler: TurnHandler;
+  readonly chat: Writer;
+  readonly services: Context.Context<TurnServices | LanguageModel.LanguageModel>;
+  readonly checkOpen: Effect.Effect<void>;
+}) => Effect.Effect<void, never, never>;
+//#endregion
+export { turns_d_exports };
+//# sourceMappingURL=turns.d.ts.map

package/dist/internal/turns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turns.d.ts","names":[],"sources":["../../src/internal/turns.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAqCa;;qBAGA;;qBAIA;;iBAII;WACN;WACA,QAAQ;WACR,aAAa,cAAc;WAC3B,KAAK;;;YAKJ,eACV,MAAM,cACH,OAAO,OAAO,gBAA8B,eAAyB,cAAc;;iBAKvE;WACN,QAAQ;WACR,SAAS,OAAO,OAAO;WACvB,QAAQ;;;iBAIF;WACN,YAAY;WACZ,OAAO,QAAQ,QAAQ,cAAc;WACrC,OAAO,MAAM,cAAc,OAAO,OAAO,oBAAoB,MAAM,QAAQ;WAC3E,aAAa;aACX,YAAY;aACZ,OAAO;;WAET,UAAU,MAAe;;;qBAIvB,WAAQ,YAAA,YAAA;WAEO,MAAA;MAuC1B,OAAA,OAAA,qBAAA,cAAA;;qBA8OW,MAAG;WAEW,cAAA;WACL,SAAA;WACH,MAAA;WACI,UAAA,QAAQ,QAAQ,eAAyB,cAAc;WAEtD,WAAA,OAAO;MA2D9B,OAAA"}