@brantrusnak/openclaw-omadeus 1.0.2 → 1.0.3

package/dist/src/nugget-lookup.js

@@ -0,0 +1,140 @@
+import { readNuggetNumber } from "./api/nugget.api.js";
+import { mergePeopleIntoNuggetAgentPayload } from "./member-resolve.js";
+//#region src/nugget-lookup.ts
+function parseNuggetLookupIntent(rawBody) {
+	const body = rawBody.trim();
+	if (!body) return null;
+	const idMatch = /\bN(\d+)\b/i.exec(body);
+	if (!idMatch) return null;
+	const nuggetNumber = Number(idMatch[1]);
+	if (!Number.isFinite(nuggetNumber)) return null;
+	if (/^N\d+\??$/i.test(body)) return { nuggetNumber };
+	if (/\bnugget\s+N?\d+\b/i.test(body)) return { nuggetNumber };
+	if (/\b(get|show|lookup|find|search|status|detail|info)\b/i.test(body)) return { nuggetNumber };
+	return null;
+}
+function parseTaskChannelTargetIntent(rawInput) {
+	const trimmed = rawInput.trim();
+	const match = /^([nt])(\d+)$/i.exec(trimmed);
+	if (!match) return null;
+	const nuggetNumber = Number(match[2]);
+	if (!Number.isFinite(nuggetNumber)) return null;
+	return {
+		nuggetNumber,
+		rawPrefix: match[1].toLowerCase()
+	};
+}
+function resolvePriorityFromText(text) {
+	const lowered = text.toLowerCase();
+	if (/\b(urgent|asap|critical|p0)\b/.test(lowered)) return "urgent";
+	if (/\b(high|important|p1)\b/.test(lowered)) return "high";
+	if (/\b(medium|normal|p2)\b/.test(lowered)) return "medium";
+	return "low";
+}
+function parseChannelTaskCreateIntent(rawBody) {
+	const body = rawBody.trim();
+	if (!body) return null;
+	const lower = body.toLowerCase();
+	const isCreateVerb = /\b(create|open|add|spawn|start)\b/.test(lower);
+	const hasTaskWord = /\b(task|nugget)\b/.test(lower);
+	if (!isCreateVerb || !hasTaskWord) return null;
+	const kind = /\bnugget\b/.test(lower) ? "nugget" : "task";
+	return {
+		kind,
+		title: body.replace(/^\s*(please\s+)?(create|open|add|spawn|start)\s+(a\s+|an\s+)?(new\s+)?/i, "").replace(/^(task|nugget)\s*/i, "").trim() || `${kind === "task" ? "Task" : "Nugget"} from channel request`,
+		description: body,
+		priority: resolvePriorityFromText(body)
+	};
+}
+function parseRecurringScheduleIntent(rawBody) {
+	const lowered = rawBody.toLowerCase();
+	const minuteMatch = /\bevery\s+(\d+)\s*(m|min|mins|minute|minutes)\b/.exec(lowered);
+	if (minuteMatch) {
+		const everyMinutes = Number(minuteMatch[1]);
+		if (Number.isFinite(everyMinutes) && everyMinutes > 0) return { everyMinutes: Math.min(60, everyMinutes) };
+	}
+	if (/\bevery\s+hour\b|\bhourly\b/.test(lowered)) return { everyMinutes: 60 };
+	return null;
+}
+/** Fields from Dolphin nuggetviews that are useful for an agent summary (avoids huge payloads). */
+const NUGGET_FIELDS_FOR_AGENT = [
+	"number",
+	"id",
+	"title",
+	"description",
+	"status",
+	"stage",
+	"leadPhaseTitle",
+	"priority",
+	"priorityValue",
+	"dueDate",
+	"kind",
+	"entityType",
+	"tempo",
+	"projectTitle",
+	"projectStatus",
+	"projectNumber",
+	"projectManagerFirstName",
+	"projectManagerLastName",
+	"projectManagerTitle",
+	"projectManagerReferenceId",
+	"clientTitle",
+	"folderTitle",
+	"createdAt",
+	"autoModifiedAt",
+	"lastMovingTime",
+	"responseTimestamp",
+	"assignmentLevel",
+	"estimated",
+	"sprintName",
+	"sprintNumber",
+	"releaseTitle",
+	"releaseNumber",
+	"publicRoomId",
+	"privateRoomId",
+	"memberReferenceId",
+	"assigneeReferenceId",
+	"ownerReferenceId",
+	"memberFirstName",
+	"memberLastName",
+	"assigneeFirstName",
+	"assigneeLastName"
+];
+function pickNuggetFieldsForAgent(record) {
+	const out = {};
+	for (const key of NUGGET_FIELDS_FOR_AGENT) if (key in record) out[key] = record[key];
+	return out;
+}
+/**
+* Picked Dolphin fields + `people` map (referenceId → display name) for the organization.
+*/
+async function buildNuggetAgentDataPayload(apiOpts, fullRecord) {
+	if (!fullRecord) return null;
+	return mergePeopleIntoNuggetAgentPayload(apiOpts, fullRecord, pickNuggetFieldsForAgent(fullRecord));
+}
+/**
+* Augments the user message so the agent receives Dolphin nugget/task data and can reply with a summary.
+* On miss or API error, the agent still gets instructions to respond helpfully.
+*/
+async function appendNuggetLookupContextForAgent(rawBody, nuggetNumber, record, apiOpts, fetchError) {
+	const header = `[Omadeus nugget/task N${nuggetNumber}]`;
+	if (fetchError) return `${rawBody}\n\n${header} Lookup failed: ${fetchError}\nBriefly explain the error to the user and suggest they try again or check permissions.`;
+	if (!record) return `${rawBody}\n\n${header} No row matched display number ${nuggetNumber} (field \`number\`) in search results.\nTell the user succinctly that this nugget/task was not found.`;
+	const payload = await buildNuggetAgentDataPayload(apiOpts, record) ?? pickNuggetFieldsForAgent(record);
+	return `${rawBody}\n\n${header} Data from Omadeus (summarize for someone tracking this work — status, ownership, timeline, project; plain language. **For assignees and anyone in \`people\` / \`*FirstName\` fields, use those names; never read raw *ReferenceId numbers to the user as a person.**):\n${JSON.stringify(payload, null, 2)}`;
+}
+/**
+* Enriches a Task or Nugget **Jaguar room** with Dolphin data matched by this chat's `roomId`, so the
+* agent can answer "status" without a bare `N###` in the message.
+*/
+async function appendNuggetContextForTaskOrNuggetRoom(rawBody, roomId, roomName, record, apiOpts, fetchError) {
+	const roomLabel = roomName?.trim() ? `room ${roomId} ("${roomName.trim()}")` : `room ${roomId}`;
+	if (fetchError) return `${rawBody}\n\n[Omadeus, this task/nugget ${roomLabel}] Lookup failed: ${fetchError}.\nAnswer from this thread. Do not tell the user to "use the Omadeus platform" or similar — give a direct reply or a concrete next step.`;
+	if (!record) return `${rawBody}\n\n[Omadeus, this task/nugget ${roomLabel}] No Dolphin row matched this room id in search yet.\nAnswer from the conversation; be honest if you cannot see live fields. Do not hand-wave to "the platform".`;
+	const n = readNuggetNumber(record);
+	const nLabel = n !== void 0 ? `N${n}` : "nugget";
+	const payload = await buildNuggetAgentDataPayload(apiOpts, record) ?? pickNuggetFieldsForAgent(record);
+	return `${rawBody}\n\n[Omadeus ${nLabel} for this chat room] The following is live task/nugget data — **answer the user with this** (stage, status, title, who, due date; plain language. **For assignee/owner, use \`people\` and name fields; never recite *ReferenceId numbers (e.g. 210) as a person's name.**). \`task/...\` in the UI is not an OpenClaw session key.\n${JSON.stringify(payload, null, 2)}`;
+}
+//#endregion
+export { appendNuggetContextForTaskOrNuggetRoom, appendNuggetLookupContextForAgent, parseChannelTaskCreateIntent, parseNuggetLookupIntent, parseRecurringScheduleIntent, parseTaskChannelTargetIntent };

