@alexein/sdk 0.0.0-stage → 0.3.0

package/dist/langgraph.js

@@ -0,0 +1,185 @@
+import {
+  LazyClient,
+  NOTHING_FOUND,
+  NOTHING_YET,
+  SAVED,
+  UNAVAILABLE,
+  isClient,
+  notFoundAnswer,
+  openAnswer,
+  outageAnswer,
+  promptBlock,
+  searchAnswer,
+  searchFor,
+  stableId
+} from "./chunk-OVDZ3D4M.js";
+import {
+  NotFoundError
+} from "./chunk-UNVZ22EN.js";
+
+// src/langgraph/index.ts
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { tool } from "@langchain/core/tools";
+import { Annotation, MessagesAnnotation, MessagesValue, StateSchema } from "@langchain/langgraph";
+import { z } from "zod";
+var MemoryAnnotation = Annotation.Root({
+  ...MessagesAnnotation.spec,
+  memory: Annotation({ reducer: (_, found) => found, default: () => "" })
+});
+var MemoryState = new StateSchema({
+  messages: MessagesValue,
+  memory: z.string().default("")
+});
+var MemoryContext = z.object({ user_id: z.string().optional() });
+function userIdOf(config) {
+  const context = config?.context;
+  const found = context?.user_id ?? config?.configurable?.user_id;
+  if (found === void 0 || found === null || found === "") {
+    throw new Error(
+      'Alexein needs to know whose memory this is: run the graph with { context: { user_id: "..." } }, or { configurable: { user_id: "..." } }'
+    );
+  }
+  return String(found);
+}
+function threadOf(config) {
+  const thread = config?.configurable?.thread_id;
+  return thread === void 0 || thread === null ? void 0 : String(thread);
+}
+function lastHuman(messages) {
+  return messages.findLast((m) => HumanMessage.isInstance(m));
+}
+function lastReply(messages) {
+  return messages.findLast((m) => AIMessage.isInstance(m) && !m.tool_calls?.length);
+}
+var AlexeinMemory = class {
+  fast;
+  maxChars;
+  strict;
+  #client;
+  /** `client` defaults to one made on first use: fail-open unless strict, a 10 s timeout. */
+  constructor(client, options = {}) {
+    const given = isClient(client) ? client : void 0;
+    const settings = isClient(client) ? options : { ...client, ...options };
+    this.fast = settings.fast ?? false;
+    this.maxChars = settings.maxChars ?? 4e3;
+    this.strict = settings.strict ?? false;
+    this.#client = new LazyClient(given, "langgraph", this.strict, settings.timeout);
+  }
+  get client() {
+    return this.#client.client;
+  }
+  user(config) {
+    return this.client.user(userIdOf(config));
+  }
+  /** A node: what memory holds for the latest human message, into `state.memory`. */
+  recall = async (state, config) => {
+    const asked = lastHuman(state.messages)?.text.trim();
+    const user = this.user(config);
+    if (!asked) return { memory: "" };
+    const found = await searchFor(user, asked, this.fast);
+    return { memory: found?.context(this.maxChars) ?? "" };
+  };
+  /**
+   * A node: save the turn - the latest human message and the last reply that is not a tool call -
+   * in the thread's session. Each message keeps its LangGraph id as its item id (else a stable
+   * hash), so running a turn again edits what was saved rather than adding a copy. Tool calls and
+   * tool results are not saved. Needs a key that writes.
+   */
+  remember = async (state, config) => {
+    const user = this.user(config);
+    const thread = threadOf(config);
+    const said = [
+      await item(lastHuman(state.messages), "user", thread),
+      await item(lastReply(state.messages), "assistant", thread)
+    ].filter((i) => i !== void 0);
+    if (said.length) await user.add(said, { session: thread });
+    return {};
+  };
+  /** What `recall` found, as a block for your system prompt; empty when it found nothing. */
+  prompt = (state) => promptBlock(state.memory ?? "");
+  /**
+   * Tools the model calls when it decides to: `memory_search` and `memory_open`, and with
+   * `write`, `memory_add`. The user comes from the run, which a model never sees.
+   */
+  tools({ write = false } = {}) {
+    const read = [this.searchTool(), this.openTool()];
+    return write ? [...read, this.addTool()] : read;
+  }
+  searchTool() {
+    return tool(
+      async ({ query }, config) => {
+        const found = await searchFor(this.user(config), query, this.fast);
+        return searchAnswer(found, this.maxChars);
+      },
+      {
+        name: "memory_search",
+        description: "Search what you remember about this user: what they said, did and decided in earlier conversations. Ask in plain language. Ends with the refs of what it found, to read whole with memory_open.",
+        schema: z.object({ query: z.string().describe("What to look for") })
+      }
+    );
+  }
+  openTool() {
+    return tool(
+      async ({ ref }, config) => {
+        const user = this.user(config);
+        try {
+          return openAnswer(await user.open(ref));
+        } catch (error) {
+          if (error instanceof NotFoundError) return notFoundAnswer(error);
+          return outageAnswer(error, this.strict);
+        }
+      },
+      {
+        name: "memory_open",
+        description: "Read one remembered memory whole, by a ref memory_search gave.",
+        schema: z.object({ ref: z.string().describe("A ref memory_search gave") })
+      }
+    );
+  }
+  addTool() {
+    return tool(
+      async ({ text }, config) => {
+        const saved = await this.user(config).add(text, {
+          kind: "note",
+          session: threadOf(config)
+        });
+        return saved.failed ? UNAVAILABLE : SAVED;
+      },
+      {
+        name: "memory_add",
+        description: "Remember something about this user for later conversations: a preference, a fact about them, a decision. Write it as one plain sentence. Never save passwords, keys or secrets.",
+        schema: z.object({ text: z.string().describe("One plain sentence") })
+      }
+    );
+  }
+};
+async function item(message, role, thread) {
+  const text = message?.text;
+  if (!text?.trim()) return void 0;
+  const id = message?.id ?? await stableId(thread, role, text);
+  return { id, role, text };
+}
+var fallback;
+function defaultMemory() {
+  fallback ??= new AlexeinMemory();
+  return fallback;
+}
+var recall = (state, config) => defaultMemory().recall(state, config);
+var remember = (state, config) => defaultMemory().remember(state, config);
+var memoryPrompt = (state) => defaultMemory().prompt(state);
+var memoryTools = (options = {}) => defaultMemory().tools(options);
+export {
+  AlexeinMemory,
+  MemoryAnnotation,
+  MemoryContext,
+  MemoryState,
+  NOTHING_FOUND,
+  NOTHING_YET,
+  UNAVAILABLE,
+  defaultMemory,
+  memoryPrompt,
+  memoryTools,
+  recall,
+  remember,
+  userIdOf
+};

