-> messages.send for final delivery

```

The old `channel.turn` runtime surface remains a deprecated alias only. New code

uses inbound/message nouns.

The old `channel.turn` runtime surface was removed. Runtime callers use

`channel.inbound.*`; channel docs and SDK subpaths use inbound/message nouns.

## Compatibility guardrails

## Migration

- `runtime.channel.turn.run(...)` -> `runtime.channel.inbound.run(...)`

- `runtime.channel.turn.runPrepared(...)` ->

`runtime.channel.inbound.runPreparedReply(...)`

- `runtime.channel.turn.runAssembled(...)` ->

`runtime.channel.inbound.dispatchReply(...)`

- `runtime.channel.turn.buildContext(...)` ->

`runtime.channel.inbound.buildContext(...)`

The old `runtime.channel.turn.*` runtime aliases were removed. Use:

- `runtime.channel.inbound.run(...)` for raw inbound events.

- `runtime.channel.inbound.dispatchReply(...)` for assembled reply contexts.

- `runtime.channel.inbound.buildContext(...)` for inbound context payloads.

- `runtime.channel.inbound.runPreparedReply(...)` only for channel-owned prepared

dispatch paths that already assemble their own dispatch closure.

New plugin code should not introduce `turn`-named channel APIs. Keep model or

agent turn vocabulary inside agent/provider code; channel plugins use inbound,

message, delivery, and reply terms.

The `runtime.channel.turn.*` aliases remain only as deprecated compatibility

for already published plugins. They can be removed in the next major SDK cleanup

after external plugins have had a migration window.

This page moved to [Channel inbound API](/plugins/sdk-channel-inbound).

The old channel-turn runtime names remain deprecated compatibility only. New

plugin code should use `runtime.channel.inbound.*`, `channel-inbound`, and

`channel-outbound`; the aliases can be removed in the next major SDK cleanup

after external plugin migration.

The old channel-turn runtime aliases were removed. Plugin code should use

`runtime.channel.inbound.*`, `channel-inbound`, and `channel-outbound`.

`channel-outbound`, then remove the compatibility subpaths in the next major

SDK cleanup. This applies to the old channel message/runtime, channel

streaming, direct-DM access, inbound helper splinter, reply-options,

pairing-path, and runtime `channel.turn.*` families.

and pairing-path families.

<Accordion title="Provider subpaths">

| Subpath | Key exports |

PreparedChannelTurn,

PreflightFacts,

RunChannelTurnParams,

RunResolvedChannelTurnParams,

} from "./types.js";

export { createChannelDeliveryResultFromReceipt } from "./delivery-result.js";

export {

ReplyPlanFacts,

RouteFacts,

RunChannelTurnParams,

RunResolvedChannelTurnParams,

SenderFacts,

SupplementalContextFacts,

} from "./types.js";

}

export const runChannelInboundEvent = runChannelTurn;

export async function runResolvedChannelTurn<

TRaw,

TDispatchResult = DispatchedChannelTurnResult["dispatchResult"],

>(

params: RunResolvedChannelTurnParams<TRaw, TDispatchResult>,

): Promise<ChannelTurnResult<TDispatchResult>> {

return await runChannelTurn({

channel: params.channel,

accountId: params.accountId,

raw: params.raw,

log: params.log,

adapter: {

ingest: (raw) => (typeof params.input === "function" ? params.input(raw) : params.input),

resolveTurn: params.resolveTurn,

},

});

}

adapter: ChannelTurnAdapter<TRaw, TDispatchResult>;

log?: (event: ChannelTurnLogEvent) => void;

};

export type RunResolvedChannelTurnParams<TRaw, TDispatchResult = DispatchFromConfigResult> = {

channel: string;

accountId?: string;

raw: TRaw;

input:

| NormalizedTurnInput

| ((raw: TRaw) => Promise<NormalizedTurnInput | null> | NormalizedTurnInput | null);

resolveTurn: (

input: NormalizedTurnInput,

eventClass: ChannelEventClass,

preflight: PreflightFacts,

) => Promise<ChannelTurnResolved<TDispatchResult>> | ChannelTurnResolved<TDispatchResult>;

log?: (event: ChannelTurnLogEvent) => void;

};

expect(vi.isMockFunction(debouncer.cancelKey)).toBe(true);

});

it("keeps deprecated turn runtime aliases aligned with inbound mocks", async () => {

it("exposes channel inbound helpers without the removed turn aliases", async () => {

const runtime = createPluginRuntimeMock();

const channel = "test";

expect(runtime.channel.turn.run).toBe(runtime.channel.inbound.run);

expect(runtime.channel.turn.runAssembled).toBe(runtime.channel.inbound.dispatchReply);

expect(runtime.channel.turn.buildContext).toBe(runtime.channel.inbound.buildContext);

expect(runtime.channel.turn.runPrepared).toBe(runtime.channel.inbound.runPreparedReply);

expect(runtime.channel.turn.dispatchAssembled).toBe(runtime.channel.inbound.dispatchReply);

expect("turn" in runtime.channel).toBe(false);

const input = vi.fn((raw: { id: string }) => ({

id: raw.id,

runDispatch,

}));

const result = await runtime.channel.turn.runResolved({

const result = await runtime.channel.inbound.run({

channel,

raw: { id: "m1" },

input,

resolveTurn,

adapter: {

ingest: input,

resolveTurn,

},

});

expect(input).toHaveBeenCalledWith({ id: "m1" });

it("routes untrusted group prompt facts into untrusted structured context", () => {

const runtime = createPluginRuntimeMock();

const ctx = runtime.channel.turn.buildContext({

const ctx = runtime.channel.inbound.buildContext({

channel: "test",

from: "test:user:u1",

sender: { id: "u1" },

buildContext: buildChannelInboundEventContextMock,

runPreparedReply: runPreparedChannelTurnMock,

},

turn: {

run: runChannelTurnMock,

runAssembled:

dispatchAssembledChannelTurnMock as unknown as PluginRuntime["channel"]["turn"]["runAssembled"],

runResolved: vi.fn(

async (params: Parameters<PluginRuntime["channel"]["turn"]["runResolved"]>[0]) =>

await runChannelTurnMock({

channel: params.channel,

accountId: params.accountId,

raw: params.raw,

log: params.log,

adapter: {

ingest: (raw) =>

typeof params.input === "function" ? params.input(raw) : params.input,

resolveTurn: params.resolveTurn,

},

}),

) as unknown as PluginRuntime["channel"]["turn"]["runResolved"],

buildContext: buildChannelInboundEventContextMock,

runPrepared: runPreparedChannelTurnMock,

dispatchAssembled:

dispatchAssembledChannelTurnMock as unknown as PluginRuntime["channel"]["turn"]["dispatchAssembled"],

},

threadBindings: {

setIdleTimeoutBySessionKey:

vi.fn() as unknown as PluginRuntime["channel"]["threadBindings"]["setIdleTimeoutBySessionKey"],

dispatchChannelInboundReply,

runChannelInboundEvent,

runPreparedInboundReply,

runResolvedChannelTurn,

} from "../../channels/turn/kernel.js";

import {

resolveChannelGroupPolicy,

runPreparedReply: runPreparedInboundReply,

dispatchReply: dispatchChannelInboundReply,

},

turn: {

run: runChannelInboundEvent,

runAssembled: dispatchChannelInboundReply,

runResolved: runResolvedChannelTurn,

buildContext: buildChannelInboundEventContext,

runPrepared: runPreparedInboundReply,

dispatchAssembled: dispatchChannelInboundReply,

},

threadBindings: {

setIdleTimeoutBySessionKey: ({ channelId, targetSessionKey, accountId, idleTimeoutMs }) =>

setChannelConversationBindingIdleTimeoutBySessionKey({

runPreparedReply: typeof import("../../channels/turn/kernel.js").runPreparedInboundReply;

dispatchReply: typeof import("../../channels/turn/kernel.js").dispatchChannelInboundReply;

};

/** @deprecated Use `inbound`. */

turn: {

run: typeof import("../../channels/turn/kernel.js").runChannelInboundEvent;

runAssembled: typeof import("../../channels/turn/kernel.js").dispatchChannelInboundReply;

/** @deprecated Prefer `inbound.run(...)`. */

runResolved: typeof import("../../channels/turn/kernel.js").runResolvedChannelTurn;

buildContext: typeof import("../../channels/inbound-event/context.js").buildChannelInboundEventContext;

runPrepared: typeof import("../../channels/turn/kernel.js").runPreparedInboundReply;

/** @deprecated Prefer `inbound.dispatchReply(...)`. */

dispatchAssembled: typeof import("../../channels/turn/kernel.js").dispatchChannelInboundReply;

};

threadBindings: {

setIdleTimeoutBySessionKey: (params: {

channelId: string;