@cognidesk/http 0.0.3-dev.3 → 0.0.3-dev.6

package/dist/index.js

@@ -1,3 +1,6 @@
+// src/handler/index.ts
+import { defineChannelContext as defineChannelContext3 } from "@cognidesk/core";
+
 // src/responses.ts
 var HttpInputError = class extends Error {
   status = 400;
@@ -25,14 +28,75 @@ function emptyResponse(status, options) {
   });
 }
 function withCors(headers, options) {
-  if (!options.cors) return headers;
+  const corsHeaders = getCorsHeaders(options);
+  if (Object.keys(corsHeaders).length === 0) return headers;
+  return mergeHeaderRecords(headers, corsHeaders);
+}
+function responseWithCors(response, options) {
+  const corsHeaders = getCorsHeaders(options);
+  if (Object.keys(corsHeaders).length === 0) return response;
+  const headers = new Headers(response.headers);
+  for (const [key, value] of Object.entries(corsHeaders)) {
+    if (key === "vary") {
+      headers.set("vary", mergeVary(headers.get("vary"), value));
+    } else if (!headers.has(key)) {
+      headers.set(key, value);
+    }
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function getCorsHeaders(options) {
+  const cors = options.cors;
+  if (!cors) return {};
+  if (cors === true) {
+    return {
+      "access-control-allow-origin": "*",
+      "access-control-allow-methods": "GET,POST,OPTIONS",
+      "access-control-allow-headers": "content-type,authorization"
+    };
+  }
+  const origin = options.request?.headers.get("origin");
+  if (!origin || !isAllowedOrigin(cors, origin)) return {};
   return {
-    ...headers,
-    "access-control-allow-origin": "*",
-    "access-control-allow-methods": "GET,POST,OPTIONS",
-    "access-control-allow-headers": "content-type,authorization"
+    "access-control-allow-origin": origin,
+    "access-control-allow-methods": formatHeaderList(cors.methods, "GET,POST,OPTIONS"),
+    "access-control-allow-headers": formatHeaderList(cors.allowedHeaders, "content-type,authorization"),
+    ...cors.exposedHeaders ? { "access-control-expose-headers": formatHeaderList(cors.exposedHeaders, "") } : {},
+    ...cors.credentials ? { "access-control-allow-credentials": "true" } : {},
+    ...cors.maxAgeSeconds !== void 0 ? { "access-control-max-age": String(cors.maxAgeSeconds) } : {},
+    vary: "Origin"
   };
 }
+function isAllowedOrigin(cors, origin) {
+  const origins = Array.isArray(cors.origins) ? cors.origins : [cors.origins];
+  return origins.includes(origin);
+}
+function formatHeaderList(value, fallback) {
+  if (value === void 0) return fallback;
+  return typeof value === "string" ? value : value.join(",");
+}
+function mergeHeaderRecords(headers, corsHeaders) {
+  const merged = { ...headers };
+  for (const [key, value] of Object.entries(corsHeaders)) {
+    if (key === "vary") {
+      merged.vary = mergeVary(merged.vary, value);
+    } else if (merged[key] === void 0) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function mergeVary(existing, value) {
+  if (!existing) return value;
+  const existingValues = existing.split(",").map((entry) => entry.trim()).filter(Boolean);
+  const normalizedValue = value.toLowerCase();
+  if (existingValues.some((entry) => entry.toLowerCase() === normalizedValue)) return existing;
+  return `${existing}, ${value}`;
+}
 
 // src/path.ts
 function normalizeBasePath(basePath) {
@@ -119,36 +183,617 @@ function formatSseError(error) {
   ].join("\n");
 }
 
-// src/handler.ts
+// src/handler/auth.ts
+async function authorizeRequest(options, input, responseOptions) {
+  if (!options.authorize) return void 0;
+  const result = await options.authorize(input);
+  if (result === true) return void 0;
+  if (result instanceof Response) return responseWithCors(result, responseOptions);
+  return json({ error: "Unauthorized" }, 401, responseOptions);
+}
+
+// src/handler/channel-events.ts
+import {
+  defineChannelContext as defineChannelContext2,
+  defineChannelEvent
+} from "@cognidesk/core";
+
+// src/channel-events.ts
+function createChannelEventInput(input) {
+  if (!isRecord(input)) throw new Error("Channel Event input must be an object.");
+  const eventRecord = isRecord(input.event) ? input.event : void 0;
+  const sourceRecord = eventRecord ?? input;
+  const kind = stringValue(sourceRecord.kind ?? sourceRecord.nature) ?? inferKind(sourceRecord, input);
+  if (!kind) throw new Error("Channel Event kind or nature is required.");
+  const direction = stringValue(sourceRecord.direction ?? input.direction) ?? inferDirection(kind);
+  const channel = sourceRecord.channel ?? input.channel;
+  if (channel === void 0) throw new Error("Channel Event channel is required.");
+  const text = firstText(sourceRecord, input);
+  const turn = firstDefined(sourceRecord.turn, input.turn);
+  const payload = buildPayload(sourceRecord, input, text, turn);
+  const source = buildSource(sourceRecord, input, inferSourceType(kind));
+  const identity = buildIdentity(sourceRecord, input);
+  const actor = normalizeActor(firstDefined(sourceRecord.actor, input.actor)) ?? inferActor(kind, direction);
+  const handling = buildHandling(input, text, turn);
+  const event = compact({
+    ...passthroughEventFields(eventRecord),
+    id: stringValue(sourceRecord.id ?? input.id),
+    channel,
+    kind,
+    nature: stringValue(sourceRecord.nature ?? input.nature) ?? kind,
+    direction,
+    intent: stringValue(sourceRecord.intent ?? input.intent) ?? inferIntent(kind, direction),
+    actor,
+    occurredAt: stringValue(sourceRecord.occurredAt ?? input.occurredAt),
+    payload,
+    identity,
+    source,
+    metadata: recordValue(sourceRecord.metadata ?? input.metadata)
+  });
+  return compact({
+    event,
+    conversationId: stringValue(input.conversationId ?? sourceRecord.conversationId),
+    agentId: stringValue(input.agentId ?? sourceRecord.agentId),
+    conversationContext: input.conversationContext,
+    createConversation: input.createConversation,
+    binding: input.binding,
+    handling,
+    app: input.app,
+    signal: input.signal,
+    onAssistantTextDelta: input.onAssistantTextDelta
+  });
+}
+function createChannelEventRequestBody(input) {
+  const { signal: _signal, onAssistantTextDelta: _onAssistantTextDelta, ...body } = createChannelEventInput(input);
+  return body;
+}
+function createMessageChannelEventInput(input) {
+  const direction = input.direction ?? "inbound";
+  return createChannelEventInput({
+    ...input,
+    kind: input.kind ?? "message",
+    nature: input.nature ?? input.kind ?? "message",
+    direction,
+    intent: input.intent ?? (direction === "outbound" ? "agent-message" : "customer-message"),
+    actor: input.actor ?? (direction === "outbound" ? "agent" : "customer")
+  });
+}
+function createProviderObjectChannelEventInput(input) {
+  return createChannelEventInput({
+    ...input,
+    kind: input.kind ?? "provider.object.updated",
+    nature: input.nature ?? input.kind ?? "provider.object.updated",
+    direction: input.direction ?? "internal",
+    intent: input.intent ?? "provider-update",
+    actor: input.actor ?? "provider",
+    sourceType: input.sourceType ?? input.source?.sourceType ?? "provider-adapter"
+  });
+}
+function createVoiceTurnChannelEventInput(input) {
+  const text = input.text ?? input.transcript;
+  return createChannelEventInput({
+    ...input,
+    channel: input.channel ?? "voice",
+    ...text !== void 0 ? { text } : {},
+    kind: input.kind ?? "voice.turn.finalized",
+    nature: input.nature ?? input.kind ?? "voice.turn.finalized",
+    direction: input.direction ?? "inbound",
+    intent: input.intent ?? "customer-voice-turn",
+    actor: input.actor ?? "customer",
+    sourceType: input.sourceType ?? input.source?.sourceType ?? "provider-adapter"
+  });
+}
+function createOutboundContactChannelEventInput(input) {
+  return createChannelEventInput({
+    ...input,
+    kind: input.kind ?? "outbound.contact.requested",
+    nature: input.nature ?? input.kind ?? "outbound.contact.requested",
+    direction: input.direction ?? "outbound",
+    intent: input.intent ?? "outbound-contact",
+    actor: input.actor ?? "application"
+  });
+}
+function createScheduledChannelEventInput(input) {
+  return createChannelEventInput({
+    ...input,
+    kind: input.kind ?? "schedule.due",
+    nature: input.nature ?? input.kind ?? "schedule.due",
+    direction: input.direction ?? "internal",
+    intent: input.intent ?? "scheduled-support-action",
+    actor: input.actor ?? "scheduler",
+    sourceType: input.sourceType ?? input.source?.sourceType ?? "schedule-adapter"
+  });
+}
+function createChannelOutputResolutionEventInput(input) {
+  return createChannelEventInput({
+    ...input,
+    kind: input.kind ?? "output.resolution",
+    nature: input.nature ?? input.kind ?? "output.resolution",
+    direction: input.direction ?? "outbound",
+    intent: input.intent ?? "output-resolution",
+    actor: input.actor ?? "application",
+    handling: {
+      ...input.handling,
+      disposition: input.handling?.disposition ?? "output-resolution"
+    }
+  });
+}
+function createChannelHandoffEventInput(input) {
+  const payload = buildPayload(input, input, void 0, input.turn);
+  return createChannelEventInput({
+    ...input,
+    payload: {
+      ...isRecord(payload) ? payload : {},
+      ...input.fromChannel ? { fromChannel: input.fromChannel } : {},
+      toChannel: input.channel,
+      ...input.reason ? { reason: input.reason } : {},
+      ...input.reasonCode ? { reasonCode: input.reasonCode } : {},
+      ...input.reasonLabel ? { reasonLabel: input.reasonLabel } : {}
+    },
+    kind: input.kind ?? "channel.handoff.requested",
+    nature: input.nature ?? input.kind ?? "channel.handoff.requested",
+    direction: input.direction ?? "internal",
+    intent: input.intent ?? "channel-handoff",
+    actor: input.actor ?? "application",
+    handling: {
+      ...input.handling,
+      disposition: input.handling?.disposition ?? "handoff-review"
+    }
+  });
+}
+function createChannelHandoffReviewEventInput(input) {
+  return createChannelEventInput({
+    ...input,
+    kind: input.kind ?? "custom",
+    nature: input.nature ?? input.kind ?? "custom",
+    direction: input.direction ?? "internal",
+    intent: input.intent ?? "handoff-review",
+    actor: input.actor ?? "operator",
+    handling: {
+      ...input.handling,
+      disposition: input.handling?.disposition ?? "handoff-review"
+    }
+  });
+}
+function buildHandling(input, _text, turn) {
+  if (!input.handling && turn === void 0) return void 0;
+  return compact({
+    ...input.handling ?? {},
+    text: input.handling?.text ?? void 0,
+    turn: input.handling?.turn ?? turn
+  });
+}
+function buildPayload(sourceRecord, input, text, turn) {
+  const seed = firstDefined(sourceRecord.payload, input.payload);
+  const fields = compact({
+    text,
+    subject: stringValue(sourceRecord.subject ?? input.subject),
+    body: stringValue(sourceRecord.body ?? input.body),
+    summary: stringValue(sourceRecord.summary ?? input.summary),
+    attachments: firstDefined(sourceRecord.attachments, input.attachments),
+    providerObject: firstDefined(sourceRecord.providerObject, input.providerObject),
+    status: stringValue(sourceRecord.status ?? input.status),
+    turn
+  });
+  if (seed === void 0) return Object.keys(fields).length > 0 ? fields : void 0;
+  if (typeof seed === "string") return Object.keys(fields).length > 0 ? { ...fields, text: fields.text ?? seed } : { text: seed };
+  if (!isRecord(seed)) return Object.keys(fields).length > 0 ? { value: seed, ...fields } : seed;
+  return { ...fields, ...seed };
+}
+function buildSource(sourceRecord, input, defaultSourceType) {
+  const seed = recordValue(sourceRecord.source ?? input.source) ?? {};
+  const hasEvidence = hasSourceEvidence(sourceRecord, input, seed);
+  const source = compact({
+    ...seed,
+    sourceType: stringValue(sourceRecord.sourceType ?? input.sourceType) ?? seed.sourceType ?? (hasEvidence ? defaultSourceType : void 0),
+    sourceId: stringValue(sourceRecord.sourceId ?? input.sourceId) ?? seed.sourceId,
+    provider: stringValue(sourceRecord.provider ?? input.provider) ?? seed.provider,
+    providerPackageId: stringValue(sourceRecord.providerPackageId ?? input.providerPackageId) ?? seed.providerPackageId,
+    eventId: stringValue(sourceRecord.eventId ?? input.eventId) ?? seed.eventId,
+    streamId: stringValue(sourceRecord.streamId ?? input.streamId) ?? seed.streamId,
+    deliveryId: stringValue(sourceRecord.deliveryId ?? input.deliveryId) ?? seed.deliveryId,
+    receivedAt: stringValue(sourceRecord.receivedAt ?? input.receivedAt) ?? seed.receivedAt,
+    verified: booleanValue(sourceRecord.verified ?? input.verified) ?? seed.verified,
+    externalObjectIds: recordValue(sourceRecord.externalObjectIds ?? input.externalObjectIds) ?? seed.externalObjectIds,
+    raw: firstDefined(sourceRecord.raw, input.raw, seed.raw)
+  });
+  return Object.keys(source).length > 0 ? source : void 0;
+}
+function buildIdentity(sourceRecord, input) {
+  const seed = recordValue(sourceRecord.identity ?? input.identity) ?? {};
+  const identity = compact({
+    ...seed,
+    key: stringValue(sourceRecord.identityKey ?? input.identityKey) ?? seed.key,
+    dedupeKey: stringValue(sourceRecord.dedupeKey ?? input.dedupeKey) ?? seed.dedupeKey,
+    streamId: stringValue(sourceRecord.identityStreamId ?? input.identityStreamId) ?? seed.streamId,
+    sequence: sequenceValue(sourceRecord.sequence ?? input.sequence) ?? seed.sequence,
+    idempotencyKey: stringValue(sourceRecord.idempotencyKey ?? input.idempotencyKey) ?? seed.idempotencyKey,
+    metadata: recordValue(sourceRecord.identityMetadata ?? input.identityMetadata) ?? seed.metadata
+  });
+  return Object.keys(identity).length > 0 ? identity : void 0;
+}
+function passthroughEventFields(eventRecord) {
+  if (!eventRecord) return {};
+  const output = { ...eventRecord };
+  for (const key of [
+    "conversationId",
+    "agentId",
+    "text",
+    "message",
+    "subject",
+    "body",
+    "summary",
+    "attachments",
+    "providerObject",
+    "status",
+    "turn",
+    "raw",
+    "sourceType",
+    "sourceId",
+    "provider",
+    "providerPackageId",
+    "eventId",
+    "streamId",
+    "deliveryId",
+    "receivedAt",
+    "verified",
+    "externalObjectIds",
+    "identity",
+    "identityKey",
+    "dedupeKey",
+    "idempotencyKey",
+    "identityStreamId",
+    "sequence",
+    "identityMetadata"
+  ]) {
+    delete output[key];
+  }
+  return output;
+}
+function firstText(sourceRecord, input) {
+  const explicit = stringValue(sourceRecord.text ?? sourceRecord.message ?? input.text ?? input.message);
+  if (explicit) return explicit;
+  const payload = firstDefined(sourceRecord.payload, input.payload);
+  if (typeof payload === "string") return payload.trim() || void 0;
+  if (isRecord(payload)) return stringValue(payload.text ?? payload.message);
+  return void 0;
+}
+function inferKind(sourceRecord, input) {
+  if (firstText(sourceRecord, input)) return "message";
+  if (sourceRecord.providerObject !== void 0 || input.providerObject !== void 0 || sourceRecord.status !== void 0 || input.status !== void 0) return "provider.object.updated";
+  return void 0;
+}
+function inferDirection(kind) {
+  if (kind === "provider.object.updated" || kind === "schedule.due" || kind === "custom") return "internal";
+  if (kind === "outbound.contact.requested" || kind === "output.resolution") return "outbound";
+  return "inbound";
+}
+function inferIntent(kind, direction) {
+  if (kind === "message") return direction === "outbound" ? "agent-message" : "customer-message";
+  if (kind === "voice.turn.finalized") return "customer-voice-turn";
+  if (kind === "provider.object.updated") return "provider-update";
+  if (kind === "operator.resume") return "operator-resume";
+  if (kind === "outbound.contact.requested") return "outbound-contact";
+  if (kind === "channel.handoff.requested") return "channel-handoff";
+  if (kind === "schedule.due") return "scheduled-support-action";
+  if (kind === "output.resolution") return "output-resolution";
+  if (kind === "delivery.updated") return "delivery-update";
+  return void 0;
+}
+function inferActor(kind, direction) {
+  if (kind === "message") return { type: direction === "outbound" ? "agent" : "customer" };
+  if (kind === "voice.turn.finalized") return { type: "customer" };
+  if (kind === "provider.object.updated" || kind === "delivery.updated") return { type: "provider" };
+  if (kind === "schedule.due") return { type: "scheduler" };
+  if (kind === "channel.handoff.requested") return { type: "application" };
+  if (kind === "outbound.contact.requested" || kind === "output.resolution") return { type: "application" };
+  if (kind === "operator.resume") return { type: "operator" };
+  return void 0;
+}
+function inferSourceType(kind) {
+  if (kind === "schedule.due") return "schedule-adapter";
+  if (kind === "message" || kind === "voice.session.started" || kind === "voice.turn.finalized" || kind === "provider.object.updated" || kind === "delivery.updated") return "provider-adapter";
+  return void 0;
+}
+function hasSourceEvidence(sourceRecord, input, seed) {
+  return Object.keys(seed).length > 0 || sourceRecord.provider !== void 0 || input.provider !== void 0 || sourceRecord.providerPackageId !== void 0 || input.providerPackageId !== void 0 || sourceRecord.eventId !== void 0 || input.eventId !== void 0 || sourceRecord.streamId !== void 0 || input.streamId !== void 0 || sourceRecord.deliveryId !== void 0 || input.deliveryId !== void 0 || sourceRecord.raw !== void 0 || input.raw !== void 0;
+}
+function normalizeActor(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return { type: value };
+  if (isRecord(value)) return value;
+  return void 0;
+}
+function compact(record) {
+  const output = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (value !== void 0) output[key] = value;
+  }
+  return output;
+}
+function firstDefined(...values) {
+  for (const value of values) {
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+function stringValue(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function booleanValue(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function sequenceValue(value) {
+  return typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+function recordValue(value) {
+  return isRecord(value) ? value : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/handler/body.ts
+async function readObject(request) {
+  const body = await readJson(request);
+  if (!isRecord2(body)) throw new HttpInputError("Request body must be a JSON object.");
+  return body;
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/handler/optional.ts
+import { defineChannelContext } from "@cognidesk/core";
+function optionalString(body, key) {
+  const value = body[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new HttpInputError(`${key} must be a string.`);
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function optionalStringProperty(body, key) {
+  const value = optionalString(body, key);
+  return value ? { [key]: value } : {};
+}
+function optionalChannel(body, key) {
+  const value = body[key];
+  if (value === void 0 || value === null) return void 0;
+  try {
+    return defineChannelContext(value);
+  } catch {
+    throw new HttpInputError(`${key} must be a valid conversation channel.`);
+  }
+}
+function optionalChannelProperty(body) {
+  const channel = optionalChannel(body, "channel");
+  return channel ? { channel } : {};
+}
+function optionalNonNegativeNumber(body, key) {
+  const value = body[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new HttpInputError(`${key} must be a non-negative integer.`);
+  }
+  return value;
+}
+function optionalRouting(body, key) {
+  const value = optionalString(body, key);
+  if (!value) return void 0;
+  if (value !== "none" && value !== "activeJourneyOnly" && value !== "full" && value !== "targeted") {
+    throw new HttpInputError(`${key} must be a valid routing mode.`);
+  }
+  return value;
+}
+function optionalTarget(body, key) {
+  const value = body[key];
+  if (value === void 0 || value === null) return void 0;
+  if (!isRecord2(value)) throw new HttpInputError(`${key} must be an object.`);
+  const journeyId = optionalString(value, "journeyId");
+  const stateId = optionalString(value, "stateId");
+  return {
+    ...journeyId ? { journeyId } : {},
+    ...stateId ? { stateId } : {}
+  };
+}
+function optionalVoiceClient(body) {
+  const value = body.client;
+  if (value === void 0 || value === null) return {};
+  if (!isRecord2(value)) throw new HttpInputError("client must be an object.");
+  const userAgent = optionalString(value, "userAgent");
+  const locale = optionalString(value, "locale");
+  const metadata = value.metadata;
+  if (metadata !== void 0 && metadata !== null && !isRecord2(metadata)) {
+    throw new HttpInputError("client.metadata must be an object.");
+  }
+  return {
+    client: {
+      ...userAgent ? { userAgent } : {},
+      ...locale ? { locale } : {},
+      ...isRecord2(metadata) ? { metadata } : {}
+    }
+  };
+}
+
+// src/handler/channel-events.ts
+async function handleChannelEvent(options, input, responseOptions) {
+  if (hasHandleChannelEvent(options.runtime)) {
+    return options.runtime.handleChannelEvent(input);
+  }
+  const userMessageInput = channelEventToUserMessageInput(input);
+  if (!userMessageInput) {
+    return json({ error: "Channel events are not supported by this runtime" }, 501, responseOptions);
+  }
+  const result = await options.runtime.handleUserMessage(userMessageInput);
+  return channelEventResultFromUserMessageResult(input, result);
+}
+function hasHandleChannelEvent(runtime) {
+  return typeof runtime.handleChannelEvent === "function";
+}
+function readChannelEventInput(body, signal) {
+  try {
+    return createChannelEventInput({ ...body, signal });
+  } catch (error) {
+    throw new HttpInputError(error instanceof Error ? error.message : "Invalid Channel Event input.");
+  }
+}
+function channelEventToUserMessageInput(input) {
+  const event = input.event;
+  if (!isInboundMessageEvent(event)) return null;
+  const conversationId = input.conversationId ?? input.binding?.conversationId;
+  if (!conversationId) return null;
+  const text = input.handling?.text ?? textFromChannelEventPayload(event.payload);
+  if (!text) return null;
+  const turn = turnFromChannelEventPayload(event.payload);
+  return {
+    conversationId,
+    text,
+    channel: defineChannelContext2(event.channel),
+    ...input.handling?.turn !== void 0 ? { turn: input.handling.turn } : turn !== void 0 ? { turn } : {},
+    ...input.app !== void 0 ? { app: input.app } : {},
+    ...input.signal ? { signal: input.signal } : {}
+  };
+}
+function isInboundMessageEvent(event) {
+  const inbound = event.direction === void 0 || event.direction === "inbound";
+  return inbound && (event.nature === "message" || event.kind === "message" || event.intent === "customer-message");
+}
+function textFromChannelEventPayload(payload) {
+  if (typeof payload === "string") return payload.trim() || void 0;
+  if (!isRecord2(payload)) return void 0;
+  return optionalString(payload, "text") ?? optionalString(payload, "message");
+}
+function turnFromChannelEventPayload(payload) {
+  if (!isRecord2(payload)) return void 0;
+  return payload.turn;
+}
+function channelEventResultFromUserMessageResult(input, result) {
+  const channelEvent = defineChannelEvent(input.event);
+  return {
+    channelEvent,
+    intake: {
+      outcome: "accepted",
+      bindingOutcome: input.binding?.outcome ?? "resume-existing",
+      conversationId: result.conversation.id,
+      handling: "started"
+    },
+    conversation: result.conversation,
+    turn: result,
+    snapshot: result.snapshot,
+    events: result.events,
+    text: result.text,
+    ...result.activeJourneyId ? { activeJourneyId: result.activeJourneyId } : {},
+    disposition: "model-turn"
+  };
+}
+function sendMessageResultFromChannelEvent(result) {
+  return {
+    text: result.turn?.text ?? result.text ?? textFromEvents(result.events) ?? "",
+    events: result.events,
+    ...result.turn?.activeJourneyId ?? result.activeJourneyId ? { activeJourneyId: result.turn?.activeJourneyId ?? result.activeJourneyId } : {}
+  };
+}
+function textFromEvents(events) {
+  for (const event of [...events].reverse()) {
+    if (event.type === "message.completed" && typeof event.data.text === "string") {
+      return event.data.text;
+    }
+  }
+  return void 0;
+}
+
+// src/handler/channel-output.ts
+function hasResolveChannelOutput(runtime) {
+  return typeof runtime.resolveChannelOutput === "function";
+}
+function readChannelOutputResolutionInput(body, signal) {
+  const record = body;
+  const conversationId = optionalString(record, "conversationId");
+  if (!conversationId) throw new HttpInputError("conversationId is required");
+  if (!isRecord2(record.intent)) throw new HttpInputError("intent is required");
+  const input = {
+    conversationId,
+    intent: record.intent,
+    signal
+  };
+  if (record.resolution !== void 0) {
+    input.resolution = record.resolution;
+  }
+  if (record.app !== void 0) {
+    input.app = record.app;
+  }
+  return input;
+}
+
+// src/handler/errors.ts
+function internalErrorMessage(error, options) {
+  if (!options.exposeInternalErrors) return "Internal server error";
+  return error instanceof Error ? error.message : "Unknown error";
+}
+
+// src/handler/voice.ts
+function withVoiceEventsUrl(result, basePath) {
+  return {
+    ...result,
+    eventsUrl: `${basePath}/conversations/${encodeURIComponent(result.conversation.id)}/events/stream`
+  };
+}
+
+// src/handler/index.ts
 function createCognideskHttpHandler(options) {
   const basePath = normalizeBasePath(options.basePath ?? "");
   const pollIntervalMs = options.ssePollIntervalMs ?? 500;
   return {
     async handle(request) {
-      if (request.method === "OPTIONS" && options.cors) {
-        return emptyResponse(204, options);
-      }
+      const responseOptions = {
+        request,
+        ...options.cors !== void 0 ? { cors: options.cors } : {}
+      };
       try {
         const url = new URL(request.url);
         const path = stripBasePath(url.pathname, basePath);
-        if (path === null) return json({ error: "Not found" }, 404, options);
+        if (path === null) return json({ error: "Not found" }, 404, responseOptions);
+        if (request.method === "OPTIONS" && options.cors) {
+          return emptyResponse(204, responseOptions);
+        }
+        const authorizationResponse = await authorizeRequest(options, { request, url, path }, responseOptions);
+        if (authorizationResponse) return authorizationResponse;
         if (request.method === "POST" && path === "/conversations") {
           const body = await readObject(request);
           const agentId = optionalString(body, "agentId") ?? options.agentId;
-          if (!agentId) return json({ error: "agentId is required" }, 400, options);
+          if (!agentId) return json({ error: "agentId is required" }, 400, responseOptions);
           const conversation = await options.runtime.createConversation({
             ...optionalStringProperty(body, "id"),
             agentId,
+            ...optionalChannelProperty(body),
             context: body.context ?? {}
           });
-          return json({ conversation }, 201, options);
+          return json({ conversation }, 201, responseOptions);
+        }
+        if (request.method === "POST" && path === "/channel-events") {
+          const body = await readObject(request);
+          const input = readChannelEventInput(body, request.signal);
+          const result = await handleChannelEvent(options, input, responseOptions);
+          if (result instanceof Response) return result;
+          return json(result, 200, responseOptions);
+        }
+        if (request.method === "POST" && path === "/channel-outputs/resolve") {
+          if (!hasResolveChannelOutput(options.runtime)) {
+            return json({ error: "Channel Output resolution is not supported by this runtime" }, 501, responseOptions);
+          }
+          const body = await readObject(request);
+          const input = readChannelOutputResolutionInput(body, request.signal);
+          const result = await options.runtime.resolveChannelOutput(input);
+          return json(result, 200, responseOptions);
         }
         if (request.method === "POST" && path === "/voice/conversations") {
-          if (!options.runtime.startVoiceConversation) return json({ error: "Voice conversations are not supported by this runtime" }, 501, options);
-          if (!options.voice?.createSocket) return json({ error: "Voice socket handshakes are not configured" }, 501, options);
+          if (!options.runtime.startVoiceConversation) return json({ error: "Voice conversations are not supported by this runtime" }, 501, responseOptions);
+          if (!options.voice?.createSocket) return json({ error: "Voice socket handshakes are not configured" }, 501, responseOptions);
           const body = await readObject(request);
           const agentId = optionalString(body, "agentId") ?? options.agentId;
-          if (!agentId) return json({ error: "agentId is required" }, 400, options);
+          if (!agentId) return json({ error: "agentId is required" }, 400, responseOptions);
           const result = await options.runtime.startVoiceConversation({
             ...optionalStringProperty(body, "id"),
             agentId,
@@ -157,12 +802,12 @@ function createCognideskHttpHandler(options) {
             ...body.app !== void 0 ? { app: body.app } : {}
           });
           const socket = await options.voice.createSocket({ result, request, basePath });
-          return json(withVoiceEventsUrl({ ...result, socket }, basePath), 201, options);
+          return json(withVoiceEventsUrl({ ...result, socket }, basePath), 201, responseOptions);
         }
         const voiceSegmentMatch = path.match(/^\/conversations\/([^/]+)\/voice-segments$/);
         if (request.method === "POST" && voiceSegmentMatch) {
-          if (!options.runtime.startVoiceSegment) return json({ error: "Voice segments are not supported by this runtime" }, 501, options);
-          if (!options.voice?.createSocket) return json({ error: "Voice socket handshakes are not configured" }, 501, options);
+          if (!options.runtime.startVoiceSegment) return json({ error: "Voice segments are not supported by this runtime" }, 501, responseOptions);
+          if (!options.voice?.createSocket) return json({ error: "Voice socket handshakes are not configured" }, 501, responseOptions);
           const conversationId = decodeURIComponent(voiceSegmentMatch[1] ?? "");
           const body = await readObject(request);
           const result = await options.runtime.startVoiceSegment({
@@ -171,45 +816,68 @@ function createCognideskHttpHandler(options) {
             ...body.app !== void 0 ? { app: body.app } : {}
           });
           const socket = await options.voice.createSocket({ result, request, basePath });
-          return json(withVoiceEventsUrl({ ...result, socket }, basePath), 200, options);
+          return json(withVoiceEventsUrl({ ...result, socket }, basePath), 200, responseOptions);
         }
         const messageMatch = path.match(/^\/conversations\/([^/]+)\/messages$/);
         if (request.method === "POST" && messageMatch) {
           const conversationId = decodeURIComponent(messageMatch[1] ?? "");
           const body = await readObject(request);
           const text = optionalString(body, "text") ?? optionalString(body, "message");
-          if (!text) return json({ error: "message is required" }, 400, options);
+          if (!text) return json({ error: "message is required" }, 400, responseOptions);
+          const channel = optionalChannel(body, "channel") ?? defineChannelContext3("chat");
+          if (hasHandleChannelEvent(options.runtime)) {
+            const result2 = await options.runtime.handleChannelEvent({
+              conversationId,
+              event: {
+                channel,
+                kind: "message",
+                nature: "message",
+                direction: "inbound",
+                intent: "customer-message",
+                actor: { type: "customer" },
+                payload: {
+                  text,
+                  ...body.turn !== void 0 ? { turn: body.turn } : {}
+                }
+              },
+              ...body.turn !== void 0 ? { handling: { turn: body.turn } } : {},
+              ...body.app !== void 0 ? { app: body.app } : {},
+              signal: request.signal
+            });
+            return json(sendMessageResultFromChannelEvent(result2), 200, responseOptions);
+          }
           const result = await options.runtime.handleUserMessage({
             conversationId,
             text,
+            channel,
             ...body.turn !== void 0 ? { turn: body.turn } : {},
             ...body.app !== void 0 ? { app: body.app } : {},
             signal: request.signal
           });
-          return json(result, 200, options);
+          return json(result, 200, responseOptions);
         }
         const customEventMatch = path.match(/^\/conversations\/([^/]+)\/custom-events\/([^/]+)$/);
         if (request.method === "POST" && customEventMatch) {
-          if (!options.runtime.emitCustomEvent) return json({ error: "Custom events are not supported by this runtime" }, 501, options);
+          if (!options.runtime.emitCustomEvent) return json({ error: "Custom events are not supported by this runtime" }, 501, responseOptions);
           const conversationId = decodeURIComponent(customEventMatch[1] ?? "");
           const eventName = decodeURIComponent(customEventMatch[2] ?? "");
           const event = options.customEvents?.find((candidate) => candidate.name === eventName);
-          if (!event) return json({ error: `Custom event '${eventName}' is not registered with the HTTP handler` }, 404, options);
+          if (!event) return json({ error: `Custom event '${eventName}' is not registered with the HTTP handler` }, 404, responseOptions);
           const body = await readObject(request);
           const emitted = await options.runtime.emitCustomEvent({
             conversationId,
             event,
             payload: body.payload
           });
-          return json({ event: emitted }, 200, options);
+          return json({ event: emitted }, 200, responseOptions);
         }
         const journeyEventMatch = path.match(/^\/conversations\/([^/]+)\/journey-events\/([^/]+)$/);
         if (request.method === "POST" && journeyEventMatch) {
-          if (!options.runtime.emitJourneyEvent) return json({ error: "Journey events are not supported by this runtime" }, 501, options);
+          if (!options.runtime.emitJourneyEvent) return json({ error: "Journey events are not supported by this runtime" }, 501, responseOptions);
           const conversationId = decodeURIComponent(journeyEventMatch[1] ?? "");
           const eventName = decodeURIComponent(journeyEventMatch[2] ?? "");
           const event = options.journeyEvents?.find((candidate) => candidate.name === eventName);
-          if (!event) return json({ error: `Journey event '${eventName}' is not registered with the HTTP handler` }, 404, options);
+          if (!event) return json({ error: `Journey event '${eventName}' is not registered with the HTTP handler` }, 404, responseOptions);
           const body = await readObject(request);
           const routing = optionalRouting(body, "routing");
           const target = optionalTarget(body, "target");
@@ -222,37 +890,37 @@ function createCognideskHttpHandler(options) {
             ...body.app !== void 0 ? { app: body.app } : {},
             signal: request.signal
           });
-          return json(result, 200, options);
+          return json(result, 200, responseOptions);
         }
         const handoffMatch = path.match(/^\/conversations\/([^/]+)\/handoff$/);
         if (request.method === "POST" && handoffMatch) {
-          if (!options.runtime.requestHandoff) return json({ error: "Handoff is not supported by this runtime" }, 501, options);
+          if (!options.runtime.requestHandoff) return json({ error: "Handoff is not supported by this runtime" }, 501, responseOptions);
           const conversationId = decodeURIComponent(handoffMatch[1] ?? "");
           const body = await readObject(request);
           const reason = optionalString(body, "reason");
-          if (!reason) return json({ error: "reason is required" }, 400, options);
+          if (!reason) return json({ error: "reason is required" }, 400, responseOptions);
           const result = await options.runtime.requestHandoff({
             conversationId,
             reason,
             ...optionalStringProperty(body, "summary"),
             ...body.payload !== void 0 ? { payload: body.payload } : {}
           });
-          return json(result, 200, options);
+          return json(result, 200, responseOptions);
         }
         const closeMatch = path.match(/^\/conversations\/([^/]+)\/close$/);
         if (request.method === "POST" && closeMatch) {
-          if (!options.runtime.closeConversation) return json({ error: "Conversation closure is not supported by this runtime" }, 501, options);
+          if (!options.runtime.closeConversation) return json({ error: "Conversation closure is not supported by this runtime" }, 501, responseOptions);
           const conversationId = decodeURIComponent(closeMatch[1] ?? "");
           const body = await readObject(request);
           const conversation = await options.runtime.closeConversation(
             conversationId,
             optionalString(body, "reason")
           );
-          return json({ conversation }, 200, options);
+          return json({ conversation }, 200, responseOptions);
         }
         const resumeMatch = path.match(/^\/conversations\/([^/]+)\/resume$/);
         if (request.method === "POST" && resumeMatch) {
-          if (!options.runtime.resumeConversation) return json({ error: "Conversation resume is not supported by this runtime" }, 501, options);
+          if (!options.runtime.resumeConversation) return json({ error: "Conversation resume is not supported by this runtime" }, 501, responseOptions);
           const conversationId = decodeURIComponent(resumeMatch[1] ?? "");
           const body = await readObject(request);
           const result = await options.runtime.resumeConversation({
@@ -260,25 +928,25 @@ function createCognideskHttpHandler(options) {
             ...optionalStringProperty(body, "reason"),
             ...body.payload !== void 0 ? { payload: body.payload } : {}
           });
-          return json(result, 200, options);
+          return json(result, 200, responseOptions);
         }
         const intermediateMessageMatch = path.match(/^\/conversations\/([^/]+)\/intermediate-messages$/);
         if (request.method === "POST" && intermediateMessageMatch) {
-          if (!options.runtime.emitIntermediateMessage) return json({ error: "Intermediate messages are not supported by this runtime" }, 501, options);
+          if (!options.runtime.emitIntermediateMessage) return json({ error: "Intermediate messages are not supported by this runtime" }, 501, responseOptions);
           const conversationId = decodeURIComponent(intermediateMessageMatch[1] ?? "");
           const body = await readObject(request);
           const text = optionalString(body, "text");
-          if (!text) return json({ error: "text is required" }, 400, options);
+          if (!text) return json({ error: "text is required" }, 400, responseOptions);
           const result = await options.runtime.emitIntermediateMessage({
             conversationId,
             text,
             ...body.visibleToModel === true ? { visibleToModel: true } : {}
           });
-          return json(result, 200, options);
+          return json(result, 200, responseOptions);
         }
         const preambleMatch = path.match(/^\/conversations\/([^/]+)\/preambles$/);
         if (request.method === "POST" && preambleMatch) {
-          if (!options.runtime.emitGeneratedPreamble) return json({ error: "Generated preambles are not supported by this runtime" }, 501, options);
+          if (!options.runtime.emitGeneratedPreamble) return json({ error: "Generated preambles are not supported by this runtime" }, 501, responseOptions);
           const conversationId = decodeURIComponent(preambleMatch[1] ?? "");
           const body = await readObject(request);
           const maxWords = optionalNonNegativeNumber(body, "maxWords");
@@ -288,11 +956,11 @@ function createCognideskHttpHandler(options) {
             ...maxWords !== void 0 ? { maxWords } : {},
             signal: request.signal
           });
-          return json(result, 200, options);
+          return json(result, 200, responseOptions);
         }
         const compactionMatch = path.match(/^\/conversations\/([^/]+)\/compact$/);
         if (request.method === "POST" && compactionMatch) {
-          if (!options.runtime.compactConversation) return json({ error: "Conversation compaction is not supported by this runtime" }, 501, options);
+          if (!options.runtime.compactConversation) return json({ error: "Conversation compaction is not supported by this runtime" }, 501, responseOptions);
           const conversationId = decodeURIComponent(compactionMatch[1] ?? "");
           const body = await readObject(request);
           const fromOffset = optionalNonNegativeNumber(body, "fromOffset");
@@ -304,48 +972,48 @@ function createCognideskHttpHandler(options) {
             ...optionalStringProperty(body, "schemaVersion"),
             signal: request.signal
           });
-          return json(result, 200, options);
+          return json(result, 200, responseOptions);
         }
         const widgetSubmissionMatch = path.match(/^\/conversations\/([^/]+)\/widgets\/([^/]+)\/submissions$/);
         if (request.method === "POST" && widgetSubmissionMatch) {
-          if (!options.runtime.submitWidget) return json({ error: "Widget submissions are not supported by this runtime" }, 501, options);
+          if (!options.runtime.submitWidget) return json({ error: "Widget submissions are not supported by this runtime" }, 501, responseOptions);
           const conversationId = decodeURIComponent(widgetSubmissionMatch[1] ?? "");
           const promptId = decodeURIComponent(widgetSubmissionMatch[2] ?? "");
           const body = await readObject(request);
           const widgetKind = optionalString(body, "widgetKind");
-          if (!widgetKind) return json({ error: "widgetKind is required" }, 400, options);
+          if (!widgetKind) return json({ error: "widgetKind is required" }, 400, responseOptions);
           const event = await options.runtime.submitWidget({
             conversationId,
             promptId,
             widgetKind,
             output: body.output
           });
-          return json({ event }, 200, options);
+          return json({ event }, 200, responseOptions);
         }
         const snapshotMatch = path.match(/^\/conversations\/([^/]+)\/snapshot$/);
         if (request.method === "GET" && snapshotMatch) {
-          if (!options.runtime.getSnapshot) return json({ error: "Snapshots are not supported by this runtime" }, 501, options);
+          if (!options.runtime.getSnapshot) return json({ error: "Snapshots are not supported by this runtime" }, 501, responseOptions);
           const conversationId = decodeURIComponent(snapshotMatch[1] ?? "");
           const snapshot = await options.runtime.getSnapshot(conversationId);
-          return json({ snapshot }, 200, options);
+          return json({ snapshot }, 200, responseOptions);
         }
         const replayMatch = path.match(/^\/conversations\/([^/]+)\/replay$/);
         if (request.method === "GET" && replayMatch) {
-          if (!options.runtime.replayConversation) return json({ error: "Event replay is not supported by this runtime" }, 501, options);
+          if (!options.runtime.replayConversation) return json({ error: "Event replay is not supported by this runtime" }, 501, responseOptions);
           const conversationId = decodeURIComponent(replayMatch[1] ?? "");
           const afterOffset = parseOptionalInteger(url.searchParams.get("after"));
           const replay = await options.runtime.replayConversation({
             conversationId,
             ...afterOffset !== void 0 ? { afterOffset } : {}
           });
-          return json(replay, 200, options);
+          return json(replay, 200, responseOptions);
         }
         const eventsMatch = path.match(/^\/conversations\/([^/]+)\/events$/);
         if (request.method === "GET" && eventsMatch) {
           const conversationId = decodeURIComponent(eventsMatch[1] ?? "");
           const afterOffset = parseOptionalInteger(url.searchParams.get("after"));
           const events = await options.runtime.listEvents(conversationId, afterOffset);
-          return json({ events }, 200, options);
+          return json({ events }, 200, responseOptions);
         }
         const streamMatch = path.match(/^\/conversations\/([^/]+)\/events\/stream$/);
         if (request.method === "GET" && streamMatch) {
@@ -357,92 +1025,31 @@ function createCognideskHttpHandler(options) {
             afterOffset,
             pollIntervalMs,
             signal: request.signal,
-            responseOptions: options
+            responseOptions
           });
         }
-        return json({ error: "Not found" }, 404, options);
+        return json({ error: "Not found" }, 404, responseOptions);
       } catch (error) {
         if (error instanceof HttpInputError) {
-          return json({ error: error.message }, error.status, options);
+          return json({ error: error.message }, error.status, responseOptions);
         }
         return json({
-          error: error instanceof Error ? error.message : "Unknown error"
-        }, 500, options);
+          error: internalErrorMessage(error, options)
+        }, 500, responseOptions);
       }
     }
   };
 }
-async function readObject(request) {
-  const body = await readJson(request);
-  if (!isRecord(body)) throw new HttpInputError("Request body must be a JSON object.");
-  return body;
-}
-function optionalString(body, key) {
-  const value = body[key];
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value !== "string") throw new HttpInputError(`${key} must be a string.`);
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function optionalStringProperty(body, key) {
-  const value = optionalString(body, key);
-  return value ? { [key]: value } : {};
-}
-function optionalNonNegativeNumber(body, key) {
-  const value = body[key];
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
-    throw new HttpInputError(`${key} must be a non-negative integer.`);
-  }
-  return value;
-}
-function optionalRouting(body, key) {
-  const value = optionalString(body, key);
-  if (!value) return void 0;
-  if (value !== "none" && value !== "activeJourneyOnly" && value !== "full" && value !== "targeted") {
-    throw new HttpInputError(`${key} must be a valid routing mode.`);
-  }
-  return value;
-}
-function optionalTarget(body, key) {
-  const value = body[key];
-  if (value === void 0 || value === null) return void 0;
-  if (!isRecord(value)) throw new HttpInputError(`${key} must be an object.`);
-  const journeyId = optionalString(value, "journeyId");
-  const stateId = optionalString(value, "stateId");
-  return {
-    ...journeyId ? { journeyId } : {},
-    ...stateId ? { stateId } : {}
-  };
-}
-function optionalVoiceClient(body) {
-  const value = body.client;
-  if (value === void 0 || value === null) return {};
-  if (!isRecord(value)) throw new HttpInputError("client must be an object.");
-  const userAgent = optionalString(value, "userAgent");
-  const locale = optionalString(value, "locale");
-  const metadata = value.metadata;
-  if (metadata !== void 0 && metadata !== null && !isRecord(metadata)) {
-    throw new HttpInputError("client.metadata must be an object.");
-  }
-  return {
-    client: {
-      ...userAgent ? { userAgent } : {},
-      ...locale ? { locale } : {},
-      ...isRecord(metadata) ? { metadata } : {}
-    }
-  };
-}
-function withVoiceEventsUrl(result, basePath) {
-  return {
-    ...result,
-    eventsUrl: `${basePath}/conversations/${encodeURIComponent(result.conversation.id)}/events/stream`
-  };
-}
-function isRecord(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
 export {
-  createCognideskHttpHandler
+  createChannelEventInput,
+  createChannelEventRequestBody,
+  createChannelHandoffEventInput,
+  createChannelHandoffReviewEventInput,
+  createChannelOutputResolutionEventInput,
+  createCognideskHttpHandler,
+  createMessageChannelEventInput,
+  createOutboundContactChannelEventInput,
+  createProviderObjectChannelEventInput,
+  createScheduledChannelEventInput,
+  createVoiceTurnChannelEventInput
 };
-//# sourceMappingURL=index.js.map