openclaw-cortex 3.4.0 → 3.5.0

package/dist/plugin-sdk/infra/scp-host.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeScpRemoteHost(value: string | null | undefined): string | undefined;
+export declare function isSafeScpRemoteHost(value: string | null | undefined): boolean;

package/dist/plugin-sdk/infra/session-cost-usage.d.ts

@@ -0,0 +1,45 @@
+import type { OpenClawConfig } from "../config/config.js";
+import type { SessionEntry } from "../config/sessions/types.js";
+import type { CostUsageSummary, DiscoveredSession, SessionCostSummary, SessionLogEntry, SessionUsageTimeSeries } from "./session-cost-usage.types.js";
+export type { CostUsageDailyEntry, CostUsageSummary, CostUsageTotals, DiscoveredSession, SessionCostSummary, SessionDailyLatency, SessionDailyMessageCounts, SessionDailyModelUsage, SessionDailyUsage, SessionLatencyStats, SessionLogEntry, SessionMessageCounts, SessionModelUsage, SessionToolUsage, SessionUsageTimePoint, SessionUsageTimeSeries, } from "./session-cost-usage.types.js";
+export declare function loadCostUsageSummary(params?: {
+    startMs?: number;
+    endMs?: number;
+    days?: number;
+    config?: OpenClawConfig;
+    agentId?: string;
+}): Promise<CostUsageSummary>;
+/**
+ * Scan all transcript files to discover sessions not in the session store.
+ * Returns basic metadata for each discovered session.
+ */
+export declare function discoverAllSessions(params?: {
+    agentId?: string;
+    startMs?: number;
+    endMs?: number;
+}): Promise<DiscoveredSession[]>;
+export declare function loadSessionCostSummary(params: {
+    sessionId?: string;
+    sessionEntry?: SessionEntry;
+    sessionFile?: string;
+    config?: OpenClawConfig;
+    agentId?: string;
+    startMs?: number;
+    endMs?: number;
+}): Promise<SessionCostSummary | null>;
+export declare function loadSessionUsageTimeSeries(params: {
+    sessionId?: string;
+    sessionEntry?: SessionEntry;
+    sessionFile?: string;
+    config?: OpenClawConfig;
+    agentId?: string;
+    maxPoints?: number;
+}): Promise<SessionUsageTimeSeries | null>;
+export declare function loadSessionLogs(params: {
+    sessionId?: string;
+    sessionEntry?: SessionEntry;
+    sessionFile?: string;
+    config?: OpenClawConfig;
+    agentId?: string;
+    limit?: number;
+}): Promise<SessionLogEntry[] | null>;

package/dist/plugin-sdk/infra/session-cost-usage.types.d.ts