package/dist/openai-agents.cjs

@@ -0,0 +1,234 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkTLAHP2PBcjs = require('./chunk-TLAHP2PB.cjs');
+
+
+
+
+
+var _chunk7KPDU3YVcjs = require('./chunk-7KPDU3YV.cjs');
+
+// src/openai-agents/run.ts
+function userIdOf(context) {
+  const found = _optionalChain([context, 'optionalAccess', _ => _.userId]);
+  if (!found) {
+    throw new Error(
+      'Alexein needs to know whose memory this is: run the agent with { context: { userId: "..." } }'
+    );
+  }
+  return String(found);
+}
+function sessionIdOf(context) {
+  const found = _optionalChain([context, 'optionalAccess', _2 => _2.sessionId]);
+  return found ? String(found) : void 0;
+}
+function textOf(item2) {
+  const content = "content" in item2 ? item2.content : void 0;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.flatMap((part) => "text" in part && typeof part.text === "string" ? [part.text] : []).join("\n");
+}
+var saidByUser = (item2) => "role" in item2 && item2.role === "user";
+var turns = /* @__PURE__ */ new WeakMap();
+function turnOf(result) {
+  if (result.lastResponseId) return result.lastResponseId;
+  const made = _nullishCoalesce(turns.get(result), () => ( crypto.randomUUID()));
+  turns.set(result, made);
+  return made;
+}
+function answer(output) {
+  if (output === void 0 || output === null) return "";
+  return typeof output === "string" ? output : JSON.stringify(output);
+}
+async function item(said, role, turn, author) {
+  if (!said.trim()) return void 0;
+  const id = await _chunkTLAHP2PBcjs.stableId.call(void 0, turn, role, said);
+  return { id, role, text: said, ...author ? { author } : {} };
+}
+async function turnItems(result, session) {
+  const input = _nullishCoalesce(result.input, () => ( []));
+  const said = typeof input === "string" ? [{ role: "user", content: input }] : input;
+  const asked2 = said.findLast(saidByUser);
+  const turn = `${_nullishCoalesce(session, () => ( ""))}|${turnOf(result)}`;
+  const items = [
+    await item(asked2 ? textOf(asked2) : "", "user", turn),
+    await item(answer(result.finalOutput), "assistant", turn, _optionalChain([result, 'access', _3 => _3.lastAgent, 'optionalAccess', _4 => _4.name]))
+  ];
+  return items.filter((i) => i !== void 0);
+}
+
+// src/openai-agents/tools.ts
+var _agents = require('@openai/agents');
+var _zod = require('zod');
+function failed(strict) {
+  return (run, error) => {
+    const yours = error instanceof _chunk7KPDU3YVcjs.AuthenticationError || error instanceof _chunk7KPDU3YVcjs.PermissionDeniedError;
+    const outage = error instanceof _chunk7KPDU3YVcjs.AlexeinError && error.outage;
+    const noUser = !_optionalChain([run, 'access', _5 => _5.context, 'optionalAccess', _6 => _6.userId]);
+    if (yours || noUser || strict && outage) throw error;
+    if (outage) {
+      console.warn(`Alexein is unavailable: ${error.message}`);
+      return _chunkTLAHP2PBcjs.UNAVAILABLE;
+    }
+    return `That did not work: ${error instanceof Error ? error.message : String(error)}`;
+  };
+}
+function buildTools(memory, write) {
+  const errorFunction = failed(memory.strict);
+  const search = _agents.tool.call(void 0, {
+    name: "memory_search",
+    description: "Search what you remember about this user: what they said, did and decided in earlier conversations. Ask in plain language. Ends with the refs of what it found, to read whole with memory_open.",
+    parameters: _zod.z.object({ query: _zod.z.string().describe("What to look for") }),
+    errorFunction,
+    async execute({ query }, run) {
+      const found = await _chunkTLAHP2PBcjs.searchFor.call(void 0, memory.userOf(_optionalChain([run, 'optionalAccess', _7 => _7.context])), query, memory.fast);
+      return _chunkTLAHP2PBcjs.searchAnswer.call(void 0, found, memory.maxChars);
+    }
+  });
+  const open = _agents.tool.call(void 0, {
+    name: "memory_open",
+    description: "Read one remembered memory whole, by a ref memory_search gave.",
+    parameters: _zod.z.object({ ref: _zod.z.string().describe("A ref memory_search gave") }),
+    errorFunction,
+    async execute({ ref }, run) {
+      try {
+        return _chunkTLAHP2PBcjs.openAnswer.call(void 0, await memory.userOf(_optionalChain([run, 'optionalAccess', _8 => _8.context])).open(ref));
+      } catch (error) {
+        if (!(error instanceof _chunk7KPDU3YVcjs.NotFoundError)) throw error;
+        return _chunkTLAHP2PBcjs.notFoundAnswer.call(void 0, error);
+      }
+    }
+  });
+  const add = _agents.tool.call(void 0, {
+    name: "memory_add",
+    description: "Remember something about this user for later conversations: a preference, a fact about them, a decision. Write it as one plain sentence. Never save passwords, keys or secrets.",
+    parameters: _zod.z.object({ text: _zod.z.string().describe("One plain sentence") }),
+    errorFunction,
+    async execute({ text }, run) {
+      const saved = await memory.userOf(_optionalChain([run, 'optionalAccess', _9 => _9.context])).add(text, {
+        kind: "note",
+        session: sessionIdOf(_optionalChain([run, 'optionalAccess', _10 => _10.context]))
+      });
+      return saved.failed ? _chunkTLAHP2PBcjs.UNAVAILABLE : _chunkTLAHP2PBcjs.SAVED;
+    }
+  });
+  return write ? [search, open, add] : [search, open];
+}
+
+// src/openai-agents/index.ts
+function asked(items) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    const item2 = items[i];
+    const role = "role" in item2 ? item2.role : "";
+    if (role === "developer" || role === "system") continue;
+    return role === "user" ? textOf(item2).trim() : void 0;
+  }
+  return void 0;
+}
+var AlexeinMemory = (_class = class {
+  
+  
+  
+  #client;
+  /**
+   * What `recall` found for each run - its context object - for the model calls after the first
+   * in a turn (a tool loop, a handoff), whose input no longer ends with the user's message. Per
+   * run, so two turns in flight for one user keep their own.
+   */
+  #recalled = /* @__PURE__ */ new WeakMap();
+  /** `client` defaults to one made on first use: fail-open unless strict, a 10 s timeout. */
+  constructor(client, options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    const given = _chunkTLAHP2PBcjs.isClient.call(void 0, client) ? client : void 0;
+    const settings = _chunkTLAHP2PBcjs.isClient.call(void 0, client) ? options : { ...client, ...options };
+    this.fast = _nullishCoalesce(settings.fast, () => ( false));
+    this.maxChars = _nullishCoalesce(settings.maxChars, () => ( 4e3));
+    this.strict = _nullishCoalesce(settings.strict, () => ( false));
+    this.#client = new (0, _chunkTLAHP2PBcjs.LazyClient)(given, "openai-agents", this.strict, settings.timeout);
+  }
+  get client() {
+    return this.#client.client;
+  }
+  /** The memory of the app user a run's context names. */
+  userOf(context) {
+    return this.client.user(userIdOf(context));
+  }
+  /**
+   * `callModelInputFilter: memory.recall`: before the model, what memory holds for the user's
+   * latest message, added to the instructions. Already using a filter? Run both:
+   * `async (args) => yours({ ...args, modelData: await memory.recall(args) })`.
+   */
+  __init() {this.recall = exports.recall = async ({
+    modelData,
+    context
+  }) => {
+    const user = this.userOf(context);
+    const run = context;
+    let question = asked(modelData.input);
+    if (question === void 0 && !this.#recalled.has(run)) {
+      const said = modelData.input.findLast(saidByUser);
+      question = said && textOf(said).trim();
+    }
+    if (question !== void 0) {
+      const found = question ? await _chunkTLAHP2PBcjs.searchFor.call(void 0, user, question, this.fast) : void 0;
+      this.#recalled.set(run, _chunkTLAHP2PBcjs.promptBlock.call(void 0, _nullishCoalesce(_optionalChain([found, 'optionalAccess', _17 => _17.context, 'call', _18 => _18(this.maxChars)]), () => ( ""))));
+    }
+    const block = this.#recalled.get(run);
+    if (!block) return modelData;
+    const given = modelData.instructions;
+    return { ...modelData, instructions: given ? `${given}
+
+${block}` : block };
+  }}
+  /**
+   * Save the turn a run answered - the user's latest message and the final output, under the
+   * agent's name - in the context's `sessionId`. Call it once the run is done (for a stream, once
+   * `completed` resolves). Saving the same result again edits rather than copies. Tool calls and
+   * their results are not saved, and a run paused for an approval saves nothing. Needs a key that
+   * writes.
+   */
+  __init2() {this.remember = exports.remember = async (result) => {
+    if (_optionalChain([result, 'access', _19 => _19.interruptions, 'optionalAccess', _20 => _20.length])) return;
+    const context = _optionalChain([result, 'access', _21 => _21.runContext, 'optionalAccess', _22 => _22.context]);
+    const session = sessionIdOf(context);
+    const items = await turnItems(result, session);
+    if (items.length) await this.userOf(context).add(items, { session });
+  }}
+  /**
+   * Tools the model calls when it decides to: `memory_search` and `memory_open`, and with
+   * `write`, `memory_add`. The user comes from the run's context, which a model never sees.
+   */
+  tools({ write = false } = {}) {
+    return buildTools(this, write);
+  }
+}, _class);
+var fallback;
+function defaultMemory() {
+  fallback ??= new AlexeinMemory();
+  return fallback;
+}
+var recall = (args) => defaultMemory().recall(args);
+var remember = (result) => defaultMemory().remember(result);
+var memoryTools = (options = {}) => defaultMemory().tools(options);
+
+
+
+
+
+
+
+
+
+
+
+exports.AlexeinMemory = AlexeinMemory; exports.NOTHING_FOUND = _chunkTLAHP2PBcjs.NOTHING_FOUND; exports.NOTHING_YET = _chunkTLAHP2PBcjs.NOTHING_YET; exports.UNAVAILABLE = _chunkTLAHP2PBcjs.UNAVAILABLE; exports.defaultMemory = defaultMemory; exports.memoryTools = memoryTools; exports.recall = recall; exports.remember = remember; exports.sessionIdOf = sessionIdOf; exports.userIdOf = userIdOf;