package/dist/src/onboarding.js

@@ -0,0 +1,363 @@
+import { OMADEUS_CAS_URL, OMADEUS_MAESTRO_URL } from "./defaults.js";
+import { getOmadeusChannelConfig, resolveOmadeusAccount } from "./config.js";
+import { listOrganizationMembers, listOrganizations } from "./api/auth.api.js";
+import { formatMemberLabel } from "./member-resolve.js";
+import { OMADEUS_INBOUND_ENTITY_KINDS } from "./types.js";
+import { listMemberChannelViews } from "./api/channel.api.js";
+import { authenticate } from "./auth.js";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+//#region src/onboarding.ts
+const channel = "omadeus";
+const DONE = "__done__";
+async function noteOmadeusAuthHelp(prompter) {
+	await prompter.note([
+		"Omadeus authenticates via CAS + Maestro (email + password + organization).",
+		"You need:",
+		"  - Email + password",
+		"  - Organization ID (we can look it up for you)",
+		`CAS URL: ${OMADEUS_CAS_URL}`,
+		`Maestro URL: ${OMADEUS_MAESTRO_URL}`,
+		"Env vars supported: OMADEUS_EMAIL, OMADEUS_PASSWORD, OMADEUS_ORGANIZATION_ID."
+	].join("\n"), "Omadeus setup");
+}
+async function promptOrganizationId(params) {
+	const { prompter, maestroUrl, email, existing } = params;
+	try {
+		const orgs = await listOrganizations({
+			maestroUrl,
+			email
+		});
+		if (orgs.length > 0) {
+			if (orgs.length === 1) {
+				await prompter.note(`Found organization: ${orgs[0].title} (${orgs[0].id})`, "Omadeus organization");
+				return orgs[0].id;
+			}
+			const choice = await prompter.select({
+				message: "Select organization",
+				options: orgs.map((org) => ({
+					value: String(org.id),
+					label: `${org.title} (${org.membersCount} members)`,
+					hint: `ID: ${org.id}`
+				})),
+				initialValue: existing ? String(existing) : String(orgs[0].id)
+			});
+			return Number(choice);
+		}
+	} catch {
+		await prompter.note("Could not fetch organizations from the API. Enter the ID manually.", "Omadeus organization");
+	}
+	const raw = await prompter.text({
+		message: "Organization ID (number)",
+		initialValue: existing ? String(existing) : void 0,
+		validate: (value) => {
+			const trimmed = String(value ?? "").trim();
+			if (!trimmed) return "Required";
+			if (!/^\d+$/.test(trimmed)) return "Must be a number";
+		}
+	});
+	return Number(String(raw).trim());
+}
+async function promptChannelSelection(params) {
+	const { prompter, maestroUrl, sessionToken, memberReferenceId, existingChannelViewIds } = params;
+	const channels = await listMemberChannelViews({
+		maestroUrl,
+		sessionToken,
+		memberReferenceId,
+		skip: 0,
+		take: 100
+	});
+	if (channels.length === 0) throw new Error("No channels found for this account.");
+	const selected = await promptMultiSelect({
+		prompter,
+		message: "Which channels should OpenClaw listen to?",
+		options: channels.map((item) => ({
+			value: String(item.id),
+			label: item.title || `Channel ${item.id}`,
+			hint: [item.privateRoomId ? `private:${item.privateRoomId}` : void 0, item.publicRoomId ? `public:${item.publicRoomId}` : void 0].filter(Boolean).join(" | ")
+		})),
+		initialValues: existingChannelViewIds && existingChannelViewIds.length > 0 ? existingChannelViewIds.map(String) : [String(channels[0].id)]
+	});
+	const chosen = channels.filter((item) => selected.includes(String(item.id)));
+	if (chosen.length === 0) throw new Error("At least one channel must be selected.");
+	return chosen;
+}
+function memberHint(member) {
+	const parts = [
+		`${member.firstName ?? ""} ${member.lastName ?? ""}`.trim(),
+		member.email?.trim(),
+		`ref:${member.referenceId}`
+	].filter(Boolean);
+	return parts.length > 0 ? parts.join(" | ") : void 0;
+}
+async function promptMultiSelect(params) {
+	const multi = params.prompter;
+	const runMulti = multi.multiSelect ?? multi.multiselect;
+	if (runMulti) return runMulti({
+		message: params.message,
+		options: params.options,
+		initialValues: params.initialValues,
+		initialValue: params.initialValues
+	});
+	const selected = new Set(params.initialValues ?? []);
+	while (true) {
+		const next = await params.prompter.select({
+			message: `${params.message} (${selected.size} selected)`,
+			options: [{
+				value: DONE,
+				label: selected.size > 0 ? "Done" : "Done (select none)"
+			}, ...params.options.map((option) => ({
+				...option,
+				label: selected.has(option.value) ? `[selected] ${option.label}` : option.label
+			}))],
+			initialValue: DONE
+		});
+		const value = String(next);
+		if (value === DONE) return [...selected];
+		if (selected.has(value)) selected.delete(value);
+		else selected.add(value);
+	}
+}
+async function loadSelectableMembers(params) {
+	const excluded = new Set(params.excludeReferenceIds ?? []);
+	return (await listOrganizationMembers({
+		maestroUrl: params.maestroUrl,
+		sessionToken: params.sessionToken,
+		organizationId: params.organizationId
+	})).filter((member) => member.isSystem !== true && !excluded.has(member.referenceId)).sort((a, b) => formatMemberLabel(a).localeCompare(formatMemberLabel(b)));
+}
+function memberOptions(members) {
+	return members.map((member) => ({
+		value: String(member.referenceId),
+		label: formatMemberLabel(member),
+		hint: memberHint(member)
+	}));
+}
+function readReferenceIds(values) {
+	return values.map((value) => Number(value)).filter((value) => Number.isInteger(value) && value > 0);
+}
+async function promptCredentials(prompter, existing) {
+	return {
+		email: String(await prompter.text({
+			message: "Omadeus username (email)",
+			initialValue: existing.email,
+			validate: (value) => String(value ?? "").trim() ? void 0 : "Required"
+		})).trim(),
+		password: String(await prompter.text({
+			message: "Omadeus password",
+			sensitive: true,
+			validate: (value) => String(value ?? "").trim() ? void 0 : "Required"
+		})).trim()
+	};
+}
+async function promptSenderAllowlist(params) {
+	const { prompter, message, members, existingReferenceIds } = params;
+	if (members.length === 0) throw new Error("No organization members found.");
+	if (await prompter.select({
+		message,
+		options: [{
+			value: "all",
+			label: "All users",
+			hint: "No sender allowlist"
+		}, {
+			value: "specific",
+			label: "Specific users",
+			hint: "Select one or more users"
+		}],
+		initialValue: existingReferenceIds && existingReferenceIds.length > 0 ? "specific" : "all"
+	}) === "all") return;
+	return readReferenceIds(await promptMultiSelect({
+		prompter,
+		message: `${message} (specific users)`,
+		options: memberOptions(members),
+		initialValues: existingReferenceIds?.map(String)
+	}));
+}
+async function promptEntityKindSelection(params) {
+	const selected = await promptMultiSelect({
+		prompter: params.prompter,
+		message: "Which entity room types should OpenClaw listen to?",
+		options: OMADEUS_INBOUND_ENTITY_KINDS.map((kind) => ({
+			value: kind,
+			label: kind
+		})),
+		initialValues: params.existingKinds && params.existingKinds.length > 0 ? params.existingKinds : [...OMADEUS_INBOUND_ENTITY_KINDS]
+	});
+	const selectedSet = new Set(selected);
+	return OMADEUS_INBOUND_ENTITY_KINDS.filter((kind) => selectedSet.has(kind));
+}
+const omadeusSetupWizard = {
+	channel,
+	resolveAccountIdForConfigure: () => DEFAULT_ACCOUNT_ID,
+	resolveShouldPromptAccountIds: () => false,
+	status: {
+		configuredLabel: "configured",
+		unconfiguredLabel: "needs credentials",
+		configuredHint: "configured",
+		unconfiguredHint: "needs credentials",
+		configuredScore: 2,
+		unconfiguredScore: 0,
+		resolveConfigured: ({ cfg }) => {
+			return resolveOmadeusAccount({ cfg }).credentialSource !== "none";
+		},
+		resolveStatusLines: ({ cfg }) => {
+			return [`Omadeus: ${resolveOmadeusAccount({ cfg }).credentialSource !== "none" ? "configured" : "needs email, password, and organization ID"}`];
+		},
+		resolveSelectionHint: ({ cfg }) => {
+			return resolveOmadeusAccount({ cfg }).credentialSource !== "none" ? "configured" : "needs credentials";
+		},
+		resolveQuickstartScore: ({ cfg }) => {
+			return resolveOmadeusAccount({ cfg }).credentialSource !== "none" ? 2 : 0;
+		}
+	},
+	credentials: [],
+	finalize: async ({ cfg, prompter }) => {
+		const account = resolveOmadeusAccount({ cfg });
+		const section = getOmadeusChannelConfig(cfg) ?? {};
+		let next = cfg;
+		if (account.credentialSource === "none") await noteOmadeusAuthHelp(prompter);
+		const envEmail = process.env.OMADEUS_EMAIL?.trim();
+		const envPassword = process.env.OMADEUS_PASSWORD?.trim();
+		const casUrl = OMADEUS_CAS_URL;
+		const maestroUrl = OMADEUS_MAESTRO_URL;
+		let { email, password } = await promptCredentials(prompter, {
+			email: section.email ?? envEmail,
+			password: section.password ?? envPassword
+		});
+		const organizationId = await promptOrganizationId({
+			prompter,
+			maestroUrl,
+			email,
+			existing: section.organizationId
+		});
+		let sessionToken;
+		let selfReferenceId;
+		while (true) try {
+			const { dolphinToken, payload } = await authenticate({
+				casUrl,
+				maestroUrl,
+				email,
+				password,
+				organizationId
+			});
+			sessionToken = dolphinToken;
+			selfReferenceId = payload.referenceId;
+			await prompter.note(`Authenticated as ${payload.email}`, "Omadeus authentication");
+			break;
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			await prompter.note(`Authentication failed: ${msg}`, "Omadeus authentication");
+			if (!await prompter.confirm({
+				message: "Re-enter email/password and try again?",
+				initialValue: true
+			})) {
+				await prompter.note("Saving config without verifying credentials. The gateway may fail to connect.", "Omadeus authentication");
+				break;
+			}
+			({email, password} = await promptCredentials(prompter, {
+				email,
+				password
+			}));
+		}
+		if (!sessionToken) throw new Error("Authentication is required to list channels.");
+		if (typeof selfReferenceId !== "number") throw new Error("Authentication did not return an Omadeus member reference ID.");
+		const members = await loadSelectableMembers({
+			maestroUrl,
+			sessionToken,
+			organizationId,
+			excludeReferenceIds: [selfReferenceId]
+		});
+		const existingInbound = section.inbound;
+		const directSenderIds = await promptSenderAllowlist({
+			prompter,
+			message: "Which users can DM OpenClaw directly?",
+			members,
+			existingReferenceIds: existingInbound?.direct?.allowedSenderReferenceIds
+		});
+		const selectedChannels = await promptChannelSelection({
+			prompter,
+			maestroUrl,
+			sessionToken,
+			memberReferenceId: selfReferenceId,
+			existingChannelViewIds: existingInbound?.channels?.allowedChannelViewIds
+		});
+		const channelSenderIds = await promptSenderAllowlist({
+			prompter,
+			message: "Which users can trigger OpenClaw from allowed channels?",
+			members,
+			existingReferenceIds: existingInbound?.channels?.allowedSenderReferenceIds
+		});
+		const entityKinds = await promptEntityKindSelection({
+			prompter,
+			existingKinds: existingInbound?.entities?.allowedKinds
+		});
+		const entitySenderIds = entityKinds.length > 0 ? await promptSenderAllowlist({
+			prompter,
+			message: "Which users can trigger OpenClaw from entity rooms?",
+			members,
+			existingReferenceIds: existingInbound?.entities?.allowedSenderReferenceIds
+		}) : void 0;
+		const channelRoomIds = selectedChannels.flatMap((selectedChannel) => [selectedChannel.publicRoomId, selectedChannel.privateRoomId]).filter((id) => typeof id === "number");
+		const channelViewIds = selectedChannels.map((selectedChannel) => selectedChannel.id);
+		const channelTitles = selectedChannels.map((selectedChannel) => selectedChannel.title || `Channel ${selectedChannel.id}`).join(", ");
+		const senderSummary = (ids) => ids && ids.length > 0 ? ids.join(", ") : "all users";
+		const entityKindSummary = entityKinds.length > 0 ? entityKinds.join(", ") : "none (entity rooms disabled)";
+		await prompter.note([
+			`Inbound policy (Jaguar chat):`,
+			`- Direct messages: enabled for ${senderSummary(directSenderIds)} (no @mention required).`,
+			`- Channels "${channelTitles}": rooms ${channelRoomIds.join(", ") || "(no room ids)"} from ${senderSummary(channelSenderIds)}; @mention not required in those rooms.`,
+			`- Entity rooms (${entityKindSummary}): ${senderSummary(entitySenderIds)}; @mention required.`
+		].join("\n"), "Omadeus inbound policy");
+		next = {
+			...next,
+			channels: {
+				...next.channels,
+				omadeus: {
+					enabled: true,
+					casUrl,
+					maestroUrl,
+					email,
+					password,
+					organizationId,
+					sessionToken,
+					inbound: {
+						version: 1,
+						direct: {
+							enabled: true,
+							...directSenderIds ? { allowedSenderReferenceIds: directSenderIds } : {},
+							requireMention: "never"
+						},
+						channels: {
+							enabled: true,
+							allowedRoomIds: channelRoomIds,
+							allowedChannelViewIds: channelViewIds,
+							...channelSenderIds ? { allowedSenderReferenceIds: channelSenderIds } : {},
+							requireMention: "outsideAllowlist"
+						},
+						entities: {
+							enabled: entityKinds.length > 0,
+							allowedKinds: entityKinds,
+							...entitySenderIds ? { allowedSenderReferenceIds: entitySenderIds } : {},
+							requireMention: "always"
+						}
+					}
+				}
+			}
+		};
+		return {
+			cfg: next,
+			accountId: DEFAULT_ACCOUNT_ID
+		};
+	},
+	disable: (cfg) => ({
+		...cfg,
+		channels: {
+			...cfg.channels,
+			omadeus: {
+				...getOmadeusChannelConfig(cfg),
+				enabled: false
+			}
+		}
+	})
+};
+//#endregion
+export { omadeusSetupWizard };

