Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

22.5 KB
Raw Blame
import dayjs from 'dayjs';
import utc from 'dayjs/plugin/utc.js';
import timezonePlugin from 'dayjs/plugin/timezone.js';
import type { ZodIssue } from 'zod';
import type * as a from './types/content';
import type * as s from './schemas';
import type * as t from './types';
import {
  openAISchema,
  openRouterSchema,
  googleSchema,
  EModelEndpoint,
  isAgentsEndpoint,
  isAssistantsEndpoint,
  Providers,
  anthropicSchema,
  assistantSchema,
  compactAgentsSchema,
  compactGoogleSchema,
  compactAssistantSchema,
} from './schemas';
import { bedrockInputSchema } from './bedrock';
import { ContentTypes } from './types/runs';
import { alternateName } from './config';

dayjs.extend(utc);
dayjs.extend(timezonePlugin);

type EndpointSchema =
  | typeof openAISchema
  | typeof openRouterSchema
  | typeof googleSchema
  | typeof anthropicSchema
  | typeof assistantSchema
  | typeof compactAgentsSchema
  | typeof bedrockInputSchema;

export type EndpointSchemaKey = EModelEndpoint;
type EndpointSchemaLookupKey = EModelEndpoint | Providers.OPENROUTER;

const endpointSchemas: Record<EndpointSchemaLookupKey, EndpointSchema> = {
  [EModelEndpoint.openAI]: openAISchema,
  [EModelEndpoint.azureOpenAI]: openAISchema,
  [EModelEndpoint.custom]: openAISchema,
  [Providers.OPENROUTER]: openRouterSchema,
  [EModelEndpoint.google]: googleSchema,
  [EModelEndpoint.anthropic]: anthropicSchema,
  [EModelEndpoint.assistants]: assistantSchema,
  [EModelEndpoint.azureAssistants]: assistantSchema,
  [EModelEndpoint.agents]: compactAgentsSchema,
  [EModelEndpoint.bedrock]: bedrockInputSchema,
};

const isEndpointSchemaLookupKey = (value?: string | null): value is EndpointSchemaLookupKey =>
  value != null && Object.prototype.hasOwnProperty.call(endpointSchemas, value);

const getFallbackEndpointSchema = <TSchema>(
  schemas: Record<EndpointSchemaLookupKey, TSchema>,
  endpointType?: EndpointSchemaKey | null,
  defaultParamsEndpoint?: string | null,
): TSchema | undefined => {
  if (!endpointType) {
    return undefined;
  }

  const overrideSchema = isEndpointSchemaLookupKey(defaultParamsEndpoint)
    ? schemas[defaultParamsEndpoint]
    : undefined;
  return overrideSchema ?? schemas[endpointType];
};

/** Get the enabled endpoints from the `ENDPOINTS` environment variable */
export function getEnabledEndpoints() {
  const defaultEndpoints: string[] = [
    EModelEndpoint.openAI,
    EModelEndpoint.agents,
    EModelEndpoint.assistants,
    EModelEndpoint.azureAssistants,
    EModelEndpoint.azureOpenAI,
    EModelEndpoint.google,
    EModelEndpoint.anthropic,
    EModelEndpoint.bedrock,
  ];

  const endpointsEnv = process.env.ENDPOINTS ?? '';
  let enabledEndpoints = defaultEndpoints;
  if (endpointsEnv) {
    enabledEndpoints = endpointsEnv
      .split(',')
      .filter((endpoint) => endpoint.trim())
      .map((endpoint) => endpoint.trim());
  }
  return enabledEndpoints;
}

