@inline-openclaw/inline 0.0.3

package/dist/inline/config-schema.d.ts

@@ -0,0 +1,166 @@
+import { z } from "zod";
+export declare const InlineAccountSchemaBase: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    tokenFile: z.ZodOptional<z.ZodString>;
+    dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        disabled: "disabled";
+        allowlist: "allowlist";
+        pairing: "pairing";
+    }>>>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        disabled: "disabled";
+        allowlist: "allowlist";
+    }>>>;
+    requireMention: z.ZodOptional<z.ZodBoolean>;
+    parseMarkdown: z.ZodOptional<z.ZodBoolean>;
+    textChunkLimit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const InlineRuntimeAccountSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    tokenFile: z.ZodOptional<z.ZodString>;
+    dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        disabled: "disabled";
+        allowlist: "allowlist";
+        pairing: "pairing";
+    }>>>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        disabled: "disabled";
+        allowlist: "allowlist";
+    }>>>;
+    requireMention: z.ZodOptional<z.ZodBoolean>;
+    parseMarkdown: z.ZodOptional<z.ZodBoolean>;
+    textChunkLimit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const InlineAccountSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    tokenFile: z.ZodOptional<z.ZodString>;
+    dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        disabled: "disabled";
+        allowlist: "allowlist";
+        pairing: "pairing";
+    }>>>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        disabled: "disabled";
+        allowlist: "allowlist";
+    }>>>;
+    requireMention: z.ZodOptional<z.ZodBoolean>;
+    parseMarkdown: z.ZodOptional<z.ZodBoolean>;
+    textChunkLimit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const InlineRuntimeConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    tokenFile: z.ZodOptional<z.ZodString>;
+    dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        disabled: "disabled";
+        allowlist: "allowlist";
+        pairing: "pairing";
+    }>>>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        disabled: "disabled";
+        allowlist: "allowlist";
+    }>>>;
+    requireMention: z.ZodOptional<z.ZodBoolean>;
+    parseMarkdown: z.ZodOptional<z.ZodBoolean>;
+    textChunkLimit: z.ZodOptional<z.ZodNumber>;
+    accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        token: z.ZodOptional<z.ZodString>;
+        tokenFile: z.ZodOptional<z.ZodString>;
+        dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            open: "open";
+            disabled: "disabled";
+            allowlist: "allowlist";
+            pairing: "pairing";
+        }>>>;
+        allowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            open: "open";
+            disabled: "disabled";
+            allowlist: "allowlist";
+        }>>>;
+        requireMention: z.ZodOptional<z.ZodBoolean>;
+        parseMarkdown: z.ZodOptional<z.ZodBoolean>;
+        textChunkLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>>;
+}, z.core.$loose>;
+export declare const InlineConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    tokenFile: z.ZodOptional<z.ZodString>;
+    dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        disabled: "disabled";
+        allowlist: "allowlist";
+        pairing: "pairing";
+    }>>>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        disabled: "disabled";
+        allowlist: "allowlist";
+    }>>>;
+    requireMention: z.ZodOptional<z.ZodBoolean>;
+    parseMarkdown: z.ZodOptional<z.ZodBoolean>;
+    textChunkLimit: z.ZodOptional<z.ZodNumber>;
+    accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        token: z.ZodOptional<z.ZodString>;
+        tokenFile: z.ZodOptional<z.ZodString>;
+        dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            open: "open";
+            disabled: "disabled";
+            allowlist: "allowlist";
+            pairing: "pairing";
+        }>>>;
+        allowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            open: "open";
+            disabled: "disabled";
+            allowlist: "allowlist";
+        }>>>;
+        requireMention: z.ZodOptional<z.ZodBoolean>;
+        parseMarkdown: z.ZodOptional<z.ZodBoolean>;
+        textChunkLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>;
+export type InlineConfig = z.infer<typeof InlineConfigSchema>;
+export type InlineAccountConfig = z.infer<typeof InlineAccountSchema>;
+export type InlineRuntimeConfig = z.infer<typeof InlineRuntimeConfigSchema>;
+//# sourceMappingURL=config-schema.d.ts.map

package/dist/inline/config-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-schema.d.ts","sourceRoot":"","sources":["../../src/inline/config-schema.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;kBAezB,CAAA;AAEX,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;iBAAwC,CAAA;AAE/E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;kBAS9B,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEtB,CAAA;AAEhB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAW7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC7D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA"}

package/dist/inline/config-schema.js

