@alexein/sdk 0.0.0-stage → 0.3.0

package/dist/index.d.cts

@@ -0,0 +1,76 @@
+export { A as AddOptions, a as AddResult, b as AddedItem, c as Adding, d as AppUser, e as Author, C as Correction, D as DEFAULT_BASE_URL, f as DEFAULT_RETRIES, g as DEFAULT_TIMEOUT_MS, h as Deleted, E as Erased, i as Excerpt, j as ExportPage, k as ExportRecord, F as Fact, l as FactsPage, m as Filters, n as FollowUp, o as ForgetOptions, p as Forgotten, G as GrepOptions, H as History, I as Item, q as ItemDefaults, r as ItemStatus, s as ItemsOptions, t as ItemsPage, J as Json, K as Known, L as LatestOptions, M as Me, u as Memories, v as Memory, w as MemoryEntry, x as MemoryOptions, O as OpenItem, y as OpenItems, z as OpenItemsOptions, B as Opened, N as Origin, P as PageOptions, S as SearchOptions, Q as SearchResult, R as Source, T as Sources, U as Statuses, V as StoredItem, W as Summary, X as User, Y as UsersPage, Z as Value, _ as VersionEntry, $ as Versions } from './client-YKZ4fkK-.cjs';
+
+declare const VERSION = "0.3.0";
+
+/**
+ * What can go wrong, one class per thing a caller would handle differently: the same classes as
+ * the Python client's, so what is true of an error there is true here.
+ */
+
+/** One field a 422 named, and what it takes. */
+interface FieldError {
+    /** Where in the body: `query`, `items[0].text`; empty for the body itself. */
+    field: string;
+    message: string;
+}
+interface ErrorFields {
+    status?: number | null;
+    detail?: string;
+    errors?: FieldError[];
+    requestId?: string | null;
+    cause?: unknown;
+}
+/** Every error this client throws. */
+declare class AlexeinError extends Error {
+    /** The HTTP status, or null when no response came back. */
+    readonly status: number | null;
+    /** The API's own explanation; for a transport failure, what went wrong. */
+    readonly detail: string;
+    /** On a 422: each field the body got wrong. Empty otherwise. */
+    readonly errors: FieldError[];
+    /**
+     * The request's id: the `X-Request-Id` this client sent, which the API logs and answers with.
+     * Quote it when you ask for help, or find the request in the console's request logs.
+     */
+    readonly requestId: string | null;
+    constructor(message: string, fields?: ErrorFields);
+    /**
+     * Whether this means memory is unavailable - unreachable, too slow, too busy or failing - rather
+     * than that the request or the key is wrong. A `failOpen` client rides out an outage; a mistake
+     * still throws.
+     */
+    get outage(): boolean;
+}
+/** 401: no key, or one the service did not issue. */
+declare class AuthenticationError extends AlexeinError {
+}
+/** 403: the key reads, and the call writes. */
+declare class PermissionDeniedError extends AlexeinError {
+}
+/**
+ * 404: nothing was ever added for this app user, or memory holds nothing by the ref or id given.
+ * Search answers an empty result instead.
+ */
+declare class NotFoundError extends AlexeinError {
+}
+/** 400, 413, 422 and any other 4xx: the request itself is wrong. Retrying will not help. */
+declare class InvalidRequestError extends AlexeinError {
+}
+/**
+ * 429, after retries: too many requests in flight, or reads too fast. Retried for you, after
+ * `Retry-After` seconds (when at most 60) or with backoff.
+ */
+declare class RateLimitError extends AlexeinError {
+}
+/** 5xx, after retries (503 is retried; the rest are not): the service is busy or failing. */
+declare class ServiceUnavailableError extends AlexeinError {
+}
+/** The service could not be reached, after retries. */
+declare class APIConnectionError extends AlexeinError {
+    get outage(): boolean;
+}
+/** The service did not answer in time, after retries. */
+declare class APITimeoutError extends APIConnectionError {
+}
+
+export { APIConnectionError, APITimeoutError, AlexeinError, AuthenticationError, type FieldError, InvalidRequestError, NotFoundError, PermissionDeniedError, RateLimitError, ServiceUnavailableError, VERSION };

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+export { A as AddOptions, a as AddResult, b as AddedItem, c as Adding, d as AppUser, e as Author, C as Correction, D as DEFAULT_BASE_URL, f as DEFAULT_RETRIES, g as DEFAULT_TIMEOUT_MS, h as Deleted, E as Erased, i as Excerpt, j as ExportPage, k as ExportRecord, F as Fact, l as FactsPage, m as Filters, n as FollowUp, o as ForgetOptions, p as Forgotten, G as GrepOptions, H as History, I as Item, q as ItemDefaults, r as ItemStatus, s as ItemsOptions, t as ItemsPage, J as Json, K as Known, L as LatestOptions, M as Me, u as Memories, v as Memory, w as MemoryEntry, x as MemoryOptions, O as OpenItem, y as OpenItems, z as OpenItemsOptions, B as Opened, N as Origin, P as PageOptions, S as SearchOptions, Q as SearchResult, R as Source, T as Sources, U as Statuses, V as StoredItem, W as Summary, X as User, Y as UsersPage, Z as Value, _ as VersionEntry, $ as Versions } from './client-YKZ4fkK-.js';
+
+declare const VERSION = "0.3.0";
+
+/**
+ * What can go wrong, one class per thing a caller would handle differently: the same classes as
+ * the Python client's, so what is true of an error there is true here.
+ */
+
+/** One field a 422 named, and what it takes. */
+interface FieldError {
+    /** Where in the body: `query`, `items[0].text`; empty for the body itself. */
+    field: string;
+    message: string;
+}
+interface ErrorFields {
+    status?: number | null;
+    detail?: string;
+    errors?: FieldError[];
+    requestId?: string | null;
+    cause?: unknown;
+}
+/** Every error this client throws. */
+declare class AlexeinError extends Error {
+    /** The HTTP status, or null when no response came back. */
+    readonly status: number | null;
+    /** The API's own explanation; for a transport failure, what went wrong. */
+    readonly detail: string;
+    /** On a 422: each field the body got wrong. Empty otherwise. */
+    readonly errors: FieldError[];
+    /**
+     * The request's id: the `X-Request-Id` this client sent, which the API logs and answers with.
+     * Quote it when you ask for help, or find the request in the console's request logs.
+     */
+    readonly requestId: string | null;
+    constructor(message: string, fields?: ErrorFields);
+    /**
+     * Whether this means memory is unavailable - unreachable, too slow, too busy or failing - rather
+     * than that the request or the key is wrong. A `failOpen` client rides out an outage; a mistake
+     * still throws.
+     */
+    get outage(): boolean;
+}
+/** 401: no key, or one the service did not issue. */
+declare class AuthenticationError extends AlexeinError {
+}
+/** 403: the key reads, and the call writes. */
+declare class PermissionDeniedError extends AlexeinError {
+}
+/**
+ * 404: nothing was ever added for this app user, or memory holds nothing by the ref or id given.
+ * Search answers an empty result instead.
+ */
+declare class NotFoundError extends AlexeinError {
+}
+/** 400, 413, 422 and any other 4xx: the request itself is wrong. Retrying will not help. */
+declare class InvalidRequestError extends AlexeinError {
+}
+/**
+ * 429, after retries: too many requests in flight, or reads too fast. Retried for you, after
+ * `Retry-After` seconds (when at most 60) or with backoff.
+ */
+declare class RateLimitError extends AlexeinError {
+}
+/** 5xx, after retries (503 is retried; the rest are not): the service is busy or failing. */
+declare class ServiceUnavailableError extends AlexeinError {
+}
+/** The service could not be reached, after retries. */
+declare class APIConnectionError extends AlexeinError {
+    get outage(): boolean;
+}
+/** The service did not answer in time, after retries. */
+declare class APITimeoutError extends APIConnectionError {
+}
+
+export { APIConnectionError, APITimeoutError, AlexeinError, AuthenticationError, type FieldError, InvalidRequestError, NotFoundError, PermissionDeniedError, RateLimitError, ServiceUnavailableError, VERSION };