/** Orders an existing EndpointsConfig object based on enabled endpoint/custom ordering */
export function orderEndpointsConfig(endpointsConfig: t.TEndpointsConfig) {
  if (!endpointsConfig) {
    return {};
  }
  const enabledEndpoints = getEnabledEndpoints();
  const endpointKeys = Object.keys(endpointsConfig);
  const defaultCustomIndex = enabledEndpoints.indexOf(EModelEndpoint.custom);
  return endpointKeys.reduce(
    (accumulatedConfig: Record<string, t.TConfig | null | undefined>, currentEndpointKey) => {
      const isCustom = !(currentEndpointKey in EModelEndpoint);
      const isEnabled = enabledEndpoints.includes(currentEndpointKey);
      if (!isEnabled && !isCustom) {
        return accumulatedConfig;
      }

      const index = enabledEndpoints.indexOf(currentEndpointKey);

      if (isCustom) {
        accumulatedConfig[currentEndpointKey] = {
          order: defaultCustomIndex >= 0 ? defaultCustomIndex : 9999,
          ...(endpointsConfig[currentEndpointKey] as Omit<t.TConfig, 'order'> & { order?: number }),
        };
      } else if (endpointsConfig[currentEndpointKey]) {
        accumulatedConfig[currentEndpointKey] = {
          ...endpointsConfig[currentEndpointKey],
          order: index,
        };
      }
      return accumulatedConfig;
    },
    {},
  );
}

/** Converts an array of Zod issues into a string. */
export function errorsToString(errors: ZodIssue[]) {
  return errors
    .map((error) => {
      const field = error.path.join('.');
      const message = error.message;

      return `${field}: ${message}`;
    })
    .join(' ');
}

export function getFirstDefinedValue(possibleValues: string[]) {
  let returnValue;
  for (const value of possibleValues) {
    if (value) {
      returnValue = value;
      break;
    }
  }
  return returnValue;
}

export function getNonEmptyValue(possibleValues: string[]) {
  for (const value of possibleValues) {
    if (value && value.trim() !== '') {
      return value;
    }
  }
  return undefined;
}

export type TPossibleValues = {
  models: string[];
};

export const parseConvo = ({
  endpoint,
  endpointType,
  conversation,
  possibleValues,
  defaultParamsEndpoint,
}: {
  endpoint: EndpointSchemaKey;
  endpointType?: EndpointSchemaKey | null;
  conversation: Partial<s.TConversation | s.TPreset> | null;
  possibleValues?: TPossibleValues;
  defaultParamsEndpoint?: string | null;
}) => {
  const primarySchema = endpointSchemas[endpoint] as EndpointSchema | undefined;

  if (!primarySchema && !endpointType) {
    throw new Error(`Unknown endpoint: ${endpoint}`);
  }

  const schema =
    primarySchema ??
    getFallbackEndpointSchema(endpointSchemas, endpointType, defaultParamsEndpoint);
  const convo = schema?.parse(conversation) as s.TConversation | undefined;
  const { models } = possibleValues ?? {};

  if (models && convo) {
    convo.model = getFirstDefinedValue(models) ?? convo.model;
  }

  return convo;
};

/** Match GPT followed by digit, optional decimal, and optional suffix
 *
 * Examples: gpt-4, gpt-4o, gpt-4.5, gpt-5a, etc. */
const extractGPTVersion = (modelStr: string): string => {
  const gptMatch = modelStr.match(/gpt-(\d+(?:\.\d+)?)([a-z])?/i);
  if (gptMatch) {
    const version = gptMatch[1];
    const suffix = gptMatch[2] || '';
    return `GPT-${version}${suffix}`;
  }
  return '';
};

/** Match omni models (o1, o3, etc.), "o" followed by a digit, possibly with decimal */
const extractOmniVersion = (modelStr: string): string => {
  const omniMatch = modelStr.match(/\bo(\d+(?:\.\d+)?)\b/i);
  if (omniMatch) {
    const version = omniMatch[1];
    return `o${version}`;
  }
  return '';
};