@@ -0,0 +1,153 @@
+import type { NormalizedUsage } from "../agents/usage.js";
+export type CostBreakdown = {
+    total?: number;
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+};
+export type ParsedUsageEntry = {
+    usage: NormalizedUsage;
+    costTotal?: number;
+    costBreakdown?: CostBreakdown;
+    provider?: string;
+    model?: string;
+    timestamp?: Date;
+};
+export type ParsedTranscriptEntry = {
+    message: Record<string, unknown>;
+    role?: "user" | "assistant";
+    timestamp?: Date;
+    durationMs?: number;
+    usage?: NormalizedUsage;
+    costTotal?: number;
+    costBreakdown?: CostBreakdown;
+    provider?: string;
+    model?: string;
+    stopReason?: string;
+    toolNames: string[];
+    toolResultCounts: {
+        total: number;
+        errors: number;
+    };
+};
+export type CostUsageTotals = {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    totalTokens: number;
+    totalCost: number;
+    inputCost: number;
+    outputCost: number;
+    cacheReadCost: number;
+    cacheWriteCost: number;
+    missingCostEntries: number;
+};
+export type CostUsageDailyEntry = CostUsageTotals & {
+    date: string;
+};
+export type CostUsageSummary = {
+    updatedAt: number;
+    days: number;
+    daily: CostUsageDailyEntry[];
+    totals: CostUsageTotals;
+};
+export type SessionDailyUsage = {
+    date: string;
+    tokens: number;
+    cost: number;
+};
+export type SessionDailyMessageCounts = {
+    date: string;
+    total: number;
+    user: number;
+    assistant: number;
+    toolCalls: number;
+    toolResults: number;
+    errors: number;
+};
+export type SessionLatencyStats = {
+    count: number;
+    avgMs: number;
+    p95Ms: number;
+    minMs: number;
+    maxMs: number;
+};
+export type SessionDailyLatency = SessionLatencyStats & {
+    date: string;
+};
+export type SessionDailyModelUsage = {
+    date: string;
+    provider?: string;
+    model?: string;
+    tokens: number;
+    cost: number;
+    count: number;
+};
+export type SessionMessageCounts = {
+    total: number;
+    user: number;
+    assistant: number;
+    toolCalls: number;
+    toolResults: number;
+    errors: number;
+};
+export type SessionToolUsage = {
+    totalCalls: number;
+    uniqueTools: number;
+    tools: Array<{
+        name: string;
+        count: number;
+    }>;
+};
+export type SessionModelUsage = {
+    provider?: string;
+    model?: string;
+    count: number;
+    totals: CostUsageTotals;
+};
+export type SessionCostSummary = CostUsageTotals & {
+    sessionId?: string;
+    sessionFile?: string;
+    firstActivity?: number;
+    lastActivity?: number;
+    durationMs?: number;
+    activityDates?: string[];
+    dailyBreakdown?: SessionDailyUsage[];
+    dailyMessageCounts?: SessionDailyMessageCounts[];
+    dailyLatency?: SessionDailyLatency[];
+    dailyModelUsage?: SessionDailyModelUsage[];
+    messageCounts?: SessionMessageCounts;
+    toolUsage?: SessionToolUsage;
+    modelUsage?: SessionModelUsage[];
+    latency?: SessionLatencyStats;
+};
+export type DiscoveredSession = {
+    sessionId: string;
+    sessionFile: string;
+    mtime: number;
+    firstUserMessage?: string;
+};
+export type SessionUsageTimePoint = {
+    timestamp: number;
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    totalTokens: number;
+    cost: number;
+    cumulativeTokens: number;
+    cumulativeCost: number;
+};
+export type SessionUsageTimeSeries = {
+    sessionId?: string;
+    points: SessionUsageTimePoint[];
+};
+export type SessionLogEntry = {
+    timestamp: number;
+    role: "user" | "assistant" | "tool" | "toolResult";
+    content: string;
+    tokens?: number;
+    cost?: number;
+};

package/dist/plugin-sdk/infra/session-maintenance-warning.d.ts

@@ -0,0 +1,10 @@
+import type { OpenClawConfig } from "../config/config.js";
+import type { SessionEntry, SessionMaintenanceWarning } from "../config/sessions.js";
+type WarningParams = {
+    cfg: OpenClawConfig;
+    sessionKey: string;
+    entry: SessionEntry;
+    warning: SessionMaintenanceWarning;
+};
+export declare function deliverSessionMaintenanceWarning(params: WarningParams): Promise<void>;
+export {};

package/dist/plugin-sdk/infra/shell-env.d.ts

