{"version":3,"file":"config.cjs","names":["CallbackManager","CONFIG_KEY_READ","AsyncLocalStorageProviderSingleton","CONFIG_KEY_SCRATCHPAD"],"sources":["../../../src/pregel/utils/config.ts"],"sourcesContent":["import { RunnableConfig } from \"@langchain/core/runnables\";\nimport { AsyncLocalStorageProviderSingleton } from \"@langchain/core/singletons\";\nimport {\n  CallbackManager,\n  ensureHandler,\n  type Callbacks,\n} from \"@langchain/core/callbacks/manager\";\nimport { BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport { LangGraphRunnableConfig } from \"../runnable_types.js\";\nimport {\n  CHECKPOINT_NAMESPACE_END,\n  CHECKPOINT_NAMESPACE_SEPARATOR,\n  CONFIG_KEY_READ,\n  CONFIG_KEY_SCRATCHPAD,\n} from \"../../constants.js\";\n\nconst COPIABLE_KEYS = [\"tags\", \"metadata\", \"callbacks\", \"configurable\"];\n\nconst CONFIG_KEYS = [\n  \"tags\",\n  \"metadata\",\n  \"callbacks\",\n  \"runName\",\n  \"maxConcurrency\",\n  \"recursionLimit\",\n  \"configurable\",\n  \"runId\",\n  \"outputKeys\",\n  \"streamMode\",\n  \"store\",\n  \"writer\",\n  \"interrupt\",\n  \"context\",\n  \"interruptBefore\",\n  \"interruptAfter\",\n  \"checkpointDuring\",\n  \"durability\",\n  \"signal\",\n  \"heartbeat\",\n  \"executionInfo\",\n  \"serverInfo\",\n  \"control\",\n];\n\nconst DEFAULT_RECURSION_LIMIT = 25;\nexport const PROPAGATE_TO_METADATA = new Set([\n  \"thread_id\",\n  \"checkpoint_id\",\n  \"checkpoint_ns\",\n  \"task_id\",\n  \"run_id\",\n  \"assistant_id\",\n  \"graph_id\",\n]);\n\nexport function propagateConfigurableToMetadata(\n  configurable?: Record<string, unknown>,\n  metadata?: Record<string, unknown>\n): Record<string, unknown> | undefined {\n  if (!configurable) {\n    return metadata;\n  }\n  const result = metadata ?? {};\n  for (const key of PROPAGATE_TO_METADATA) {\n    if (key in result) {\n      continue;\n    }\n    const value = configurable[key];\n    if (value !== undefined) {\n      result[key] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Drop langgraph's internal `seq:step*` bookkeeping tags.\n *\n * `seq:step:N` tags are added internally to mark sequence steps; everything\n * else (user-supplied tags and any other framework tags) is kept. Returns the\n * surviving tags, or `undefined` if none remain. Shared by the stream handlers\n * (e.g. {@link mapDebugTasks}) so the same tag set is surfaced consistently.\n */\nexport function filterToUserTags(\n  tags: readonly string[] | undefined\n): string[] | undefined {\n  if (tags == null || tags.length === 0) return undefined;\n  const filtered = tags.filter((tag) => !tag.startsWith(\"seq:step\"));\n  return filtered.length > 0 ? filtered : undefined;\n}\n\n/**\n * Merge two `callbacks` values across configs.\n *\n * A `callbacks` value may be `undefined`, an array of handlers, or a\n * {@link CallbackManager}, so merging two of them has six cases. This\n * mirrors the callbacks branch of langchain-core's `mergeConfigs` and\n * langgraph's `_merge_callbacks`, so a handler bound via\n * `.withConfig({ callbacks: [...] })` is preserved when a later config\n * (e.g. `streamEvents` injecting its own internal handler) is merged on\n * top instead of overwriting it.\n */\nfunction mergeCallbacks(\n  base: Callbacks | undefined,\n  provided: Callbacks | undefined\n): Callbacks | undefined {\n  if (provided === undefined) return base;\n  if (base === undefined) {\n    return Array.isArray(provided) ? [...provided] : provided.copy();\n  }\n  if (Array.isArray(provided)) {\n    if (Array.isArray(base)) return base.concat(provided);\n    // base is a manager\n    const manager = base.copy();\n    for (const callback of provided) {\n      manager.addHandler(ensureHandler(callback), true);\n    }\n    return manager;\n  }\n  // provided is a manager\n  if (Array.isArray(base)) {\n    const manager = provided.copy();\n    for (const callback of base) {\n      manager.addHandler(ensureHandler(callback), true);\n    }\n    return manager;\n  }\n  // both are managers\n  return new CallbackManager(provided._parentRunId, {\n    handlers: base.handlers.concat(provided.handlers),\n    inheritableHandlers: base.inheritableHandlers.concat(\n      provided.inheritableHandlers\n    ),\n    tags: Array.from(new Set(base.tags.concat(provided.tags))),\n    inheritableTags: Array.from(\n      new Set(base.inheritableTags.concat(provided.inheritableTags))\n    ),\n    metadata: { ...base.metadata, ...provided.metadata },\n    inheritableMetadata: {\n      ...base.inheritableMetadata,\n      ...provided.inheritableMetadata,\n    },\n  });\n}\n\n/**\n * True when the caller is starting a fresh top-level run (invoke-time\n * `thread_id`, no active nesting keys). In that case the ambient `configurable`\n * from `AsyncLocalStorage` cannot be trusted per-key — it may belong to another\n * concurrent invocation on a shared singleton agent (scratchpad/task-input as\n * well as arbitrary user keys like `tenant_id`/`user_id`). The whole ambient\n * `configurable` is therefore ignored; any value the caller actually wants for\n * this run arrives through the explicit (bound + invoke-time) configs instead.\n *\n * Only the last caller-supplied config is treated as invoke-time options.\n * Earlier entries are graph-bound defaults from `.withConfig()` / compile and\n * must not count — a child graph bound with `thread_id` and invoked from a\n * parent task without a fresh config still needs ambient nesting keys from ALS.\n */\nfunction isRootLevelExplicitInvoke(\n  configs: (LangGraphRunnableConfig | undefined)[]\n): boolean {\n  let invokeConfig: LangGraphRunnableConfig | undefined;\n  for (let i = configs.length - 1; i >= 0; i -= 1) {\n    if (configs[i] !== undefined) {\n      invokeConfig = configs[i];\n      break;\n    }\n  }\n  const hasInvokeTimeThreadId =\n    invokeConfig?.configurable?.thread_id !== undefined;\n\n  const hasExplicitNesting = configs.some(\n    (c) => c?.configurable?.[CONFIG_KEY_READ] !== undefined\n  );\n\n  const ambientConfigurable =\n    AsyncLocalStorageProviderSingleton.getRunnableConfig()?.configurable;\n  const hasAmbientNesting =\n    ambientConfigurable?.[CONFIG_KEY_READ] !== undefined;\n\n  return hasInvokeTimeThreadId && !hasExplicitNesting && !hasAmbientNesting;\n}\n\nexport function ensureLangGraphConfig(\n  ...configs: (LangGraphRunnableConfig | undefined)[]\n): RunnableConfig {\n  const empty: LangGraphRunnableConfig = {\n    tags: [],\n    metadata: {},\n    callbacks: undefined,\n    recursionLimit: DEFAULT_RECURSION_LIMIT,\n    configurable: {},\n  };\n\n  const skipImplicitConfigurable = isRootLevelExplicitInvoke(configs);\n\n  const implicitConfig: RunnableConfig =\n    AsyncLocalStorageProviderSingleton.getRunnableConfig();\n  if (implicitConfig !== undefined) {\n    for (const [k, v] of Object.entries(implicitConfig)) {\n      if (v !== undefined) {\n        // Stale-ALS root invoke: ignore the ambient `configurable` entirely,\n        // since its keys may belong to another concurrent invocation.\n        if (k === \"configurable\" && skipImplicitConfigurable) {\n          continue;\n        }\n        if (COPIABLE_KEYS.includes(k)) {\n          let copiedValue;\n          if (Array.isArray(v)) {\n            copiedValue = [...v];\n          } else if (typeof v === \"object\") {\n            if (\n              k === \"callbacks\" &&\n              \"copy\" in v &&\n              typeof v.copy === \"function\"\n            ) {\n              copiedValue = v.copy();\n            } else {\n              copiedValue = { ...v };\n            }\n          } else {\n            copiedValue = v;\n          }\n          empty[k as keyof RunnableConfig] = copiedValue;\n        } else {\n          empty[k as keyof RunnableConfig] = v;\n        }\n      }\n    }\n  }\n\n  for (const config of configs) {\n    if (config === undefined) {\n      continue;\n    }\n\n    for (const [k, v] of Object.entries(config)) {\n      if (v === undefined || !CONFIG_KEYS.includes(k)) {\n        continue;\n      }\n\n      // Merge (rather than overwrite) the fields that compose across\n      // multiple configs, matching langgraph's `merge_configs` /\n      // langchain-core's `mergeConfigs`. Without this, a value bound via\n      // `.withConfig({...})` is silently dropped whenever a later config\n      // (e.g. invoke-time, or `streamEvents`' internal handler) supplies\n      // any other key in the same field. Later configs still win per key\n      // on collision.\n      if (k === \"configurable\") {\n        empty.configurable = {\n          ...(empty.configurable as Record<string, unknown> | undefined),\n          ...(v as Record<string, unknown>),\n        };\n      } else if (k === \"metadata\") {\n        empty.metadata = {\n          ...(empty.metadata as Record<string, unknown> | undefined),\n          ...(v as Record<string, unknown>),\n        };\n      } else if (k === \"tags\") {\n        // Plain concat (matches langgraph's `merge_configs`): no dedup,\n        // no sort.\n        empty.tags = [\n          ...((empty.tags as string[] | undefined) ?? []),\n          ...(v as string[]),\n        ];\n      } else if (k === \"callbacks\") {\n        empty.callbacks = mergeCallbacks(empty.callbacks, v as Callbacks);\n      } else {\n        empty[k as keyof LangGraphRunnableConfig] = v;\n      }\n    }\n  }\n\n  empty.metadata =\n    propagateConfigurableToMetadata(\n      empty.configurable as Record<string, unknown> | undefined,\n      empty.metadata as Record<string, unknown> | undefined\n    ) ?? {};\n  return empty;\n}\n\n/**\n * A helper utility function that returns the {@link BaseStore} that was set when the graph was initialized\n *\n * @returns a reference to the {@link BaseStore} that was set when the graph was initialized\n */\nexport function getStore(\n  config?: LangGraphRunnableConfig\n): BaseStore | undefined {\n  const runConfig: LangGraphRunnableConfig =\n    config ?? AsyncLocalStorageProviderSingleton.getRunnableConfig();\n\n  if (runConfig === undefined) {\n    throw new Error(\n      [\n        \"Config not retrievable. This is likely because you are running in an environment without support for AsyncLocalStorage.\",\n        \"If you're running `getStore` in such environment, pass the `config` from the node function directly.\",\n      ].join(\"\\n\")\n    );\n  }\n\n  return runConfig?.store;\n}\n\n/**\n * A helper utility function that returns the {@link LangGraphRunnableConfig#writer} if \"custom\" stream mode is enabled, otherwise undefined.\n *\n * @returns a reference to the {@link LangGraphRunnableConfig#writer} if \"custom\" stream mode is enabled, otherwise undefined\n */\nexport function getWriter(\n  config?: LangGraphRunnableConfig\n): ((chunk: unknown) => void) | undefined {\n  const runConfig: LangGraphRunnableConfig =\n    config ?? AsyncLocalStorageProviderSingleton.getRunnableConfig();\n\n  if (runConfig === undefined) {\n    throw new Error(\n      [\n        \"Config not retrievable. This is likely because you are running in an environment without support for AsyncLocalStorage.\",\n        \"If you're running `getWriter` in such environment, pass the `config` from the node function directly.\",\n      ].join(\"\\n\")\n    );\n  }\n\n  return runConfig?.writer || runConfig?.configurable?.writer;\n}\n\n/**\n * A helper utility function that returns the {@link LangGraphRunnableConfig} that was set when the graph was initialized.\n *\n * Note: This only works when running in an environment that supports node:async_hooks and AsyncLocalStorage. If you're running this in a\n * web environment, access the LangGraphRunnableConfig from the node function directly.\n *\n * @returns the {@link LangGraphRunnableConfig} that was set when the graph was initialized\n */\nexport function getConfig(): LangGraphRunnableConfig {\n  return AsyncLocalStorageProviderSingleton.getRunnableConfig();\n}\n\n/**\n * A helper utility function that returns the input for the currently executing\n * task.\n *\n * Note: When called without arguments, this relies on `node:async_hooks` /\n * `AsyncLocalStorage`, which is available in many JavaScript environments\n * (Node.js, Deno, Cloudflare Workers) but not in web browsers. In environments\n * without `AsyncLocalStorage` support, pass the `config` that your node/tool\n * function receives directly, e.g. `getCurrentTaskInput(config)`.\n *\n * Tip: Inside a tool run by a `ToolNode`, prefer reading graph state from\n * `runtime.state` on the second tool argument (typed as `ToolRuntime` from\n * `@langchain/core/tools`). It works in every runtime, including web browsers.\n *\n * @param config - Optional {@link LangGraphRunnableConfig} to read the task\n * input from. Provide this when running in an environment without\n * `AsyncLocalStorage` support (e.g. web browsers).\n * @returns the input for the currently executing task\n */\nexport function getCurrentTaskInput<T = unknown>(\n  config?: LangGraphRunnableConfig\n): T {\n  const runConfig: LangGraphRunnableConfig =\n    config ?? AsyncLocalStorageProviderSingleton.getRunnableConfig();\n\n  if (runConfig === undefined) {\n    throw new Error(\n      [\n        \"Config not retrievable. This is likely because you are running in an environment without support for AsyncLocalStorage.\",\n        \"If you're running `getCurrentTaskInput` in such environment, pass the `config` from the node function directly.\",\n      ].join(\"\\n\")\n    );\n  }\n\n  if (\n    runConfig.configurable?.[CONFIG_KEY_SCRATCHPAD]?.currentTaskInput ===\n    undefined\n  ) {\n    throw new Error(\"BUG: internal scratchpad not initialized.\");\n  }\n\n  return runConfig!.configurable![CONFIG_KEY_SCRATCHPAD]!.currentTaskInput as T;\n}\n\nexport function recastCheckpointNamespace(namespace: string): string {\n  return namespace\n    .split(CHECKPOINT_NAMESPACE_SEPARATOR)\n    .filter((part) => !part.match(/^\\d+$/))\n    .map((part) => part.split(CHECKPOINT_NAMESPACE_END)[0])\n    .join(CHECKPOINT_NAMESPACE_SEPARATOR);\n}\n\nexport function getParentCheckpointNamespace(namespace: string): string {\n  const parts = namespace.split(CHECKPOINT_NAMESPACE_SEPARATOR);\n  while (parts.length > 1 && parts[parts.length - 1].match(/^\\d+$/)) {\n    parts.pop();\n  }\n  return parts.slice(0, -1).join(CHECKPOINT_NAMESPACE_SEPARATOR);\n}\n"],"mappings":"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"}