export const getResponseSender = (endpointOption: Partial<t.TEndpointOption>): string => {
  const {
    model: _m,
    endpoint: _e,
    endpointType,
    modelDisplayLabel: _mdl,
    chatGptLabel: _cgl,
    modelLabel: _ml,
  } = endpointOption;

  const endpoint = _e as EModelEndpoint;

  const model = _m ?? '';
  const modelDisplayLabel = _mdl ?? '';
  const chatGptLabel = _cgl ?? '';
  const modelLabel = _ml ?? '';
  if (
    [EModelEndpoint.openAI, EModelEndpoint.bedrock, EModelEndpoint.azureOpenAI].includes(endpoint)
  ) {
    if (modelLabel) {
      return modelLabel;
    } else if (chatGptLabel) {
      // @deprecated - prefer modelLabel
      return chatGptLabel;
    } else if (model && extractOmniVersion(model)) {
      return extractOmniVersion(model);
    } else if (model && (model.includes('mistral') || model.includes('codestral'))) {
      return 'Mistral';
    } else if (model && model.includes('deepseek')) {
      return 'Deepseek';
    } else if (model && model.includes('kimi')) {
      return 'Kimi';
    } else if (model && model.includes('moonshot')) {
      return 'Moonshot';
    } else if (model && model.includes('gpt-')) {
      const gptVersion = extractGPTVersion(model);
      return gptVersion || 'GPT';
    }
    return (alternateName[endpoint] as string | undefined) ?? 'AI';
  }

  if (endpoint === EModelEndpoint.anthropic) {
    return modelLabel || 'Claude';
  }

  if (endpoint === EModelEndpoint.bedrock) {
    return modelLabel || alternateName[endpoint];
  }

  if (endpoint === EModelEndpoint.google) {
    if (modelLabel) {
      return modelLabel;
    } else if (model?.toLowerCase().includes('gemma') === true) {
      return 'Gemma';
    }

    return 'Gemini';
  }

  if (endpoint === EModelEndpoint.custom || endpointType === EModelEndpoint.custom) {
    if (modelLabel) {
      return modelLabel;
    } else if (chatGptLabel) {
      // @deprecated - prefer modelLabel
      return chatGptLabel;
    } else if (model && extractOmniVersion(model)) {
      return extractOmniVersion(model);
    } else if (model && (model.includes('mistral') || model.includes('codestral'))) {
      return 'Mistral';
    } else if (model && model.includes('deepseek')) {
      return 'Deepseek';
    } else if (model && model.includes('kimi')) {
      return 'Kimi';
    } else if (model && model.includes('moonshot')) {
      return 'Moonshot';
    } else if (model && model.includes('gpt-')) {
      const gptVersion = extractGPTVersion(model);
      return gptVersion || 'GPT';
    } else if (modelDisplayLabel) {
      return modelDisplayLabel;
    }

    return 'AI';
  }

  return '';
};

type CompactEndpointSchema =
  | typeof openAISchema
  | typeof compactAssistantSchema
  | typeof compactAgentsSchema
  | typeof compactGoogleSchema
  | typeof openRouterSchema
  | typeof anthropicSchema
  | typeof bedrockInputSchema;

const compactEndpointSchemas: Record<EndpointSchemaLookupKey, CompactEndpointSchema> = {
  [EModelEndpoint.openAI]: openAISchema,
  [EModelEndpoint.azureOpenAI]: openAISchema,
  [EModelEndpoint.custom]: openAISchema,
  [Providers.OPENROUTER]: openRouterSchema,
  [EModelEndpoint.assistants]: compactAssistantSchema,
  [EModelEndpoint.azureAssistants]: compactAssistantSchema,
  [EModelEndpoint.agents]: compactAgentsSchema,
  [EModelEndpoint.google]: compactGoogleSchema,
  [EModelEndpoint.bedrock]: bedrockInputSchema,
  [EModelEndpoint.anthropic]: anthropicSchema,
};

export const parseCompactConvo = ({
  endpoint,
  endpointType,
  conversation,
  possibleValues,
  defaultParamsEndpoint,
}: {
  endpoint?: EndpointSchemaKey;
  endpointType?: EndpointSchemaKey | null;
  conversation: Partial<s.TConversation | s.TPreset>;
  possibleValues?: TPossibleValues;
  defaultParamsEndpoint?: string | null;
}): Omit<s.TConversation, 'iconURL'> | null => {
  if (!endpoint) {
    throw new Error(`undefined endpoint: ${endpoint}`);
  }

  const primarySchema = compactEndpointSchemas[endpoint] as CompactEndpointSchema | undefined;

  if (!primarySchema && !endpointType) {
    throw new Error(`Unknown endpoint: ${endpoint}`);
  }

  const schema =
    primarySchema ??
    getFallbackEndpointSchema(compactEndpointSchemas, endpointType, defaultParamsEndpoint);

  if (!schema) {
    throw new Error(`Unknown endpointType: ${endpointType}`);
  }

  // Strip iconURL from input before parsing - it should only be derived server-side
  // from model spec configuration, not accepted from client requests
  const { iconURL: _clientIconURL, ...conversationWithoutIconURL } = conversation;

  const convo = schema.parse(conversationWithoutIconURL) as s.TConversation | null;
  const { models } = possibleValues ?? {};

  if (models && convo) {
    convo.model = getFirstDefinedValue(models) ?? convo.model;
  }

  return convo;
};

