effect-assistant 0.3.0 → 0.4.0

package/src/internal/loop.ts

@@ -21,7 +21,18 @@ import * as Toolkits from "./toolkit.ts"
 import { isTurnEnding } from "./tools.ts"
 
 /** @internal */
-export type Event = AssistantEvent.ModelOutput | AssistantEvent.ToolStarted | AssistantEvent.ToolResult
+export type Event =
+  | AssistantEvent.ModelOutput
+  | AssistantEvent.ToolStarted
+  | AssistantEvent.ToolResult
+  | AssistantEvent.ApprovalRequested
+
+// Only a turn's loop can wait for the user's approval, and runs the calls they approved. A turn's specialists inherit
+// its context, so their runs set it back to none.
+/** @internal */
+export const TurnApprovals = Context.Reference<
+  Option.Option<{ readonly approved: Effect.Effect<ReadonlyArray<AssistantEvent.ToolCallPart>> }>
+>("effect-assistant/TurnApprovals", { defaultValue: Option.none })
 
 // The assistant's own tools with the turn's services, so an app's own loop in a turn can message the user. A
 // specialist's run has none.
@@ -61,8 +72,9 @@ export interface StepResult {
   /** The model's output; unset when the step only ran calls a crash cut off. */
   readonly output: AssistantEvent.ModelOutput | undefined
   /**
-   * Whether the model is done: it made no tool calls, or ended its turn (`wait`, or a message
-   * with `wait: true`) and none of the step's calls failed.
+   * Whether the model is done: it made no tool calls, one of its calls waits for the user's
+   * approval, or it ended its turn (`wait`, or a message with `wait: true`) and none of the step's
+   * calls failed.
    */
   readonly done: boolean
   /**
@@ -71,9 +83,15 @@ export interface StepResult {
   readonly historyLength: number
 }
 
-// The loop runs the calls itself, after storing each as started, so the model call runs none.
+// The loop runs the calls itself, after storing each as started, so the model call runs none. It also decides which
+// calls wait for approval: the model call would ask for approvals of its own.
 const requestToolkit = (definitions: ReadonlyArray<Tool.Any>): Toolkit.WithHandler<Record<string, Tool.Any>> => ({
-  tools: Object.fromEntries(definitions.map((tool) => [tool.name, tool])),
+  tools: Object.fromEntries(
+    definitions.map((tool) => [
+      tool.name,
+      tool.needsApproval === undefined || tool.needsApproval === false ? tool : tool.setNeedsApproval(false)
+    ])
+  ),
   handle: () => Effect.succeed(Stream.empty)
 })
 
@@ -111,28 +129,79 @@ const runCall = Effect.fnUntraced(function* <R>(tools: Toolkits.Tools<R>, call:
   return AssistantEvent.ToolResult.make({ callId: call.id, tool: call.name, ...result })
 })
 
-// Every `ToolStarted` is stored before any call runs. `then` is told whether one of the calls failed, so the model
-// has to read the results.
+// A call that needs approval waits for the user in a turn. A specialist's run can't ask them, so its call fails.
+const awaitApproval = Effect.fnUntraced(function* (call: AssistantEvent.ToolCallPart) {
+  if (Option.isNone(yield* TurnApprovals)) {
+    return AssistantEvent.ToolResult.make({
+      callId: call.id,
+      tool: call.name,
+      ...Toolkits.failed(
+        `${call.name} needs the user's approval, and only the assistant can ask for it. Don't run it: say in your answer what needs approving, with the details.`,
+        "NeedsApproval"
+      )
+    })
+  }
+
+  return AssistantEvent.ApprovalRequested.make({ callId: call.id, tool: call.name, params: call.params })
+})
+
+interface Pending {
+  readonly call: AssistantEvent.ToolCallPart
+  /** The user approved it: it runs without asking again. */
+  readonly approved: boolean
+}
+
+interface Ran {
+  /** One of the calls failed, so the model has to read the results. */
+  readonly failed: boolean
+  /** One of the calls waits for the user's approval, so the turn ends. */
+  readonly waiting: boolean
+}
+
+// Every `ToolStarted` is stored before any call runs; a call that waits for approval doesn't start.
 const runCalls = <R, S, E, R2>(
   tools: Toolkits.Tools<R>,
-  calls: ReadonlyArray<AssistantEvent.ToolCallPart>,
-  then: (failed: boolean) => Stream.Stream<Step<never, S>, E, R2>
+  pending: ReadonlyArray<Pending>,
+  history: ReadonlyArray<Prompt.Message>,
+  then: (ran: Ran) => Stream.Stream<Step<never, S>, E, R2>
 ): Stream.Stream<Step<Event, S>, E, R | R2> =>
