effect-assistant 0.3.0 → 0.5.0

package/src/internal/turns.ts

@@ -1,4 +1,5 @@
 import type * as LanguageModel from "effect/ai/LanguageModel"
+import * as Response from "effect/ai/Response"
 import type * as Tool from "effect/ai/Tool"
 import * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
@@ -16,11 +17,10 @@ import type { ChatId } from "../ChatId.ts"
 import * as AssistantEvent from "../AssistantEvent.ts"
 import type * as AssistantLoop from "../AssistantLoop.ts"
 import * as Loop from "./loop.ts"
-import type * as BlockKit from "../BlockKit.ts"
+import * as BlockKit from "../BlockKit.ts"
 import type { CurrentChat } from "../CurrentChat.ts"
 import * as Instructions from "../Instructions.ts"
-import * as Skill from "../Skill.ts"
-import * as Skills from "./skills.ts"
+import * as ToolApproval from "../ToolApproval.ts"
 import type * as Specialist from "../Specialist.ts"
 import * as AppEvents from "./events.ts"
 import * as History from "./history.ts"
@@ -125,6 +125,21 @@ const failureMessage = (cause: Cause.Cause<unknown>): string =>
     onSome: ({ _tag, raw }) => `${_tag ?? "Error"}: ${Predicate.isString(raw) ? raw : toJsonText(raw)}`
   })
 
+// Approved, and not run yet: also one a crash cut off while it ran, which runs again with the same id.
+const approvedCalls = (entries: ReadonlyArray<AssistantEvent.AnyEntry>): ReadonlyArray<AssistantEvent.ToolCallPart> =>
+  [...ToolApproval.fromEntries(entries).values()].flatMap(({ request, status, outcome }) =>
+    status === "approved" && outcome === undefined
+      ? [
+          Response.makePart("tool-call", {
+            id: request.callId,
+            name: request.tool,
+            params: request.params,
+            providerExecuted: false
+          })
+        ]
+      : []
+  )
+
 const lastSeq = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, otherwise: number) => entries.at(-1)?.seq ?? otherwise
 
 // The handler's stream can end between a step's output and its tools, or while they run. An interrupted turn (a
@@ -199,6 +214,7 @@ const makeTurnApi = (
 ): Assistant.Turn<any> => {
   const { definition, builtins } = registration
   const { app } = definition
+  const shownTools = BlockKit.toolNames(definition.blocks)
 
   const running = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
     Stream.unwrap(Ref.set(ranLoop, true).pipe(Effect.as(stream)))
@@ -265,8 +281,12 @@ const makeTurnApi = (
             }
           }),
           // A second step, for a reply after a call it was refused.
-          maxSteps: 2
-        })
+          maxSteps: 2,
+          // The pass runs because the model wrote text of its own instead of replying, which reaches nobody: it has to
+          // call a tool now. Changing the choice costs a read of the history at full price, on these rare turns only.
+          toolChoice: "required"
+          // The loop ran the approved calls; a pass that can only reply runs none.
+        }).pipe(Stream.provideService(Loop.TurnApprovals, Option.none()))
       })
     )
 
@@ -280,13 +300,12 @@ const makeTurnApi = (
       })
     )
 