export function parseTextParts(
  contentParts: Array<a.TMessageContentParts | undefined>,
  skipReasoning: boolean = false,
  options?: { includeSteer?: boolean },
): string {
  let result = '';
  const append = (textValue: string) => {
    if (
      result.length > 0 &&
      textValue.length > 0 &&
      result[result.length - 1] !== ' ' &&
      textValue[0] !== ' '
    ) {
      result += ' ';
    }
    result += textValue;
  };

  for (const part of contentParts) {
    if (!part?.type) {
      continue;
    }
    if (part.type === ContentTypes.TEXT) {
      append((typeof part.text === 'string' ? part.text : part.text?.value) || '');
    } else if (part.type === ContentTypes.STEER && options?.includeSteer === true) {
      /** Mid-run user speech: excluded by default so generic extraction (TTS
       *  reading assistant output) never speaks the user's own words — the
       *  full-record surfaces (search indexing, persisted abort text) opt in. */
      append(typeof part.steer === 'string' ? part.steer : '');
    } else if (part.type === ContentTypes.THINK && !skipReasoning) {
      append(typeof part.think === 'string' ? part.think : '');
    }
  }

  return result;
}

const thinkingBlockPattern = /:::thinking([\s\S]*?):::/;

/**
 * Splits legacy plain-text reasoning from the answer exactly as the message view renders it:
 * the first `:::thinking ... :::` block becomes the collapsible Thoughts, the rest is the answer.
 */
export function parseThinkingContent(text: string): {
  thinkingContent: string;
  regularContent: string;
} {
  const thinkingMatch = text.match(thinkingBlockPattern);
  return {
    thinkingContent: thinkingMatch ? thinkingMatch[1].trim() : '',
    regularContent: thinkingMatch ? text.replace(thinkingBlockPattern, '').trim() : text,
  };
}

/**
 * The text Read Aloud speaks for a message: the answer the message view shows, never its
 * reasoning. Covers both reasoning shapes the UI collapses into Thoughts: `think` content parts
 * and the legacy `:::thinking ... :::` block in plain text.
 */
export function getSpeechText(message: {
  content?: Array<a.TMessageContentParts | undefined> | string | null;
  text?: string | null;
}): string {
  if (Array.isArray(message.content) && message.content.length > 0) {
    return parseTextParts(message.content, true).trim();
  }
  const text =
    typeof message.content === 'string' && message.content ? message.content : message.text;
  return parseThinkingContent(text ?? '').regularContent.trim();
}

export const SEPARATORS = ['.', '?', '!', '۔', '。', '‥', ';', '¡', '¿', '\n', '```'];

export function findLastSeparatorIndex(text: string, separators = SEPARATORS): number {
  let lastIndex = -1;
  for (const separator of separators) {
    const index = text.lastIndexOf(separator);
    if (index > lastIndex) {
      lastIndex = index;
    }
  }
  return lastIndex;
}

/**
 * Anchors a dayjs instant to the user's IANA timezone when one is supplied,
 * so local-time special vars reflect the user's wall clock rather than the
 * server's. Falls back to the original instant for missing or invalid zones.
 */
function applyTimezone(value: dayjs.Dayjs, timezone?: string): dayjs.Dayjs {
  if (!timezone) {
    return value;
  }
  try {
    const zoned = value.tz(timezone);
    return zoned.isValid() ? zoned : value;
  } catch {
    return value;
  }
}

export function replaceSpecialVars({
  text,
  user,
  now: inputNow,
  timezone,
}: {
  text: string;
  user?: t.TUser | null;
  now?: string | number | Date;
  timezone?: string;
}) {
  let result = text;
  if (!result) {
    return result;
  }

  const now = applyTimezone(inputNow != null ? dayjs(inputNow) : dayjs(), timezone);
  const weekdayName = now.format('dddd');

  const currentDate = now.format('YYYY-MM-DD');
  result = result.replace(/{{\s*current_date\s*}}/gi, `${currentDate} (${weekdayName})`);

  const currentDatetime = now.format('YYYY-MM-DD HH:mm:ss Z');
  result = result.replace(/{{\s*current_datetime\s*}}/gi, `${currentDatetime} (${weekdayName})`);

  const isoDatetime = now.toISOString();
  result = result.replace(/{{\s*iso_datetime\s*}}/gi, isoDatetime);

  if (user && user.name) {
    result = result.replace(/{{\s*current_user\s*}}/gi, user.name);
  }

  return result;
}