@@ -0,0 +1,34 @@
+import { execFileSync } from "node:child_process";
+export type ShellEnvFallbackResult = {
+    ok: true;
+    applied: string[];
+    skippedReason?: never;
+} | {
+    ok: true;
+    applied: [];
+    skippedReason: "already-has-keys" | "disabled";
+} | {
+    ok: false;
+    error: string;
+    applied: [];
+};
+export type ShellEnvFallbackOptions = {
+    enabled: boolean;
+    env: NodeJS.ProcessEnv;
+    expectedKeys: string[];
+    logger?: Pick<typeof console, "warn">;
+    timeoutMs?: number;
+    exec?: typeof execFileSync;
+};
+export declare function loadShellEnvFallback(opts: ShellEnvFallbackOptions): ShellEnvFallbackResult;
+export declare function shouldEnableShellEnvFallback(env: NodeJS.ProcessEnv): boolean;
+export declare function shouldDeferShellEnvFallback(env: NodeJS.ProcessEnv): boolean;
+export declare function resolveShellEnvFallbackTimeoutMs(env: NodeJS.ProcessEnv): number;
+export declare function getShellPathFromLoginShell(opts: {
+    env: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+    exec?: typeof execFileSync;
+    platform?: NodeJS.Platform;
+}): string | null;
+export declare function resetShellPathCacheForTests(): void;
+export declare function getShellEnvAppliedKeys(): string[];

package/dist/plugin-sdk/infra/skills-remote.d.ts

@@ -0,0 +1,25 @@
+import type { SkillEligibilityContext } from "../agents/skills.js";
+import type { OpenClawConfig } from "../config/config.js";
+import type { NodeRegistry } from "../gateway/node-registry.js";
+export declare function setSkillsRemoteRegistry(registry: NodeRegistry | null): void;
+export declare function primeRemoteSkillsCache(): Promise<void>;
+export declare function recordRemoteNodeInfo(node: {
+    nodeId: string;
+    displayName?: string;
+    platform?: string;
+    deviceFamily?: string;
+    commands?: string[];
+    remoteIp?: string;
+}): void;
+export declare function recordRemoteNodeBins(nodeId: string, bins: string[]): void;
+export declare function removeRemoteNodeInfo(nodeId: string): void;
+export declare function refreshRemoteNodeBins(params: {
+    nodeId: string;
+    platform?: string;
+    deviceFamily?: string;
+    commands?: string[];
+    cfg: OpenClawConfig;
+    timeoutMs?: number;
+}): Promise<void>;
+export declare function getRemoteSkillEligibility(): SkillEligibilityContext["remote"] | undefined;
+export declare function refreshRemoteBinsForConnectedNodes(cfg: OpenClawConfig): Promise<void>;

package/dist/plugin-sdk/infra/system-events.d.ts

@@ -0,0 +1,18 @@
+export type SystemEvent = {
+    text: string;
+    ts: number;
+    contextKey?: string | null;
+};
+type SystemEventOptions = {
+    sessionKey: string;
+    contextKey?: string | null;
+};
+export declare function isSystemEventContextChanged(sessionKey: string, contextKey?: string | null): boolean;
+export declare function enqueueSystemEvent(text: string, options: SystemEventOptions): void;
+export declare function drainSystemEventEntries(sessionKey: string): SystemEvent[];
+export declare function drainSystemEvents(sessionKey: string): string[];
+export declare function peekSystemEventEntries(sessionKey: string): SystemEvent[];
+export declare function peekSystemEvents(sessionKey: string): string[];
+export declare function hasSystemEvents(sessionKey: string): boolean;
+export declare function resetSystemEventsForTest(): void;
+export {};

package/dist/plugin-sdk/infra/tailnet.d.ts

@@ -0,0 +1,8 @@
+export type TailnetAddresses = {
+    ipv4: string[];
+    ipv6: string[];
+};
+export declare function isTailnetIPv4(address: string): boolean;
+export declare function listTailnetAddresses(): TailnetAddresses;
+export declare function pickPrimaryTailnetIPv4(): string | undefined;
+export declare function pickPrimaryTailnetIPv6(): string | undefined;

package/dist/plugin-sdk/infra/tailscale.d.ts