@@ -0,0 +1,43 @@
+import { DmPolicySchema, GroupPolicySchema, requireOpenAllowFrom, } from "openclaw/plugin-sdk";
+import { z } from "zod";
+export const InlineAccountSchemaBase = z
+    .object({
+    name: z.string().optional(),
+    enabled: z.boolean().optional(),
+    baseUrl: z.string().optional(),
+    token: z.string().optional(),
+    tokenFile: z.string().optional(),
+    dmPolicy: DmPolicySchema.optional().default("pairing"),
+    allowFrom: z.array(z.string()).optional(),
+    groupAllowFrom: z.array(z.string()).optional(),
+    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+    requireMention: z.boolean().optional(),
+    parseMarkdown: z.boolean().optional(),
+    textChunkLimit: z.number().int().positive().optional(),
+})
+    .strict();
+export const InlineRuntimeAccountSchema = InlineAccountSchemaBase.passthrough();
+export const InlineAccountSchema = InlineAccountSchemaBase.superRefine((value, ctx) => {
+    requireOpenAllowFrom({
+        policy: value.dmPolicy,
+        ...(value.allowFrom ? { allowFrom: value.allowFrom } : {}),
+        ctx,
+        path: ["allowFrom"],
+        message: 'channels.inline.dmPolicy="open" requires channels.inline.allowFrom to include "*"',
+    });
+});
+export const InlineRuntimeConfigSchema = InlineRuntimeAccountSchema.extend({
+    accounts: z.record(z.string(), InlineRuntimeAccountSchema.optional()).optional(),
+}).passthrough();
+export const InlineConfigSchema = InlineAccountSchemaBase.extend({
+    accounts: z.record(z.string(), InlineAccountSchema.optional()).optional(),
+}).superRefine((value, ctx) => {
+    requireOpenAllowFrom({
+        policy: value.dmPolicy,
+        ...(value.allowFrom ? { allowFrom: value.allowFrom } : {}),
+        ctx,
+        path: ["allowFrom"],
+        message: 'channels.inline.dmPolicy="open" requires channels.inline.allowFrom to include "*"',
+    });
+});
+//# sourceMappingURL=config-schema.js.map

package/dist/inline/config-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-schema.js","sourceRoot":"","sources":["../../src/inline/config-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC;KACrC,MAAM,CAAC;IACN,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAC/B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,QAAQ,EAAE,cAAc,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC;IACtD,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACzC,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IAC9C,WAAW,EAAE,iBAAiB,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC;IAC9D,cAAc,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IACtC,aAAa,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IACrC,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CACvD,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,0BAA0B,GAAG,uBAAuB,CAAC,WAAW,EAAE,CAAA;AAE/E,MAAM,CAAC,MAAM,mBAAmB,GAAG,uBAAuB,CAAC,WAAW,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;IACpF,oBAAoB,CAAC;QACnB,MAAM,EAAE,KAAK,CAAC,QAAQ;QACtB,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1D,GAAG;QACH,IAAI,EAAE,CAAC,WAAW,CAAC;QACnB,OAAO,EACL,mFAAmF;KACtF,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG,0BAA0B,CAAC,MAAM,CAAC;IACzE,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,0BAA0B,CAAC,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE;CACjF,CAAC,CAAC,WAAW,EAAE,CAAA;AAEhB,MAAM,CAAC,MAAM,kBAAkB,GAAG,uBAAuB,CAAC,MAAM,CAAC;IAC/D,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,mBAAmB,CAAC,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE;CAC1E,CAAC,CAAC,WAAW,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;IAC5B,oBAAoB,CAAC;QACnB,MAAM,EAAE,KAAK,CAAC,QAAQ;QACtB,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1D,GAAG;QACH,IAAI,EAAE,CAAC,WAAW,CAAC;QACnB,OAAO,EACL,mFAAmF;KACtF,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/dist/inline/monitor.d.ts

@@ -0,0 +1,25 @@
+import { type OpenClawConfig, type RuntimeEnv } from "openclaw/plugin-sdk";
+import { type ResolvedInlineAccount } from "./accounts.js";
+type InlineMonitorHandle = {
+    stop: () => Promise<void>;
+};
+type StatusSink = (patch: {
+    lastInboundAt?: number;
+    lastOutboundAt?: number;
+    lastError?: string;
+}) => void;
+export declare function monitorInlineProvider(params: {
+    cfg: OpenClawConfig;
+    account: ResolvedInlineAccount;
+    runtime: RuntimeEnv;
+    abortSignal: AbortSignal;
+    log?: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+        debug?: (msg: string) => void;
+    };
+    statusSink?: StatusSink;
+}): Promise<InlineMonitorHandle>;
+export {};
+//# sourceMappingURL=monitor.d.ts.map