/**
 * Parsed ephemeral agent ID result
 */
export type ParsedEphemeralAgentId = {
  endpoint: string;
  model: string;
  sender?: string;
  index?: number;
};

/**
 * Resolves the display label ("sender") for an ephemeral agent:
 * `modelLabel` (user/preset) → model spec's `label` → endpoint config's
 * `modelDisplayLabel` → `''` (lets consumers fall back to the model name).
 */
export function getEphemeralSender({
  modelLabel,
  specLabel,
  modelDisplayLabel,
}: {
  modelLabel?: string | null;
  specLabel?: string | null;
  modelDisplayLabel?: string | null;
}): string {
  return modelLabel ?? specLabel ?? modelDisplayLabel ?? '';
}

/** Built-in endpoints; anything else in `endpoint` is a custom endpoint's own name. */
const builtInEndpoints = new Set<string>(Object.values(EModelEndpoint));

/**
 * Whether a persisted `sender` is a label someone configured rather than the
 * model-derived name `getResponseSender` produces.
 *
 * The sender is the one thing that records which it was: `resolveSender` writes an
 * agent's name, then the `getEphemeralSender` chain (`modelLabel` → a model spec's
 * `label` → an endpoint's `modelDisplayLabel`), and falls back to `getResponseSender`
 * only when none of those is set. Asking the message rather than the conversation
 * settles three things a settings lookup cannot: labels that live in config a caller
 * may not hold, labels an endpoint ignores (Anthropic keeps reading `Claude` whatever
 * `chatGptLabel` says, and matches here), and labels changed since the message was
 * written — its header still shows the sender it was written under.
 *
 * Equality is the test, so the only way to be wrong is a stored name that no longer
 * matches what the current heuristics produce, which withholds a model rather than
 * revealing one.
 */
export const isConfiguredSender = ({
  sender,
  endpoint,
  endpointType,
  model,
  isCreatedByUser,
}: {
  sender?: string | null;
  endpoint?: EModelEndpoint | string | null;
  endpointType?: EModelEndpoint | string | null;
  model?: string | null;
  isCreatedByUser?: boolean | null;
}): boolean => {
  /** A user turn is headed by the person who wrote it, so it has no model to withhold
   *  and its `User` sender would never match a derived name. */
  if (isCreatedByUser === true) {
    return false;
  }
  /** Agents and assistants are named by whoever authored them: the header shows that
   *  name whether or not the response stored a sender, and `getResponseSender` has no
   *  branch to derive one. */
  if (isAgentsEndpoint(endpoint) || isAssistantsEndpoint(endpoint)) {
    return true;
  }
  if (sender == null || sender === '') {
    return false;
  }
  /** A custom endpoint carries its own configured name in `endpoint`, which
   *  `getResponseSender` recognizes only through `endpointType`. */
  const resolvedType =
    endpointType ??
    (endpoint != null && !builtInEndpoints.has(endpoint) ? EModelEndpoint.custom : undefined);
  const derived = getResponseSender({
    endpoint: endpoint as EModelEndpoint,
    endpointType: resolvedType as EModelEndpoint,
    model,
  });
  /** An endpoint this cannot name — an older message stored without one, say — says
   *  nothing either way, and reading that silence as "configured" would withhold the
   *  model from every unlabelled row it reached. */
  if (derived === '') {
    return false;
  }
  return sender !== derived;
};