@@ -0,0 +1,34 @@
+import { promptYesNo } from "../cli/prompt.js";
+import { runExec } from "../process/exec.js";
+import { type RuntimeEnv } from "../runtime.js";
+/**
+ * Locate Tailscale binary using multiple strategies:
+ * 1. PATH lookup (via which command)
+ * 2. Known macOS app path
+ * 3. find /Applications for Tailscale.app
+ * 4. locate database (if available)
+ *
+ * @returns Path to Tailscale binary or null if not found
+ */
+export declare function findTailscaleBinary(): Promise<string | null>;
+export declare function getTailnetHostname(exec?: typeof runExec, detectedBinary?: string): Promise<string>;
+export declare function getTailscaleBinary(): Promise<string>;
+export declare function readTailscaleStatusJson(exec?: typeof runExec, opts?: {
+    timeoutMs?: number;
+}): Promise<Record<string, unknown>>;
+export declare function ensureGoInstalled(exec?: typeof runExec, prompt?: typeof promptYesNo, runtime?: RuntimeEnv): Promise<void>;
+export declare function ensureTailscaledInstalled(exec?: typeof runExec, prompt?: typeof promptYesNo, runtime?: RuntimeEnv): Promise<void>;
+export type TailscaleWhoisIdentity = {
+    login: string;
+    name?: string;
+};
+export declare function ensureFunnel(port: number, exec?: typeof runExec, runtime?: RuntimeEnv, prompt?: typeof promptYesNo): Promise<void>;
+export declare function enableTailscaleServe(port: number, exec?: typeof runExec): Promise<void>;
+export declare function disableTailscaleServe(exec?: typeof runExec): Promise<void>;
+export declare function enableTailscaleFunnel(port: number, exec?: typeof runExec): Promise<void>;
+export declare function disableTailscaleFunnel(exec?: typeof runExec): Promise<void>;
+export declare function readTailscaleWhoisIdentity(ip: string, exec?: typeof runExec, opts?: {
+    timeoutMs?: number;
+    cacheTtlMs?: number;
+    errorTtlMs?: number;
+}): Promise<TailscaleWhoisIdentity | null>;

package/dist/plugin-sdk/infra/tls/fingerprint.d.ts

@@ -0,0 +1 @@
+export declare function normalizeFingerprint(input: string): string;

package/dist/plugin-sdk/infra/tls/gateway.d.ts

@@ -0,0 +1,16 @@
+import tls from "node:tls";
+import type { GatewayTlsConfig } from "../../config/types.gateway.js";
+export type GatewayTlsRuntime = {
+    enabled: boolean;
+    required: boolean;
+    certPath?: string;
+    keyPath?: string;
+    caPath?: string;
+    fingerprintSha256?: string;
+    tlsOptions?: tls.TlsOptions;
+    error?: string;
+};
+export declare function loadGatewayTlsRuntime(cfg: GatewayTlsConfig | undefined, log?: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+}): Promise<GatewayTlsRuntime>;

package/dist/plugin-sdk/infra/tmp-openclaw-dir.d.ts

@@ -0,0 +1,18 @@
+export declare const POSIX_OPENCLAW_TMP_DIR = "/tmp/openclaw";
+type ResolvePreferredOpenClawTmpDirOptions = {
+    accessSync?: (path: string, mode?: number) => void;
+    lstatSync?: (path: string) => {
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+        mode?: number;
+        uid?: number;
+    };
+    mkdirSync?: (path: string, opts: {
+        recursive: boolean;
+        mode?: number;
+    }) => void;
+    getuid?: () => number | undefined;
+    tmpdir?: () => string;
+};
+export declare function resolvePreferredOpenClawTmpDir(options?: ResolvePreferredOpenClawTmpDirOptions): string;
+export {};

package/dist/plugin-sdk/infra/transport-ready.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeEnv } from "../runtime.js";
+export type TransportReadyResult = {
+    ok: boolean;
+    error?: string | null;
+};
+export type WaitForTransportReadyParams = {
+    label: string;
+    timeoutMs: number;
+    logAfterMs?: number;
+    logIntervalMs?: number;
+    pollIntervalMs?: number;
+    abortSignal?: AbortSignal;
+    runtime: RuntimeEnv;
+    check: () => Promise<TransportReadyResult>;
+};
+export declare function waitForTransportReady(params: WaitForTransportReadyParams): Promise<void>;

