import type { MessagePresentation } from "openclaw/plugin-sdk/interactive-runtime";

import { createTelegramActionGate, resolveTelegramPollActionGateState } from "./accounts.js";

import { resolveTelegramInlineButtons } from "./button-types.js";

import {

notifyTelegramInboundTurnOutboundSuccess,

type TelegramInboundTurnDeliveryKind,

} from "./inbound-turn-delivery.js";

import { notifyTelegramInboundTurnOutboundSuccess } from "./inbound-turn-delivery.js";

import {

resolveTelegramInlineButtonsScope,

resolveTelegramTargetChatType,

mediaLocalRoots?: readonly string[];

mediaReadFile?: (filePath: string) => Promise<Buffer>;

sessionKey?: string | null;

inboundTurnKind?: TelegramInboundTurnDeliveryKind | string;

inboundTurnKind?: string;

},

): Promise<AgentToolResult<unknown>> {

const { action, accountId } = {

export function resolveTelegramInboundTurnDeliveryCorrelationKey(

sessionKey: string | undefined,

inboundTurnKind?: TelegramInboundTurnDeliveryKind | string,

inboundTurnKind?: string,

): string | undefined {

const key = sessionKey?.trim();

if (!key) {

export function beginTelegramInboundTurnDeliveryCorrelation(

sessionKey: string | undefined,

turn: ActiveTurn,

options?: { inboundTurnKind?: TelegramInboundTurnDeliveryKind | string },

options?: { inboundTurnKind?: string },

): TelegramInboundTurnDeliveryEnd {

const key = resolveTelegramInboundTurnDeliveryCorrelationKey(

sessionKey,

sessionKey: string | undefined;

to: string;

accountId?: string | null;

inboundTurnKind?: TelegramInboundTurnDeliveryKind | string;

inboundTurnKind?: string;

}): void {

const key = resolveTelegramInboundTurnDeliveryCorrelationKey(

params.sessionKey,

type TelegramPollingSessionOpts = {

token: string;

config: Parameters<typeof createTelegramBot>[0]["config"];

config: NonNullable<Parameters<typeof createTelegramBot>[0]["config"]>;

accountId: string;

runtime: Parameters<typeof createTelegramBot>[0]["runtime"];

proxyFetch: Parameters<typeof createTelegramBot>[0]["proxyFetch"];

try {

const drain = await this.#drainSpooledUpdates({ bot, spoolDir });

consecutiveDrainFailures = 0;

for (const handlerKey of [...stalledBacklogKeys]) {

for (const handlerKey of stalledBacklogKeys) {

if (

!activeSpooledUpdateHandlersByLane.has(handlerKey) ||

!drain.blockedByLane.has(handlerKey)

import { describe, expect, it } from "vitest";

import type { ModelDefinitionConfig } from "../config/types.models.js";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { resolveModelRuntimePolicy } from "./model-runtime-policy.js";

const createModelConfig = (agentRuntimeId: string): ModelDefinitionConfig => ({

id: "qwen-local",

name: "Qwen Local",

reasoning: false,

input: ["text"],

cost: {

input: 0,

output: 0,

cacheRead: 0,

cacheWrite: 0,

},

contextWindow: 32_768,

maxTokens: 4096,

agentRuntime: { id: agentRuntimeId },

});

describe("resolveModelRuntimePolicy", () => {

it("honors provider wildcard agent model runtime policy entries", () => {

const config = {

models: {

providers: {

vllm: {

models: [{ id: "qwen-local", agentRuntime: { id: "codex" } }],

baseUrl: "http://127.0.0.1:11434/v1",

models: [createModelConfig("codex")],

},

},

},

models: {

providers: {

vllm: {

baseUrl: "http://127.0.0.1:11434/v1",

agentRuntime: { id: "codex" },

models: [],

},

modelId: modelUsed,

});

} finally {

for (const end of endDeliveryCorrelations.reverse()) {

for (const end of endDeliveryCorrelations.toReversed()) {

try {

end();

} catch (err) {

defaultRuntime.error?.(`followup queue: delivery correlation cleanup failed: ${err}`);

defaultRuntime.error?.(

`followup queue: delivery correlation cleanup failed: ${formatErrorMessage(err)}`,

);

}

}

completeFollowupRunLifecycle(queued);

originatingTo?: string;

originatingAccountId?: string;

originatingThreadId?: string | number;

currentTurnKind?: FollowupRun["currentTurnKind"];

}): FollowupRun {

return {

prompt: params.prompt,

originatingTo: params.originatingTo,

originatingAccountId: params.originatingAccountId,

originatingThreadId: params.originatingThreadId,

currentTurnKind: params.currentTurnKind,

run: {

agentId: "agent",

agentDir: "/tmp",

): Promise<number> {

let dropped = 0;

for (let index = items.length - 1; index >= 0; index -= 1) {

const item = items[index]!;

const item = items[index];

if (isFollowupRunAborted(item)) {

await runFollowup(item);

completeFollowupRunLifecycle(item);

sessionKey?: string;

accountId?: string;

messageProvider?: string;

inboundTurnKind?: string;

senderIsOwner?: boolean;

surface?: string;

excludeToolNames?: Iterable<string>;