/**
 * Encodes an ephemeral agent ID from endpoint, model, optional sender, and optional index.
 * Uses __ to replace : (reserved in graph node names) and ___ to separate sender.
 *
 * Format: endpoint__model___sender or endpoint__model___sender____index (if index provided)
 *
 * @example
 * encodeEphemeralAgentId({ endpoint: 'openAI', model: 'gpt-4o', sender: 'GPT-4o' })
 * // => 'openAI__gpt-4o___GPT-4o'
 *
 * @example
 * encodeEphemeralAgentId({ endpoint: 'openAI', model: 'gpt-4o', sender: 'GPT-4o', index: 1 })
 * // => 'openAI__gpt-4o___GPT-4o____1'
 */
export function encodeEphemeralAgentId({
  endpoint,
  model,
  sender,
  index,
}: {
  endpoint: string;
  model: string;
  sender?: string;
  index?: number;
}): string {
  const base = `${endpoint}:${model}`.replace(/:/g, '__');
  let result = base;
  if (sender) {
    // Use ___ as separator before sender to distinguish from __ in model names
    result = `${base}___${sender.replace(/:/g, '__')}`;
  }
  if (index != null) {
    // Use ____ (4 underscores) as separator for index
    result = `${result}____${index}`;
  }
  return result;
}

/**
 * Parses an ephemeral agent ID back into its components.
 * Returns undefined if the ID doesn't match the expected format.
 *
 * Format: endpoint__model___sender or endpoint__model___sender____index
 * - ____ (4 underscores) separates optional index suffix
 * - ___ (triple underscore) separates model from optional sender
 * - __ (double underscore) replaces : in endpoint/model names
 *
 * @example
 * parseEphemeralAgentId('openAI__gpt-4o___GPT-4o')
 * // => { endpoint: 'openAI', model: 'gpt-4o', sender: 'GPT-4o' }
 *
 * @example
 * parseEphemeralAgentId('openAI__gpt-4o___GPT-4o____1')
 * // => { endpoint: 'openAI', model: 'gpt-4o', sender: 'GPT-4o', index: 1 }
 */
export function parseEphemeralAgentId(agentId: string): ParsedEphemeralAgentId | undefined {
  if (!agentId.includes('__')) {
    return undefined;
  }

  // First check for index suffix (separated by ____)
  let index: number | undefined;
  let workingId = agentId;
  if (agentId.includes('____')) {
    const lastIndexSep = agentId.lastIndexOf('____');
    const indexStr = agentId.slice(lastIndexSep + 4);
    const parsedIndex = parseInt(indexStr, 10);
    if (!isNaN(parsedIndex)) {
      index = parsedIndex;
      workingId = agentId.slice(0, lastIndexSep);
    }
  }

  // Check for sender (separated by ___)
  let sender: string | undefined;
  let mainPart = workingId;
  if (workingId.includes('___')) {
    const [before, after] = workingId.split('___');
    mainPart = before;
    // Restore colons in sender if any
    sender = after?.replace(/__/g, ':');
  }

  const [endpoint, ...modelParts] = mainPart.split('__');
  if (!endpoint || modelParts.length === 0) {
    return undefined;
  }
  // Restore colons in model name (model names can contain colons like claude-3:opus)
  const model = modelParts.join(':');
  return { endpoint, model, sender, index };
}

/**
 * Checks if an agent ID represents an ephemeral (non-saved) agent.
 * Real agent IDs always start with "agent_", so anything else is ephemeral.
 */
export function isEphemeralAgentId(agentId: string | null | undefined): boolean {
  return !agentId?.startsWith('agent_');
}

/**
 * Strips the index suffix (____N) from an agent ID if present.
 * Works with both ephemeral and real agent IDs.
 *
 * @example
 * stripAgentIdSuffix('agent_abc123____1') // => 'agent_abc123'
 * stripAgentIdSuffix('openAI__gpt-4o___GPT-4o____1') // => 'openAI__gpt-4o___GPT-4o'
 * stripAgentIdSuffix('agent_abc123') // => 'agent_abc123' (unchanged)
 */
export { stripAgentIdSuffix } from './agents/identity';

/**
 * Appends an index suffix (____N) to an agent ID.
 * Used to distinguish parallel agents with the same base ID.
 *
 * @example
 * appendAgentIdSuffix('agent_abc123', 1) // => 'agent_abc123____1'
 * appendAgentIdSuffix('openAI__gpt-4o___GPT-4o', 1) // => 'openAI__gpt-4o___GPT-4o____1'
 */
export { appendAgentIdSuffix } from './agents/identity';