package/dist/src/outbound.js

@@ -0,0 +1,17 @@
+import { sendRoomMessage } from "./api/message.api.js";
+//#region src/outbound.ts
+async function sendOmadeusMessage(deps, params) {
+	const { to, text } = params;
+	const result = await sendRoomMessage(deps.apiOpts, {
+		roomId: to,
+		body: text
+	});
+	if (!result.ok) throw new Error(`Omadeus send failed: ${result.error}`);
+	return {
+		channel: "omadeus",
+		messageId: String(result.message?.id ?? ""),
+		chatId: to
+	};
+}
+//#endregion
+export { sendOmadeusMessage };

package/dist/src/reply-dispatcher.js

@@ -0,0 +1,46 @@
+import { createReplyPrefixContext } from "../runtime-api.js";
+import { sendOmadeusMessage } from "./outbound.js";
+import { getOmadeusRuntime } from "./runtime.js";
+//#region src/reply-dispatcher.ts
+function createOmadeusReplyDispatcher(params) {
+	const core = getOmadeusRuntime();
+	const { cfg, agentId, roomId, accountId } = params;
+	const prefixContext = createReplyPrefixContext({
+		cfg,
+		agentId
+	});
+	const textChunkLimit = core.channel.text.resolveTextChunkLimit(cfg, "omadeus", accountId, { fallbackLimit: 4e3 });
+	const chunkMode = core.channel.text.resolveChunkMode(cfg, "omadeus");
+	const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+		responsePrefix: prefixContext.responsePrefix,
+		responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+		humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
+		deliver: async (payload) => {
+			const text = payload.text ?? "";
+			if (!text.trim()) return;
+			const chunks = core.channel.text.chunkTextWithMode(text, textChunkLimit, chunkMode);
+			for (const chunk of chunks) await sendOmadeusMessage(params.outboundDeps, {
+				to: String(roomId),
+				text: chunk
+			});
+		},
+		onError: (error, info) => {
+			const errMsg = error instanceof Error ? error.message : String(error);
+			params.runtime.error?.(`omadeus ${info.kind} reply failed: ${errMsg}`);
+			params.log.error("reply failed", {
+				kind: info.kind,
+				error: errMsg
+			});
+		}
+	});
+	return {
+		dispatcher,
+		replyOptions: {
+			...replyOptions,
+			onModelSelected: prefixContext.onModelSelected
+		},
+		markDispatchIdle
+	};
+}
+//#endregion
+export { createOmadeusReplyDispatcher };