package/dist/index.js

@@ -0,0 +1,36 @@
+import {
+  APIConnectionError,
+  APITimeoutError,
+  AlexeinError,
+  AuthenticationError,
+  DEFAULT_BASE_URL,
+  DEFAULT_RETRIES,
+  DEFAULT_TIMEOUT_MS,
+  InvalidRequestError,
+  Memory,
+  NotFoundError,
+  PermissionDeniedError,
+  RateLimitError,
+  SearchResult,
+  ServiceUnavailableError,
+  User,
+  VERSION
+} from "./chunk-UNVZ22EN.js";
+export {
+  APIConnectionError,
+  APITimeoutError,
+  AlexeinError,
+  AuthenticationError,
+  DEFAULT_BASE_URL,
+  DEFAULT_RETRIES,
+  DEFAULT_TIMEOUT_MS,
+  InvalidRequestError,
+  Memory,
+  NotFoundError,
+  PermissionDeniedError,
+  RateLimitError,
+  SearchResult,
+  ServiceUnavailableError,
+  User,
+  VERSION
+};

package/dist/langgraph.cjs

@@ -0,0 +1,185 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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; } async function _asyncOptionalChain(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 = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await 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/langgraph/index.ts
+var _messages = require('@langchain/core/messages');
+var _tools = require('@langchain/core/tools');
+var _langgraph = require('@langchain/langgraph');
+var _zod = require('zod');
+var MemoryAnnotation = _langgraph.Annotation.Root({
+  ..._langgraph.MessagesAnnotation.spec,
+  memory: _langgraph.Annotation.call(void 0, { reducer: (_, found) => found, default: () => "" })
+});
+var MemoryState = new (0, _langgraph.StateSchema)({
+  messages: _langgraph.MessagesValue,
+  memory: _zod.z.string().default("")
+});
+var MemoryContext = _zod.z.object({ user_id: _zod.z.string().optional() });
+function userIdOf(config) {
+  const context = _optionalChain([config, 'optionalAccess', _2 => _2.context]);
+  const found = _nullishCoalesce(_optionalChain([context, 'optionalAccess', _3 => _3.user_id]), () => ( _optionalChain([config, 'optionalAccess', _4 => _4.configurable, 'optionalAccess', _5 => _5.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 = _optionalChain([config, 'optionalAccess', _6 => _6.configurable, 'optionalAccess', _7 => _7.thread_id]);
+  return thread === void 0 || thread === null ? void 0 : String(thread);
+}
+function lastHuman(messages) {
+  return messages.findLast((m) => _messages.HumanMessage.isInstance(m));
+}
+function lastReply(messages) {
+  return messages.findLast((m) => _messages.AIMessage.isInstance(m) && !_optionalChain([m, 'access', _8 => _8.tool_calls, 'optionalAccess', _9 => _9.length]));
+}
+var AlexeinMemory = (_class = class {
+  
+  
+  
+  #client;
+  /** `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);_class.prototype.__init3.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, "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`. */
+  __init() {this.recall = exports.recall = async (state, config) => {
+    const asked = _optionalChain([lastHuman, 'call', _16 => _16(state.messages), 'optionalAccess', _17 => _17.text, 'access', _18 => _18.trim, 'call', _19 => _19()]);
+    const user = this.user(config);
+    if (!asked) return { memory: "" };
+    const found = await _chunkTLAHP2PBcjs.searchFor.call(void 0, user, asked, this.fast);
+    return { memory: _nullishCoalesce(_optionalChain([found, 'optionalAccess', _20 => _20.context, 'call', _21 => _21(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.
+   */
+  __init2() {this.remember = exports.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. */
+  __init3() {this.prompt = (state) => _chunkTLAHP2PBcjs.promptBlock.call(void 0, _nullishCoalesce(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 _tools.tool.call(void 0, 
+      async ({ query }, config) => {
+        const found = await _chunkTLAHP2PBcjs.searchFor.call(void 0, this.user(config), query, this.fast);
+        return _chunkTLAHP2PBcjs.searchAnswer.call(void 0, 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: _zod.z.object({ query: _zod.z.string().describe("What to look for") })
+      }
+    );
+  }
+  openTool() {
+    return _tools.tool.call(void 0, 
+      async ({ ref }, config) => {
+        const user = this.user(config);
+        try {
+          return _chunkTLAHP2PBcjs.openAnswer.call(void 0, await user.open(ref));
+        } catch (error) {
+          if (error instanceof _chunk7KPDU3YVcjs.NotFoundError) return _chunkTLAHP2PBcjs.notFoundAnswer.call(void 0, error);
+          return _chunkTLAHP2PBcjs.outageAnswer.call(void 0, error, this.strict);
+        }
+      },
+      {
+        name: "memory_open",
+        description: "Read one remembered memory whole, by a ref memory_search gave.",
+        schema: _zod.z.object({ ref: _zod.z.string().describe("A ref memory_search gave") })
+      }
+    );
+  }
+  addTool() {
+    return _tools.tool.call(void 0, 
+      async ({ text }, config) => {
+        const saved = await this.user(config).add(text, {
+          kind: "note",
+          session: threadOf(config)
+        });
+        return saved.failed ? _chunkTLAHP2PBcjs.UNAVAILABLE : _chunkTLAHP2PBcjs.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: _zod.z.object({ text: _zod.z.string().describe("One plain sentence") })
+      }
+    );
+  }
+}, _class);
+async function item(message, role, thread) {
+  const text = _optionalChain([message, 'optionalAccess', _22 => _22.text]);
+  if (!_optionalChain([text, 'optionalAccess', _23 => _23.trim, 'call', _24 => _24()])) return void 0;
+  const id = await _asyncNullishCoalesce(await _asyncOptionalChain([message, 'optionalAccess', async _25 => _25.id]), async () => ( await _chunkTLAHP2PBcjs.stableId.call(void 0, 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);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AlexeinMemory = AlexeinMemory; exports.MemoryAnnotation = MemoryAnnotation; exports.MemoryContext = MemoryContext; exports.MemoryState = MemoryState; exports.NOTHING_FOUND = _chunkTLAHP2PBcjs.NOTHING_FOUND; exports.NOTHING_YET = _chunkTLAHP2PBcjs.NOTHING_YET; exports.UNAVAILABLE = _chunkTLAHP2PBcjs.UNAVAILABLE; exports.defaultMemory = defaultMemory; exports.memoryPrompt = memoryPrompt; exports.memoryTools = memoryTools; exports.recall = recall; exports.remember = remember; exports.userIdOf = userIdOf;

package/dist/langgraph.d.cts

@@ -0,0 +1,93 @@
+import * as _langchain_core_messages from '@langchain/core/messages';
+import { BaseMessage } from '@langchain/core/messages';
+import * as _langchain_langgraph from '@langchain/langgraph';
+import { StateSchema } from '@langchain/langgraph';
+import { StructuredToolInterface } from '@langchain/core/tools';
+import { z } from 'zod';
+import { v as Memory } 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';
+
+/** A graph's state with room for what `recall` found: `messages` and `memory`. */
+declare const MemoryAnnotation: _langchain_langgraph.AnnotationRoot<{
+    memory: _langchain_langgraph.BaseChannel<string, string | _langchain_langgraph.OverwriteValue<string>, unknown>;
+    messages: _langchain_langgraph.BaseChannel<BaseMessage<_langchain_core_messages.MessageStructure<_langchain_core_messages.MessageToolSet>, _langchain_core_messages.MessageType>[], _langchain_langgraph.OverwriteValue<BaseMessage<_langchain_core_messages.MessageStructure<_langchain_core_messages.MessageToolSet>, _langchain_core_messages.MessageType>[]> | _langchain_langgraph.Messages, unknown>;
+}>;
+/** The same state as a `StateSchema`, for graphs written that way. */
+declare const MemoryState: StateSchema<{
+    messages: _langchain_langgraph.ReducedValue<BaseMessage<_langchain_core_messages.MessageStructure<_langchain_core_messages.MessageToolSet>, _langchain_core_messages.MessageType>[], _langchain_langgraph.Messages>;
+    memory: z.ZodDefault<z.ZodString>;
+}>;
+/**
+ * Whose memory a run reads, as a context schema. Optional, so that a run without it reaches the
+ * check that says how to give one instead of failing the schema's.
+ */
+declare const MemoryContext: z.ZodObject<{
+    user_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** What a node or tool is handed about its run: its context and its thread. */
+interface RunConfig {
+    context?: unknown;
+    configurable?: Record<string, unknown>;
+}
+/** A state with messages, and `memory` once `recall` has run. */
+interface MemoryStateValue {
+    messages: BaseMessage[];
+    memory?: string;
+}
+/** The app user this run is for: `context.user_id`, else `configurable.user_id`. */
+declare function userIdOf(config: RunConfig | undefined): string;
+/** Memory for a LangGraph.js graph: nodes, a prompt block 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;
+    private user;
+    /** A node: what memory holds for the latest human message, into `state.memory`. */
+    readonly recall: (state: MemoryStateValue, config?: RunConfig) => Promise<{
+        memory: string;
+    }>;
+    /**
+     * 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.
+     */
+    readonly remember: (state: MemoryStateValue, config?: RunConfig) => Promise<Record<string, never>>;
+    /** What `recall` found, as a block for your system prompt; empty when it found nothing. */
+    readonly prompt: (state: {
+        memory?: string;
+    }) => string;
+    /**
+     * 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 }?: {
+        write?: boolean;
+    }): StructuredToolInterface[];
+    private searchTool;
+    private openTool;
+    private addTool;
+}
+/** 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: (state: MemoryStateValue, config?: RunConfig) => Promise<{
+    memory: string;
+}>;
+/** `remember` of the default `AlexeinMemory`. */
+declare const remember: (state: MemoryStateValue, config?: RunConfig) => Promise<Record<string, never>>;
+/** `prompt` of the default `AlexeinMemory`. */
+declare const memoryPrompt: (state: {
+    memory?: string;
+}) => string;
+/** `tools` of the default `AlexeinMemory`. */
+declare const memoryTools: (options?: {
+    write?: boolean;
+}) => StructuredToolInterface[];
+
+export { AlexeinMemory, IntegrationOptions as AlexeinMemoryOptions, MemoryAnnotation, MemoryContext, MemoryState, type MemoryStateValue, type RunConfig, defaultMemory, memoryPrompt, memoryTools, recall, remember, userIdOf };

package/dist/langgraph.d.ts

@@ -0,0 +1,93 @@
+import * as _langchain_core_messages from '@langchain/core/messages';
+import { BaseMessage } from '@langchain/core/messages';
+import * as _langchain_langgraph from '@langchain/langgraph';
+import { StateSchema } from '@langchain/langgraph';
+import { StructuredToolInterface } from '@langchain/core/tools';
+import { z } from 'zod';
+import { v as Memory } 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';
+
+/** A graph's state with room for what `recall` found: `messages` and `memory`. */
+declare const MemoryAnnotation: _langchain_langgraph.AnnotationRoot<{
+    memory: _langchain_langgraph.BaseChannel<string, string | _langchain_langgraph.OverwriteValue<string>, unknown>;
+    messages: _langchain_langgraph.BaseChannel<BaseMessage<_langchain_core_messages.MessageStructure<_langchain_core_messages.MessageToolSet>, _langchain_core_messages.MessageType>[], _langchain_langgraph.OverwriteValue<BaseMessage<_langchain_core_messages.MessageStructure<_langchain_core_messages.MessageToolSet>, _langchain_core_messages.MessageType>[]> | _langchain_langgraph.Messages, unknown>;
+}>;
+/** The same state as a `StateSchema`, for graphs written that way. */
+declare const MemoryState: StateSchema<{
+    messages: _langchain_langgraph.ReducedValue<BaseMessage<_langchain_core_messages.MessageStructure<_langchain_core_messages.MessageToolSet>, _langchain_core_messages.MessageType>[], _langchain_langgraph.Messages>;
+    memory: z.ZodDefault<z.ZodString>;
+}>;
+/**
+ * Whose memory a run reads, as a context schema. Optional, so that a run without it reaches the
+ * check that says how to give one instead of failing the schema's.
+ */
+declare const MemoryContext: z.ZodObject<{
+    user_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** What a node or tool is handed about its run: its context and its thread. */
+interface RunConfig {
+    context?: unknown;
+    configurable?: Record<string, unknown>;
+}
+/** A state with messages, and `memory` once `recall` has run. */
+interface MemoryStateValue {
+    messages: BaseMessage[];
+    memory?: string;
+}
+/** The app user this run is for: `context.user_id`, else `configurable.user_id`. */
+declare function userIdOf(config: RunConfig | undefined): string;
+/** Memory for a LangGraph.js graph: nodes, a prompt block 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;
+    private user;
+    /** A node: what memory holds for the latest human message, into `state.memory`. */
+    readonly recall: (state: MemoryStateValue, config?: RunConfig) => Promise<{
+        memory: string;
+    }>;
+    /**
+     * 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.
+     */
+    readonly remember: (state: MemoryStateValue, config?: RunConfig) => Promise<Record<string, never>>;
+    /** What `recall` found, as a block for your system prompt; empty when it found nothing. */
+    readonly prompt: (state: {
+        memory?: string;
+    }) => string;
+    /**
+     * 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 }?: {
+        write?: boolean;
+    }): StructuredToolInterface[];
+    private searchTool;
+    private openTool;
+    private addTool;
+}
+/** 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: (state: MemoryStateValue, config?: RunConfig) => Promise<{
+    memory: string;
+}>;
+/** `remember` of the default `AlexeinMemory`. */
+declare const remember: (state: MemoryStateValue, config?: RunConfig) => Promise<Record<string, never>>;
+/** `prompt` of the default `AlexeinMemory`. */
+declare const memoryPrompt: (state: {
+    memory?: string;
+}) => string;
+/** `tools` of the default `AlexeinMemory`. */
+declare const memoryTools: (options?: {
+    write?: boolean;
+}) => StructuredToolInterface[];
+
+export { AlexeinMemory, IntegrationOptions as AlexeinMemoryOptions, MemoryAnnotation, MemoryContext, MemoryState, type MemoryStateValue, type RunConfig, defaultMemory, memoryPrompt, memoryTools, recall, remember, userIdOf };