openclaw
Version:
Multi-channel AI gateway with extensible messaging integrations
687 lines (686 loc) • 27.9 kB
JavaScript
import "./src-vebZIeLe.js";
import { t as expectDefined } from "./expect-CyE8FADM.js";
import { l as normalizeOptionalString, o as normalizeLowercaseStringOrEmpty } from "./string-coerce-CIXf7egm.js";
import { n as getRuntimeConfig } from "./io.runtime-B9iJRs3w.js";
import { n as normalizeAgentId } from "./agent-id-CeT3w4ap.js";
import { i as listAgentEntries, m as resolveAgentWorkspaceDir, o as listAgentIds } from "./agent-scope-config-DcbEhP0R.js";
import { O as parseAgentSessionKey, S as isAcpSessionKey } from "./session-key-BnWWjqNc.js";
import { t as isIncognitoSessionKey } from "./incognito-session-key-BwpD1Lwd.js";
import { o as resolveSessionStorePathCore } from "./paths-CXdaYWF_.js";
import { t as splitTrailingAuthProfile } from "./model-ref-profile-BIKs-96s.js";
import { i as resolveAgentModelFallbackValues } from "./model-input-BuGMCNOz.js";
import { u as resolveAgentModelFallbacksOverride } from "./agent-scope-DbtJyKUL.js";
import { t as resolveDefaultModelForAgent } from "./model-selection-config-BrdmmqKD.js";
import "./io-bdCzpGWJ.js";
import { O as resolveIncognitoOpenClawAgentSqlitePath } from "./openclaw-agent-db-lease-Djvd6LWN.js";
import { r as listAgentProvenance } from "./agent-provenance-Cp8HmAX0.js";
import "./openclaw-agent-db-CWtDoRbC.js";
import "./session-accessor-YsytfDtG.js";
import { A as isInternalSessionEffectsKey, C as loadExactSessionEntryCandidatesReadOnlyBatch, S as loadExactSessionEntryCandidates, a as listSessionEntriesReadOnly, r as listSessionChildEntriesReadOnly } from "./session-accessor.sqlite-entry-CWk3jL7s.js";
import { m as canonicalSessionKeyMigrationRequiredError } from "./session-accessor.sqlite-transcript-state-DwF2owZS.js";
import { r as resolveAgentMainSessionKey } from "./main-session-Br0F9dzh.js";
import { a as resolveStoredSessionKeyForAgentStore, r as resolveSessionStoreIdentity } from "./session-store-key-8xEjWSNi.js";
import { t as listSessionEntriesCore } from "./session-accessor.entry-CQ2WPpfn.js";
import { l as resolveExistingAgentSessionStoreTargetsSync, t as isConfiguredSessionStoreAgentId } from "./targets-Cknmo7YZ.js";
import "./model-selection-di2kjKCB.js";
import { a as readAcpSessionMetaForEntry, o as repairAcpSessionMetaKeyForMigration, r as readAcpSessionMeta } from "./session-meta-dzG4VkYo.js";
import "./sessions-9nxpeTwt.js";
import { S as resolveExecPolicyForMode } from "./exec-approvals-policy-CCFUzTzd.js";
import { t as SESSION_PERMISSION_BY_EXEC_MODE } from "./session-permission-exec-mode-CJHB47SR.js";
import { i as resolveSandboxConfigForAgent } from "./config-RoLkL_H5.js";
import { r as loadExecApprovals } from "./exec-approvals-store-DBR0neS0.js";
import { i as resolveGatewayModelThinkingProfile } from "./session-utils-model-BYAclq2V.js";
import { n as resolveModelAgentRuntimeMetadata } from "./agent-runtime-metadata-BVVh8XFs.js";
import { t as resolveExecDefaults } from "./exec-defaults-CET-_UfH.js";
import { r as resolveAgentAvatarUrlFromSource } from "./identity-avatar-file-D-HGbA6u.js";
import { a as insideGitCheckout } from "./git-BuLvhVpD.js";
import { t as listGatewayAgentsBasic } from "./agent-list-BefyS8Gv.js";
import { r as resolveGatewayAssistantAvatar } from "./assistant-avatar-B0tiesfb.js";
import { i as tryResolveSessionCompatibilityOwnerAgentId } from "./session-request-agent-CCRSEGCB.js";
import { t as projectWorkerPlacementAgentRuntime } from "./placement-session-runtime-Cts2P0Rr.js";
//#region src/gateway/session-utils-store-read.ts
/** Single-target resolution keeps its original lazy read and failure order. */
function readGatewaySessionStore(read) {
return read.store ??= loadGatewaySessionLookupStore(read.storePath, read.clone, read.agentId, read.options);
}
/** Populate exact logical lookups without materializing unrelated store entries. */
function loadGatewaySessionStoreReads(reads) {
const pending = reads.filter((read) => read.store === void 0);
const results = loadExactSessionEntryCandidatesReadOnlyBatch(pending.map((read) => ({
agentId: read.agentId,
storePath: read.storePath,
projection: read.options.projection,
clone: false,
sessionKeys: expectDefined(read.options.exactKeys, "exact batch lookup keys")
})));
for (const [index, read] of pending.entries()) {
const result = expectDefined(results[index], "exact batch lookup result");
read.store = result.ok ? Object.fromEntries(result.value.map(({ sessionKey, entry }) => [sessionKey, entry])) : {};
}
}
function loadGatewaySessionLookupStore(storePath, clone, agentId, options = {}) {
const cache = options.cache;
const cacheKey = cache ? `${storePath}\u0000${agentId ?? ""}\u0000${clone === false ? "0" : "1"}\u0000${options.readOnly}\u0000${options.projection ?? "full"}\u0000${options.exactKeys?.join("") ?? ""}` : "";
if (cache) {
const cached = cache.get(cacheKey);
if (cached) return cached;
}
const loaded = loadGatewaySessionLookupStoreUncached(storePath, clone, agentId, options);
cache?.set(cacheKey, loaded);
return loaded;
}
function loadGatewaySessionLookupStoreUncached(storePath, clone, agentId, options = {}) {
try {
if (options.exactKeys) return Object.fromEntries(loadExactSessionEntryCandidates({
...agentId ? { agentId } : {},
clone: false,
projection: options.projection,
sessionKeys: options.exactKeys,
readOnly: options.readOnly !== false || clone === false,
storePath
}).map(({ sessionKey, entry }) => [sessionKey, entry]));
const listEntries = options.readOnly ? listSessionEntriesReadOnly : listSessionEntriesCore;
return Object.fromEntries(listEntries({
...agentId ? { agentId } : {},
...clone === false ? { clone: false } : {},
...options.projection ? { projection: options.projection } : {},
storePath
}).map(({ sessionKey, entry }) => [sessionKey, entry]));
} catch {
return {};
}
}
//#endregion
//#region src/gateway/session-utils-store-lookup.ts
function findCanonicalStoreMatch(store, candidates, onCanonicalError) {
const matches = /* @__PURE__ */ new Map();
for (const candidate of candidates) {
const trimmed = normalizeOptionalString(candidate) ?? "";
if (!trimmed) continue;
const exact = store[trimmed];
if (exact) matches.set(trimmed, {
entry: exact,
key: trimmed
});
}
if (matches.size === 0) return;
const canonicalKey = candidates[0] ?? "";
const selected = matches.get(canonicalKey) ?? matches.values().next().value;
if (matches.size > 1) {
const error = canonicalSessionKeyMigrationRequiredError(`duplicate rows resolve to canonical session key ${canonicalKey || selected?.key || ""}`);
if (!onCanonicalError) throw error;
onCanonicalError(error);
}
if (selected && selected.key !== canonicalKey) {
const error = canonicalSessionKeyMigrationRequiredError(`non-canonical persisted row resolves to session key ${canonicalKey || selected.key}`);
if (!onCanonicalError) throw error;
onCanonicalError(error);
}
return selected;
}
function buildGatewaySessionStoreScanTargets(params) {
const targets = /* @__PURE__ */ new Set();
if (params.canonicalKey) targets.add(params.canonicalKey);
if (params.key && params.key !== params.canonicalKey) targets.add(params.key);
if (params.canonicalKey === "global" || params.canonicalKey === "unknown") return [...targets];
const agentMainKey = resolveAgentMainSessionKey({
cfg: params.cfg,
agentId: params.agentId
});
if (params.canonicalKey === agentMainKey) targets.add(`agent:${params.agentId}:main`);
return [...targets];
}
function resolveGatewaySessionStoreCandidates(cfg, agentId, cache) {
const cached = cache?.get(agentId);
if (cached) return cached;
const storeConfig = cfg.session?.store;
const fallback = {
agentId,
storePath: resolveSessionStorePathCore(storeConfig, { agentId })
};
const discovery = {
existing: resolveExistingAgentSessionStoreTargetsSync(cfg, agentId),
fallback
};
cache?.set(agentId, discovery);
return discovery;
}
function createGatewaySessionStoreDiscoveryCache(params) {
const cache = /* @__PURE__ */ new Map();
const prepare = (rawAgentId, target) => {
const agentId = normalizeAgentId(rawAgentId);
const current = cache.get(agentId);
if (current) {
if (target) current.existing.push(target);
return;
}
const fallback = {
agentId,
storePath: resolveSessionStorePathCore(params.cfg.session?.store, { agentId })
};
const existing = target ? [target] : params.targets.length > 0 ? [...params.targets] : [fallback];
cache.set(agentId, {
existing,
fallback,
prepared: true
});
};
for (const target of params.targets) prepare(target.agentId, target);
for (const agentId of params.agentIds) prepare(agentId);
return cache;
}
function prepareGatewaySessionStoreLookup(params) {
const scanTargets = buildGatewaySessionStoreScanTargets(params);
const discovery = resolveGatewaySessionStoreCandidates(params.cfg, params.agentId, params.targetDiscoveryCache);
const { existing, fallback } = discovery;
const configured = isConfiguredSessionStoreAgentId(params.cfg, params.agentId);
const candidates = discovery.prepared ? existing : configured ? [fallback, ...existing.filter((target) => target.storePath !== fallback.storePath)] : existing;
if (candidates.length === 0) return {
reads: [],
resolve: () => ({
storePath: fallback.storePath,
store: {},
match: void 0
})
};
const reads = candidates.map((target, index) => ({
storePath: target.storePath,
agentId: target.agentId,
clone: params.clone,
options: {
readOnly: configured ? params.readOnly : true,
...params.exactRead ? { exactKeys: scanTargets } : {},
...params.projection ? { projection: params.projection } : {},
...params.storeCache ? { cache: params.storeCache } : {}
},
store: index === 0 && target.storePath === fallback.storePath ? params.store : void 0
}));
return {
reads,
resolve: () => {
const first = expectDefined(reads[0], "first configured or discovered session store");
let selectedStorePath = first.storePath;
let selectedStore = readGatewaySessionStore(first);
let canonicalValidationError;
const recordCanonicalError = params.deferCanonicalValidation ? (error) => {
canonicalValidationError ??= error;
} : void 0;
let selectedMatch = findCanonicalStoreMatch(selectedStore, scanTargets, recordCanonicalError);
for (const candidate of reads.slice(1)) {
const store = readGatewaySessionStore(candidate);
const match = findCanonicalStoreMatch(store, scanTargets, recordCanonicalError);
if (!match) continue;
if (selectedMatch) {
const error = canonicalSessionKeyMigrationRequiredError(`duplicate rows resolve to canonical session key ${params.canonicalKey}`);
if (!recordCanonicalError) throw error;
recordCanonicalError(error);
if (match.key !== params.canonicalKey || selectedMatch.key === params.canonicalKey) continue;
}
selectedStorePath = candidate.storePath;
selectedStore = store;
selectedMatch = match;
}
return {
storePath: selectedStorePath,
store: selectedStore,
match: selectedMatch,
...canonicalValidationError ? { canonicalValidationError } : {}
};
}
};
}
function isAgentScopedSentinelSessionKey(canonicalKey) {
return canonicalKey === "global" || canonicalKey === "unknown";
}
function prepareExplicitDeletedLegacyMainStoreTarget(params) {
const parsed = parseAgentSessionKey(params.key);
const legacyAgentId = normalizeAgentId(parsed?.agentId);
if (!parsed || isIncognitoSessionKey(params.key) || legacyAgentId !== "main" || listAgentIds(params.cfg).includes(legacyAgentId)) return null;
const canonicalKey = resolveStoredSessionKeyForAgentStore({
cfg: params.cfg,
agentId: legacyAgentId,
sessionKey: params.key
});
const agentMainKey = resolveAgentMainSessionKey({
cfg: params.cfg,
agentId: legacyAgentId
});
const lookupSeeds = Array.from(/* @__PURE__ */ new Set([
params.key,
canonicalKey,
agentMainKey,
`agent:${legacyAgentId}:main`
]));
const { existing } = resolveGatewaySessionStoreCandidates(params.cfg, legacyAgentId, params.targetDiscoveryCache);
const reads = existing.filter((target) => target.agentId === legacyAgentId).map((target) => ({
storePath: target.storePath,
clone: params.clone,
agentId: target.agentId,
options: {
readOnly: true,
...params.exactRead ? { exactKeys: lookupSeeds } : {},
...params.projection ? { projection: params.projection } : {},
...params.storeCache ? { cache: params.storeCache } : {}
}
}));
return {
reads,
resolve: () => {
let best;
let canonicalValidationError;
const recordCanonicalError = params.deferCanonicalValidation ? (error) => {
canonicalValidationError ??= error;
} : void 0;
for (const target of reads) {
const store = readGatewaySessionStore(target);
const match = findCanonicalStoreMatch(store, lookupSeeds, recordCanonicalError);
if (!match) continue;
if (best) {
const error = canonicalSessionKeyMigrationRequiredError(`duplicate rows resolve to canonical session key ${canonicalKey}`);
if (!recordCanonicalError) throw error;
recordCanonicalError(error);
}
if (!best || (match.entry.updatedAt ?? 0) >= (best.match.entry.updatedAt ?? 0)) best = {
storePath: target.storePath,
store,
match
};
}
if (!best) return null;
const storeKeys = /* @__PURE__ */ new Set([canonicalKey]);
if (params.key !== canonicalKey) storeKeys.add(params.key);
storeKeys.add(best.match.key);
for (const seed of lookupSeeds) storeKeys.add(seed);
return {
agentId: legacyAgentId,
storePath: best.storePath,
canonicalKey,
storeKeys: Array.from(storeKeys),
store: best.store,
...canonicalValidationError ? { canonicalValidationError } : {}
};
}
};
}
function prepareGatewaySessionStoreTarget(params) {
const key = params.key;
const { canonicalKey, agentId } = resolveSessionStoreIdentity({
cfg: params.cfg,
sessionKey: key,
agentId: params.agentId
});
if (isIncognitoSessionKey(canonicalKey)) {
const storePath = resolveIncognitoOpenClawAgentSqlitePath({ agentId });
const read = {
storePath,
agentId,
clone: params.clone,
options: {
readOnly: true,
...params.exactRead ? { exactKeys: [canonicalKey] } : {},
...params.projection ? { projection: params.projection } : {},
...params.storeCache ? { cache: params.storeCache } : {}
}
};
return {
reads: [read],
resolve: () => ({
agentId,
storePath,
canonicalKey,
storeKeys: [canonicalKey],
store: readGatewaySessionStore(read)
})
};
}
const lookup = prepareGatewaySessionStoreLookup({
...params,
canonicalKey,
agentId
});
return {
reads: lookup.reads,
resolve: () => {
const { canonicalValidationError, storePath, store } = lookup.resolve();
const storeKeys = isAgentScopedSentinelSessionKey(canonicalKey) ? key && key !== canonicalKey ? [canonicalKey, key] : [key] : Array.from(new Set(buildGatewaySessionStoreScanTargets({
cfg: params.cfg,
key,
canonicalKey,
agentId
})));
return {
agentId,
storePath,
canonicalKey,
storeKeys,
store,
...canonicalValidationError ? { canonicalValidationError } : {}
};
}
};
}
function resolveGatewaySessionStoreTargetWithStore(params) {
const normalized = {
...params,
key: normalizeOptionalString(params.key) ?? ""
};
const deletedMain = prepareExplicitDeletedLegacyMainStoreTarget(normalized)?.resolve();
return includeDirectChildEntries(deletedMain ?? prepareGatewaySessionStoreTarget(normalized).resolve(), params.includeStoreChildEntries, params.projection);
}
/** Resolve one synchronous set of logical metadata targets using exact grouped reads. */
function resolveGatewaySessionStoreTargetsReadOnly(params) {
const targetDiscoveryCache = params.targetDiscoveryCache ?? /* @__PURE__ */ new Map();
const requests = params.targets.map((target) => {
const lookup = {
...target,
key: normalizeOptionalString(target.key) ?? "",
cfg: params.cfg,
clone: false,
readOnly: true,
exactRead: true,
projection: "list",
targetDiscoveryCache
};
return {
lookup,
legacy: prepareExplicitDeletedLegacyMainStoreTarget(lookup)
};
});
loadGatewaySessionStoreReads(requests.flatMap((request) => request.legacy?.reads ?? []));
const selected = requests.map((request) => {
const target = request.legacy?.resolve();
return target ? { target } : { plan: prepareGatewaySessionStoreTarget(request.lookup) };
});
loadGatewaySessionStoreReads(selected.flatMap((selection) => selection.plan?.reads ?? []));
return selected.map((selection) => selection.target ?? expectDefined(selection.plan, "unresolved logical session plan").resolve());
}
function includeDirectChildEntries(target, include, projection) {
if (!include) return target;
try {
const parentKeys = /* @__PURE__ */ new Set([target.canonicalKey, ...target.storeKeys]);
for (const parentKey of parentKeys) for (const { sessionKey, entry } of listSessionChildEntriesReadOnly({
agentId: target.agentId,
clone: false,
projection,
sessionKey: parentKey,
storePath: target.storePath
})) target.store[sessionKey] = entry;
} catch {}
return target;
}
function resolveGatewaySessionStoreTarget(params) {
const { store: _store, ...target } = resolveGatewaySessionStoreTargetWithStore({
...params,
projection: "list"
});
return target;
}
//#endregion
//#region src/gateway/session-utils-store.ts
/**
* Returns the owning agent id if the session key belongs to an agent that is no
* longer present in config (deleted). Returns null for non-agent legacy/global
* keys, confirmed ACP runtime session keys, or when the owning agent still
* exists (#65524).
*/
function resolveDeletedAgentIdFromSessionKey(cfg, sessionKey, entry, options) {
const parsed = parseAgentSessionKey(sessionKey);
if (!parsed) return null;
const agentId = normalizeAgentId(parsed.agentId);
if (listAgentIds(cfg).includes(agentId)) return null;
if (isAcpSessionKey(sessionKey) && !parsed.rest.startsWith("acp:binding:")) {
if (readAcpMetaForDeletedAgentCheck({
cfg,
sessionKey,
entry,
acpMetadataSessionKey: options?.acpMetadataSessionKey
})) return null;
}
return agentId;
}
function readAcpMetaForDeletedAgentCheck(params) {
if (params.entry?.acp) return params.entry.acp;
const acpMetadataSessionKey = normalizeOptionalString(params.acpMetadataSessionKey);
const directKeys = /* @__PURE__ */ new Set();
if (acpMetadataSessionKey) directKeys.add(acpMetadataSessionKey);
else {
const acpMeta = readAcpSessionMeta({
sessionKey: params.sessionKey,
cfg: params.cfg
});
if (acpMeta) return acpMeta;
}
directKeys.add(params.sessionKey);
for (const directKey of directKeys) {
const agentId = parseAgentSessionKey(directKey)?.agentId ?? tryResolveSessionCompatibilityOwnerAgentId(params.cfg, directKey);
const acpMeta = readAcpSessionMetaForEntry({
sessionKey: directKey,
...agentId ? { agentId } : {},
entry: params.entry ?? void 0
});
if (acpMeta) return acpMeta;
}
repairAcpSessionMetaKeyForMigration({
sessionKey: params.sessionKey,
candidateSessionKeys: directKeys,
entry: params.entry ?? void 0
});
const finalAgentId = parseAgentSessionKey(params.sessionKey)?.agentId ?? tryResolveSessionCompatibilityOwnerAgentId(params.cfg, params.sessionKey);
return readAcpSessionMetaForEntry({
sessionKey: params.sessionKey,
...finalAgentId ? { agentId: finalAgentId } : {},
entry: params.entry ?? void 0
});
}
function loadSessionEntryWithMode(sessionKey, opts, readOnly) {
const cfg = getRuntimeConfig();
const target = resolveGatewaySessionStoreTargetWithStore({
cfg,
key: normalizeOptionalString(sessionKey) ?? "",
exactRead: true,
readOnly,
projection: opts?.projection,
targetDiscoveryCache: opts?.targetDiscoveryCache,
...opts?.clone === false ? { clone: false } : {},
...opts?.agentId ? { agentId: opts.agentId } : {},
...opts?.includeStoreChildEntries ? { includeStoreChildEntries: true } : {}
});
const storePath = target.storePath;
const store = target.store;
if (!readOnly) {
for (const storeKey of target.storeKeys) if (isInternalSessionEffectsKey(storeKey)) delete store[storeKey];
}
const canonicalMatch = resolveCanonicalSessionStoreMatchFromStoreKeys(store, target.storeKeys);
const legacyKey = canonicalMatch?.key !== target.canonicalKey ? canonicalMatch?.key : void 0;
const entry = readOnly && opts?.clone !== false && canonicalMatch?.entry ? structuredClone(canonicalMatch.entry) : canonicalMatch?.entry;
return {
cfg,
agentId: target.agentId,
storePath,
store,
entry,
canonicalKey: target.canonicalKey,
storeKeys: target.storeKeys,
legacyKey
};
}
function loadGatewaySessionEntry(sessionKey, opts) {
return loadSessionEntryWithMode(sessionKey, opts, false);
}
function loadGatewaySessionEntryReadOnly(sessionKey, opts) {
return loadSessionEntryWithMode(sessionKey, opts, true);
}
/** Returns the one canonical entry and the exact persisted key that owns it. */
function resolveCanonicalSessionStoreMatchFromStoreKeys(store, storeKeys) {
let selected;
for (const key of storeKeys) {
const entry = store[key];
if (!entry) continue;
const match = {
key,
entry
};
if (selected) throw canonicalSessionKeyMigrationRequiredError(`duplicate rows resolve to canonical session key ${storeKeys[0] ?? key}`);
selected = match;
}
if (selected && selected.key !== storeKeys[0]) throw canonicalSessionKeyMigrationRequiredError(`non-canonical persisted row resolves to session key ${storeKeys[0] ?? selected.key}`);
return selected;
}
function resolveCanonicalSessionEntryFromStoreKeys(store, storeKeys) {
return resolveCanonicalSessionStoreMatchFromStoreKeys(store, storeKeys)?.entry;
}
function resolveCanonicalGatewaySessionStoreKey(params) {
const target = resolveGatewaySessionStoreTarget({
cfg: params.cfg,
key: params.key,
store: params.store,
...params.agentId ? { agentId: params.agentId } : {}
});
const primaryKey = target.canonicalKey;
resolveCanonicalSessionStoreMatchFromStoreKeys(params.store, target.storeKeys);
return {
target,
primaryKey,
entry: params.store[primaryKey]
};
}
function parseGroupKey(key) {
const parts = (parseAgentSessionKey(key)?.rest ?? key).split(":").filter(Boolean);
if (parts.length >= 3) {
const [channel, kind, ...rest] = parts;
if (kind === "group" || kind === "channel") return {
channel,
kind,
id: rest.join(":")
};
}
return null;
}
function isGroupOrChannelDisplaySession(entry, parsed) {
return entry?.chatType === "group" || entry?.chatType === "channel" || parsed?.kind === "group" || parsed?.kind === "channel";
}
function normalizeFallbackList(values) {
const out = [];
const seen = /* @__PURE__ */ new Set();
for (const value of values) {
const trimmed = value.trim();
if (!trimmed) continue;
const key = normalizeLowercaseStringOrEmpty(trimmed);
if (seen.has(key)) continue;
seen.add(key);
out.push(trimmed);
}
return out;
}
function resolveGatewayAgentModel(cfg, agentId, resolvedModel) {
const primary = `${resolvedModel.provider}/${resolvedModel.model}`;
const fallbackOverride = resolveAgentModelFallbacksOverride(cfg, agentId);
const defaultFallbacks = resolveAgentModelFallbackValues(cfg.agents?.defaults?.model);
const fallbacks = normalizeFallbackList((fallbackOverride ?? defaultFallbacks).map((value) => splitTrailingAuthProfile(value).model));
return {
primary,
...fallbacks.length > 0 ? { fallbacks } : {}
};
}
function resolvedPermissionLabel(policy) {
const { mode } = policy;
const canonical = resolveExecPolicyForMode(mode);
return mode !== "allowlist" && policy.security === canonical.security && policy.ask === canonical.ask ? SESSION_PERMISSION_BY_EXEC_MODE[mode] : void 0;
}
function listAgentsForGateway(cfg, modelCatalog, options) {
const basic = listGatewayAgentsBasic(cfg);
const execApprovals = loadExecApprovals();
const identityById = /* @__PURE__ */ new Map();
for (const entry of listAgentEntries(cfg)) {
if (!entry?.id) continue;
const agentId = normalizeAgentId(entry.id);
const avatar = normalizeOptionalString(entry.identity?.avatar);
const httpAvatar = avatar && options?.httpAvatarBasePath !== void 0 ? resolveGatewayAssistantAvatar({
cfg,
identity: {
agentId,
avatar
},
httpBasePath: options.httpAvatarBasePath
}).avatar : void 0;
const avatarUrl = httpAvatar ?? resolveAgentAvatarUrlFromSource(cfg, agentId, avatar);
const identity = entry.identity ? {
name: normalizeOptionalString(entry.identity.name),
theme: normalizeOptionalString(entry.identity.theme),
emoji: normalizeOptionalString(entry.identity.emoji),
avatar: httpAvatar ?? avatar,
avatarUrl
} : void 0;
identityById.set(agentId, identity);
}
const roster = options?.includeSystem ? basic.agents : basic.agents.filter((entry) => entry.kind !== "system");
const provenanceById = new Map(listAgentProvenance().map((record) => [record.agentId, record]));
const agents = roster.map((entry) => {
const { id } = entry;
const execDefaults = resolveExecDefaults({
cfg,
agentId: id,
execApprovals
});
const defaultPermissionMode = resolveSandboxConfigForAgent(cfg, id).mode === "off" ? resolvedPermissionLabel(execDefaults) : void 0;
const resolvedModel = resolveDefaultModelForAgent({
cfg,
agentId: id
});
const model = resolveGatewayAgentModel(cfg, id, resolvedModel);
const sessionKey = resolveAgentMainSessionKey({
cfg,
agentId: id
});
const agentRuntime = projectWorkerPlacementAgentRuntime(resolveModelAgentRuntimeMetadata({
cfg,
agentId: id,
provider: resolvedModel.provider,
model: resolvedModel.model,
sessionKey,
acpRuntime: false
}));
const hasAgentCatalog = options?.modelCatalogByAgentId?.has(id);
const preparedCatalog = hasAgentCatalog ? options?.modelCatalogByAgentId?.get(id) : modelCatalog ? void 0 : options?.modelCatalogByAgentId?.get(basic.defaultId);
const agentModelCatalog = hasAgentCatalog ? preparedCatalog?.entries : modelCatalog ?? preparedCatalog?.entries;
const thinkingProfile = resolveGatewayModelThinkingProfile({
cfg,
agentId: id,
provider: resolvedModel.provider,
model: resolvedModel.model,
modelCatalog: agentModelCatalog,
sessionKey,
providerPolicySource: preparedCatalog?.pluginRegistry
});
const workspace = resolveAgentWorkspaceDir(cfg, id);
const workspaceGit = insideGitCheckout(workspace);
const agent = Object.assign({
id,
...options?.includeSystem ? { kind: entry.kind } : {},
name: entry.name,
identity: identityById.get(id),
workspace,
workspaceGit,
agentRuntime,
thinkingLevels: thinkingProfile.thinkingLevels,
thinkingOptions: thinkingProfile.thinkingLevels.map((level) => level.label),
thinkingDefault: thinkingProfile.thinkingDefault
}, { model }, defaultPermissionMode ? { defaultPermissionMode } : {});
const provenance = provenanceById.get(id);
return provenance ? Object.assign(agent, {
createdVia: provenance.createdVia,
creatorAgentId: provenance.creatorAgentId,
createdAt: provenance.createdAtMs
}) : agent;
});
return {
defaultId: basic.defaultId,
ownership: basic.ownership,
selectionRequired: basic.selectionRequired,
mainKey: basic.mainKey,
scope: basic.scope,
agents
};
}
//#endregion
export { parseGroupKey as a, resolveCanonicalSessionStoreMatchFromStoreKeys as c, resolveGatewaySessionStoreTarget as d, resolveGatewaySessionStoreTargetWithStore as f, loadGatewaySessionEntryReadOnly as i, resolveDeletedAgentIdFromSessionKey as l, listAgentsForGateway as n, resolveCanonicalGatewaySessionStoreKey as o, resolveGatewaySessionStoreTargetsReadOnly as p, loadGatewaySessionEntry as r, resolveCanonicalSessionEntryFromStoreKeys as s, isGroupOrChannelDisplaySession as t, createGatewaySessionStoreDiscoveryCache as u };