-  Stream.fromIterable(
-    calls.map((call) => value(AssistantEvent.ToolStarted.make({ callId: call.id, tool: call.name })))
-  ).pipe(
-    Stream.concat(
-      Stream.unwrap(
-        Effect.gen(function* () {
-          const done = yield* Effect.forEach(calls, (call) => runCall(tools, call), { concurrency: "unbounded" })
-
-          return Stream.fromIterable(done.map(value)).pipe(Stream.concat(then(done.some(isFailure))))
-        })
+  Stream.unwrap(
+    Effect.gen(function* () {
+      const waits = yield* Effect.forEach(pending, ({ call, approved }) =>
+        approved ? Effect.succeed(false) : tools.needsApproval(call, history)
       )
-    )
+
+      const started = pending.flatMap(({ call }, i) =>
+        waits[i] === true ? [] : [value(AssistantEvent.ToolStarted.make({ callId: call.id, tool: call.name }))]
+      )
+
+      return Stream.fromIterable(started).pipe(
+        Stream.concat(
+          Stream.unwrap(
+            Effect.gen(function* () {
+              const done = yield* Effect.forEach(
+                pending,
+                ({ call }, i): Effect.Effect<Event, never, R> =>
+                  waits[i] === true ? awaitApproval(call) : runCall(tools, call),
+                { concurrency: "unbounded" }
+              )
+
+              return Stream.fromIterable(done.map(value)).pipe(
+                Stream.concat(
+                  then({
+                    failed: done.some(isFailure),
+                    waiting: done.some((event) => Predicate.isTagged(event, "ApprovalRequested"))
+                  })
+                )
+              )
+            })
+          )
+        )
+      )
+    })
   )
 
-const isFailure = (result: AssistantEvent.ToolResult) => result.outcome === "failure"
+const isFailure = (event: Event) => Predicate.isTagged(event, "ToolResult") && event.outcome === "failure"
 
 /** @internal */
 export type Step<A, S> = Data.TaggedEnum<{
@@ -192,19 +261,31 @@ export const step = <R, S, E2 = never, R2 = never>(
   const instructions = Predicate.isString(options.instructions) ? { text: options.instructions } : options.instructions
 
   const after = (result: StepResult) => Stream.suspend(() => then(result))
-  const needingApproval = Toolkits.needingApproval(toolkit.definitions)
-
-  if (needingApproval.length > 0) return Stream.die(Toolkits.needsApprovalMessage(needingApproval))
 
   return Stream.unwrap(
     Effect.gen(function* () {
       const { messages: history, throughSeq } = readHistory(yield* options.history)
       // Calls a crash cut off, with no result: they run again, with the same ids, before the model goes on.
       const cutOff = History.unansweredCalls(history)
+      const approvals = yield* TurnApprovals
+
+      // Calls the user approved: they run as the model made them, with the same ids, before the model goes on. Not in
+      // a loop without their tools.
+      const approved = Option.isNone(approvals)
+        ? []
+        : (yield* approvals.value.approved).filter(
+            (call) =>
+              toolkit.definitions.some((tool) => tool.name === call.name) && !cutOff.some((cut) => cut.id === call.id)
+          )
+
+      if (cutOff.length > 0 || approved.length > 0) {
+        const pending = [
+          ...cutOff.map((call) => ({ call, approved: false })),
+          ...approved.map((call) => ({ call, approved: true }))
+        ]
 
-      if (cutOff.length > 0) {
-        return runCalls(toolkit, cutOff, () =>
-          after({ output: undefined, done: false, historyLength: history.length + cutOff.length })
+        return runCalls(toolkit, pending, history, ({ waiting }) =>
+          after({ output: undefined, done: waiting, historyLength: history.length + pending.length })
         )
       }
 
@@ -230,15 +311,20 @@ export const step = <R, S, E2 = never, R2 = never>(
       const calls = toolCalls(output.parts)
       const historyLength = history.length + Prompt.fromResponseParts(output.parts).content.length + calls.length
 
-      // A failed call doesn't end the turn: a message that failed never reached the user, so the model reads why.
+      // A failed call doesn't end the turn: a message that failed never reached the user, so the model reads why. A call
+      // that waits for approval does: the turn waits for the user.
       return Stream.make(value(output)).pipe(
         Stream.concat(
-          runCalls(toolkit, calls, (failed) =>
-            after({
-              output,
-              done: calls.length === 0 || (!failed && calls.some(isTurnEnding)),
-              historyLength
-            })
+          runCalls(
+            toolkit,
+            calls.map((call) => ({ call, approved: false })),
+            history,
+            ({ failed, waiting }) =>
+              after({
+                output,
+                done: calls.length === 0 || waiting || (!failed && calls.some(isTurnEnding)),
+                historyLength
+              })
           )
         )
       )

package/src/internal/specialists.ts

@@ -22,12 +22,9 @@ import * as Loop from "./loop.ts"
 import { CurrentChat } from "../CurrentChat.ts"
 import * as InputId from "../InputId.ts"
 import * as RunId from "../RunId.ts"
-import * as Skill from "../Skill.ts"
-import * as Skills from "./skills.ts"
 import * as Specialist from "../Specialist.ts"
 import * as ToolFailure from "../ToolFailure.ts"
 import { toolMessage, userText } from "./history.ts"
-import { mapText } from "./instructions.ts"
 import * as Telemetry from "./telemetry.ts"
 import * as Toolkits from "./toolkit.ts"
 import type { Writer } from "./writer.ts"
@@ -83,22 +80,19 @@ export const runBrief = Effect.fnUntraced(
       chatId: options.chatId,
       brief: options.brief,
       history: current,
-      loop: (loop) => {
-        const own = Toolkits.fromToolkitOrEmpty(loop.toolkit)
-        const skills = Skills.available(loop.skills ?? [], own.definitions)
-
-        return Loop.run({
-          instructions: mapText(loop.instructions, (text) => Skill.withCatalog(text, skills)),
-          toolkit: Toolkits.merge(Skills.toTools(skills), own),
+      // A run can't wait for the user's approval: a call that needs it fails, and the run reads why.
+      loop: (loop) =>
+        Loop.run({
+          instructions: loop.instructions,
+          toolkit: Toolkits.fromToolkitOrEmpty(loop.toolkit),
           history: current,
           maxSteps: loop.maxSteps ?? 8
-        })
-      }
+        }).pipe(Stream.provideService(Loop.TurnApprovals, Option.none()))
     }
 
     // A run lives in memory, so there's nothing to run again after a crash: `ToolStarted` isn't kept.
     const record = Effect.fnUntraced(function* (event: AssistantLoop.Event) {
-      if (Predicate.isTagged(event, "ToolStarted")) return
+      if (Predicate.isTagged(event, "ToolStarted") || Predicate.isTagged(event, "ApprovalRequested")) return
 
       if (Predicate.isTagged(event, "ToolResult")) return yield* add([toolMessage(event)])
 

package/src/internal/toolkit.ts

@@ -1,9 +1,11 @@
 import * as AiError from "effect/ai/AiError"
+import type * as Prompt from "effect/ai/Prompt"
 import type * as Tool from "effect/ai/Tool"
 import type * as Toolkit from "effect/ai/Toolkit"
 import type * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
+import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import type * as AssistantEvent from "../AssistantEvent.ts"
@@ -23,13 +25,18 @@ export interface CallResult {
 export interface Tools<out R = never> {
   readonly definitions: ReadonlyArray<Tool.Any>
   readonly run: (call: AssistantEvent.ToolCallPart) => Effect.Effect<CallResult, never, R>
+  // Whether the call waits for the user's approval instead of running: its tool's `needsApproval`.
+  readonly needsApproval: (
+    call: AssistantEvent.ToolCallPart,
+    history: ReadonlyArray<Prompt.Message>
+  ) => Effect.Effect<boolean, never, R>
 }
 
 /** @internal */
-export type ToolServices<T extends Record<string, Tool.Any>> = Exclude<
-  Tool.HandlerServices<T[keyof T]>,
-  AssistantToolCall
->
+export type ToolServices<T extends Record<string, Tool.Any>> =
+  | Exclude<Tool.HandlerServices<T[keyof T]>, AssistantToolCall>
+  // Already in the handlers' services; stated for the loop, which decodes params to ask `needsApproval`.
+  | T[keyof T]["parametersSchema"]["DecodingServices"]
 
 const encodeFailure = Schema.encodeSync(ToolFailure.ToolFailure)
 
@@ -60,15 +67,32 @@ const hasTool = <T extends Record<string, Tool.Any>>(
   name: PropertyKey
 ): name is keyof T => Object.hasOwn(toolkit.tools, name)
 
-// Approval would park a call until the user decides, which this library doesn't do: the model calls a tool with
-// final values, and a user's own commitment goes through the app's API from a block.
 /** @internal */
 export const needingApproval = (definitions: ReadonlyArray<Tool.Any>): ReadonlyArray<string> =>
   definitions.flatMap((tool) => (tool.needsApproval === undefined || tool.needsApproval === false ? [] : [tool.name]))
 
-/** @internal */
-export const needsApprovalMessage = (names: ReadonlyArray<string>): string =>
-  `${names.join(", ")} ${names.length === 1 ? "sets" : "set"} needsApproval, and effect-assistant doesn't run tools that wait for approval. Remove needsApproval: let the model call the tool with final values, or show a block whose button calls your app's API, which does the work and submits an app event that wakes the chat.`
+// With noUncheckedIndexedAccess, an index doesn't narrow on `hasTool`.
+const toolNamed = (toolkit: { readonly tools: Record<string, Tool.Any> }, name: string): Tool.Any | undefined =>
+  Object.hasOwn(toolkit.tools, name) ? toolkit.tools[name] : undefined
+
+// Params that don't fit the tool don't wait: the call runs, and fails with why.
+const needsApprovalNative = Effect.fnUntraced(function* <T extends Record<string, Tool.Any>>(
+  toolkit: { readonly tools: T },
+  call: AssistantEvent.ToolCallPart,
+  history: ReadonlyArray<Prompt.Message>
+): Effect.fn.Return<boolean, never, ToolServices<T>> {
+  const tool = toolNamed(toolkit, call.name)
+  const needs = tool?.needsApproval
+
+  if (tool === undefined || needs === undefined || Predicate.isBoolean(needs)) return needs === true
+
+  return yield* Effect.gen(function* () {
+    const params = yield* Schema.decodeUnknownEffect(tool.parametersSchema)(call.params)
+    const decided = needs(params, { toolCallId: call.id, messages: history })
+
+    return Effect.isEffect(decided) ? yield* decided : decided
+  }).pipe(Effect.orElseSucceed(() => false))
+})
 
 // The toolkit decodes the params with the tool's schema before its handler sees them, and a call whose params don't
 // fit fails with a validation error the model reads: the model's JSON is what `handle` takes.
@@ -117,7 +141,8 @@ export const fromWithHandler = <T extends Record<string, Tool.Any>>(
   toolkit: Toolkit.WithHandler<T>
 ): Tools<ToolServices<T>> => ({
   definitions: Object.values(toolkit.tools),
-  run: (call) => runNative(toolkit, call)
+  run: (call) => runNative(toolkit, call),
+  needsApproval: (call, history) => needsApprovalNative(toolkit, call, history)
 })
 
 /** @internal */
@@ -127,22 +152,8 @@ export const fromToolkit = <T extends Record<string, Tool.Any>>(
   definitions: Object.values(toolkit.tools),
   run: Effect.fnUntraced(function* (call) {
     return yield* runNative(yield* toolkit, call)
-  })
-})
-
-// The handlers use services of the loop they run in, so they're made for each call, with its context.
-/** @internal */
-export 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>> => ({
-  definitions: Object.values(toolkit.tools),
-  run: Effect.fnUntraced(function* (call) {
-    const context = yield* Effect.context<R>()
-    const resolved = yield* Effect.provideContext(toolkit, yield* toolkit.toHandlers(handlers(context)))
-
-    return yield* runNative(resolved, call)
-  })
+  }),
+  needsApproval: (call, history) => needsApprovalNative(toolkit, call, history)
 })
 
 /** @internal */
@@ -153,7 +164,8 @@ export const fromToolkitOrEmpty = <T extends Record<string, Tool.Any>>(
 /** @internal */
 export const empty: Tools = {
   definitions: [],
-  run: (call) => Effect.succeed(failed(`No tool named ${call.name}.`, "ToolNotFoundError"))
+  run: (call) => Effect.succeed(failed(`No tool named ${call.name}.`, "ToolNotFoundError")),
+  needsApproval: () => Effect.succeed(false)
 }
 
 /** @internal */
@@ -162,7 +174,9 @@ export const merge = <A, B>(self: Tools<A>, that: Tools<B>): Tools<A | B> => {
 
   return {
     definitions: [...self.definitions, ...that.definitions],
-    run: (call) => (inSelf(call) ? self.run(call) : that.run(call))
+    run: (call) => (inSelf(call) ? self.run(call) : that.run(call)),
+    needsApproval: (call, history) =>
+      inSelf(call) ? self.needsApproval(call, history) : that.needsApproval(call, history)
   }
 }
 
@@ -170,7 +184,8 @@ export const merge = <A, B>(self: Tools<A>, that: Tools<B>): Tools<A | B> => {
 /** @internal */
 export const provide = <R>(tools: Tools<R>, context: Context.Context<R>): Tools => ({
   definitions: tools.definitions,
-  run: (call) => Effect.provideContext(tools.run(call), context)
+  run: (call) => Effect.provideContext(tools.run(call), context),
+  needsApproval: (call, history) => Effect.provideContext(tools.needsApproval(call, history), context)
 })
 
 /** @internal */
@@ -184,5 +199,7 @@ export const duplicateNames = (tools: Tools<unknown>): ReadonlyArray<string> =>
 /** @internal */
 export const runOnly = <R>(tools: Tools<R>, names: ReadonlyArray<string>, message: string): Tools<R> => ({
   definitions: tools.definitions,
-  run: (call) => (names.includes(call.name) ? tools.run(call) : Effect.succeed(failed(message, "NotNow")))
+  run: (call) => (names.includes(call.name) ? tools.run(call) : Effect.succeed(failed(message, "NotNow"))),
+  // Refused like any other call it doesn't run.
+  needsApproval: () => Effect.succeed(false)
 })

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"
@@ -19,8 +20,7 @@ import * as Loop from "./loop.ts"
 import type * 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
@@ -266,7 +281,8 @@ const makeTurnApi = (
           }),
           // A second step, for a reply after a call it was refused.
           maxSteps: 2
-        })
+          // The loop ran the approved calls; a pass that can only reply runs none.
+        }).pipe(Stream.provideService(Loop.TurnApprovals, Option.none()))
       })
     )
 
@@ -280,13 +296,12 @@ const makeTurnApi = (
       })
     )
 
-  const prepare = <T extends Record<string, Tool.Any>, RS>(options: Assistant.LoopOptions<T, RS, any>) => {
+  const prepare = <T extends Record<string, Tool.Any>>(options: Assistant.LoopOptions<T, any>) => {
     const own = Toolkits.fromToolkitOrEmpty(options.toolkit)
-    const skills = Skills.available(options.skills ?? [], [...builtins.definitions, ...own.definitions])
 
     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 +372,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
-    })
-  }))
-}