@batonfx/memory 0.1.0 → 0.2.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 $ bun build ./src/index.ts --outdir dist --target bun --format esm
-Bundled 248 modules in 624ms
+Bundled 176 modules in 476ms
 
   index.js  1.1 MB  (entry point)
 

package/dist/index.js

@@ -10320,6 +10320,7 @@ function resolveAt(key) {
 }
 var resolveIdentifier = /* @__PURE__ */ resolveAt("identifier");
 var resolveTitle = /* @__PURE__ */ resolveAt("title");
+var resolveDescription = /* @__PURE__ */ resolveAt("description");
 var resolveBrands = /* @__PURE__ */ resolveAt("brands");
 var getExpected = /* @__PURE__ */ memoize((ast) => {
   const identifier2 = resolveIdentifier(ast);
@@ -12893,6 +12894,7 @@ function runChecks(checks, s) {
 var ClassTypeId = "~effect/Schema/Class";
 var STRUCTURAL_ANNOTATION_KEY = "~structural";
 var resolveIdentifier2 = resolveIdentifier;
+var resolveDescription2 = resolveDescription;
 function isJson(u) {
   const onPath = new Set;
   const validated = new Set;
@@ -30518,6 +30520,43 @@ class AiError extends (/* @__PURE__ */ ErrorClass("effect/ai/AiError/AiError")({
 }
 var isAiErrorReason = (u) => hasProperty(u, ReasonTypeId);
 var make27 = (params) => new AiError(params);
+// ../../node_modules/.bun/effect@4.0.0-beta.93/node_modules/effect/dist/Random.js
+var Random5 = Random;
+var randomWith = (f) => withFiber2((fiber3) => succeed6(f(fiber3.getRef(Random5))));
+var next2 = /* @__PURE__ */ randomWith((r) => r.nextDoubleUnsafe());
+
+// ../../node_modules/.bun/effect@4.0.0-beta.93/node_modules/effect/dist/unstable/ai/IdGenerator.js
+class IdGenerator extends (/* @__PURE__ */ Service()("@effect/ai/IdGenerator")) {
+}
+var DEFAULT_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var DEFAULT_SEPARATOR = "_";
+var DEFAULT_SIZE = 16;
+var makeGenerator = ({
+  alphabet = DEFAULT_ALPHABET,
+  prefix,
+  separator = DEFAULT_SEPARATOR,
+  size: size6 = DEFAULT_SIZE
+}) => {
+  const alphabetLength = alphabet.length;
+  return fnUntraced2(function* () {
+    const chars = new Array(size6);
+    for (let i = 0;i < size6; i++) {
+      const index2 = yield* next2;
+      chars[i] = alphabet[index2 * alphabetLength | 0];
+    }
+    const identifier2 = chars.join("");
+    if (isUndefined(prefix)) {
+      return identifier2;
+    }
+    return `${prefix}${separator}${identifier2}`;
+  });
+};
+var defaultIdGenerator = {
+  generateId: /* @__PURE__ */ makeGenerator({
+    prefix: "id"
+  })
+};
+
 // ../../node_modules/.bun/effect@4.0.0-beta.93/node_modules/effect/dist/unstable/ai/LanguageModel.js
 var exports_LanguageModel = {};
 __export(exports_LanguageModel, {
@@ -30622,43 +30661,6 @@ var awaitEmpty = (self) => whileLoop2({
   step: constVoid
 });
 
-// ../../node_modules/.bun/effect@4.0.0-beta.93/node_modules/effect/dist/Random.js
-var Random5 = Random;
-var randomWith = (f) => withFiber2((fiber3) => succeed6(f(fiber3.getRef(Random5))));
-var next2 = /* @__PURE__ */ randomWith((r) => r.nextDoubleUnsafe());
-
-// ../../node_modules/.bun/effect@4.0.0-beta.93/node_modules/effect/dist/unstable/ai/IdGenerator.js
-class IdGenerator extends (/* @__PURE__ */ Service()("@effect/ai/IdGenerator")) {
-}
-var DEFAULT_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-var DEFAULT_SEPARATOR = "_";
-var DEFAULT_SIZE = 16;
-var makeGenerator = ({
-  alphabet = DEFAULT_ALPHABET,
-  prefix,
-  separator = DEFAULT_SEPARATOR,
-  size: size6 = DEFAULT_SIZE
-}) => {
-  const alphabetLength = alphabet.length;
-  return fnUntraced2(function* () {
-    const chars = new Array(size6);
-    for (let i = 0;i < size6; i++) {
-      const index2 = yield* next2;
-      chars[i] = alphabet[index2 * alphabetLength | 0];
-    }
-    const identifier2 = chars.join("");
-    if (isUndefined(prefix)) {
-      return identifier2;
-    }
-    return `${prefix}${separator}${identifier2}`;
-  });
-};
-var defaultIdGenerator = {
-  generateId: /* @__PURE__ */ makeGenerator({
-    prefix: "id"
-  })
-};
-
 // ../../node_modules/.bun/effect@4.0.0-beta.93/node_modules/effect/dist/unstable/ai/internal/codec-transformer.js
 var defaultCodecTransformer = (codec) => {
   const document = resolveTopLevel$ref(toJsonSchemaDocument2(codec));
@@ -32200,6 +32202,275 @@ var mapProviderResults = (inputLength, results) => {
   }
   return succeed6(embeddings);
 };
+// ../../node_modules/.bun/effect@4.0.0-beta.93/node_modules/effect/dist/unstable/ai/Tool.js
+var exports_Tool = {};
+__export(exports_Tool, {
+  unsafeSecureJsonParse: () => unsafeSecureJsonParse,
+  providerDefined: () => providerDefined,
+  make: () => make34,
+  isUserDefined: () => isUserDefined,
+  isProviderDefined: () => isProviderDefined,
+  isEmptyParamsRecord: () => isEmptyParamsRecord,
+  isDynamic: () => isDynamic,
+  getStrictMode: () => getStrictMode,
+  getJsonSchemaFromSchema: () => getJsonSchemaFromSchema,
+  getJsonSchema: () => getJsonSchema,
+  getDescription: () => getDescription,
+  dynamic: () => dynamic,
+  TypeId: () => TypeId35,
+  Title: () => Title,
+  Strict: () => Strict,
+  Readonly: () => Readonly,
+  ProviderDefinedTypeId: () => ProviderDefinedTypeId,
+  OpenWorld: () => OpenWorld,
+  NameMapper: () => NameMapper,
+  Meta: () => Meta,
+  Idempotent: () => Idempotent,
+  EmptyParams: () => EmptyParams,
+  DynamicTypeId: () => DynamicTypeId,
+  Destructive: () => Destructive
+});
+var TypeId35 = "~effect/ai/Tool";
+var ProviderDefinedTypeId = "~effect/ai/Tool/ProviderDefined";
+var DynamicTypeId = "~effect/ai/Tool/Dynamic";
+var isUserDefined = (u) => hasProperty(u, TypeId35) && !isProviderDefined(u) && !isDynamic(u);
+var isProviderDefined = (u) => hasProperty(u, ProviderDefinedTypeId);
+var isDynamic = (u) => hasProperty(u, DynamicTypeId);
+var Proto8 = {
+  [TypeId35]: {
+    _Requirements: identity
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  addDependency() {
+    return userDefinedProto({
+      ...this
+    });
+  },
+  setParameters(parametersSchema) {
+    return userDefinedProto({
+      ...this,
+      parametersSchema
+    });
+  },
+  setSuccess(successSchema) {
+    return userDefinedProto({
+      ...this,
+      successSchema
+    });
+  },
+  setFailure(failureSchema) {
+    return userDefinedProto({
+      ...this,
+      failureSchema
+    });
+  },
+  annotate(tag2, value3) {
+    return userDefinedProto({
+      ...this,
+      annotations: add(this.annotations, tag2, value3)
+    });
+  },
+  annotateMerge(context4) {
+    return userDefinedProto({
+      ...this,
+      annotations: merge(this.annotations, context4)
+    });
+  }
+};
+var ProviderDefinedProto = {
+  ...Proto8,
+  [ProviderDefinedTypeId]: ProviderDefinedTypeId
+};
+var DynamicProto = {
+  ...Proto8,
+  [DynamicTypeId]: DynamicTypeId
+};
+var userDefinedProto = (options) => {
+  const self = Object.assign(Object.create(Proto8), options);
+  self.id = `effect/ai/Tool/${options.name}`;
+  return self;
+};
+var providerDefinedProto = (options) => Object.assign(Object.create(ProviderDefinedProto), {
+  ...options
+});
+var dynamicProto = (options) => {
+  const self = Object.assign(Object.create(DynamicProto), options);
+  self.id = `effect/ai/Tool/${options.name}`;
+  return self;
+};
+var make34 = (name, options) => {
+  const successSchema = options?.success ?? Void2;
+  const failureSchema = options?.failure ?? Never2;
+  return userDefinedProto({
+    name,
+    description: options?.description,
+    parametersSchema: options?.parameters ?? EmptyParams,
+    successSchema,
+    failureSchema,
+    failureMode: options?.failureMode ?? "error",
+    annotations: empty(),
+    needsApproval: options?.needsApproval
+  });
+};
+var dynamic = (name, options) => {
+  const successSchema = options?.success ?? Unknown2;
+  const failureSchema = options?.failure ?? Never2;
+  const rawParameters = options?.parameters ?? Unknown2;
+  const isEffectSchema = isSchema(rawParameters);
+  const parametersSchema = isEffectSchema ? rawParameters : Unknown2;
+  const jsonSchema = isEffectSchema ? undefined : rawParameters;
+  return dynamicProto({
+    name,
+    description: options?.description,
+    parametersSchema,
+    successSchema,
+    failureSchema,
+    failureMode: options?.failureMode ?? "error",
+    annotations: empty(),
+    needsApproval: options?.needsApproval,
+    jsonSchema
+  });
+};
+var providerDefined = (options) => (args2) => {
+  const failureMode = isNotUndefined(args2) && "failureMode" in args2 ? args2.failureMode : undefined;
+  const successSchema = options?.success ?? Void2;
+  const failureSchema = options?.failure ?? Never2;
+  return providerDefinedProto({
+    id: options.id,
+    name: options.customName,
+    providerName: options.providerName,
+    args: args2,
+    argsSchema: options?.args ?? Void2,
+    requiresHandler: options.requiresHandler ?? false,
+    parametersSchema: options?.parameters ?? Void2,
+    successSchema,
+    failureSchema,
+    failureMode: failureMode ?? "error"
+  });
+};
+
+class NameMapper {
+  #customToProvider = /* @__PURE__ */ new Map;
+  #providerToCustom = /* @__PURE__ */ new Map;
+  constructor(tools) {
+    for (const tool of tools) {
+      if (isProviderDefined(tool)) {
+        this.#customToProvider.set(tool.name, tool.providerName);
+        this.#providerToCustom.set(tool.providerName, tool.name);
+      }
+    }
+  }
+  get customNames() {
+    return Array.from(this.#customToProvider.keys());
+  }
+  get providerNames() {
+    return Array.from(this.#providerToCustom.keys());
+  }
+  getCustomName(providerName) {
+    return this.#providerToCustom.get(providerName) ?? providerName;
+  }
+  getProviderName(customName) {
+    return this.#customToProvider.get(customName) ?? customName;
+  }
+}
+var getDescription = (tool) => {
+  if (tool.description !== undefined) {
+    return tool.description;
+  }
+  if (isSchema(tool.parametersSchema)) {
+    return resolveDescription2(tool.parametersSchema.ast);
+  }
+  return;
+};
+var getJsonSchema = (tool, options) => {
+  if (isDynamic(tool) && tool.jsonSchema !== undefined) {
+    return tool.jsonSchema;
+  }
+  return getJsonSchemaFromSchema(tool.parametersSchema, options);
+};
+var getJsonSchemaFromSchema = (schema, options) => {
+  if (isNotUndefined(options?.transformer)) {
+    return options.transformer(schema).jsonSchema;
+  }
+  const document = toJsonSchemaDocument2(schema);
+  if (Object.keys(document.definitions).length > 0) {
+    document.schema.$defs = document.definitions;
+  }
+  return document.schema;
+};
+
+class Title extends (/* @__PURE__ */ Service()("effect/ai/Tool/Title")) {
+}
+
+class Meta extends (/* @__PURE__ */ Service()("effect/ai/Tool/Meta")) {
+}
+var Readonly = /* @__PURE__ */ Reference("effect/ai/Tool/Readonly", {
+  defaultValue: constFalse
+});
+var Destructive = /* @__PURE__ */ Reference("effect/ai/Tool/Destructive", {
+  defaultValue: constTrue
+});
+var Idempotent = /* @__PURE__ */ Reference("effect/ai/Tool/Idempotent", {
+  defaultValue: constFalse
+});
+var OpenWorld = /* @__PURE__ */ Reference("effect/ai/Tool/OpenWorld", {
+  defaultValue: constTrue
+});
+var Strict = /* @__PURE__ */ Reference("effect/ai/Tool/Strict", {
+  defaultValue: () => {
+    return;
+  }
+});
+var getStrictMode = (tool) => get(tool.annotations, Strict);
+var suspectProtoRx = /"__proto__"\s*:/;
+var suspectConstructorRx = /"constructor"\s*:/;
+function _parse(text) {
+  const obj = JSON.parse(text);
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+    return obj;
+  }
+  return filter12(obj);
+}
+function filter12(obj) {
+  let next3 = [obj];
+  while (next3.length) {
+    const nodes = next3;
+    next3 = [];
+    for (const node of nodes) {
+      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      for (const key in node) {
+        const value3 = node[key];
+        if (value3 && typeof value3 === "object") {
+          next3.push(value3);
+        }
+      }
+    }
+  }
+  return obj;
+}
+var unsafeSecureJsonParse = (text) => {
+  const prevLimit = getStackTraceLimit();
+  setStackTraceLimit(0);
+  try {
+    return _parse(text);
+  } finally {
+    setStackTraceLimit(prevLimit);
+  }
+};
+var EmptyParams = /* @__PURE__ */ Record(String5, Never2);
+function isEmptyParamsRecord(indexSignature) {
+  return indexSignature.parameter === string2 && isNever2(indexSignature.type);
+}
 // ../core/src/agent-event.ts
 class AgentError extends exports_Schema.TaggedErrorClass()("@batonfx/core/AgentError", {
   message: exports_Schema.String,
@@ -32414,6 +32685,25 @@ var allowAll = exports_Layer.succeed(Permissions, Permissions.of({
   await: () => exports_Effect.succeed(exports_Option.none())
 }));
 
+// ../core/src/skill-source.ts
+class SkillSourceError extends exports_Schema.TaggedErrorClass()("@batonfx/core/SkillSourceError", {
+  source: exports_Schema.String,
+  message: exports_Schema.String,
+  cause: exports_Schema.optionalKey(exports_Schema.Defect())
+}) {
+}
+class SkillSource extends exports_Context.Service()("@batonfx/core/SkillSource") {
+}
+var fromSkills = (skills) => {
+  const all5 = [...skills];
+  const byName = new Map(all5.map((skill) => [skill.frontmatter.name, skill]));
+  return exports_Layer.succeed(SkillSource, SkillSource.of({
+    all: exports_Effect.succeed(all5),
+    get: (name) => exports_Effect.succeed(byName.get(name))
+  }));
+};
+var empty15 = fromSkills([]);
+
 // ../core/src/steering.ts
 class Steering extends exports_Context.Service()("@batonfx/core/Steering") {
 }
@@ -32439,9 +32729,22 @@ var decision = {
   }),
   stop: { _tag: "Stop" }
 };
-var make34 = (decide) => ({ decide });
-var recurs2 = (n) => make34((info) => exports_Effect.succeed(info.turn < n + 1 ? decision.continue() : decision.stop));
+var make35 = (decide) => ({ decide });
+var recurs2 = (n) => make35((info) => exports_Effect.succeed(info.turn < n + 1 ? decision.continue() : decision.stop));
 var defaultPolicy = recurs2(8);
+
+// ../core/src/agent.ts
+var activateSkillToolName = "activate_skill";
+var activateSkillParameters = exports_Schema.Struct({ name: exports_Schema.String });
+var activateSkillTool = exports_Tool.make(activateSkillToolName, {
+  description: "Load the full body for one listed Baton skill by name before applying that skill.",
+  parameters: activateSkillParameters,
+  success: exports_Schema.Struct({
+    name: exports_Schema.String,
+    body: exports_Schema.String,
+    allowedTools: exports_Schema.Array(exports_Schema.String)
+  })
+});
 // ../core/src/agent-tool.ts
 var defaultParameters = exports_Schema.Struct({ prompt: exports_Schema.String });
 // ../core/src/handoff.ts
@@ -32464,28 +32767,11 @@ var registrations = exports_Effect.fn("ModelRegistry.registrations.call")(functi
   const service3 = yield* Service2;
   return yield* service3.registrations;
 });
-// ../core/src/skill-source.ts
-class SkillSourceError extends exports_Schema.TaggedErrorClass()("@batonfx/core/SkillSourceError", {
-  source: exports_Schema.String,
-  message: exports_Schema.String,
-  cause: exports_Schema.optionalKey(exports_Schema.Defect())
-}) {
-}
-class SkillSource extends exports_Context.Service()("@batonfx/core/SkillSource") {
-}
-var fromSkills = (skills) => {
-  const all5 = [...skills];
-  const byName = new Map(all5.map((skill) => [skill.frontmatter.name, skill]));
-  return exports_Layer.succeed(SkillSource, SkillSource.of({
-    all: exports_Effect.succeed(all5),
-    get: (name) => exports_Effect.succeed(byName.get(name))
-  }));
-};
-var empty15 = fromSkills([]);
 // src/semantic-recall.ts
 var exports_semantic_recall = {};
 __export(exports_semantic_recall, {
-  make: () => make37,
+  makeSemanticRecall: () => makeSemanticRecall,
+  make: () => make38,
   layer: () => layer
 });
 
@@ -32525,7 +32811,7 @@ var cosine = (left, right) => {
     return 0;
   return dot / (Math.sqrt(leftMagnitude) * Math.sqrt(rightMagnitude));
 };
-var make36 = exports_Ref.make(exports_HashMap.empty()).pipe(exports_Effect.map((documents) => ({
+var make37 = exports_Ref.make(exports_HashMap.empty()).pipe(exports_Effect.map((documents) => ({
   upsert: (nextDocuments) => exports_Effect.gen(function* () {
     for (const document of nextDocuments) {
       yield* validateVector(`document ${document.id} embedding`, document.embedding);
@@ -32560,7 +32846,7 @@ var make36 = exports_Ref.make(exports_HashMap.empty()).pipe(exports_Effect.map((
     return matches.toSorted((left, right) => right.score - left.score).slice(0, input.limit);
   })
 })));
-var memoryLayer2 = exports_Layer.effect(VectorStore, make36.pipe(exports_Effect.map(VectorStore.of)));
+var memoryLayer2 = exports_Layer.effect(VectorStore, make37.pipe(exports_Effect.map(VectorStore.of)));
 var testLayer2 = (implementation) => exports_Layer.succeed(VectorStore, VectorStore.of(implementation));
 
 // src/semantic-recall.ts
@@ -32604,7 +32890,7 @@ var itemFromMatch = (match7) => ({
   parts: [textPart2(match7.document.text)],
   metadata: { ...match7.document.metadata, score: match7.score }
 });
-var make37 = (options = {}) => exports_Effect.gen(function* () {
+var make38 = (options = {}) => exports_Effect.gen(function* () {
   const store = yield* VectorStore;
   const embeddingModel = yield* exports_EmbeddingModel.EmbeddingModel;
   const counter = yield* exports_Ref.make(0);
@@ -32638,12 +32924,14 @@ var make37 = (options = {}) => exports_Effect.gen(function* () {
     }
   };
 });
-var layer = (options = {}) => exports_Layer.effect(exports_memory.Memory, make37(options).pipe(exports_Effect.map(exports_memory.Memory.of)));
+var makeSemanticRecall = make38;
+var layer = (options = {}) => exports_Layer.effect(exports_memory.Memory, make38(options).pipe(exports_Effect.map(exports_memory.Memory.of)));
 
 // src/working-memory.ts
 var exports_working_memory = {};
 __export(exports_working_memory, {
-  make: () => make38,
+  makeWorkingMemory: () => makeWorkingMemory,
+  make: () => make39,
   layer: () => layer2
 });
 var emptyState = {
@@ -32727,7 +33015,7 @@ ${state.summary}
   ],
   ...state.recent.map((item) => ({ id: item.id, parts: [textPart3(formatItem(item))] }))
 ];
-var make38 = (options = {}) => exports_Ref.make(exports_HashMap.empty()).pipe(exports_Effect.map((states) => {
+var make39 = (options = {}) => exports_Ref.make(exports_HashMap.empty()).pipe(exports_Effect.map((states) => {
   const maxMessages = Math.max(0, Math.floor(options.maxMessages ?? 20));
   return {
     recall: (input) => exports_Ref.get(states).pipe(exports_Effect.map((current) => exports_HashMap.get(current, keyId(input.key))), exports_Effect.map((state) => state._tag === "Some" ? recallItems(state.value) : [])),
@@ -32761,12 +33049,13 @@ var make38 = (options = {}) => exports_Ref.make(exports_HashMap.empty()).pipe(ex
     }
   };
 }));
-var layer2 = (options = {}) => exports_Layer.effect(exports_memory.Memory, make38(options).pipe(exports_Effect.map(exports_memory.Memory.of)));
+var makeWorkingMemory = make39;
+var layer2 = (options = {}) => exports_Layer.effect(exports_memory.Memory, make39(options).pipe(exports_Effect.map(exports_memory.Memory.of)));
 
 // src/index.ts
 var combinedLayer = (options = {}) => exports_Layer.effect(exports_memory.Memory, exports_Effect.gen(function* () {
-  const working = yield* make38(options.working);
-  const semantic = yield* make37(options.semantic);
+  const working = yield* makeWorkingMemory(options.working);
+  const semantic = yield* makeSemanticRecall(options.semantic);
   return exports_memory.Memory.of(exports_memory.merge(working, semantic));
 }));
 export {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@batonfx/memory",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -14,7 +14,7 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@batonfx/core": "0.1.0",
+    "@batonfx/core": "0.2.0",
     "effect": "4.0.0-beta.93"
   },
   "devDependencies": {

package/src/index.ts

@@ -1,9 +1,9 @@
 import { Effect, Layer } from "effect"
-import * as Ai from "effect/unstable/ai"
+import { EmbeddingModel } from "effect/unstable/ai"
 import { Memory } from "@batonfx/core"
-import * as SemanticRecall from "./semantic-recall"
-import * as VectorStore from "./vector-store"
-import * as WorkingMemory from "./working-memory"
+import { makeSemanticRecall } from "./semantic-recall"
+import { VectorStore } from "./vector-store"
+import { makeWorkingMemory } from "./working-memory"
 
 export * as SemanticRecall from "./semantic-recall"
 export * as VectorStore from "./vector-store"
@@ -11,19 +11,19 @@ export * as WorkingMemory from "./working-memory"
 
 /** @experimental */
 export interface CombinedOptions {
-  readonly working?: WorkingMemory.Options
-  readonly semantic?: SemanticRecall.Options
+  readonly working?: import("./working-memory").Options
+  readonly semantic?: import("./semantic-recall").Options
 }
 
 /** @experimental */
 export const combinedLayer = (
   options: CombinedOptions = {},
-): Layer.Layer<Memory.Memory, never, VectorStore.VectorStore | Ai.EmbeddingModel.EmbeddingModel> =>
+): Layer.Layer<Memory.Memory, never, VectorStore | EmbeddingModel.EmbeddingModel> =>
   Layer.effect(
     Memory.Memory,
     Effect.gen(function* () {
-      const working = yield* WorkingMemory.make(options.working)
-      const semantic = yield* SemanticRecall.make(options.semantic)
+      const working = yield* makeWorkingMemory(options.working)
+      const semantic = yield* makeSemanticRecall(options.semantic)
       return Memory.Memory.of(Memory.merge(working, semantic))
     }),
   )

package/src/semantic-recall.ts

@@ -1,8 +1,8 @@
 import { Effect, Layer, Ref } from "effect"
-import * as Ai from "effect/unstable/ai"
+import { EmbeddingModel, Prompt } from "effect/unstable/ai"
 import { Memory } from "@batonfx/core"
-import * as VectorStore from "./vector-store"
-
+import { VectorStore } from "./vector-store"
+import type { Match } from "./vector-store"
 /** @experimental */
 export interface Options {
   readonly limit?: number
@@ -13,22 +13,22 @@ const errorMessage = (error: unknown) => (error instanceof Error ? `${error.name
 
 const memoryError = (error: unknown): Memory.MemoryError => new Memory.MemoryError({ message: errorMessage(error) })
 
-const textPart = (text: string) => Ai.Prompt.makePart("text", { text })
+const textPart = (text: string) => Prompt.makePart("text", { text })
 
-const textFromParts = (parts: ReadonlyArray<Ai.Prompt.Part>): string =>
+const textFromParts = (parts: ReadonlyArray<Prompt.Part>): string =>
   parts
-    .filter((part): part is Ai.Prompt.TextPart => part.type === "text")
+    .filter((part): part is Prompt.TextPart => part.type === "text")
     .map((part) => part.text)
     .join("")
 
-const userText = (prompt: Ai.Prompt.Prompt): string =>
+const userText = (prompt: Prompt.Prompt): string =>
   prompt.content
-    .filter((message): message is Ai.Prompt.UserMessage => message.role === "user")
+    .filter((message): message is Prompt.UserMessage => message.role === "user")
     .map((message) => textFromParts(message.content))
     .filter((text) => text.length > 0)
     .join("\n\n")
 
-const finalExchangeText = (prompt: Ai.Prompt.Prompt): string | undefined => {
+const finalExchangeText = (prompt: Prompt.Prompt): string | undefined => {
   let assistant: string | undefined
   let assistantIndex = -1
   for (let index = prompt.content.length - 1; index >= 0; index -= 1) {
@@ -51,7 +51,7 @@ const finalExchangeText = (prompt: Ai.Prompt.Prompt): string | undefined => {
   return undefined
 }
 
-const itemFromMatch = (match: VectorStore.Match): Memory.Item => ({
+const itemFromMatch = (match: Match): Memory.Item => ({
   id: match.document.id,
   parts: [textPart(match.document.text)],
   metadata: { ...match.document.metadata, score: match.score },
@@ -60,10 +60,10 @@ const itemFromMatch = (match: VectorStore.Match): Memory.Item => ({
 /** @experimental */
 export const make = (
   options: Options = {},
-): Effect.Effect<Memory.Interface, never, VectorStore.VectorStore | Ai.EmbeddingModel.EmbeddingModel> =>
+): Effect.Effect<Memory.Interface, never, VectorStore | EmbeddingModel.EmbeddingModel> =>
   Effect.gen(function* () {
-    const store = yield* VectorStore.VectorStore
-    const embeddingModel = yield* Ai.EmbeddingModel.EmbeddingModel
+    const store = yield* VectorStore
+    const embeddingModel = yield* EmbeddingModel.EmbeddingModel
     const counter = yield* Ref.make(0)
     const limit = options.limit ?? 5
 
@@ -112,8 +112,11 @@ export const make = (
     }
   })
 
+/** @experimental */
+export const makeSemanticRecall = make
+
 /** @experimental */
 export const layer = (
   options: Options = {},
-): Layer.Layer<Memory.Memory, never, VectorStore.VectorStore | Ai.EmbeddingModel.EmbeddingModel> =>
+): Layer.Layer<Memory.Memory, never, VectorStore | EmbeddingModel.EmbeddingModel> =>
   Layer.effect(Memory.Memory, make(options).pipe(Effect.map(Memory.Memory.of)))

package/src/working-memory.ts

@@ -1,10 +1,10 @@
 import { Effect, HashMap, Layer, Ref } from "effect"
-import * as Ai from "effect/unstable/ai"
+import { LanguageModel, Prompt, Toolkit } from "effect/unstable/ai"
 import { Memory } from "@batonfx/core"
 
 /** @experimental */
 export interface SummarizeOptions {
-  readonly model: Layer.Layer<Ai.LanguageModel.LanguageModel>
+  readonly model: Layer.Layer<LanguageModel.LanguageModel>
   readonly prompt?: string
 }
 
@@ -44,11 +44,11 @@ const memoryError = (error: unknown): Memory.MemoryError => new Memory.MemoryErr
 
 const keyId = (key: Memory.Key): string => JSON.stringify([key.agent, key.subject])
 
-const textPart = (text: string) => Ai.Prompt.makePart("text", { text })
+const textPart = (text: string) => Prompt.makePart("text", { text })
 
-const textFromParts = (parts: ReadonlyArray<Ai.Prompt.Part>): string =>
+const textFromParts = (parts: ReadonlyArray<Prompt.Part>): string =>
   parts
-    .filter((part): part is Ai.Prompt.TextPart => part.type === "text")
+    .filter((part): part is Prompt.TextPart => part.type === "text")
     .map((part) => part.text)
     .join("")
 
@@ -56,7 +56,7 @@ const roleLabel = (role: StoredRole): string => (role === "user" ? "User" : "Ass
 
 const formatItem = (item: IncomingItem): string => `${roleLabel(item.role)}: ${item.text}`
 
-const normalize = (prompt: Ai.Prompt.Prompt): ReadonlyArray<IncomingItem> =>
+const normalize = (prompt: Prompt.Prompt): ReadonlyArray<IncomingItem> =>
   prompt.content.flatMap((message) => {
     if (message.role !== "user" && message.role !== "assistant") return []
     const text = textFromParts(message.content).trim()
@@ -114,10 +114,10 @@ const summarizeOverflow = (
   overflow: ReadonlyArray<StoredItem>,
 ): Effect.Effect<string | undefined, Memory.MemoryError> =>
   Effect.gen(function* () {
-    const model = yield* Ai.LanguageModel.LanguageModel
+    const model = yield* LanguageModel.LanguageModel
     const response = yield* model.generateText({
       prompt: renderSummaryPrompt(options.prompt ?? defaultSummaryPrompt, summary, overflow),
-      toolkit: Ai.Toolkit.empty,
+      toolkit: Toolkit.empty,
       toolChoice: "none",
     })
     const text = response.text.trim()
@@ -184,6 +184,9 @@ export const make = (options: Options = {}): Effect.Effect<Memory.Interface> =>
     }),
   )
 
+/** @experimental */
+export const makeWorkingMemory = make
+
 /** @experimental */
 export const layer = (options: Options = {}): Layer.Layer<Memory.Memory> =>
   Layer.effect(Memory.Memory, make(options).pipe(Effect.map(Memory.Memory.of)))

package/test/index.test.ts

@@ -1,25 +1,25 @@
 import { describe, expect, it } from "@effect/vitest"
 import { Effect, Layer } from "effect"
-import * as Ai from "effect/unstable/ai"
+import { EmbeddingModel, Prompt } from "effect/unstable/ai"
 import { Memory } from "@batonfx/core"
 import { combinedLayer, VectorStore } from "../src/index"
 
 const key: Memory.Key = { agent: "memory-agent", subject: "subject-a" }
 
-const textPart = (text: string) => Ai.Prompt.makePart("text", { text })
-const user = (text: string) => Ai.Prompt.makeMessage("user", { content: [textPart(text)] })
-const assistant = (text: string) => Ai.Prompt.makeMessage("assistant", { content: [textPart(text)] })
-const prompt = (...messages: ReadonlyArray<Ai.Prompt.Message>) => Ai.Prompt.fromMessages(messages)
+const textPart = (text: string) => Prompt.makePart("text", { text })
+const user = (text: string) => Prompt.makeMessage("user", { content: [textPart(text)] })
+const assistant = (text: string) => Prompt.makeMessage("assistant", { content: [textPart(text)] })
+const prompt = (...messages: ReadonlyArray<Prompt.Message>) => Prompt.fromMessages(messages)
 
 const itemText = (item: Memory.Item): string =>
   item.parts
-    .filter((part): part is Ai.Prompt.TextPart => part.type === "text")
+    .filter((part): part is Prompt.TextPart => part.type === "text")
     .map((part) => part.text)
     .join("")
 
 const embeddingLayer = Layer.effect(
-  Ai.EmbeddingModel.EmbeddingModel,
-  Ai.EmbeddingModel.make({
+  EmbeddingModel.EmbeddingModel,
+  EmbeddingModel.make({
     embedMany: ({ inputs }) =>
       Effect.succeed({
         results: inputs.map(() => [1, 0]),

package/test/semantic-recall.test.ts

@@ -1,20 +1,20 @@
 import { describe, expect, it } from "@effect/vitest"
 import { Effect, Layer } from "effect"
-import * as Ai from "effect/unstable/ai"
+import { AiError, EmbeddingModel, Prompt } from "effect/unstable/ai"
 import { Memory } from "@batonfx/core"
 import { SemanticRecall, VectorStore } from "../src/index"
 
 const key: Memory.Key = { agent: "memory-agent", subject: "subject-a" }
 const otherKey: Memory.Key = { agent: "memory-agent", subject: "subject-b" }
 
-const textPart = (text: string) => Ai.Prompt.makePart("text", { text })
-const user = (text: string) => Ai.Prompt.makeMessage("user", { content: [textPart(text)] })
-const assistant = (text: string) => Ai.Prompt.makeMessage("assistant", { content: [textPart(text)] })
-const prompt = (...messages: ReadonlyArray<Ai.Prompt.Message>) => Ai.Prompt.fromMessages(messages)
+const textPart = (text: string) => Prompt.makePart("text", { text })
+const user = (text: string) => Prompt.makeMessage("user", { content: [textPart(text)] })
+const assistant = (text: string) => Prompt.makeMessage("assistant", { content: [textPart(text)] })
+const prompt = (...messages: ReadonlyArray<Prompt.Message>) => Prompt.fromMessages(messages)
 
 const itemText = (item: Memory.Item): string =>
   item.parts
-    .filter((part): part is Ai.Prompt.TextPart => part.type === "text")
+    .filter((part): part is Prompt.TextPart => part.type === "text")
     .map((part) => part.text)
     .join("")
 
@@ -22,8 +22,8 @@ const vectorForText = (text: string): Array<number> =>
   text.toLowerCase().includes("color") || text.toLowerCase().includes("blue") ? [1, 0] : [0, 1]
 
 const embeddingLayer = Layer.effect(
-  Ai.EmbeddingModel.EmbeddingModel,
-  Ai.EmbeddingModel.make({
+  EmbeddingModel.EmbeddingModel,
+  EmbeddingModel.make({
     embedMany: ({ inputs }) =>
       Effect.succeed({
         results: inputs.map(vectorForText),
@@ -92,14 +92,14 @@ describe("SemanticRecall", () => {
   )
 
   it.effect("maps embedding failures to MemoryError", () => {
-    const embeddingError = Ai.AiError.make({
+    const embeddingError = AiError.make({
       module: "SemanticRecallTest",
       method: "embedMany",
-      reason: new Ai.AiError.UnknownError({ description: "embedding failed" }),
+      reason: new AiError.UnknownError({ description: "embedding failed" }),
     })
     const failingEmbedding = Layer.effect(
-      Ai.EmbeddingModel.EmbeddingModel,
-      Ai.EmbeddingModel.make({ embedMany: () => Effect.fail(embeddingError) }),
+      EmbeddingModel.EmbeddingModel,
+      EmbeddingModel.make({ embedMany: () => Effect.fail(embeddingError) }),
     )
 
     return Effect.gen(function* () {

package/test/working-memory.test.ts

@@ -1,20 +1,20 @@
 import { describe, expect, it } from "@effect/vitest"
 import { Effect, Layer, Stream } from "effect"
-import * as Ai from "effect/unstable/ai"
+import { LanguageModel, Prompt } from "effect/unstable/ai"
 import { Memory } from "@batonfx/core"
 import { WorkingMemory } from "../src/index"
 
 const key: Memory.Key = { agent: "memory-agent", subject: "subject-a" }
 const otherKey: Memory.Key = { agent: "memory-agent", subject: "subject-b" }
 
-const textPart = (text: string) => Ai.Prompt.makePart("text", { text })
-const user = (text: string) => Ai.Prompt.makeMessage("user", { content: [textPart(text)] })
-const assistant = (text: string) => Ai.Prompt.makeMessage("assistant", { content: [textPart(text)] })
-const prompt = (...messages: ReadonlyArray<Ai.Prompt.Message>) => Ai.Prompt.fromMessages(messages)
+const textPart = (text: string) => Prompt.makePart("text", { text })
+const user = (text: string) => Prompt.makeMessage("user", { content: [textPart(text)] })
+const assistant = (text: string) => Prompt.makeMessage("assistant", { content: [textPart(text)] })
+const prompt = (...messages: ReadonlyArray<Prompt.Message>) => Prompt.fromMessages(messages)
 
 const itemText = (item: Memory.Item): string =>
   item.parts
-    .filter((part): part is Ai.Prompt.TextPart => part.type === "text")
+    .filter((part): part is Prompt.TextPart => part.type === "text")
     .map((part) => part.text)
     .join("")
 
@@ -40,8 +40,8 @@ describe("WorkingMemory", () => {
     let summaryCalls = 0
     let summaryPrompt = ""
     const summaryModel = Layer.effect(
-      Ai.LanguageModel.LanguageModel,
-      Ai.LanguageModel.make({
+      LanguageModel.LanguageModel,
+      LanguageModel.make({
         generateText: (options) =>
           Effect.sync(() => {
             summaryCalls += 1