package/dist/src/runtime.js

@@ -0,0 +1,5 @@
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+//#region src/runtime.ts
+const { setRuntime: setOmadeusRuntime, getRuntime: getOmadeusRuntime } = createPluginRuntimeStore("Omadeus runtime not initialized");
+//#endregion
+export { getOmadeusRuntime, setOmadeusRuntime };

package/dist/src/setup-core.js

@@ -0,0 +1,46 @@
+//#region src/setup-core.ts
+function readSetupStringField(input, key) {
+	const value = input[key];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readSetupNumberField(input, key) {
+	const value = input[key];
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim()) {
+		const parsed = Number(value.trim());
+		return Number.isFinite(parsed) ? parsed : void 0;
+	}
+}
+const omadeusSetupAdapter = {
+	validateInput: ({ input }) => {
+		if (!readSetupStringField(input, "email") && !input.useEnv) return "Omadeus requires --email (or use OMADEUS_EMAIL env var).";
+		return null;
+	},
+	applyAccountConfig: ({ cfg, input }) => {
+		const rawInput = input;
+		const casUrl = input.httpUrl?.trim() || void 0;
+		const maestroUrl = input.url?.trim() || void 0;
+		const email = readSetupStringField(rawInput, "email");
+		const password = input.password?.trim() || void 0;
+		const organizationId = readSetupNumberField(rawInput, "organizationId");
+		const omadeusExisting = cfg.channels?.["omadeus"];
+		const omadeusPrevious = omadeusExisting !== null && typeof omadeusExisting === "object" && !Array.isArray(omadeusExisting) ? omadeusExisting : {};
+		return {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				omadeus: {
+					...omadeusPrevious,
+					enabled: true,
+					...casUrl ? { casUrl } : {},
+					...maestroUrl ? { maestroUrl } : {},
+					...email ? { email } : {},
+					...password ? { password } : {},
+					...organizationId ? { organizationId } : {}
+				}
+			}
+		};
+	}
+};
+//#endregion
+export { omadeusSetupAdapter };