package/dist/plugin-sdk/infra/unhandled-rejections.d.ts

@@ -0,0 +1,15 @@
+type UnhandledRejectionHandler = (reason: unknown) => boolean;
+/**
+ * Checks if an error is an AbortError.
+ * These are typically intentional cancellations (e.g., during shutdown) and shouldn't crash.
+ */
+export declare function isAbortError(err: unknown): boolean;
+/**
+ * Checks if an error is a transient network error that shouldn't crash the gateway.
+ * These are typically temporary connectivity issues that will resolve on their own.
+ */
+export declare function isTransientNetworkError(err: unknown): boolean;
+export declare function registerUnhandledRejectionHandler(handler: UnhandledRejectionHandler): () => void;
+export declare function isUnhandledRejectionHandled(reason: unknown): boolean;
+export declare function installUnhandledRejectionHandler(): void;
+export {};

package/dist/plugin-sdk/infra/warning-filter.d.ts

@@ -0,0 +1,7 @@
+export type ProcessWarning = {
+    code?: string;
+    name?: string;
+    message?: string;
+};
+export declare function shouldIgnoreWarning(warning: ProcessWarning): boolean;
+export declare function installProcessWarningFilter(): void;

package/dist/plugin-sdk/infra/ws.d.ts

@@ -0,0 +1,2 @@
+import type WebSocket from "ws";
+export declare function rawDataToString(data: WebSocket.RawData, encoding?: BufferEncoding): string;

package/dist/plugin-sdk/infra/wsl.d.ts

@@ -0,0 +1,11 @@
+export declare function isWSLEnv(): boolean;
+/**
+ * Synchronously check if running in WSL.
+ * Checks env vars first, then /proc/version.
+ */
+export declare function isWSLSync(): boolean;
+/**
+ * Synchronously check if running in WSL2.
+ */
+export declare function isWSL2Sync(): boolean;
+export declare function isWSL(): Promise<boolean>;

package/dist/plugin-sdk/line/accounts.d.ts

@@ -0,0 +1,10 @@
+import type { OpenClawConfig } from "../config/config.js";
+import type { ResolvedLineAccount } from "./types.js";
+export declare const DEFAULT_ACCOUNT_ID = "default";
+export declare function resolveLineAccount(params: {
+    cfg: OpenClawConfig;
+    accountId?: string;
+}): ResolvedLineAccount;
+export declare function listLineAccountIds(cfg: OpenClawConfig): string[];
+export declare function resolveDefaultLineAccountId(cfg: OpenClawConfig): string;
+export declare function normalizeAccountId(accountId: string | undefined): string;

package/dist/plugin-sdk/line/actions.d.ts

@@ -0,0 +1,22 @@
+import type { messagingApi } from "@line/bot-sdk";
+export type Action = messagingApi.Action;
+/**
+ * Create a message action (sends text when tapped)
+ */
+export declare function messageAction(label: string, text?: string): Action;
+/**
+ * Create a URI action (opens a URL when tapped)
+ */
+export declare function uriAction(label: string, uri: string): Action;
+/**
+ * Create a postback action (sends data to webhook when tapped)
+ */
+export declare function postbackAction(label: string, data: string, displayText?: string): Action;
+/**
+ * Create a datetime picker action
+ */
+export declare function datetimePickerAction(label: string, data: string, mode: "date" | "time" | "datetime", options?: {
+    initial?: string;
+    max?: string;
+    min?: string;
+}): Action;

package/dist/plugin-sdk/line/auto-reply-delivery.d.ts