package/dist/openai-agents.d.cts

@@ -0,0 +1,101 @@
+import { AgentInputItem, CallModelInputFilterArgs, ModelInputData, FunctionTool } from '@openai/agents';
+import { v as Memory, X as User } from './client-YKZ4fkK-.cjs';
+import { I as IntegrationOptions } from './shared-Btg8LbKC.cjs';
+export { N as NOTHING_FOUND, a as NOTHING_YET, U as UNAVAILABLE } from './shared-Btg8LbKC.cjs';
+
+/**
+ * What a run says: whose memory it reads (its context), what the user asked, and the turn
+ * `remember` saves - the user's latest message and the final output.
+ */
+
+/**
+ * Whose memory a run reads: pass it as the run's `context`, or give a context of your own a
+ * `userId` (and, if you like, a `sessionId`, which groups what is saved by conversation).
+ */
+interface MemoryContext {
+    userId: string;
+    sessionId?: string;
+}
+/** The app user a run's context names; never the model. */
+declare function userIdOf(context: unknown): string;
+declare function sessionIdOf(context: unknown): string | undefined;
+/** What `remember` reads of a run's result: a `RunResult` or a completed `StreamedRunResult`. */
+interface SavedResult {
+    readonly interruptions?: readonly unknown[];
+    readonly runContext?: {
+        readonly context: unknown;
+    };
+    readonly input?: string | AgentInputItem[];
+    readonly finalOutput?: unknown;
+    readonly lastAgent?: {
+        readonly name: string;
+    } | undefined;
+    readonly lastResponseId?: string | undefined;
+}
+
+/**
+ * Long-term memory for OpenAI Agents SDK agents, from Alexein.
+ *
+ * ```ts
+ * import { AlexeinMemory } from "@alexein/sdk/openai-agents";
+ *
+ * const memory = new AlexeinMemory(); // or new AlexeinMemory(client, { fast, maxChars, strict })
+ * const agent = new Agent({ name: "Assistant", tools: memory.tools() });
+ * const result = await run(agent, message, {
+ *   context: { userId: "dana", sessionId: "conv-7" },
+ *   callModelInputFilter: memory.recall,
+ * });
+ * await memory.remember(result);
+ * ```
+ *
+ * `recall` searches once a turn, with the user's latest message, and adds what it finds to the
+ * instructions of every model call in that turn, so it is never written into your session or
+ * history. Whose memory is read is decided by your code, never by a model: the run's
+ * `context.userId`.
+ */
+
+/** Memory for OpenAI Agents SDK runs: `recall`, `remember` and tools, over one client. */
+declare class AlexeinMemory {
+    #private;
+    readonly fast: boolean;
+    readonly maxChars: number;
+    readonly strict: boolean;
+    /** `client` defaults to one made on first use: fail-open unless strict, a 10 s timeout. */
+    constructor(client?: Memory | IntegrationOptions, options?: IntegrationOptions);
+    get client(): Memory;
+    /** The memory of the app user a run's context names. */
+    userOf(context: unknown): User;
+    /**
+     * `callModelInputFilter: memory.recall`: before the model, what memory holds for the user's
+     * latest message, added to the instructions. Already using a filter? Run both:
+     * `async (args) => yours({ ...args, modelData: await memory.recall(args) })`.
+     */
+    readonly recall: ({ modelData, context, }: CallModelInputFilterArgs<unknown>) => Promise<ModelInputData>;
+    /**
+     * Save the turn a run answered - the user's latest message and the final output, under the
+     * agent's name - in the context's `sessionId`. Call it once the run is done (for a stream, once
+     * `completed` resolves). Saving the same result again edits rather than copies. Tool calls and
+     * their results are not saved, and a run paused for an approval saves nothing. Needs a key that
+     * writes.
+     */
+    readonly remember: (result: SavedResult) => Promise<void>;
+    /**
+     * Tools the model calls when it decides to: `memory_search` and `memory_open`, and with
+     * `write`, `memory_add`. The user comes from the run's context, which a model never sees.
+     */
+    tools({ write }?: {
+        write?: boolean;
+    }): FunctionTool<unknown, any, string>[];
+}
+/** The `AlexeinMemory` the module-level functions use: made on first use, from the environment. */
+declare function defaultMemory(): AlexeinMemory;
+/** `recall` of the default `AlexeinMemory`. */
+declare const recall: (args: CallModelInputFilterArgs<unknown>) => Promise<ModelInputData>;
+/** `remember` of the default `AlexeinMemory`. */
+declare const remember: (result: SavedResult) => Promise<void>;
+/** `tools` of the default `AlexeinMemory`. */
+declare const memoryTools: (options?: {
+    write?: boolean;
+}) => FunctionTool<unknown, any, string>[];
+
+export { AlexeinMemory, IntegrationOptions as AlexeinMemoryOptions, type MemoryContext, type SavedResult, defaultMemory, memoryTools, recall, remember, sessionIdOf, userIdOf };