-  const prepare = <T extends Record<string, Tool.Any>, RS>(options: Assistant.LoopOptions<T, RS, any>) => {
-    const own = Toolkits.fromToolkitOrEmpty(options.toolkit)
-    const skills = Skills.available(options.skills ?? [], [...builtins.definitions, ...own.definitions])
+  const prepare = <T extends Record<string, Tool.Any>>(options: Assistant.LoopOptions<T, any>) => {
+    const own = Toolkits.showing(Toolkits.fromToolkitOrEmpty(options.toolkit), shownTools)
 
     return {
-      system: mapText(instructions(options.instructions), (text) => Skill.withCatalog(text, skills)),
-      toolkit: Toolkits.merge(Toolkits.merge(builtins, Skills.toTools(skills)), own),
+      system: instructions(options.instructions),
+      toolkit: Toolkits.merge(builtins, own),
       view: options.history ?? identity
     }
   }
@@ -357,6 +376,8 @@ export const run = Effect.fnUntraced(
         Loop.TurnTools,
         Option.some(Toolkits.provide(options.registration.builtins, options.services))
       ),
+      // A turn's loop waits for the user's approval, and runs the calls they approved.
+      Effect.provideService(Loop.TurnApprovals, Option.some({ approved: Effect.map(chat.entries, approvedCalls) })),
       Effect.provideContext(options.services),
       Effect.matchCauseEffect({
         onSuccess: Effect.fnUntraced(function* () {

package/dist/internal/skills.js

@@ -1,33 +0,0 @@
-import { ToolFailure, fail } from "../ToolFailure.js";
-import { empty, withContext } from "./toolkit.js";
-import { resolve } from "../Instructions.js";
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import * as Tool from "effect/ai/Tool";
-import * as Toolkit from "effect/ai/Toolkit";
-//#region src/internal/skills.ts
-/** @internal */
-const available = (skills, definitions) => {
-	const names = new Set(definitions.map((tool) => tool.name));
-	return skills.filter((skill) => (skill.tools ?? []).every((tool) => names.has(tool.name)));
-};
-/** @internal */
-const toTools = (skills) => {
-	if (skills.length === 0) return empty;
-	const byName = new Map(skills.map((skill) => [skill.name, skill]));
-	const LoadSkill = Tool.make("load_skill", {
-		description: "Load a skill's instructions by name, in the same step as your first lookups (not in a step of its own). Follow them for the rest of the task.",
-		parameters: Schema.Struct({ name: Schema.Literals(skills.map((skill) => skill.name)) }),
-		success: Schema.String,
-		failure: ToolFailure
-	});
-	return withContext(Toolkit.make(LoadSkill), (context) => ({ load_skill: Effect.fnUntraced(function* ({ name }) {
-		const skill = byName.get(name);
-		if (skill === void 0) return yield* fail(`No skill named ${name}.`);
-		return (yield* resolve(skill.instructions).pipe(Effect.provideContext(context))).text;
-	}) }));
-};
-//#endregion
-export { available, toTools };
-
-//# sourceMappingURL=skills.js.map

package/dist/internal/skills.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skills.js","names":["Toolkits.empty","ToolFailure.ToolFailure","Toolkits.withContext","ToolFailure.fail","Instructions.resolve"],"sources":["../../src/internal/skills.ts"],"sourcesContent":["import * as Tool from \"effect/ai/Tool\"\nimport * as Toolkit from \"effect/ai/Toolkit\"\nimport type * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport * as Instructions from \"../Instructions.ts\"\nimport type { Skill } from \"../Skill.ts\"\nimport * as ToolFailure from \"../ToolFailure.ts\"\nimport * as Toolkits from \"./toolkit.ts\"\n\n// A skill whose tools the loop doesn't have would send the model after calls it can't make.\n/** @internal */\nexport const available = <R>(\n  skills: ReadonlyArray<Skill<R>>,\n  definitions: ReadonlyArray<Tool.Any>\n): ReadonlyArray<Skill<R>> => {\n  const names = new Set(definitions.map((tool) => tool.name))\n\n  return skills.filter((skill) => (skill.tools ?? []).every((tool) => names.has(tool.name)))\n}\n\n/** @internal */\nexport const toTools = <R>(skills: ReadonlyArray<Skill<R>>): Toolkits.Tools<R> => {\n  if (skills.length === 0) return Toolkits.empty\n\n  const byName = new Map(skills.map((skill) => [skill.name, skill]))\n\n  const LoadSkill = Tool.make(\"load_skill\", {\n    description:\n      \"Load a skill's instructions by name, in the same step as your first lookups (not in a step of its own). Follow them for the rest of the task.\",\n    parameters: Schema.Struct({ name: Schema.Literals(skills.map((skill) => skill.name)) }),\n    success: Schema.String,\n    failure: ToolFailure.ToolFailure\n  })\n\n  // A skill's instructions resolve with the services of the loop that loads it.\n  return Toolkits.withContext(Toolkit.make(LoadSkill), (context: Context.Context<R>) => ({\n    load_skill: Effect.fnUntraced(function* ({ name }) {\n      const skill = byName.get(name)\n\n      if (skill === undefined) return yield* ToolFailure.fail(`No skill named ${name}.`)\n\n      const resolved = yield* Instructions.resolve(skill.instructions).pipe(Effect.provideContext(context))\n\n      return resolved.text\n    })\n  }))\n}\n"],"mappings":";;;;;;;;;AAYA,MAAa,aACX,QACA,gBAC4B;CAC5B,MAAM,QAAQ,IAAI,IAAI,YAAY,KAAK,SAAS,KAAK,IAAI,CAAC;CAE1D,OAAO,OAAO,QAAQ,WAAW,MAAM,SAAS,CAAC,EAAA,CAAG,OAAO,SAAS,MAAM,IAAI,KAAK,IAAI,CAAC,CAAC;AAC3F;;AAGA,MAAa,WAAc,WAAuD;CAChF,IAAI,OAAO,WAAW,GAAG,OAAOA;CAEhC,MAAM,SAAS,IAAI,IAAI,OAAO,KAAK,UAAU,CAAC,MAAM,MAAM,KAAK,CAAC,CAAC;CAEjE,MAAM,YAAY,KAAK,KAAK,cAAc;EACxC,aACE;EACF,YAAY,OAAO,OAAO,EAAE,MAAM,OAAO,SAAS,OAAO,KAAK,UAAU,MAAM,IAAI,CAAC,EAAE,CAAC;EACtF,SAAS,OAAO;EAChB,SAASC;CACX,CAAC;CAGD,OAAOC,YAAqB,QAAQ,KAAK,SAAS,IAAI,aAAiC,EACrF,YAAY,OAAO,WAAW,WAAW,EAAE,QAAQ;EACjD,MAAM,QAAQ,OAAO,IAAI,IAAI;EAE7B,IAAI,UAAU,KAAA,GAAW,OAAO,OAAOC,KAAiB,kBAAkB,KAAK,EAAE;EAIjF,QAAO,OAFiBC,QAAqB,MAAM,YAAY,CAAC,CAAC,KAAK,OAAO,eAAe,OAAO,CAAC,EAAA,CAEpF;CAClB,CAAC,EACH,EAAE;AACJ"}

package/src/internal/skills.ts

@@ -1,48 +0,0 @@
-import * as Tool from "effect/ai/Tool"
-import * as Toolkit from "effect/ai/Toolkit"
-import type * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Schema from "effect/Schema"
-import * as Instructions from "../Instructions.ts"
-import type { Skill } from "../Skill.ts"
-import * as ToolFailure from "../ToolFailure.ts"
-import * as Toolkits from "./toolkit.ts"
-
-// A skill whose tools the loop doesn't have would send the model after calls it can't make.
-/** @internal */
-export const available = <R>(
-  skills: ReadonlyArray<Skill<R>>,
-  definitions: ReadonlyArray<Tool.Any>
-): ReadonlyArray<Skill<R>> => {
-  const names = new Set(definitions.map((tool) => tool.name))
-
-  return skills.filter((skill) => (skill.tools ?? []).every((tool) => names.has(tool.name)))
-}
-
-/** @internal */
-export const toTools = <R>(skills: ReadonlyArray<Skill<R>>): Toolkits.Tools<R> => {
-  if (skills.length === 0) return Toolkits.empty
-
-  const byName = new Map(skills.map((skill) => [skill.name, skill]))
-
-  const LoadSkill = Tool.make("load_skill", {
-    description:
-      "Load a skill's instructions by name, in the same step as your first lookups (not in a step of its own). Follow them for the rest of the task.",
-    parameters: Schema.Struct({ name: Schema.Literals(skills.map((skill) => skill.name)) }),
-    success: Schema.String,
-    failure: ToolFailure.ToolFailure
-  })
-
-  // A skill's instructions resolve with the services of the loop that loads it.
-  return Toolkits.withContext(Toolkit.make(LoadSkill), (context: Context.Context<R>) => ({
-    load_skill: Effect.fnUntraced(function* ({ name }) {
-      const skill = byName.get(name)
-
-      if (skill === undefined) return yield* ToolFailure.fail(`No skill named ${name}.`)
-
-      const resolved = yield* Instructions.resolve(skill.instructions).pipe(Effect.provideContext(context))
-
-      return resolved.text
-    })
-  }))
-}