package/dist/src/setup-surface.js

@@ -0,0 +1,2 @@
+import "./onboarding.js";
+export {};

package/dist/src/socket/dolphin.socket.js

@@ -0,0 +1,18 @@
+import { createOmadeusSocketClient } from "./socket.js";
+//#region src/socket/dolphin.socket.ts
+function createDolphinSocketClient(opts) {
+	const { maestroUrl, tokenManager, onEvent, onConnect, onDisconnect, onError, log } = opts;
+	return createOmadeusSocketClient({
+		maestroUrl,
+		tokenManager,
+		pathSuffix: "dolphin-ws",
+		logPrefix: "[dolphin]",
+		onEvent,
+		onConnect,
+		onDisconnect,
+		onError,
+		log
+	});
+}
+//#endregion
+export { createDolphinSocketClient };

package/dist/src/socket/jaguar.socket.js

@@ -0,0 +1,22 @@
+import { isOmadeusMessage } from "../inbound.js";
+import { createOmadeusSocketClient } from "./socket.js";
+//#region src/socket/jaguar.socket.ts
+function createJaguarSocketClient(opts) {
+	const { maestroUrl, tokenManager, onMessage, onOtherEvent, onConnect, onDisconnect, onError, log } = opts;
+	return createOmadeusSocketClient({
+		maestroUrl,
+		tokenManager,
+		pathSuffix: "ws",
+		logPrefix: "[jaguar]",
+		onEvent: (data) => {
+			if (isOmadeusMessage(data)) onMessage?.(data);
+			else onOtherEvent?.(data);
+		},
+		onConnect,
+		onDisconnect,
+		onError,
+		log
+	});
+}
+//#endregion
+export { createJaguarSocketClient };