package/dist/openai-agents.d.ts

@@ -0,0 +1,101 @@
+import { AgentInputItem, CallModelInputFilterArgs, ModelInputData, FunctionTool } from '@openai/agents';
+import { v as Memory, X as User } from './client-YKZ4fkK-.js';
+import { I as IntegrationOptions } from './shared-Btg8LbKC.js';
+export { N as NOTHING_FOUND, a as NOTHING_YET, U as UNAVAILABLE } from './shared-Btg8LbKC.js';
+
+/**
+ * What a run says: whose memory it reads (its context), what the user asked, and the turn
+ * `remember` saves - the user's latest message and the final output.
+ */
+
+/**
+ * Whose memory a run reads: pass it as the run's `context`, or give a context of your own a
+ * `userId` (and, if you like, a `sessionId`, which groups what is saved by conversation).
+ */
+interface MemoryContext {
+    userId: string;
+    sessionId?: string;
+}
+/** The app user a run's context names; never the model. */
+declare function userIdOf(context: unknown): string;
+declare function sessionIdOf(context: unknown): string | undefined;
+/** What `remember` reads of a run's result: a `RunResult` or a completed `StreamedRunResult`. */
+interface SavedResult {
+    readonly interruptions?: readonly unknown[];
+    readonly runContext?: {
+        readonly context: unknown;
+    };
+    readonly input?: string | AgentInputItem[];
+    readonly finalOutput?: unknown;
+    readonly lastAgent?: {
+        readonly name: string;
+    } | undefined;
+    readonly lastResponseId?: string | undefined;
+}
+
+/**
+ * Long-term memory for OpenAI Agents SDK agents, from Alexein.
+ *
+ * ```ts
+ * import { AlexeinMemory } from "@alexein/sdk/openai-agents";
+ *
+ * const memory = new AlexeinMemory(); // or new AlexeinMemory(client, { fast, maxChars, strict })
+ * const agent = new Agent({ name: "Assistant", tools: memory.tools() });
+ * const result = await run(agent, message, {
+ *   context: { userId: "dana", sessionId: "conv-7" },
+ *   callModelInputFilter: memory.recall,
+ * });
+ * await memory.remember(result);
+ * ```
+ *
+ * `recall` searches once a turn, with the user's latest message, and adds what it finds to the
+ * instructions of every model call in that turn, so it is never written into your session or
+ * history. Whose memory is read is decided by your code, never by a model: the run's
+ * `context.userId`.
+ */
+
+/** Memory for OpenAI Agents SDK runs: `recall`, `remember` and tools, over one client. */
+declare class AlexeinMemory {
+    #private;
+    readonly fast: boolean;
+    readonly maxChars: number;
+    readonly strict: boolean;
+    /** `client` defaults to one made on first use: fail-open unless strict, a 10 s timeout. */
+    constructor(client?: Memory | IntegrationOptions, options?: IntegrationOptions);
+    get client(): Memory;
+    /** The memory of the app user a run's context names. */
+    userOf(context: unknown): User;
+    /**
+     * `callModelInputFilter: memory.recall`: before the model, what memory holds for the user's
+     * latest message, added to the instructions. Already using a filter? Run both:
+     * `async (args) => yours({ ...args, modelData: await memory.recall(args) })`.
+     */
+    readonly recall: ({ modelData, context, }: CallModelInputFilterArgs<unknown>) => Promise<ModelInputData>;
+    /**
+     * Save the turn a run answered - the user's latest message and the final output, under the
+     * agent's name - in the context's `sessionId`. Call it once the run is done (for a stream, once
+     * `completed` resolves). Saving the same result again edits rather than copies. Tool calls and
+     * their results are not saved, and a run paused for an approval saves nothing. Needs a key that
+     * writes.
+     */
+    readonly remember: (result: SavedResult) => Promise<void>;
+    /**
+     * Tools the model calls when it decides to: `memory_search` and `memory_open`, and with
+     * `write`, `memory_add`. The user comes from the run's context, which a model never sees.
+     */
+    tools({ write }?: {
+        write?: boolean;
+    }): FunctionTool<unknown, any, string>[];
+}
+/** The `AlexeinMemory` the module-level functions use: made on first use, from the environment. */
+declare function defaultMemory(): AlexeinMemory;
+/** `recall` of the default `AlexeinMemory`. */
+declare const recall: (args: CallModelInputFilterArgs<unknown>) => Promise<ModelInputData>;
+/** `remember` of the default `AlexeinMemory`. */
+declare const remember: (result: SavedResult) => Promise<void>;
+/** `tools` of the default `AlexeinMemory`. */
+declare const memoryTools: (options?: {
+    write?: boolean;
+}) => FunctionTool<unknown, any, string>[];
+
+export { AlexeinMemory, IntegrationOptions as AlexeinMemoryOptions, type MemoryContext, type SavedResult, defaultMemory, memoryTools, recall, remember, sessionIdOf, userIdOf };