@@ -0,0 +1,38 @@
+import type { messagingApi } from "@line/bot-sdk";
+import type { ReplyPayload } from "../auto-reply/types.js";
+import type { FlexContainer } from "./flex-templates.js";
+import type { ProcessedLineMessage } from "./markdown-to-line.js";
+import type { SendLineReplyChunksParams } from "./reply-chunks.js";
+import type { LineChannelData, LineTemplateMessagePayload } from "./types.js";
+export type LineAutoReplyDeps = {
+    buildTemplateMessageFromPayload: (payload: LineTemplateMessagePayload) => messagingApi.TemplateMessage | null;
+    processLineMessage: (text: string) => ProcessedLineMessage;
+    chunkMarkdownText: (text: string, limit: number) => string[];
+    sendLineReplyChunks: (params: SendLineReplyChunksParams) => Promise<{
+        replyTokenUsed: boolean;
+    }>;
+    createQuickReplyItems: (labels: string[]) => messagingApi.QuickReply;
+    pushMessagesLine: (to: string, messages: messagingApi.Message[], opts?: {
+        accountId?: string;
+    }) => Promise<unknown>;
+    createFlexMessage: (altText: string, contents: FlexContainer) => messagingApi.FlexMessage;
+    createImageMessage: (originalContentUrl: string, previewImageUrl?: string) => messagingApi.ImageMessage;
+    createLocationMessage: (location: {
+        title: string;
+        address: string;
+        latitude: number;
+        longitude: number;
+    }) => messagingApi.LocationMessage;
+} & Pick<SendLineReplyChunksParams, "replyMessageLine" | "pushMessageLine" | "pushTextMessageWithQuickReplies" | "createTextMessageWithQuickReplies" | "onReplyError">;
+export declare function deliverLineAutoReply(params: {
+    payload: ReplyPayload;
+    lineData: LineChannelData;
+    to: string;
+    replyToken?: string | null;
+    replyTokenUsed: boolean;
+    accountId?: string;
+    textLimit: number;
+    deps: LineAutoReplyDeps;
+}): Promise<{
+    replyTokenUsed: boolean;
+}>;

package/dist/plugin-sdk/line/bot-access.d.ts

@@ -0,0 +1,16 @@
+import { firstDefined } from "../channels/allow-from.js";
+export type NormalizedAllowFrom = {
+    entries: string[];
+    hasWildcard: boolean;
+    hasEntries: boolean;
+};
+export declare const normalizeAllowFrom: (list?: Array<string | number>) => NormalizedAllowFrom;
+export declare const normalizeAllowFromWithStore: (params: {
+    allowFrom?: Array<string | number>;
+    storeAllowFrom?: string[];
+}) => NormalizedAllowFrom;
+export declare const isSenderAllowed: (params: {
+    allow: NormalizedAllowFrom;
+    senderId?: string;
+}) => boolean;
+export { firstDefined };

package/dist/plugin-sdk/line/bot-handlers.d.ts

@@ -0,0 +1,13 @@
+import type { WebhookEvent } from "@line/bot-sdk";
+import type { OpenClawConfig } from "../config/config.js";
+import type { RuntimeEnv } from "../runtime.js";
+import { type LineInboundContext } from "./bot-message-context.js";
+import type { ResolvedLineAccount } from "./types.js";
+export interface LineHandlerContext {
+    cfg: OpenClawConfig;
+    account: ResolvedLineAccount;
+    runtime: RuntimeEnv;
+    mediaMaxBytes: number;
+    processMessage: (ctx: LineInboundContext) => Promise<void>;
+}
+export declare function handleLineWebhookEvents(events: WebhookEvent[], context: LineHandlerContext): Promise<void>;

package/dist/plugin-sdk/line/bot-message-context.d.ts