package/dist/inline/monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitor.d.ts","sourceRoot":"","sources":["../../src/inline/monitor.ts"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,cAAc,EACnB,KAAK,UAAU,EAChB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAsB,KAAK,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAK9E,KAAK,mBAAmB,GAAG;IACzB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B,CAAA;AAED,KAAK,UAAU,GAAG,CAAC,KAAK,EAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,CAAA;AAwE1G,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IAClD,GAAG,EAAE,cAAc,CAAA;IACnB,OAAO,EAAE,qBAAqB,CAAA;IAC9B,OAAO,EAAE,UAAU,CAAA;IACnB,WAAW,EAAE,WAAW,CAAA;IACxB,GAAG,CAAC,EAAE;QAAE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAA;IAC/H,UAAU,CAAC,EAAE,UAAU,CAAA;CACxB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAuX/B"}

package/dist/inline/monitor.js

@@ -0,0 +1,401 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { createReplyPrefixOptions, createTypingCallbacks, logInboundDrop, resolveControlCommandGate, resolveMentionGatingWithBypass, } from "openclaw/plugin-sdk";
+import { InlineSdkClient, JsonFileStateStore, Method } from "@inline-chat/realtime-sdk";
+import { resolveInlineToken } from "./accounts.js";
+import { getInlineRuntime } from "../runtime.js";
+const CHANNEL_ID = "inline";
+function normalizeAllowEntry(raw) {
+    return raw.trim().replace(/^inline:/i, "").replace(/^user:/i, "");
+}
+function normalizeAllowlist(entries) {
+    return (entries ?? [])
+        .map((entry) => normalizeAllowEntry(String(entry)))
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function allowlistMatch(params) {
+    if (params.allowFrom.some((entry) => entry === "*"))
+        return true;
+    return params.allowFrom.some((entry) => entry === params.senderId);
+}
+async function resolveChatInfo(client, cache, chatId) {
+    const existing = cache.get(chatId);
+    if (existing)
+        return existing;
+    const result = await client.getChat({ chatId });
+    const peerKind = result.peer?.type.oneofKind;
+    const kind = peerKind === "user" ? "direct" : "group";
+    const title = result.title?.trim() || null;
+    const info = { kind, title };
+    cache.set(chatId, info);
+    return info;
+}
+function messageText(message) {
+    return (message.message ?? "").trim();
+}
+function normalizeInlineUsername(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+}
+function buildInlineSenderName(params) {
+    const name = [params.firstName, params.lastName].filter(Boolean).join(" ").trim();
+    return name || undefined;
+}
+function rewriteNumericMentionsToUsernames(text, senderProfilesById) {
+    if (!text.includes("@"))
+        return text;
+    return text.replace(/(^|[^\w])@([0-9]+)\b/g, (full, prefix, userId) => {
+        const username = senderProfilesById.get(userId)?.username;
+        if (!username)
+            return full;
+        return `${prefix}@${username}`;
+    });
+}
+export async function monitorInlineProvider(params) {
+    const { cfg, account, runtime, abortSignal, log, statusSink } = params;
+    const core = getInlineRuntime();
+    if (!account.configured || !account.baseUrl) {
+        throw new Error(`Inline not configured for account "${account.accountId}" (missing baseUrl or token)`);
+    }
+    const token = await resolveInlineToken(account);
+    const stateDir = core.state.resolveStateDir();
+    const statePath = path.join(stateDir, "channels", "inline", `${account.accountId}.json`);
+    await mkdir(path.dirname(statePath), { recursive: true });
+    const sdkLog = {
+        debug: (msg) => log?.debug?.(msg),
+        info: (msg) => log?.info(msg),
+        warn: (msg) => log?.warn(msg),
+        error: (msg) => log?.error(msg),
+    };
+    const client = new InlineSdkClient({
+        baseUrl: account.baseUrl,
+        token,
+        logger: sdkLog,
+        state: new JsonFileStateStore(statePath),
+    });
+    await client.connect(abortSignal);
+    const me = await client.getMe();
+    log?.info(`[${account.accountId}] inline connected (me=${String(me.userId)})`);
+    const chatCache = new Map();
+    const senderProfilesById = new Map();
+    const hydratedParticipantChats = new Set();
+    const participantFetches = new Map();
+    const hydrateChatParticipants = async (chatId) => {
+        const chatKey = String(chatId);
+        if (hydratedParticipantChats.has(chatKey))
+            return;
+        const existing = participantFetches.get(chatKey);
+        if (existing)
+            return existing;
+        const run = (async () => {
+            const result = await client.invokeRaw(Method.GET_CHAT_PARTICIPANTS, {
+                oneofKind: "getChatParticipants",
+                getChatParticipants: { chatId },
+            });
+            if (result.oneofKind !== "getChatParticipants")
+                return;
+            for (const user of result.getChatParticipants.users ?? []) {
+                const userId = String(user.id);
+                if (!userId)
+                    continue;
+                const nextName = buildInlineSenderName({ firstName: user.firstName, lastName: user.lastName });
+                const nextUsername = normalizeInlineUsername(user.username);
+                const previous = senderProfilesById.get(userId);
+                const mergedName = nextName ?? previous?.name;
+                const mergedUsername = nextUsername ?? previous?.username;
+                senderProfilesById.set(userId, {
+                    ...(mergedName ? { name: mergedName } : {}),
+                    ...(mergedUsername ? { username: mergedUsername } : {}),
+                });
+            }
+            hydratedParticipantChats.add(chatKey);
+        })()
+            .catch((err) => {
+            statusSink?.({ lastError: `getChatParticipants failed: ${String(err)}` });
+        })
+            .finally(() => {
+            participantFetches.delete(chatKey);
+        });
+        participantFetches.set(chatKey, run);
+        await run;
+    };
+    const loop = (async () => {
+        try {
+            for await (const event of client.events()) {
+                if (abortSignal.aborted)
+                    break;
+                if (event.kind !== "message.new")
+                    continue;
+                const msg = event.message;
+                const rawBody = messageText(msg);
+                if (!rawBody)
+                    continue;
+                // Ignore echoes / our own outbound messages.
+                if (msg.out || msg.fromId === me.userId)
+                    continue;
+                const chatId = event.chatId;
+                statusSink?.({ lastInboundAt: Date.now() });
+                let chatInfo;
+                try {
+                    chatInfo = await resolveChatInfo(client, chatCache, chatId);
+                }
+                catch (err) {
+                    // Default conservative behavior if metadata fetch fails.
+                    chatInfo = { kind: "group", title: null };
+                    statusSink?.({ lastError: `getChat failed: ${String(err)}` });
+                }
+                const isGroup = chatInfo.kind !== "direct";
+                const senderId = String(msg.fromId);
+                await hydrateChatParticipants(chatId);
+                const senderProfile = senderProfilesById.get(senderId);
+                const senderUsername = senderProfile?.username;
+                const senderName = senderProfile?.name ?? (!isGroup ? chatInfo.title ?? undefined : undefined);
+                const dmPolicy = account.config.dmPolicy ?? "pairing";
+                const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
+                const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+                const configAllowFrom = normalizeAllowlist(account.config.allowFrom);
+                const configGroupAllowFrom = normalizeAllowlist(account.config.groupAllowFrom);
+                const storeAllowFrom = await core.channel.pairing.readAllowFromStore(CHANNEL_ID).catch(() => []);
+                const storeAllowList = normalizeAllowlist(storeAllowFrom);
+                const effectiveAllowFrom = [...configAllowFrom, ...storeAllowList].filter(Boolean);
+                const effectiveGroupAllowFrom = [
+                    ...(configGroupAllowFrom.length > 0 ? configGroupAllowFrom : configAllowFrom),
+                    ...storeAllowList,
+                ].filter(Boolean);
+                const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
+                    cfg,
+                    surface: CHANNEL_ID,
+                });
+                const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+                const allowForCommands = isGroup ? effectiveGroupAllowFrom : effectiveAllowFrom;
+                const senderAllowedForCommands = allowlistMatch({ allowFrom: allowForCommands, senderId });
+                const hasControlCommand = core.channel.text.hasControlCommand(rawBody, cfg);
+                const commandGate = resolveControlCommandGate({
+                    useAccessGroups,
+                    authorizers: [{ configured: allowForCommands.length > 0, allowed: senderAllowedForCommands }],
+                    allowTextCommands,
+                    hasControlCommand,
+                });
+                const commandAuthorized = commandGate.commandAuthorized;
+                if (isGroup) {
+                    if (groupPolicy === "disabled") {
+                        log?.info(`[${account.accountId}] inline: drop group chat=${String(chatId)} (groupPolicy=disabled)`);
+                        continue;
+                    }
+                    if (groupPolicy === "allowlist") {
+                        const allowed = allowlistMatch({ allowFrom: effectiveGroupAllowFrom, senderId });
+                        if (!allowed) {
+                            log?.info(`[${account.accountId}] inline: drop group sender=${senderId} (groupPolicy=allowlist)`);
+                            continue;
+                        }
+                    }
+                }
+                else {
+                    if (dmPolicy === "disabled") {
+                        log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=disabled)`);
+                        continue;
+                    }
+                    if (dmPolicy !== "open") {
+                        const allowed = allowlistMatch({ allowFrom: effectiveAllowFrom, senderId });
+                        if (!allowed) {
+                            if (dmPolicy === "pairing") {
+                                const { code, created } = await core.channel.pairing.upsertPairingRequest({
+                                    channel: CHANNEL_ID,
+                                    id: senderId,
+                                    meta: {},
+                                    // Pass adapter explicitly to avoid relying on registry lookup for plugin channels.
+                                    pairingAdapter: { idLabel: "inlineUserId", normalizeAllowEntry },
+                                });
+                                if (created) {
+                                    try {
+                                        await client.sendMessage({
+                                            chatId,
+                                            text: core.channel.pairing.buildPairingReply({
+                                                channel: CHANNEL_ID,
+                                                idLine: `Your Inline user id: ${senderId}`,
+                                                code,
+                                            }),
+                                        });
+                                        statusSink?.({ lastOutboundAt: Date.now() });
+                                    }
+                                    catch (err) {
+                                        runtime.error?.(`inline: pairing reply failed for ${senderId}: ${String(err)}`);
+                                    }
+                                }
+                            }
+                            log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=${dmPolicy})`);
+                            continue;
+                        }
+                    }
+                }
+                if (commandGate.shouldBlock) {
+                    logInboundDrop({
+                        log: (m) => runtime.log?.(m),
+                        channel: CHANNEL_ID,
+                        reason: "control command (unauthorized)",
+                        target: senderId,
+                    });
+                    continue;
+                }
+                const route = core.channel.routing.resolveAgentRoute({
+                    cfg,
+                    channel: CHANNEL_ID,
+                    accountId: account.accountId,
+                    peer: {
+                        kind: isGroup ? "group" : "direct",
+                        // DM sessions should be stable per sender. Group sessions should be stable per chat.
+                        id: isGroup ? String(chatId) : senderId,
+                    },
+                });
+                const mentionRegexes = core.channel.mentions.buildMentionRegexes(cfg, route.agentId);
+                const wasMentioned = typeof msg.mentioned === "boolean"
+                    ? msg.mentioned
+                    : mentionRegexes.length
+                        ? core.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes)
+                        : false;
+                const requireMention = isGroup ? (account.config.requireMention ?? true) : false;
+                const mentionGate = resolveMentionGatingWithBypass({
+                    isGroup,
+                    requireMention,
+                    canDetectMention: typeof msg.mentioned === "boolean" || mentionRegexes.length > 0,
+                    wasMentioned,
+                    allowTextCommands,
+                    hasControlCommand,
+                    commandAuthorized,
+                });
+                if (isGroup && mentionGate.shouldSkip) {
+                    runtime.log?.(`inline: drop group chat ${String(chatId)} (no mention)`);
+                    continue;
+                }
+                const timestamp = Number(msg.date) * 1000;
+                const fromLabel = isGroup ? `chat:${chatInfo.title ?? String(chatId)}` : `user:${senderId}`;
+                const storePath = core.channel.session.resolveStorePath(cfg.session?.store, { agentId: route.agentId });
+                const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+                const previousTimestamp = core.channel.session.readSessionUpdatedAt({ storePath, sessionKey: route.sessionKey });
+                const body = core.channel.reply.formatAgentEnvelope({
+                    channel: "Inline",
+                    from: fromLabel,
+                    timestamp,
+                    ...(previousTimestamp != null ? { previousTimestamp } : {}),
+                    envelope: envelopeOptions,
+                    body: rawBody,
+                });
+                const ctxPayload = core.channel.reply.finalizeInboundContext({
+                    Body: body,
+                    RawBody: rawBody,
+                    CommandBody: rawBody,
+                    From: isGroup ? `inline:chat:${String(chatId)}` : `inline:${senderId}`,
+                    To: `inline:${String(chatId)}`,
+                    SessionKey: route.sessionKey,
+                    AccountId: route.accountId,
+                    ChatType: isGroup ? "group" : "direct",
+                    ConversationLabel: fromLabel,
+                    ...(isGroup ? { GroupSubject: chatInfo.title ?? String(chatId) } : {}),
+                    SenderId: senderId,
+                    ...(senderName ? { SenderName: senderName } : {}),
+                    ...(senderUsername ? { SenderUsername: senderUsername } : {}),
+                    Provider: CHANNEL_ID,
+                    Surface: CHANNEL_ID,
+                    MessageSid: String(msg.id),
+                    ...(msg.replyToMsgId != null ? { ReplyToId: String(msg.replyToMsgId) } : {}),
+                    Timestamp: timestamp || Date.now(),
+                    WasMentioned: mentionGate.effectiveWasMentioned,
+                    CommandAuthorized: commandAuthorized,
+                    OriginatingChannel: CHANNEL_ID,
+                    OriginatingTo: `inline:${String(chatId)}`,
+                });
+                await core.channel.session.recordInboundSession({
+                    storePath,
+                    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+                    ctx: ctxPayload,
+                    ...(!isGroup
+                        ? {
+                            updateLastRoute: {
+                                sessionKey: route.mainSessionKey,
+                                channel: CHANNEL_ID,
+                                to: `inline:${String(chatId)}`,
+                                accountId: route.accountId,
+                            },
+                        }
+                        : {}),
+                    onRecordError: (err) => runtime.error?.(`inline: failed updating session meta: ${String(err)}`),
+                });
+                const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+                    cfg,
+                    agentId: route.agentId,
+                    channel: CHANNEL_ID,
+                    accountId: account.accountId,
+                });
+                const typingCallbacks = createTypingCallbacks({
+                    start: () => client.sendTyping({ chatId, typing: true }),
+                    stop: () => client.sendTyping({ chatId, typing: false }),
+                    onStartError: (err) => runtime.error?.(`inline typing start failed: ${String(err)}`),
+                    onStopError: (err) => runtime.error?.(`inline typing stop failed: ${String(err)}`),
+                });
+                const parseMarkdown = account.config.parseMarkdown ?? true;
+                await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                    ctx: ctxPayload,
+                    cfg,
+                    dispatcherOptions: {
+                        ...prefixOptions,
+                        ...typingCallbacks,
+                        deliver: async (payload) => {
+                            const text = (payload.text ?? "").trim();
+                            const mediaList = payload.mediaUrls?.length
+                                ? payload.mediaUrls
+                                : payload.mediaUrl
+                                    ? [payload.mediaUrl]
+                                    : [];
+                            const mediaBlock = mediaList.length ? mediaList.map((url) => `Attachment: ${url}`).join("\n") : "";
+                            const combined = text
+                                ? mediaBlock
+                                    ? `${text}\n\n${mediaBlock}`
+                                    : text
+                                : mediaBlock;
+                            if (!combined.trim())
+                                return;
+                            const outboundText = rewriteNumericMentionsToUsernames(combined, senderProfilesById);
+                            let replyToMsgId;
+                            if (payload.replyToId != null) {
+                                try {
+                                    replyToMsgId = BigInt(payload.replyToId);
+                                }
+                                catch {
+                                    // ignore
+                                }
+                            }
+                            await client.sendMessage({
+                                chatId,
+                                text: outboundText,
+                                ...(replyToMsgId != null ? { replyToMsgId } : {}),
+                                parseMarkdown,
+                            });
+                            statusSink?.({ lastOutboundAt: Date.now() });
+                        },
+                        onError: (err, info) => runtime.error?.(`inline ${info.kind} reply failed: ${String(err)}`),
+                    },
+                    replyOptions: {
+                        onModelSelected,
+                        blockReplyTimeoutMs: 25_000,
+                    },
+                });
+            }
+        }
+        catch (err) {
+            statusSink?.({ lastError: String(err) });
+            runtime.error?.(`inline monitor loop crashed: ${String(err)}`);
+        }
+    })();
+    const stop = async () => {
+        await client.close().catch(() => { });
+        await loop.catch(() => { });
+    };
+    abortSignal.addEventListener("abort", () => {
+        void stop();
+    }, { once: true });
+    return { stop };
+}
+//# sourceMappingURL=monitor.js.map