@@ -0,0 +1,118 @@
+import type { MessageEvent, EventSource, PostbackEvent } from "@line/bot-sdk";
+import type { OpenClawConfig } from "../config/config.js";
+import type { ResolvedLineAccount } from "./types.js";
+interface MediaRef {
+    path: string;
+    contentType?: string;
+}
+interface BuildLineMessageContextParams {
+    event: MessageEvent;
+    allMedia: MediaRef[];
+    cfg: OpenClawConfig;
+    account: ResolvedLineAccount;
+}
+export type LineSourceInfo = {
+    userId?: string;
+    groupId?: string;
+    roomId?: string;
+    isGroup: boolean;
+};
+export declare function getLineSourceInfo(source: EventSource): LineSourceInfo;
+export declare function buildLineMessageContext(params: BuildLineMessageContextParams): Promise<{
+    ctxPayload: {
+        OriginatingChannel: "line";
+        OriginatingTo: string;
+        LocationLat?: number | undefined;
+        LocationLon?: number | undefined;
+        LocationAccuracy?: number;
+        LocationName?: string;
+        LocationAddress?: string;
+        LocationSource?: import("../channels/location.js").LocationSource | undefined;
+        LocationIsLive?: boolean | undefined;
+        Body: string;
+        BodyForAgent: string;
+        RawBody: string;
+        CommandBody: string;
+        From: string;
+        To: string;
+        SessionKey: string;
+        AccountId: string;
+        ChatType: string;
+        ConversationLabel: string;
+        GroupSubject: string | undefined;
+        SenderId: string;
+        Provider: string;
+        Surface: string;
+        MessageSid: string;
+        Timestamp: number;
+        MediaPath: string | undefined;
+        MediaType: string | undefined;
+        MediaUrl: string | undefined;
+        MediaPaths: string[] | undefined;
+        MediaUrls: string[] | undefined;
+        MediaTypes: string[] | undefined;
+    } & Omit<import("../auto-reply/templating.ts").MsgContext, "CommandAuthorized"> & {
+        CommandAuthorized: boolean;
+    };
+    event: MessageEvent;
+    userId: string | undefined;
+    groupId: string | undefined;
+    roomId: string | undefined;
+    isGroup: boolean;
+    route: import("../routing/resolve-route.js").ResolvedAgentRoute;
+    replyToken: string;
+    accountId: string;
+} | null>;
+export declare function buildLinePostbackContext(params: {
+    event: PostbackEvent;
+    cfg: OpenClawConfig;
+    account: ResolvedLineAccount;
+}): Promise<{
+    ctxPayload: {
+        OriginatingChannel: "line";
+        OriginatingTo: string;
+        LocationLat?: number | undefined;
+        LocationLon?: number | undefined;
+        LocationAccuracy?: number;
+        LocationName?: string;
+        LocationAddress?: string;
+        LocationSource?: import("../channels/location.js").LocationSource | undefined;
+        LocationIsLive?: boolean | undefined;
+        Body: string;
+        BodyForAgent: string;
+        RawBody: string;
+        CommandBody: string;
+        From: string;
+        To: string;
+        SessionKey: string;
+        AccountId: string;
+        ChatType: string;
+        ConversationLabel: string;
+        GroupSubject: string | undefined;
+        SenderId: string;
+        Provider: string;
+        Surface: string;
+        MessageSid: string;
+        Timestamp: number;
+        MediaPath: string | undefined;
+        MediaType: string | undefined;
+        MediaUrl: string | undefined;
+        MediaPaths: string[] | undefined;
+        MediaUrls: string[] | undefined;
+        MediaTypes: string[] | undefined;
+    } & Omit<import("../auto-reply/templating.ts").MsgContext, "CommandAuthorized"> & {
+        CommandAuthorized: boolean;
+    };
+    event: PostbackEvent;
+    userId: string | undefined;
+    groupId: string | undefined;
+    roomId: string | undefined;
+    isGroup: boolean;
+    route: import("../routing/resolve-route.js").ResolvedAgentRoute;
+    replyToken: string;
+    accountId: string;
+} | null>;
+export type LineMessageContext = NonNullable<Awaited<ReturnType<typeof buildLineMessageContext>>>;
+export type LinePostbackContext = NonNullable<Awaited<ReturnType<typeof buildLinePostbackContext>>>;
+export type LineInboundContext = LineMessageContext | LinePostbackContext;
+export {};